*DECK DB$CARS 
USETEXT CDCSCTX 
      PROC DB$CARS(ABORTFLG,SCHID); 
      BEGIN 
 #
* *   DB$CARS - CONTROL AUTO-RECOVERY SEQUENCE   PAGE  1
* *   D E TRIGLIA/W P CEAGLIO                    DATE  01/14/81 
* *   BOB MCALLESTER                             DATE  01/14/85 
* 
* DC  PURPOSE 
* 
*     TO CONTROL THE EXECUTION OF AUTO-RECOVERY INITIALIZATION, ALSO
*     KNOWN AS SYSTEM RECOVERY. 
* 
* DC  ENTRY CONDITIONS
* 
* D   PARAMETERS
# 
      ITEM ABORTFLG B;             # TRUE IF ALL SCHEMAS UNRECOVERABLE #
      ITEM SCHID I;                # SCHEMA ID TO BE RECOVERED         #
                                   # = 0 FOR RECOVERY OF ALL SCHEMAS   #
# 
* D   ASSUMPTIONS 
* 
*     SAL HAS BEEN SET UP CORRECTLY.
*     SALL CONTAINS (COUNT-1) OF SAL ENTRIES. 
*     SASCHST ALWAYS INDICATES THE CURRENT STATUS OF A SCHEMA.
* 
*     IF CALLED FROM DB$DSCS, P<RCB> POINTS TO RCBMTR.
*     THIS IS ALWAYS TRUE DURING OPERATOR INTERFACE PROCEDURES SINCE
*     THEY ARE ENTERED ONLY FROM DB$MTR.
* 
* DC  EXIT CONDITIONS 
* 
*     ALL RECOVERABLE SCHEMAS ARE UP.  ALL UNRECOVERABLE SCHEMAS ARE
*     PLACED IN "ERRDOWN" STATUS.  IF ALL SCHEMAS WERE UNRECOVERABLE, 
*     ABORTFLG IS SET TO TRUE.
*     IF CALLED FROM DB$DSCS, P<RCB> IS RESTORED TO POINT TO RCBMTR.
* 
* DC  CALLING ROUTINES
* 
*     DB$ARRO      0,0 OVERLAY ROUTINE TO CONTROL AUTO-RECOVERY ROLL OUT
*     DB$DSCS      DISPLAY DRIVER ROUTINE THAT WILL "UP" A SCHEMA 
*     DB$TARE      TERMINATE AN AREA ON AN ERROR
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$AREH;           # AUTO-RECOVERY ERROR HANDLER       #
      XREF FUNC DB$CDEC C(10);     # CONVERT INTEGER TO DECIMAL        #
      XREF FUNC DB$CFIL C(30);     # FILL WITH ZEROS/BLANKS            #
      XREF PROC DB$FLOP;           # GENERATE FLOW POINT               #
      XREF PROC DB$LNKS;           # RETURN A BLOCK TO ITS IDLE LIST   #
      XREF PROC DB$MBFA;           # RETURN TEMPORARY MEMORY BLOCKS    #
      XREF PROC DB$MSG;            # PUT MESSAGE ON DAYFILE            #
      XREF PROC DB$ODLC;           # DECREMENT OVCAP LOCK CT           #
      XREF PROC DB$POP;            # RESTORE VARIABLE FROM RCB STACK   #
      XREF PROC DB$PUSH;           # SAVE VARIABLE IN RCB STACK        #
      XREF PROC DB$QRFA;           # APPLY QRF TO DATABASE             #
      XREF PROC DB$RCBC;           # CREATE AN RCB                     #
      XREF PROC DB$RCLR;           # RECALL THE CPU                    #
      XREF PROC DB$RFOR;           # APPLY AFTER IMAGES FROM JOURN LOG #
      XREF PROC DB$RUTR;           # ROLLBACK UNCOMMITTED TRANSACTIONS #
      XREF PROC DB$SCHD;           # CDCS TASK SCHEDULER               #
      XREF PROC DB$SFIN;           # SYSTEM FILES INITIALIZATION       #
      XREF PROC DB$WRAR;           # WRAP UP AUTO-RECOVERY FOR A SCHEMA#
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     SALX                   INDEX INTO SCHEMA ACCESS LIST
# 
      XREF ITEM DB$TARN;           # TERMINATING AREA ID NUMBER -      #
                                   # ZERO IF ALL AREAS ARE TO BE       #
                                   # RECOVERED.                        #
  
      XREF ITEM DB$TARV C(7);      # TERMINATING AREA VERSION NAME     #
