*DECK DB$INIT 
USETEXT CDCSCTX 
      PROC DB$INIT; 
      BEGIN 
 #
* *   DB$INIT -- CDCS INITIALIZER                PAGE  1
* *   C O GIMBER                                 10/10/75 
* *   W P CEAGLIO                                DATE  12/01/78 
* *   R L MCALLESTER         CHANGE ENTRY NAME   DATE  10/08/80 
* 
* 
* DC  PURPOSE 
* 
*     PERFORMS THE CDCS INITIALIZATION FUNCTION.
* 
* DC  CALLED ROUTINES 
# 
      XREF PROC CAPL$RM;     # LOCK IN SELECTED AAM CAPSULES           #
      XREF PROC DB$ABRT;     #ISSUE ABORT MACRO#
      XREF PROC DB$AINT;     #INITIALIZE ACCOUNTING TABLE              #
      XREF PROC DB$ARRO;     #INITIATE AUTOMATIC RECOVERY#
      XREF PROC DB$CAPL;     #LOAD AND LOCK CDCS OVCAPS                #
      XREF PROC DB$CMOH;     #CDCS/CMM OVERFLOW HANDLER#
      XREF FUNC DB$COCB C(10);  # CONVERT INTEGER TO OCTAL DISPLAY     #
      XREF PROC DB$DIDM;     #INITIALIZE DISPLAY MANAGER# 
      XREF PROC DB$MDER;     #MD CRM ERROR PROCESSOR# 
      XREF PROC DB$MFA;      #ALLOCATE FIXED POSITION BLOCK#
      XREF PROC DB$MFI;      #INITIALIZE CMM.OWN EXIT FOR CDCS# 
      XREF PROC DB$MFO9;     #CALL DB$PUNT TO ABORT CDCS# 
      XREF FUNC DB$MGFS;     #GET MAXIMUM AVAILABLE BLOCK SIZE# 
      XREF PROC DB$MPOE;     #ADD CMM OVERFLOW ENTRY TO STACK#
      XREF PROC DB$MSG;      #ISSUE MSG MACRO#
      XREF PROC DB$OLLO;     #LOAD AND LOCK AN OVCAP FOR CDCS DURATION #
      XREF PROC DB$OUAC;     #UNLOAD UNLOCKED OVCAPS                   #
      XREF PROC DB$PUNT;     #CDCS ABORT PROCESSOR# 
      XREF PROC DB$QRF;      #ENTRY POINT USED AS A DB$OLLO PARAMETER  #
      XREF PROC DB$RCBC;     #RCB CREATOR#
      XREF PROC DB$RCVD;     #TAKE A MEMORY DUMP ON ABNORMAL TERMINATN #
      XREF PROC DB$RCVR;     #REPRIEVE/RECOVER PROCESSING              #
      XREF PROC DB$SSIN;     #INITIALIZE AS SYSTEM CONTROL POINT# 
      XREF FUNC DB$STAT;     #RETURN STATUS OF FILE GIVEN LFN#
      XREF PROC DB$TQTC;     #TQT CREATOR#
      XREF PROC DB$WGET;     #READ WA FILE# 
      XREF PROC DB$WOPN;     #OPEN WA FILE# 
      XREF PROC RECOVR;      #FTN CALLABLE RECOVER# 
