*DECK DB$IOER 
USETEXT CDCSCTX 
      PROC DB$IOER((FETLOC)); 
      BEGIN 
 #
* *   DB$IOER - I-O ERROR ON A LOG FILE          PAGE  1
* *   BOB MCALLESTER                             DATE  05/25/81 
* 
* DC  PURPOSE 
* 
*     GIVE NOTIFICATION OF THE ERROR. 
*     DUMP THE CONTENTS OF THE FET AND THE I-O BUFFER.
*     RESPOND TO THE ERROR CONDITION. 
*       FOR THE 
*       JOURNAL LOG FILE - DROP USERS CURRENTLY USING THE LOG.
*                        - SWITCH TO AN ALTERNATE LOG FILE. 
*       FOR THE 
*       TRANSACTION RECOVERY FILE OR QUICK RECOVERY FILE
*                        - ERROR-DOWN THE SCHEMA. 
*                        - DROP ALL SCHEMA USERS. 
* 
* DC  ENTRY CONDITIONS
* 
* D   PARAMETERS
# 
      ITEM FETLOC I;         # LOCATION OF THE FET WITH THE ERROR CODE #
# 
* D   ASSUMPTIONS 
* 
*     P<RCB>                 POINTS TO THE RUN-UNIT COMMAND BLOCK 
*                            OF THE USER BEING PROCESSED WHEN THE 
*                            ERROR OCCURRED.
*                            IT MIGHT POINT TO RCBMTR (INTERNAL TASK).
* 
*     SALX                   SUBSCRIPT TO SCHEMA ACCESS LIST. 
# 
      XREF ITEM DB$NOS B;    # TRUE IF NOS, FALSE IF NOS/BE            #
# 
* DC  EXIT CONDITIONS 
* 
*     IF CALLED FROM AN INTERNAL TASK, DB$IOER RETURNS. 
*     OTHERWISE, IT TERMINATES THE REQUEST BEING PROCESSED. 
* 
* DC  CALLING ROUTINES
* 
*     DB$QRF                 QUICK RECOVERY FILE PROCESSOR
*     DB$QFWR                WRITE TO QRF DURING SYSTEM RECOVERY
*     DB$JLCT                JOURNAL LOG CONTROLLER 
*     DB$JRPT                JOURNAL LOG RECOVERY POINT PROCESSOR 
*     DB$RWTR                REWRITE RECORD 
*     DB$TRFW                WRITE TO TRANSACTION FILE
*     DB$TRJL                COPY TRANSACTION LOG RECORDS TO JOURNAL LOG
*     DB$WART                WRITE THE AUTO-RECOVERY TABLE
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$AREH;     # AUTOMATIC RECOVERY ERROR HANDLER        #
      XREF PROC DB$DUMP;     # WRITE A MEMORY DUMP TO THE OUTPUT FILE  #
      XREF PROC DB$ERR;      # RUN-UNIT ERROR PROCESSOR                #
      XREF PROC DB$ERRI;     # INFORMATIONAL ERROR MESSAGE EDITOR      #
      XREF PROC DB$FLOP;     # RECORD A FLOW POINT                     #
      XREF PROC DB$JRPT;     # JOURNAL LOG RECOVERY POINT AND SWITCH   #
      XREF PROC DB$POP;      # RESTORE ITEM FROM PUSH-DOWN STACK       #
      XREF PROC DB$PUSH;     # SAVE ITEM IN RCB PUSH-DOWN STACK        #
      XREF PROC DB$TQTD;     # DELETE TQT                              #
      XREF PROC DB$TSCH;     # TERMINATE SCHEMA                        #
      XREF LABEL DB$TSLE;    # LOGGING I-O ERROR MESSAGE               #
      XREF PROC DB$WRP;      # WRAP UP RUN UNIT REQUEST                #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     ATTACHSTATUS           ATTACH STATUS WORD USED FOR CIO ERROR CODE 