# 
* DC  DESCRIPTION 
* 
*     DB$CARS IS CALLED DURING CDCS INITIALIZATION TO AUTOMATICALLY 
*     RECOVER ALL OF THE SCHEMAS.  IN THIS CASE THE SCHID PARAMETER 
*     IS ZERO.
* 
*     IT MAY BE CALLED AGAIN DURING CDCS EXECUTION TO RECOVER A 
*     SPECIFIC SCHEMA WHICH IS SPECIFIED BY SCHID.
*     IN THIS CASE, THE LOOP PARAMETERS ARE SET TO RECOVER ONLY THAT
*     SINGLE SCHEMA.
*     CDCS TEMPORARILY DELINKS ANY OTHER ACTIVE RCB ENTRIES AND 
*     RE-ENTERS A SYSTEM RECOVERY MODE TO RECOVER THE SCHEMA. 
* 
*     FOR EACH SCHEMA, DO THE FOLLOWING:  
* 
*       -  ATTACH AND INITIALIZE ALL SYSTEM FILES (QRF, JOURNAL LOG,
*          TRF, RIF, DATA BASE PROCEDURE LIBRARY).
* 
*       -  APPLY THE CONTENTS OF THE QRF IF APPLICABLE. 
* 
*       -  APPLY THE AFTER IMAGES FROM THE LAST RECOVERY POINT UP TO
*          THE END OF THE JOURNAL LOG.
* 
*       -  ROLL BACK ANY UNCOMMITTED TRANSACTIONS ON THE TRF. 
* 
*       -  IF ANY ERROR OCCURRED IN THE PREVIOUS PROCESSES, CALL THE
*          ERROR HANDLER. 
* 
*       -  WRAP UP AUTO-RECOVERY FOR THIS SCHEMA BY RELEASING BUFFERS 
*          AND TEMPORARY TABLES (EXCEPT DUMMY OFTS).
* 
*       -  ISSUE A DAYFILE MESSAGE INDICATING WHETHER THE SCHEMA WAS
*          RECOVERED.  IF THE SCHEMA WAS RECOVERED, SET ABORTFLG TO 
*          FALSE. 
* 
 #
  
  
#     LOCAL VARIABLES                                                  #
  
      ITEM ARMSG    C(30) = "           AREA ID  9999:";
      ITEM AVMSG    C(30) = "           VERSION  VVVVVVV:"; 
      ITEM SCMSGBEG C(60) = "  RECOVERING SCHEMA XXXXXXXXXXXXXXXXXXXXXXX
XXXXXXX:";
      ITEM SCMSGERR C(70) = "  RECOVERY IMPOSSIBLE FOR SCHEMA XXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX:"; 
  
      ARRAY ERRBLOK P(2);              # AUTO-RECOVERY ERROR BLOCK     #
        BEGIN 
        ITEM ERRWRD     U(00,00,60);   # ENTIRE WORD                   #
        ITEM ERRNUM     U(00,00,09);   # ERROR NUMBER                  #
        END 
  
      ITEM SAVECA    I;            # DB$MTR CONTINUATION ADDRESS       #
      ITEM SAVENEXT I;             # SAVE RCBMTR NEXT POINTER          #
      ITEM SAVEPRIOR I;            # SAVE RCBMTR PRIOR POINTER         #
      ITEM SAVERCB   I;            # SAVE CURRENT RCB POINTER          #
      ITEM SCNAME C(30);           # ZERO FILLED SCHEMA NAME           #
      ITEM XXI I;                  # INITIAL VALUE OF SALX             #
      ITEM XXL I;                  # LIMITING VALUE OF SALX            #
  
  
  
  
#     I N T E R N A L   P R O C E D U R E   -   M I N I M T R .        #
  
  
      PROC MINIMTR; 
      BEGIN 
 #
* *   DB$CARS                                    PAGE  1
* *   MINIMTR - 
* *     SUBSTITUTE FOR DB$MTR DURING SYSTEM RECOVERY
* *   BOB MCALLESTER                             DATE  07/13/81 
* 
* DC  PURPOSE 
* 
*     PROVIDE A DEFAULT RECALL DURING SYSTEM RECOVERY.
* 
* DC  ENTRY CONDITIONS
* 
*     NONE
* 
* DC  EXIT CONDITIONS 
* 
*     IT NEVER EXITS, ONLY RETURNS TO SCHEDULER.
* 
* DC  CALLING ROUTINES
* 
*     DB$CARS 
* 
* DC  CALLED ROUTINES 
* 
*     DB$RCLR                RECALL THE CPU 
*     DB$SCHD                CDCS TASK SCHEDULER
* 
* DC  DESCRIPTION 
* 
*     EVERY TIME SCHEDULER RETURNS TO MINIMTR, IT CALLS DB$RCLR TO
*     RELINQUISH THE CPU FOR ONE RECALL PERIOD. 
*     IT THEN CALLS DB$SCHD TO RESUME EXECUTION OF THE SYSTEM RECOVERY. 
 #
  
