*DECK DB$JLRS 
USETEXT CDCSCTX 
      PROC DB$JLRS((LENGTH)); 
      BEGIN 
 #
* *   DB$JLRS  - JOURNAL LOG FILE RESERVATION    PAGE  1
* *   R L MCALLESTER                             DATE  09/22/80 
* 
* DC  PURPOSE 
* 
*     RESERVE SPACE ON THE JOURNAL LOG FILE.
*     THE SPACE RESERVATION IS REQUIRED TO BE SURE THAT THERE IS
*     ENOUGH SPACE AVAILABLE ON THE PREALLOCATED FILE FOR THE 
*     ENTIRE TRANSACTION. 
*     IT IS REQUIRED FOR ALL LOG RECORDS - TRANSACTION AND OTHERS.
* 
* DC  ENTRY CONDITIONS
* 
* D   PARAMETERS
# 
      ITEM LENGTH I;         # DATA LENGTH TO BE RESERVED (WORDS)      #
# 
* D   ASSUMPTIONS 
* 
*     P<RCB>                 POINTER TO CURRENT RUN-UNIT COMMAND BLOCK
*     SALX                   SUBSCRIPT TO SCHEMA ACCESS LIST
* 
* DC  EXIT CONDITIONS 
* 
*     JOURNAL LOG FILE SPACE HAS BEEN RESERVED. 
* 
*     ABNORMAL -
* 
*       DB$JRPT WILL DOWN THE SCHEMA AND NOT RETURN WHEN THERE IS 
*       NO OTHER JOURNAL LOG FILE AVAILABLE.
* 
* DC  CALLING ROUTINES
* 
*     DB$JLO                 JOURNAL LOG OUTPUT ROUTINE 
*     DB$TRJL                COPY THE TRANSACTION TO THE JOURNAL LOG
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC DB$FLOP;     # RECORD A FLOW POINT EXECUTION           #
      XREF PROC DB$JRPT;     # JOURNAL LOG RECOVERY PT / FILE SWITCH   #
      XREF PROC DB$POP;      # RETURN A VARIABLE FROM PUSH DOWN STACK  #
      XREF PROC DB$POP2;     # RETURN TWO VARIABLES                    #
      XREF PROC DB$PSH2;     # SAVE TWO WORDS IN RCB PUSH DOWN STACK   #
      XREF PROC DB$PUNT;     # CDCS INTERNAL ERROR                     #
      XREF PROC DB$PUSH;     # SAVE A WORD IN THE RCB PUSH DOWN STACK  #
      XREF PROC DB$SCHD;     # PROCESS OTHER TASKS                     #
# 
* DC  NON-LOCAL VARIABLES MODIFIED
* 
*     JFQUEUE - 
*       JFQWORD              FULL WORD ENTRY DEFINITION 
*       JFQRCB               RCB ADDRESS OF USER
*       JFQLEN               LENGTH OF RESERVATION
*       JFILEOK              TRUE IF NOT CURRENTLY SWITCHING
* 
 #
      CONTROL NOLIST;        # JFQUEDCLS  -  SEE DB$JLCT FOR LIST      #
*CALL JFQUEDCLS 
  
      BASED ARRAY FET;
*CALL FETDCLS 
      CONTROL LIST; 
 #
* 
* DC  DESCRIPTION 
* 
*     IF THERE IS NOT ROOM IN THE QUEUE FOR THIS RESERVATION, STILL 
*     LEAVING ROOM FOR RECORD DESCRIPTORS 
*     OR IF A JOURNAL LOG SWITCH IS IN PROGRESS 
*     THEN CALL DB$SCHD TO WAIT FOR THE END OF THE HINDERING STATUS.
* 
*     THE JFQUEUE IS SCANNED LOOKING FOR THE FIRST EMPTY SLOT.
*     DURING THE SCAN, RESERVED SPACE AND WAITING RECORDS ARE DEDUCTED
*     FROM THE SPACE AVAILABLE. 
*     WHEN THE AVAILABLE SPACE IS EXHAUSTED, INITIATE A LOG FILE SWITCH.
*     THE RESERVATION IS DELAYED UNTIL THE FILE SWITCH IS COMPLETED.
* 
*     WHEN THE SPACE IS AVAILABLE, A RESERVATION ENTRY IS PLACED IN 
*     THE EMPTY SLOT AND AN RCB END-CASE FLAG IS SET TO FORCE THE 
*     RESERVATION TO BE CANCELLED IN THE EVENT THE RUN-UNIT IS DROPPED. 
* 
 #
# 
*     LOCAL VARIABLES 
# 
      ITEM AVAIL I;          # SPACE AVAILABLE                         #
      ITEM CONSLOC I;        # CONSTRAINT LOCATION FOR DB$SCHD CALL    #
      ITEM SAVERCB I;        # SAVE THE CURRENT RCB ADDRESS            #
      ITEM TEXT C(30) = " JOURNAL LOG FILE OVERFLOW ";
      ITEM XA I;             # INDUCTION VARIABLE                      #
  
  