# 
* DC  CALLING ROUTINES
* 
*     CDCS -- CDCS MAIN PROGRAM 
* 
* DC  NON-LOCAL VARIABLES 
# 
      XREF ARRAY DB$AIRM;;   # PARAMETER LIST FOR CAPL$RM              #
  
      XREF ARRAY DB$RA0;
        BEGIN 
        ITEM ABSPTR  I(00,42,18);  # POINTER AT ABSOLUTE ADDRESS       #
        ITEM CWORD   C(00,00,10);  # CHARACTER DEFINITION OF WORD      #
        ITEM NEXTIDL I(00,00,60); 
        ITEM HIGHLOC I(00,42,18);  # HIGHEST LOCATION OF THE OVERLAY   #
        ITEM OVLAYNO U(00,00,06);  # PRIMARY OVERLAY NUMBER            #
        END 
      XREF ITEM AAM$BL  I;         # THE AAM BL VALUE                  #
      XREF ITEM AAMBLS  B;         # THE AAM BL VALUE IS SET FROM THE  #
                                   # CDCS CONTROL STATEMENT.           #
      XREF ITEM CMMIFL  I;         # INITIAL FIELD LENGTH OF CDCS      #
      XREF ITEM CMMMFL  I;         # MAXIMUM FIELD LENGTH OF CDCS      #
      XREF ITEM CMMSBI  I;         # SMALL BLOCK BOUNDARY INCREMENT    #
      XREF ITEM DB$DNAU I;         # NUMBER OF ACTIVE CDCS USERS       #
      XREF ITEM DB$DNTU I;         # NUMBER OF TOTAL CDCS USERS        #
      XREF ITEM DB$HHAE;           # HIGHEST HIGH ADDR DURING EXECUTION#
      XREF ITEM DB$MFMX;           # MAXIMUM MEMORY AVAILABILITY       #
      XREF ITEM DB$MFPA;           # ADDR OF PROC TO HANDLE MEM OVERFLW#
      XREF ITEM DB$ORCB I;         # ADDRESS OF RCB BASED ARRAY POINTER#
                                   # FOR USE BY COMPASS ROUTINE DB$OSUP#
      XREF ITEM SBITAB  I;         # FIRST WORD OF SMALL BLOCK BOUNDARY#
                                   # GROUP COUNT TABLE. SEE DB$CMOH    #
      XREF ITEM UNDOBUF I;         # POINTER TO A BUFFER TO BE USED    #
                                   # DURING DB$UNDO PROCESSING         #
# 
*     MASTER DIRECTORY FIT
 #
*CALL FITMDDCLS 
 #
# 
      XREF ARRAY DB$FTSW;;   #CDCS SWAP FILE FIT# 
  
      XREF ARRAY DB$SSC;     # SSC COMMUNICATION WORD (RA+51).         #
        BEGIN 
        ITEM SSCWORD U(00,00,60); 
        END 
  
 #
# 
# 
*     LOCAL VARIABLES 
# 
      ITEM BLMSG  C(20) = "  BL SET TO 666666:";
      ITEM COUNT;            #COUNT ON SCHEMA DIRECTORY ENTRIES#
      BASED ARRAY DUMMY;;    #DUMMY BASED ARRAY#
      ITEM INDEX;            #INDEX FOR LOOPS#
      ITEM INDEX2 I;         #INDEX FOR LOOPS#
      ITEM IFLMSG C(30) = "  INITIAL LOAD FL = 666666:";
      ITEM MAXLOG  I;        # MAXIMUM LOG RECORD SIZE IN ALL SCHEMAS  #
      ITEM NUMWRDS I;        # NUMBER OF SDT ENTRY WORDS TO READ       #
      ITEM ORIGHHA I;        # SAVE THE INITIAL HIGHEST HIGH ADDRESS   #
      ITEM UNDOHI  I;        # HIGH ADDRESS OF OVERLAY CD2UNDO         #
  
  
  
#     B E G I N   D B $ I N I T   E X E C U T A B L E   C O D E .      #
 #
* 
* DC  DESCRIPTION 
* 
 #
 #
*     INITIALIZE THE SSC COMMUNICATION WORD (RA+51).
 #
      SSCWORD[0] = 0; 
 #
*     INITIALIZE DB$ORCB FOR DB$OSUP. 
 #
      P<RCB> = LOC(RCBMTR); 
      DB$ORCB = LOC(P<RCB>);
 #
*     SET THE DEFAULT NUMBER OF BUFFERS FOR EACH OPEN 
*     SETTING THIS TO ZERO LETS AAM DETERMINE THE DEFAULT.
 #
      BFNUMBER = 0; 
 #
*     SET THE DEFAULT FIT COUNT OPTION
 #
      FCADJUST = 2;                   # DEFAULT IS (LOG N + 2)         #
 #
*     SET THE DEFAULT PRIORITY BLOCK COUNT
 #
      PBCOUNT = 2;
 #
