*DECK DB$SFIN 
USETEXT CDCSCTX 
      PROC DB$SFIN( (ERRBLKA) );
      BEGIN 
 #
* *   DB$SFIN - INITIALIZE SYSTEM FILES          PAGE  1
* *   D E TRIGLIA/W P CEAGLIO                    DATE  01/21/81 
* 
* DC  PURPOSE 
* 
*     ATTACH AND INITIALIZE ALL SYSTEM FILES FOR THIS SCHEMA. 
* 
* DC  ENTRY CONDITIONS
* 
* D   PARAMETERS
# 
      ITEM ERRBLKA   I;            # ADDRESS OF ERROR BLOCK            #
# 
* D   ASSUMPTIONS 
* 
*     SALX IS SET.
*     THE RCB MUST BE SET UP SO THAT PUSHES AND POPS CAN BE DONE. 
*     THE MD IS ALREADY OPEN. 
* 
* DC  EXIT CONDITIONS 
* 
*     IF THIS SCHEMA HAS DBPS, THE DBP LIBRARY IS ATTACHED, 
*                              THE APL IS SET UP IN CORE, AND 
*                              THE APL POINTER IS SET.
* 
*     IF THIS SCHEMA HAS BLOCK LOGGING, THE QRF IS ATTACHED, AND
*                                       THE POINTER SET IN THE SAL. 
* 
*     IF THIS SCHEMA HAS JOURNAL LOGGING, THE JOURNAL LOG IS ATTACHED,
*                                         THE POINTER SET IN THE SAL AND
*                                         THE LOG POSITIONED AT EOI.
* 
*     IF THIS SCHEMA HAS AUTO-RECOVERY, THE TRF IS ATTACHED,
*                                       THE ART IS SET UP IN CORE, AND
*                                       THE POINTER SET IN THE SAL. 
* 
*     IF THIS SCHEMA HAS A RESTART ID FILE, THE RIF IS ATTACHED AND 
*                                           THE POINTER SET IN THE SAL. 
* 
*     IF AN ERROR OCCURRED ON ANY OF THE SYSTEM FILES, RETURN ALL 
*     ATTACHED SYSTEM FILES.  IF AN ERROR OCCURRED AND IT IS
*     NOT (AN IMMEDIATE RETURN JOB AND BUSY FILE ERROR) THEN
*     DOWN THE SCHEMA AND RETURN ALL ATTACHED SYSTEM FILES. 
* 
* DC  CALLING ROUTINES
* 
*     DB$CARS      AUTO-RECOVERY CONTROLLER 
*     DB$INV$      INVOKE SYMBIONT
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$DFIN;           # INITIALIZE DBP LIBRARY            #
      XREF PROC DB$FLOP;           # GENERATE A FLOW POINT ENTRY       #
      XREF PROC DB$JFIN;           # INITIALIZE JOURNAL LOG FILE       #
      XREF PROC DB$MBA;            # ALLOCATE TEMPORARY CMM BLOCK      #
      XREF PROC DB$MBF;            # RELEASE TEMPORARY CMM BLOCK       #
      XREF PROC DB$MDER;           # MASTER DIRECTORY ERROR HANDLER    #
      XREF PROC DB$OIUL;           # IMMEDIATELY UNLOAD AN OVCAP       #
      XREF PROC DB$POP;            # POP VARIABLE FROM (RCB) STACK     #
      XREF PROC DB$PUSH;           # PUSH VARIABLE ONTO (RCB) STACK    #
      XREF PROC DB$QFIN;           # INITIALIZE QUICK RECOVERY FILE    #
      XREF PROC DB$RFIN;           # INITIALIZE RESTART IDENTIFIER FILE#
      XREF PROC DB$SFRT;           # RETURN SYSTEM FILES               #
      XREF PROC DB$TFIN;           # INITIALIZE TRANSACTION RECOV FILE #
      XREF PROC DB$WGET;           # READ FROM MASTER DIRECTORY        #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     P<APL> (VIA DB$DFIN)
* 
*     SAL 
*       SADBPPTR   POINTER TO DBP LIST (DB$DFIN)
*       SAJLFPTR   POINTER TO JOURNAL LOG QUEUE (DB$JFIN) 
*       SAQRFPTR   POINTER TO QRF TABLE (DB$QFIN) 
*       SATRFPTR   POINTER TO TRF FET (DB$TFIN) 
*       SARIDFIT   POINTER TO RESTART ID FILE FIT (DB$RFIN) 
* 
*     ART 
*       ARMODFET   POINTER TO TRF MODEL FET (DB$TFIN) 
* 
* DC  DESCRIPTION 
* 
*     A SEPARATE PROCESSOR EXISTS FOR INITIALIZATION OF EACH SYSTEM 
*     FILE.  THE FIELDS (FLAGS) IN THE SAL DETERMINE IF A PARTICULAR
*     SYSTEM FILE IS PRESENT--IF SO, THE APPLICABLE PROCEDURE IS CALLED 
*     TO PERFORM THE INTIALIZATION.  THE SYSTEM FILES ARE:  
* 
*     -  DATABASE PROCEDURE LIBRARY 
*     -  JOURNAL LOG FILE 
*     -  QUICK RECOVERY FILE
*     -  TRANSACTION RECOVERY FILE
*     -  RESTART IDENTIFIER FILE
* 
 #
  
  
  
#     LOCAL VARIABLES                                                  #
  
*CALL SRERRDCLS 
  
      BASED ARRAY MDSCINFO;        # FOR READING SCHEMA INFO ENTRY     #
        BEGIN 
*CALL MDSCIDCLS 
        END 
  
      BASED ARRAY MDPFT;;          # FOR PASSING MD PF ENTRY PARAMETER #
  
*CALL FITMDDCLS 
  
  
  
  
  