#     LOCAL VARIABLES                                                  #
  
      ITEM XX I;             # INDUCTION VARIABLE                      #
  
  
  
  
#     B E G I N   M I N I M T R   E X E C U T A B L E   C O D E        #
  
  
      FOR XX = XX 
      DO
        BEGIN 
        DB$SCHD(LOC(STATCOMP),0); 
        DB$RCLR(0); 
        END 
      END 
  
  
  
  
# S T A R T   O F   D B $ C A R S   E X E C U T A B L E   C O D E      #
  
  
      CONTROL IFGR DFFLOP,0;
        DB$FLOP("CARS");
      CONTROL ENDIF;
  
      SYSRECOVERY = TRUE; 
      XXI = 0;                     # SET LIMITS FOR ALL SCHEMAS        #
      XXL = SALL; 
      IF SCHID NQ 0 
      THEN                         # SET LIMITS FOR JUST ONE SCHEMA    #
        BEGIN 
        SAVERCB = P<RCB>;          # SAVE CURRENT RCB POINTER          #
        P<RCB> = LOC(RCBMTR); 
  
#       P<RCB> POINTS TO RCBMTR.  SAVE ITS LINKAGES TO OTHER RCB'S     #
#       AND DELINK IT.                                                 #
  
        XXI = SCHID -1; 
        XXL = SCHID -1; 
        SAVECA = RCCONTA[0];       # SAVE THE CONTINUATION ADDRESS     #
        SAVEPRIOR = RCPRIOR[0];    # SAVE RCB QUEUE LINKAGES           #
        SAVENEXT  = RCNEXT [0]; 
        RCPRIOR[0] = LOC(RCBMTR);  # ELIMINATE LINKS TO OTHER RCB'S    #
        RCNEXT [0] = LOC(RCBMTR); 
        END 
  
#**********************************************************************#
#                                                                      #
#     CREATE AN ADDITIONAL RCB FOR USE DURING SYSTEM RECOVERY.         #
#     SET THE RCB POINTER TO RCBMTR AND CALL MINIMTR TO PROVIDE        #
#     A RECALL CAPABILITY BY CALLING DB$SCHD.                          #
#                                                                      #
#**********************************************************************#
  
      DB$RCBC;               # PREPARE THE SYSTEM RECOVERY RCB         #
      RCCONSTRA[0] = LOC(STATCOMP); 
      RCCONTA[0] = LOC(CARSCONT); 
      RCIRTASK[0] = 0;
      RCFUNC[0] = DFMTR;     # MONITOR FUNCTION CODE USED TO IDENTIFY  #
                             # INTERNAL TASKS.                         #
      RCIRRUID[0] = O"23312322032622000000";
#                      S Y S R C V R                                   #
  
      P<RCB> = LOC(RCBMTR); 
      MINIMTR;               # INITIATE THE MINIMTR                    #
  
#     THE SYSTEM RECOVERY RCB HAS BEEN SET UP TO CONTINUE HERE.        #
  
CARSCONT: 
  