*     CRACK CONTROL CARD PARAMETERS AND INITIALIZE THE ACCOUNT TABLE. 
 #
      DB$AINT;
 #
*     CREATE MONITOR RCB AND ASSIGN IT HIGH PRIORITY
 #
      IDLERCBP = LOC(RCBMTR);      # LINK MONITOR RCB INTO IDLE CHAIN  #
                                   # WHERE DB$RCBC WILL FIND IT        #
      NEXTIDL[IDLERCBP] = 0;
      INDEX = 0;
      P<RCB> = LOC(INDEX);
      DB$RCBC;
      RCFUNC[0] = DFMTR;
      RCPRIOR[0] = LOC(RCB);
      RCNEXT[0] = LOC(RCB); 
      RCCONSTRA[0] = LOC(STATCOMP); 
      FOR INDEX = 0 STEP 1 UNTIL 4 DO 
        BEGIN 
        RCIR [INDEX] = 0; 
        END 
                      # M O N I T O R      #
      RCIRRUID [0] = O"15171611241722000000"; 
      RCIRVER [0] = DFRQVERSN;
  
      IDLEALTP = 0;                # INITIALIZE IDLE ALT POINTER       #
 #
*     CREATE MONITOR TQT ENTRY. 
 #
      TQTCHAIN = 0; 
      DB$TQTC;
      TQTMTR = LOC(TQT);
      TQRUID[0] = O"15171611241722000000";
 #
*     AFTER CREATING MONITOR TQT, INITIALIZE THE COUNTS FOR ACTIVE AND
*     TOTAL USERS OF CDCS.
 #
      DB$DNAU = 0;                 # INITIALIZE ACTIVE USER COUNT      #
      DB$DNTU = 0;                 # INITIALIZE TOTAL USER COUNT       #
 #
*     INITIALIZE RCB ACTIVE AND IDLE COUNTS.
 #
      RCBIC = 0;
      RCBAC = -4; 
# 
*     SET DISPLAY CODED MARKERS IN CDCSCOMMN. 
*     THESE ARE USEFUL FOR FLAGING LOCATIONS IN A CDCS DUMP.
# 
      CDCSCID = " CDCSCOM  "; 
      ACLID   = "   ACL    "; 
      FKLID   = "   FKL    "; 
      OFTID   = "   OFT    "; 
# 
*     SET THE FKL AND FPT POINTERS TO ZERO. 
# 
      P<FKL> = 0; 
      P<FPT> = 0; 
# 
*     SET THE FIT EXIT ADDRESSES TO ZERO. 
# 
      FTDX2 = 0;
      FTEX2 = 0;
 #
*     THE ORDER OF THE TWO CALLS TO -RECOVR- AND THE INTERVENING
*     CALL TO -CAPL$RM- IS REQUIRED.
*     -CAPL$RM- ALSO MAKES A -RECOVR- CALL SO THAT CRM CAN FLUSH FILE 
*     BUFFERS.
*     THE REPRIEVES ARE TAKEN IN REVERSE ORDER THAT THE -RECOVR- CALLS
*     ARE MADE. 
*     THE RESULTING SEQUENCE OF ABNORMAL TERMINATION REPRIEVES IS...
* 
*       1. -DB$RCVD- TAKES A MEMORY DUMP BEFORE ANY OTHER REPRIEVE. 
*                DOES END PROCESSING ON A NORMAL TERMINATION. 
*       2. CRM REPRIEVE ROUTINE FLUSHES BUFFERS OF OPEN FILES.
*       3. -DB$RCVR- DOES CDCS DIAGNOSTICS AND RETURNS PERMANENT FILES. 
* 
 #
      RECOVR(DB$RCVR,O"177",0); 
 #
*     LOCK IN OPEN/CLOSE AND OTHER DESIGNATED AAM CAPSULES
 #
      CAPL$RM(DB$AIRM); 
  
      RECOVR(DB$RCVD,O"177",0); 
 #