* 
*     JFQUEUE                JOURNAL LOG QUEUE
*       JFILEOK                RELEASE THE RECOVERY POINT INTERLOCK.
*       JFQWORD                THE WHOLE QUEUE IS EMPTIED.
* 
*     RCB                    RUN-UNIT COMMAND BLOCK 
*       RCCONTA                CONTINUATION ADDRESS SET FOR ERROR MSG.
*       RCRPTI                 RECOVERY POINT INTERLOCK FLAG IN RCB.
* 
*     SAL 
*       SASCHST                SCHEMA STATUS
* 
* DC  DESCRIPTION 
* 
*     THE ABNORMAL TERMINATION ERROR CODE IS MOVED TO ATTACHSTATUS
*     WHERE IT IS AVAILABLE FOR DB$ERRE TO INSERT IN AN ERROR MESSAGE.
*     AN ERROR MESSAGE TO IDENTIFY THE BAD LOG FILE IS WRITTEN TO THE 
*     OUTPUT FILE BY DB$ERRE IF NOT IN SYSTEM RECOVERY MODE, ELSE TO THE
*     OUTPUT FILE AND CDCS DAYFILE BY DB$AREH.
* 
*     IF THE ERROR IS ON THE TRF OR THE QRF,
*       THE SCHEMA IS SET TO ERROR-DOWN STATUS AND ALL USERS OF THE 
*       SCHEMA ARE TERMINATED.
* 
*     IF THE ERROR IS ON THE JLF,THEN 
*     IF IN SYSTEM RECOVERY MODE
*     THEN
*       SET ERROR BLOCK FILE TYPE FIELD TO INDICATE JLF.
*       SET THE SCHEMA STATUS TO *ERRDOWN*. 
*     ELSE
*       THE JFQUEUE IS EMPTIED. 
*       EACH USER THAT HAS AN ENTRY IN THE JFQUEUE HAS THE CDCS 
*       REQUEST THAT WAS IN PROGRESS ABORTED. 
*       THE JOURNAL LOG IS SWITCHED TO AN ALTERNATE FILE. 
* 
*     DB$DUMP IS CALLED TO PRINT THE DUMP OF THE FET AND I-O BUFFER.
*     THE REQUEST THAT WAS BEING PROCESSED WHEN THE ERROR OCCURRED
*     IS ABORTED IF CDCS IS NOT EXECUTING IN SYSTEM RECOVERY MODE ELSE
*     DB$AREH IS CALLED TO PRINT AN ERROR MESSAGE.
* 
*     IF IT WAS AN INTERNAL TASK, CONTROL IS RETURNED.
 #
  
  
  
# 
*     LOCAL VARIABLES 
# 
      ITEM RPTEXT C(30) = "I-O ERROR CAUSED LOG SWITCH";
      ITEM SAVERCB I;        # SAVE THE RCB POINTER                    #
      ITEM XX I;             # INDUCTION VARIABLE                      #
  
*CALL SRERRDCLS 
  
      ARRAY ERRBLK P(DFSRESIZE);;  # SYSTEM RECOVERY ERROR BLOCK       #
  
      CONTROL NOLIST;        # JFQUEDCLS, FETDCLS                      #
*CALL JFQUEDCLS 
  
      BASED ARRAY FET;
*CALL FETDCLS 
      CONTROL LIST; 
  
  
  
  
#     S T A R T   O F   D B $ I O E R   E X E C U T A B L E   C O D E  #
  
  
      CONTROL IFGR DFFLOP,0;
        DB$FLOP("IOER");     # RECORD FLOW POINT                       #
      CONTROL ENDIF;
  
      P<FET> = FETLOC;
      IF DB$NOS 
      THEN                   # USE APPROPRIATE ERROR CODE FIELD        #
        BEGIN 
        ATTACHSTATUS = FETNOSAT[0]; 
        END 
      ELSE
        BEGIN 
        ATTACHSTATUS = FETNBAT[0];
        END 
  
# 
*     IF CDCS IS EXECUTING IN SYSTEM RECOVERY MODE, SET UP A SYSTEM 
*     RECOVERY ERROR BLOCK TO REPORT THE ERROR VIA DB$AREH. 
# 
      IF SYSRECOVERY
      THEN
        BEGIN 
        P<SRERRBLK> = LOC(ERRBLK);
        SRENUMB[0] = DFSRENFUN;  # FUNCTION ERROR                      #
        SREFUNC[0] = DFSREFNIO;  # FUNCTION IS CIO                     #
        SREFPAR[0] = ATTACHSTATUS;  # CIO ERROR CODE                   #
        END 
  
      IF (SAJLFPTR[SALX] + DFJFET) EQ FETLOC
      THEN
