*DECK DB$UNDU 
USETEXT CDCSCTX 
      PROC DB$UNDU; 
      BEGIN 
 #
* *   DB$UNDU - DB$UNDO INTERFACE                PAGE  1
* *   P A MURRAY                                 DATE  03/24/81 
* *   R L MCALLESTER                             DATE  08/02/82 
* 
* DC  PURPOSE 
* 
*     THIS IS AN INTERFACE ROUTINE TO DB$UNDO.
*     IT CONTAINS INTERRUPTIBLE PORTIONS AND DB$ERR CALLS.
*     THIS PERMITS DB$UNDO TO RESIDE IN AN OVERLAY. 
* 
* DC  ENTRY CONDITIONS
* 
*     P<TQT> IS SET FOR THE CURRENT RUN-UNIT. 
* 
* DC  EXIT CONDITIONS 
* 
*     DB$UNDO HAS BEEN CALLED TO BACK OUT UNCOMMITTED TRANSACTIONS. 
* 
* DC  CALLING ROUTINES
* 
*     DB$DRP$      DROP TRANSACTION SYMBIONT
*     DB$LOK       LOCK MANAGER (DEADLOCK DETECTION)
*     DB$TQTD      TASK (RUN-UNIT) NORMAL/ABNORMAL TERMINATION
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$AREH;           # AUTO-RECOVERY ERROR MESSAGES      #
      XREF PROC DB$ERR;            # CDCS ERROR MESSAGES               #
      XREF PROC DB$FLOP;           # RECORD A FLOW POINT               #
      XREF PROC DB$MBA;            # ALLOCATE TEMPORARY BUFFER         #
      XREF PROC DB$MBF;            # FREE TEMPORARY BUFFER             #
      XREF PROC DB$UNDO;           # BACK OUT UNCOMMITTED TRANSACTION  #
      XREF PROC DB$POP;            # RESTORE A VARIABLE FROM THE STACK #
      XREF PROC DB$PUSH;           # SAVE A VARIABLE IN THE RCB STACK  #
      XREF PROC DB$SCHD;           # SCHEDULE OTHER USERS              #
      XREF PROC DB$TSCH;           # TERMINATE SCHEMA USERS            #
      XREF PROC DB$WART;           # WRITE AUTO-RECOVERY TABLE         #
# 
* DC  EXTERNAL LABELS REFERENCED
# 
      XREF LABEL DB$MMER;          # TERMINATION OF USER ON A MEMORY   #
                                   # OVERFLOW                          #
      XREF LABEL DB$TRER;          # TRF I-O ERROR                     #
# 
* DC  LOCAL VARIABLE EXTERNALLY DEFINED 
# 
      XDEF ITEM UNDOBUF;           # POINTER TO THE LOG RECORD BUFFER  #
                                   # USED DURING DB$UNDO PROCESSING    #
                                   # DEFINED IN DB$UNDU INSTEAD OF     #
                                   # DB$UNDO BECAUSE DB$UNDU RESIDES   #
                                   # IN OVERLAY 0,0                    #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     NONE
* 
* DC  DESCRIPTION 
* 
*     DB$UNDO IS USED DURING SYSTEM RECOVERY AND ALSO DURING CDCS 
*     EXECUTION TO BACK OUT A TRANSACTION THAT HAS NOT BEEN COMMITTED.
* 
*     DB$UNDU IS THE CDCS EXECUTION TIME INTERFACE THAT ALLOWS DB$UNDO
*     TO RESIDE IN AN OVERLAY.
* 
*     BEFORE CALLING DB$UNDO BE SURE THAT NONE OF THE OTHER TRF FET'S 
*     ARE CURRENTLY IN USE. 
*     DB$UNDO IS NON-INTERRUPTIBLE, SO IT WILL RETAIN ACCESS TO THE 
*     TRF FET UNTIL THE TRANSACTION IS BACKED OUT.
* 
*     AFTER RETURN FROM DB$UNDO, DB$UNDU CHECKS FOR ERROR STATUS
*     AND PROCESSES THE ERRORS IF NECESSARY.
*     IT THEN WRITES THE ART TO THE TRF.
* 
 #
  
      CONTROL NOLIST;              # CALL SRERRDCLS                    #
*CALL SRERRDCLS 
      CONTROL LIST; 
# 
*     LOCAL VARIABLES 
# 
      BASED ARRAY FET;
        BEGIN 
        ITEM FETCOMP  B(00,59,01);  # FET COMPLETION BIT               #
        END 
  
  
  
#     B E G I N   D B $ U N D U   E X E C U T A B L E   C O D E        #
  
  
      DB$PUSH(DB$UNDU); 
  
      P<FET> = SATRFPTR[SALX];
      IF NOT FETCOMP[0] 
      THEN                   # WAIT FOR ACCESS TO A TRF FET            #
        BEGIN 
  
#       THE FOLLOWING DB$SCHD CALL HAS A NEGATIVE PARAMETER TO INDICATE#
#       THAT THE ADDRESS POINTED TO BY SATRFPTR IS WHERE THE COMPLETION#
#       BIT MUST BE FOUND.  THIS INDIRECTION IS NECESSARY BECAUSE THE  #
#       POINTER MAY POINT TO SEVERAL FETS BEFORE ALL                   #
#       OUTSTANDING I/O ON THE TRF IS COMPLETE.                        #
  
        DB$SCHD(-LOC(SATRFPTR[SALX]), DFWAITLOG); 
  
        CONTROL IFGR DFFLOP,0;
          DB$FLOP("UNDU-S1"); 
        CONTROL ENDIF;
  
        END 
      DB$MBA(DFSRESIZE,P<SRERRBLK>);
      DB$UNDO(TQARTX[0],P<SRERRBLK>); 
  
#     CHECK FOR ERROR STATUS                                           #
  
      IF SRENUMB[0] NQ 0
      THEN
        BEGIN 
        IF SRENUMB[0] EQ DFSRENARB
        THEN
          BEGIN              # AN AREA ERROR OCCURRED                  #
          DB$ERR(78);        # ABORT CURRENT RUN UNIT                  #
                             # RETURNS ONLY WHEN CALLED BY DB$TQTD     #
          END 
        ELSE
          BEGIN 
          DB$AREH(P<SRERRBLK>);  # WRITE TO CDCS OUTPUT AND DAYFILE    #
  
          IF SRENUMB[0] EQ DFSRENMEM
          THEN
            BEGIN            # A MEMORY ERROR OCCURRED                 #
            DB$TSCH(LOC(DB$MMER));
            DB$ERR(79); 
            END 
          ELSE
            BEGIN            # A TRF I-O ERROR OCCURRED                #
            DB$TSCH(LOC(DB$TRER));
            DB$ERR(80); 
            END 
          END 
        END 
      DB$WART;               # WRITE AUTO RECOVERY TABLE TO TRF        #
      DB$MBF(P<SRERRBLK>);
      DB$POP(DB$UNDU);
      RETURN; 
  
      END 
      TERM