*     ERROR IF MASTER DIRECTORY IS NOT A PERMANENT FILE.
 #
      IF DB$STAT(FTMDLFN[0]) NQ 2 THEN
        BEGIN 
        DB$MSG("  MASTER DIRECTORY MUST BE A PERMANENT FILE.:");
        DB$ABRT;
        END 
 #
*     OPEN MD SCHEMA. 
*     READ MD SCHEMA CONTROL WORDS. 
 #
      DB$WOPN(DB$FTMD,DB$MDER); 
      DB$WGET(DB$FTMD,MDCW,DFMDNUMCW,1,DB$MDER);
 #
*     VERIFY THAT A VALID AND CURRENT MASTER DIRECTORY IS BEING USED. 
*     IF NOT, ABORT INITIALIZATION. 
* 
*     VERIFICATION INVOLVES THE FOLLOWING CONSISTENCY CHECKS--
* 
*       - THE LOCATION AND SIZE OF THE LOG TABLE (MINUS 2) DOES NOT 
*         EXCEED THE LAST WORD OF THE MD
* 
*       - THE LOCATION AND SIZE OF THE PERMANENT FILE TABLE (MINUS 2) 
*         DOES NOT EXCEED THE LAST WORD OF THE MD 
* 
*       - THE LOCATION AND SIZE OF THE SCHEMA DIRECTORY (MINUS 2) DOES
*         NOT EXCEED THE LAST WORD OF THE MD
* 
*       - THE INTERNAL VERSION NUMBER EQUALS THE CURRENT NUMBER 
* 
*       - THE INTERNAL MD IDENTIFIER EQUALS THE CURRENT IDENTIFIER
* 
*       - THE EXTERNAL PRODUCT VERSION EQUALS THE CURRENT VERSION 
* 
 #
      IF MDWAPFN[0] + MDSZPFN[0] - 2 GQ MDWALUWD[0] 
        OR MDSDWA [0] + (MDSDNO[0]*DFMDSCDESIZE) - 2 GQ MDWALUWD [0]
          OR (MDCWVERS [0] NQ DFMDVERSOL
            AND MDCWVERS [0] NQ DFMDVERS) 
        OR MDCWIDNT [0] NQ DFMDIDNT 
          OR (MDCWPROD [0] NQ DFMDPRODOL
            AND MDCWPROD [0] NQ DFMDPROD) 
      THEN
        BEGIN 
        DB$MSG(" CDCS ABORT, INVALID MASTER DIRECTORY :");
        DB$ABRT;
        END 
  
 #
*     COUNT NUMBER OF ENTRIES IN ALL SCHEMA DIRECTORIES.
*       ERROR IF NO SCHEMA ENTRIES IN MD. 
 #
      SALL = MDSDNO [0] - 1;
      IF SALL LS 0  THEN
        BEGIN 
        DB$MSG("  CDCS ABORT, NO SCHEMA ENTRIES IN MASTER DIRECTORY.:");
        DB$ABRT;
        END 
 #
*     GET FIXED BLOCK OF MEMORY FOR SCHEMA DIRECTORY ENTRIES. 
 #
      DB$MFA (DFSALENSIZE*(SALL+1),P<SAL>); 
 #