# S T A R T   O F   D B $ S F I N   E X E C U T A B L E   C O D E      #
  
  
      CONTROL IFGR DFFLOP,0;
        DB$FLOP("SFIN");
      CONTROL ENDIF;
  
      DB$PUSH(DB$SFIN); 
  
#     IF DATABASE PROCEDURE LIBRARY PRESENT, PERFORM INTIALIZATION.    #
  
      P<SRERRBLK> = ERRBLKA;
      IF SASCDPSZ[SALX] NQ 0
      THEN
        BEGIN 
        DB$PUSH(P<SRERRBLK>); 
        DB$DFIN(P<SRERRBLK>); 
        DB$POP(P<SRERRBLK>);
        IF SREWORD[0] NQ 0
        THEN
          BEGIN 
          IF SYSRECOVERY OR SREFPAR[0] GQ 0 
          THEN
            BEGIN 
            SASCHST[SALX] = S"ERRDOWN"; 
            END 
          DB$POP(DB$SFIN);
  
          RETURN; 
  
          END 
        END 
  
#     IF NO OTHER SYSTEM FILES PRESENT FOR THIS SCHEMA, RETURN.        #
  
      IF NOT SASCJLF[SALX]
        AND NOT SASCQRF[SALX] 
        AND NOT SASCARF[SALX] 
        AND NOT SASCRIF[SALX] 
      THEN
        BEGIN 
        DB$POP(DB$SFIN);
  
        RETURN; 
  
        END 
  
#     AT LEAST ONE OTHER SYSTEM FILE PRESENT.  READ IN ENTIRE SCHEMA   #
#     INFORMATION ENTRY FROM THE MD (INCLUDING ATTACH DATA FOR ALL     #
#     SYSTEM FILES).                                                   #
  
      DB$MBA(SASCSISZ[SALX],P<MDSCINFO>); 
      DB$WGET(DB$FTMD,MDSCINFO,SASCSISZ[SALX],SASCWASC[SALX],DB$MDER);
  
  
#     IF QUICK RECOVERY FILE PRESENT, PERFORM INITIALIZATION.          #
  
      IF SASCQRF[SALX]
        AND SREWORD[0] EQ 0 
      THEN
        BEGIN 
        P<MDPFT> = LOC(MDSCINFO) + MDSIQRFP[0]; 
        DB$PUSH(P<SRERRBLK>); 
        DB$QFIN(P<MDPFT>,P<SRERRBLK>);
        DB$POP(P<SRERRBLK>);
        END 
  
#     IF TRANSACTION RECOVERY FILE PRESENT, PERFORM INITIALIZATION.    #
  
      IF SASCARF[SALX]
        AND SREWORD[0] EQ 0 
      THEN
        BEGIN 
        P<MDPFT> = LOC(MDSCINFO) + MDSITRFP[0]; 
        DB$PUSH(P<SRERRBLK>); 
        DB$TFIN(P<MDPFT>,MDSIUNIL[0],P<SRERRBLK>);
        DB$POP(P<SRERRBLK>);
        END 
  
#     IF RESTART IDENTIFIER FILE PRESENT, PERFORM INITIALIZATION.      #
  
      IF SASCRIF[SALX]
        AND SREWORD[0] EQ 0 
      THEN
        BEGIN 
        P<MDPFT> = LOC(MDSCINFO) + MDSIRIFP[0]; 
        DB$PUSH(P<SRERRBLK>); 
        DB$RFIN(P<MDPFT>,P<SRERRBLK>);
        DB$POP(P<SRERRBLK>);
        END 
  
#     UNLOAD THE DB$TFIN/DB$RFIN OVCAP                                 #
#     IF LOADED AND NOT LOCKED IN BY OTHER PROCEDURES.                 #
  
      DB$OIUL(DB$TFIN); 
  
#     IF JOURNAL LOG FILE PRESENT, PERFORM INITIALIZATION.             #
  
#     THE JOURNAL LOG FILE IS DONE LAST TO AVOID A PERMANENT FILE      #
#     ATTACH DEADLOCK BETWEEN MULTIPLE CDCSBTF JOBS.                   #
  
      IF SASCJLF[SALX]
        AND SREWORD[0] EQ 0 
      THEN
        BEGIN 
        P<MDPFT> = LOC(MDSCINFO) + MDSIJLFP[0]; 
        DB$PUSH(P<SRERRBLK>); 
        DB$JFIN(P<MDPFT>,MDSIJLFN[0],P<SRERRBLK>);
        DB$POP(P<SRERRBLK>);
        DB$OIUL(DB$JFIN);    # UNLOAD THE OVCAP CONTAINING DB$JFIN.    #
        END 
  
  
#     RELEASE TEMPORARY BUFFER.                                        #
  
      DB$MBF(P<MDSCINFO>);
  
#     IF AN ERROR OCCURRED ON ANY OF THE SYSTEM FILES, RETURN ALL      #
#     ATTACHED SYSTEM FILES.  IF AN ERROR OCCURRED AND IT IS NOT A     #
#     TEMPORARY TYPE OF ERROR THEN DOWN THE SCHEMA AND RETURN ALL      #
#     ATTACHED SYSTEM FILES.                                           #
#     DURING SYSTEM RECOVERY, ANY ATTACH ERROR WILL CAUSE THE SCHEMA   #
#     TO BE SET IN DOWN STATUS.                                        #
  
      IF SRENUMB[0] NQ 0
      THEN
        BEGIN 
        IF SYSRECOVERY OR SREFPAR[0] GQ 0 
        THEN
          BEGIN 
          SASCHST[SALX] = S"ERRDOWN"; 
          END 
        DB$SFRT;
        END 
  
      DB$POP(DB$SFIN);
  
      END 
      TERM; 