#     B E G I N   D B $ J L R S   E X E C U T A B L E   C O D E .      #
  
      CONTROL IFGR DFFLOP,0;
        DB$FLOP("JLRS");
      CONTROL ENDIF;
  
      RCJLRS[0] = TRUE;      # SET FLAG USED BY DB$RCBF AND DB$TQTD.   #
                             # CLEARED BY DB$JLCT.                     #
JLRS: 
      P<JFQUEUE> = SAJLFPTR[SALX];
      IF LOC(JFQUEUE) EQ 0
      THEN
        BEGIN 
        DB$PUNT("DB$JLRS  1");         # CDCS INTERNAL ERROR, GET DUMP #
        END 
      IF JFQWORD[DFJFNLAST-2] NQ DFJFQEMPTY 
        OR NOT (JFILEOK[0]
                             # THE RECOVERY POINT TASK IS EXEMPT       #
          OR C<0,10>RCIRRUID[0] EQ "RP*TASK   ")
      THEN
        BEGIN 
        DB$PSH2(DB$JLRS,LENGTH);
  
                             # WAIT UNTIL THE RESERVATION CAN BE       #
                             # INSERTED, STILL LEAVING THREE EMPTY     #
                             # SLOTS IN THE QUEUE.                     #
  
        CONSLOC = LOC(JFQWORD[DFJFNLAST-2]);
  
        IF JFQWORD[DFJFNLAST-2] EQ DFJFQEMPTY 
        THEN
          BEGIN              # OR WAIT FOR FILE SWITCH TO COMPLETE     #
          CONSLOC = LOC(JFILEOK[0]);
          END 
        P<JFQUEUE> = DFNPTR;
        P<FET> = DFNPTR;
  
        DB$SCHD(CONSLOC,DFWAITJFOK);
  
        CONTROL IFGR DFFLOP,0;
          DB$FLOP("JLRS-S1"); 
        CONTROL ENDIF;
  
        DB$POP2(LENGTH,DB$JLRS);
        GOTO JLRS;           # BE SURE THAT BOTH CONDITIONS ARE MET    #
  
        END 
      P<FET> = LOC(JFQFET[0]);
      AVAIL = JFQMAX[0]*64 - FETCWA[0] - LENGTH;
  
      FOR XA = 0 STEP 1 WHILE AVAIL GQ 0
      DO
        BEGIN 
  
        IF JFQCODE[XA] EQ DFJFQEMPTY
        THEN
          BEGIN              # CREATE THE RESERVATION ENTRY            #
          JFQWORD[XA] = DFJFQRES; 
          JFQLEN[XA] = LENGTH;
          JFQRCB[XA] = LOC(RCB);
          P<JFQUEUE> = DFNPTR;
          P<FET> = DFNPTR;
          RETURN; 
  
          END 
  
        IF JFQCODE[XA] EQ DFJFQFORCE
          OR JFQCODE[XA] EQ DFJFQNULL 
        THEN
          BEGIN 
          TEST XA;
  
          END 
  
#       IF NOT -FORCE- OR -EMPTY-, THEN IT MUST BE -REC-, -RECF-       #
#         OR -RES-.  REDUCE AVAILABILITY BY RESERVED OR WAITING LENGTH.#
  
        AVAIL = AVAIL - JFQLEN[XA]; 
        END 
  
#     THIS JOURNAL LOG FILE IS FULL.                                   #
#     INITIATE A JOURNAL LOG FILE SWITCH.                              #
#     DB$JRPT WILL INITIATE A RECOVERY POINT AND A FILE SWITCH IF      #
#     JFQSW IS TRUE.                                                   #
#     THE RECOVERY POINT LOG RECORD WILL BE THE FIRST LOG RECORD ON    #
#     THE NEW LOG FILE.                                                #
  
      DB$PSH2(DB$JLRS,LENGTH);
      JFQSW[0] = TRUE;
      DB$JRPT(LOC(TEXT)); 
      DB$POP2(LENGTH,DB$JLRS);
  
#     WHEN THERE IS NO ALTERNATE JOURNAL LOG FILE AVAILABLE, THE       #
#     RECOVERY POINT REQUEST IS TERMINATED.                            #
#     THIS CAUSES MOST REQUESTS TO GO TO DB$ERR AND EXIT THROUGH       #
#     DB$WRP.                                                          #
#     INTERNAL TASKS AND USERS THAT ARE BEING PROCESSED BY DB$TQTD     #
#     HAVE NO LONG TERM CONNECTIONS.  THEY RETURN THROUGH HERE.        #
#     NO RESERVATION SHOULD BE MADE IN THAT CASE.                      #
  
      IF RCCT[0] NQ DFWAITTERM
      THEN
        BEGIN 
        GOTO JLRS;           # MAKE THE RESERVATION ON THE NEW FILE    #
  
        END 
  
      CONTROL IFGR DFFLOP,0;
        DB$FLOP("JLRS-E1");  # ERROR RETURN, RCCT EQ DFWAITTERM        #
      CONTROL ENDIF;
  
      P<JFQUEUE> = DFNPTR;
      P<FET> = DFNPTR;
      RETURN;                # RETURN WITHOUT A RESERVATION            #
  
      END 
      TERM