#**********************************************************************#
#                                                                      #
#     LOOP THRU ALL ENTRIES IN THE SAL.  FOR EACH SCHEMA, DO THE       #
#     FOLLOWING:                                                       #
#                                                                      #
#       *  INITIALIZE SYSTEM FILES--QUICK RECOVERY FILE, JOURNAL LOG   #
#          FILE, TRANSACTION RECOVERY FILE, RESTART IDENTIFIER FILE,   #
#          DATA BASE PROCEDURE LIBRARY.                                #
#       *  APPLY CONTENTS OF QRF IF APPLICABLE.                        #
#       *  ROLL FORWARD EACH AFFECTED AREA FROM THE LAST RECOVERY POINT#
#          USING THE LATEST JOURNAL LOG.                               #
#       *  ROLL BACK UNCOMMITTED TRANSACTIONS FROM THE TRF.            #
#       *  IF ANY ERROR OCCURRED IN THE PREVIOUS PROCESSES, DISPLAY    #
#          APPLICABLE MESSAGE.                                         #
#       *  CALL DB$WRAR TO RELEASE TEMPORARY BUFFERS, FITS, FETS.      #
#          DUMMY OFTS ARE LEFT IN THE OFT CHAIN.                       #
#       *  ISSUE A DAYFILE MESSAGE INDICATING WHETHER THE SCHEMA WAS   #
#          RECOVERED.  IF THE SCHEMA WAS RECOVERED, SET THE ABORT FLAG #
#          TO FALSE.                                                   #
#                                                                      #
#**********************************************************************#
  
      ABORTFLG = TRUE;
      FOR SALX = XXI STEP 1 UNTIL XXL 
      DO
        BEGIN 
        DB$PUSH(SALX);
        SCNAME = DB$CFIL(SASCNAME[SALX],30,0);
        C<20,30>SCMSGBEG = SCNAME;
        DB$MSG(SCMSGBEG); 
        ERRWRD[0] = 0;
  
        IF DB$TARN EQ 0 
        THEN
          BEGIN 
          DB$SFIN(LOC(ERRBLOK));   # INITIALIZE SYSTEM FILES           #
          END 
        ELSE
          BEGIN 
          C<20,4>ARMSG = DB$CDEC(DB$TARN,4);
          DB$MSG(ARMSG);           # AREA ID NUMBER                    #
          C<20,7>AVMSG = DB$TARV; 
          DB$MSG(AVMSG);           # VERSION NAME                      #
          END 
  
        IF SASCQRF[SALX]
          AND ERRNUM[0] EQ 0
        THEN
          BEGIN 
          DB$QRFA(LOC(ERRBLOK));   # APPLY CONTENTS OF QRF             #
          END 
  
        IF SASCJLF[SALX]
          AND ERRNUM[0] EQ 0
        THEN
          BEGIN 
          DB$RFOR(LOC(ERRBLOK));   # ROLL FORWARD DATABASE             #
          END 
  
        IF SASCARF[SALX]
          AND ERRNUM[0] EQ 0
          AND DB$TARN EQ 0
        THEN
          BEGIN 
          DB$RUTR(LOC(ERRBLOK));   # ROLL BACK UNCOMMITTED TRANSACTIONS#
          END 
  
        IF ERRNUM[0] NQ 0 
        THEN
          BEGIN 
          DB$AREH(LOC(ERRBLOK));   # PERFORM ANY ERROR PROCESSING      #
          END 
  
        IF DB$TARN EQ 0 
        THEN
          BEGIN 
          DB$WRAR(LOC(ERRBLOK));   # WRAP UP PROCESSING FOR SCHEMA     #
          END 
        ELSE
          BEGIN 
          DB$MBFA;                 # RETURN ALL TEMPORARY ALLOCATIONS  #
          END 
  
        IF SASCHST[SALX] EQ S"UP"  # ISSUE MESSAGE ON RECOVERY STATUS  #
        THEN
          BEGIN 
          ABORTFLG = FALSE; 
          END 
        ELSE
          BEGIN 
          C<33,30>SCMSGERR = SCNAME;
          DB$MSG(SCMSGERR);        # RECOVERY IMPOSSIBLE               #
          END 
  
        DB$POP(SALX); 
        END 
  
#     UNLOCK OVCAPS LOCKED BY THIS RCB.                                #
  
      DB$ODLC;
  
      DB$TARN = 0;
      SYSRECOVERY = FALSE;
  
#     IF CALLED TO "UP" A PARTICULAR SCHEMA,                           #
#       RETURN THE SYSTEM RECOVERY RCB.                                #
#       RESTORE THE EXISTING REQUEST QUEUE TO THE RCBMTR LINKAGES.     #
#       RETURN TO RCBMTR EXECUTION.                                    #
  
      IF SCHID NQ 0 
      THEN
        BEGIN 
        DB$LNKS(P<RCB>,IDLERCBP); 
        RCBIC = RCBIC +1;          # INCREMENT IDLE RCB COUNT          #
        P<RCB> = LOC(RCBMTR); 
        RCCONTA[0] = SAVECA;
        RCPRIOR[0] = SAVEPRIOR; 
        RCNEXT[0] = SAVENEXT; 
        P<RCB> = SAVERCB; 
        SALX = SCHID -1;
  
        CONTROL IFGR DFFLOP,0;
          DB$FLOP("CARS-R1"); 
        CONTROL ENDIF;
  
        END 
  
      RETURN; 
  
      END 
      TERM; 