*     SET NUMBER OF WORDS TO READ FOR EACH SCHEMA DIRECTORY TABLE (SDT) 
*     ENTRY TO THE SMALLER OF THE SAL OR SDT ENTRY SIZE.
*     READ ALL SCHEMA DIRECTORY TABLE ENTRIES INTO MEMORY.
 #
      CONTROL IFLQ DFMDSCDESIZE,DFSALENSIZE;
        NUMWRDS = DFMDSCDESIZE; 
      CONTROL ENDIF;
  
      CONTROL IFLS DFSALENSIZE,DFMDSCDESIZE;
        NUMWRDS = DFSALENSIZE;
      CONTROL ENDIF;
  
      MAXLOG = 0; 
      SALX = 0; 
      COUNT = SALL; 
      FOR INDEX2=0 STEP 1 UNTIL COUNT  DO 
        BEGIN 
        P<DUMMY> = LOC(SAL[SALX]);
        DB$WGET (DB$FTMD,DUMMY,NUMWRDS
                ,MDSDWA[0]+(INDEX2*DFMDSCDESIZE),DB$MDER);
        SASCWD09[SALX] = 0; 
        SASCWD10[SALX] = 0; 
        SASCWD11[SALX] = 0; 
        SASCWD12[SALX] = 0; 
        SASCWD13[SALX] = 0; 
        SASCWD14[SALX] = 0; 
        SASCWD15[SALX] = "** SAL ** ";
        SASCHST[SALX] = S"UP";     # SCHEMA IS INITIALLY UP            #
        SASFINCOMP[SALX] = TRUE;   # SCH SYS FILE INIT NOT IN PROGRESS #
        IF SASCQRF[SALX]
        THEN
          BEGIN 
          DB$OLLO(DB$QRF);   # LOAD AND LOCK THE QUICK RECOVERY OVCAP  #
          END 
        SASCMAXLOG[SALX] = SASCMDMLOG[SALX];
        IF SASCMAXLXL[SALX] 
        THEN
          BEGIN 
          SASCMAXLOG[SALX] = SASCMDMLOG[SALX] * 80; 
          END 
        IF SASCMAXLOG[SALX] GR MAXLOG 
            AND SASCARF[SALX] 
        THEN                 # GET THE MAXIMUM JOURNAL LOG RECORD SIZE #
          BEGIN              # THAT MIGHT PARTICIPATE IN AN UNDO.      #
          MAXLOG = SASCMAXLOG[SALX];
          END 
        SALX = SALX + 1;
        END 
 #
*     CONVERT THE MAXIMUM LOG RECORD SIZE FROM CHARACTERS TO WORDS
 #
      MAXLOG = (MAXLOG +9) /10; 
  
 #
*     CALL DB$CAPL TO LOAD AND LOCK ALL CDCS OVCAPS WHICH THE 
*     USER REQUESTED. 
 #
      DB$CAPL;
 #
*     SET SIZE OF VERSION NAME LIST (VNL) TO USE FOR CDCS.
 #
  
      VNLSIZE = DFVNLCDCS;
      PROC SWERROR; 
      BEGIN 
      DB$PUNT("DB$INIT  "); 
      END 
 #
*     INITIALIZE CMM.OWN EXIT SO CDCS CAN ABORT USER IF CMM 
*     CANNOT SATISFY REQUEST.  ALTERNATIVE IS TO ABORT CDCS.
 #
      DB$MFI; 
 #
*     ESTABLISH CMM OVERFLOW STACK ENTRY
 #
      DB$MPOE(.95,100,DB$CMOH); 
 #
*     INITIALIZE PROCEDURE ADDRESS TO HANDLE MEMORY OVERFLOW
 #
      DB$MFPA = LOC(DB$MFO9); 
 #
*     CALL CMM TO GET MAXIMUM MEMORY AVAILABILITY 
 #
      DB$MFMX = DB$MGFS(1,0); 
 #
*     ESTABLISH THE HIGHEST HIGH ADDRESS (HHA) THAT WILL BE USED
*     AFTER CDCS INITIALIZATION.
*     LOOP THROUGH THE FOL OVERLAY DIRECTORY, FIND THE HIGHEST ADDRESS. 
*     PERFORM A SECOND SCAN TO INCLUDE THE SYSTEM RECOVERY OVERLAYS.
*     THIS IS REQUIRED BECAUSED AN "UP" OF A SCHEMA IN "ERRDOWN"
*     STATUS CAUSES EXECUTION OF THESE OVERLAYS.
 #
      DB$HHAE = 0;
      FOR INDEX = O"112" STEP 2 
        WHILE OVLAYNO[INDEX] NQ O"70" 
      DO
        BEGIN 
        INDEX2 = INDEX;      # SAVE CURRENT INDEX                      #
        IF OVLAYNO[INDEX] EQ O"60"
        THEN
          BEGIN              # LAST WORD ADDRESS +1 OF CD2UNDO         #
          UNDOHI = HIGHLOC[INDEX];
          END 
        IF HIGHLOC[INDEX] GR DB$HHAE
        THEN
          BEGIN 
          DB$HHAE = HIGHLOC[INDEX]; 
          END 
        END 
      FOR INDEX = INDEX2 +2 STEP 2
        WHILE OVLAYNO[INDEX] EQ O"70" 
      DO
        BEGIN                # LOOP THROUGH SYSTEM RECOVERY OVERLAYS   #
        IF HIGHLOC[INDEX] GR DB$HHAE
        THEN
          BEGIN 
          DB$HHAE = HIGHLOC[INDEX]; 
          END 
        END 
 #