# 
*       THE ERROR WAS ON THE JOURNAL LOG FILE 
# 
        IF SYSRECOVERY       # IF IN SYSTEM RECOVERY MODE              #
        THEN
          BEGIN 
          SREFTYP[0] = DFSREFTJL;  # FILE TYPE IS JOURNAL LOG          #
          SASCHST[SALX] = S"ERRDOWN"; 
          END 
        ELSE
          BEGIN 
          DB$ERRI(82);       # INFO MSG TO CDCS OUTPUT FILE            #
          P<JFQUEUE> = SAJLFPTR[SALX];
          SAVERCB = P<RCB>; 
  
          FOR XX = DFJFLAST STEP -1 UNTIL 0 
          DO
            BEGIN              # SCAN THE JFQUEUE                      #
            IF JFQRCB[XX] NQ 0
            THEN               # TERMINATE ALL WAITING REQUESTS        #
              BEGIN 
              P<RCB> = JFQRCB[XX];
              RCCONTA[0] = LOC(DB$TSLE);
              END 
            JFQWORD[XX] = DFJFQEMPTY;  # EMPTY THE QUEUE               #
            END 
          P<RCB> = SAVERCB; 
          IF NOT JFQSW[0]      # IF NOT ALREADY SWITCHING JOURNAL LOGS #
          THEN
            BEGIN 
# 
*           IF THE CURRENT TASK ALREADY HOLDS THE RECOVERY POINT INTERLOCK
*             RELEASE IT SO THAT A JLF SWITCH CAN BE INITIATED. 
# 
            IF RCRPTI[0]
            THEN
              BEGIN 
              JFILEOK[0] = TRUE;
              RCRPTI[0] = FALSE;
              END 
  
            JFQSW[0] = TRUE;   # INITIATE A LOG FILE SWITCH            #
            DB$PUSH(DB$IOER); 
            DB$JRPT(LOC(RPTEXT)); 
            DB$POP(DB$IOER);
            END 
        END 
  
      ELSE
  
        BEGIN 
        IF (SAQRFPTR[SALX] + DFQRFQFET) EQ FETLOC 
        THEN
          BEGIN 
# 
*         THE ERROR WAS ON THE QUICK RECOVERY FILE. 
# 
          IF SYSRECOVERY
          THEN
            BEGIN 
            SREFTYP[0] = DFSREFTQR;  # FILE TYPE IS QRF                #
            END 
          ELSE
            BEGIN 
            DB$ERRI(85);     # INFO MSG TO CDCS OUTPUT FILE            #
            END 
          END 
        ELSE
          BEGIN 
# 
*         THE ERROR WAS ON THE TRANSACTION RECOVERY FILE. 
# 
          IF SYSRECOVERY     # IF IN SYSTEM RECOVERY MODE              #
          THEN
            BEGIN 
            SREFTYP[0] = DFSREFTTR;  # FILE TYPE IS TRF                #
            END 
          ELSE
            BEGIN 
            DB$ERRI(83);     # INFO MSG TO CDCS OUTPUT FILE            #
            END 
          END 
  
        SASCHST[SALX] = S"ERRDOWN";  # ERROR-DOWN THE SCHEMA           #
        DB$TSCH(LOC(DB$TSLE));
        END 
  
      DB$DUMP(P<FET>,LOC(FET)+DFFETLEN);  # DUMP THE FET               #
      DB$DUMP(FETFIRST[0],FETLIMIT[0]);  # DUMP THE BUFFER             #
  
      IF SYSRECOVERY
      THEN
        BEGIN 
        DB$AREH(LOC(ERRBLK)); #PRINT ERROR MESSAGE                   #
        END 
      ELSE
        BEGIN 
        DB$ERR(84);          # ABORT REQUEST - RETURNS IF NOT TQLTCF   #
        IF LOC(TQT) NQ TQTMTR 
        THEN
          BEGIN 
          DB$TQTD;
          DB$WRP; 
          END 
        END 
      RETURN; 
  
      END 
      TERM