*     INITIATE SYSTEM RECOVERY. 
 #
      DB$ARRO;               # INITIATE SYSTEM RECOVERY                #
 #
*     INITIALIZE THE POINTER TO LOG RECORD BUFFER USED BY DB$UNDO 
 #
      ORIGHHA = HIGHLOC[O"104"];
      IF (UNDOHI + MAXLOG) GR ORIGHHA 
      THEN
        BEGIN                # BUFFER WONT FIT, ALLOCATE ONE           #
        DB$MFA(MAXLOG,UNDOBUF); 
        FOR INDEX = (UNDOBUF + MAXLOG -1) STEP -1 UNTIL UNDOBUF 
        DO
          BEGIN 
          CWORD[INDEX] = " UNDO-BUF ";
          END 
        END 
      ELSE
        BEGIN                # BUFFER IS IN THE OVERLAY AREA           #
        UNDOBUF = UNDOHI; 
        IF (UNDOHI + MAXLOG) GR DB$HHAE 
        THEN
          BEGIN              # BE SURE TO LEAVE ROOM FOR IT            #
          DB$HHAE = UNDOHI + MAXLOG;
          END 
        END 
 #
*     INITIALIZE THE OPERATOR DISPLAY MANAGER.
 #
      DB$DIDM;
 #
*     SET INITIAL FIELD LENGTH. 
*     SEND INITIAL FL MESSAGE TO THE DAYFILE. 
 #
      CMMIFL = ABSPTR [ -ABSPTR[O"65"] ]; 
      C<20,6>IFLMSG = DB$COCB(CMMIFL,6);
      DB$MSG(IFLMSG); 
 #
*     IF NOT SET BY DB$AINT,
*       COMPUTE THE DEFAULT BL FOR AAM AND RECORD IT ON THE DAYFILE.
 #
      IF NOT AAMBLS 
      THEN
        BEGIN 
        AAM$BL = (CMMMFL - CMMIFL +O"11000") / 2**10 * 2**9;
        C<12,6>BLMSG = DB$COCB(AAM$BL,6); 
        DB$MSG(BLMSG);
        END 
 #
*     ADJUST INITIAL FIELD LENGTH FOR DB$CMOH TO USE AS A MINIMUM 
*     SMALL BLOCK BOUNDARY. 
 #
      CMMIFL = CMMIFL + 2 * CMMSBI; 
      SBITAB = CMMIFL + CMMSBI; 
 #
*     UNLOAD ALL UNLOCKED OVCAPS. 
 #
      DB$OUAC;
 #
*     THERE ARE TWO RCB ENTRIES.
*     BE SURE THAT WE ARE NOT USING THE MONITOR RCB.
*     REVISE THE SYSTEM RECOVERY RCB TO BE USED AS A RECEIVING RCB
*     FOR THE FIRST REQUEST AFTER ENTERING SYSTEM CTL PT STATUS.
 #
      IF P<RCB> EQ LOC(RCBMTR)
      THEN
        BEGIN 
        P<RCB> = RCNEXT[0]; 
        END 
      RCCONSTRA[0] = LOC(STATBUSY); 
      RCCT[0] = DFWAITINP;
 #
*     INITIATE SYSTEM CONTROL POINT STATUS, USING THE NEW RCB LOCATION. 
 #
      DB$SSIN(LOC(RCB)+DFRCIR0, DFINRQBFSIZE+2);
      P<RCB> = LOC(RCBMTR); 
 #
*     ISSUE CDCS INITIALIZATION COMPLETE MESSAGE. 
 #
      DB$MSG("  CDCS INITIALIZATION COMPLETE.:"); 
      RETURN; 
      END 
      TERM; 
