COMXMMF 
COMMON
  
#     COMXMMF - MULTIMAINFRAME COMMUNICATIONS FILE DESCRIPTION.       # 
                                               CONTROL NOLIST;
                                               CONTROL IFEQ LISTCON,1;
                                               CONTROL LIST;
                                               CONTROL FI;
  
  
# 
***   COMXMMF - MULTIMAINFRAME COMMUNICATIONS FILE DESCRIPTION. 
* 
*     *COMXMMF* DESCRIBES THE PARAMETERS OF THE *MTOS* AND *STOM* 
*     FILES WHICH ARE USED TO COMMUNICATE BETWEEN THE *SSEXEC*
*     AND THE *SSLVEXEC*. 
* 
*     NOTE - COMMON DECK *COMXIPR* MUST BE CALLED PRIOR TO *COMXMMF*. 
# 
  
      BEGIN  # COMXMMF #
  
      DEF MAXSECS    #O"77777777"#;  # MAXIMUM TIME SINCE DEADSTART # 
  
# 
*     PFN AND PASSWORDS FOR THE *MTOS* AND *STOM* FILES.
# 
  
      DEF MTBSPFN    #"MTBSPFN"#;    # PFN OF THE *MTOS* FILE # 
      DEF MTOSPW     #"MTOSPW"#;     # PASSWORD FOR THE *MTOS* FILE # 
      DEF STOMPFN    #"STBMNO0"#;    # PFN OF THE *STOM* FILE(S) #
      DEF STOMPW     #"STOMPW"#;     # PASSWORD FOR THE *STOM* FILE # 
  
# 
*     LOCAL FILE NAMES USED FOR THE *MTOS* AND *STOM* FILES.
# 
  
      DEF MTOSMLFN   #"MTOSMST"#; 
      DEF MTOSSLFN   #"MTOSSLV"#; 
      DEF STOMMLFN   #"STBMNO0"#; 
      DEF STOMSLFN   #"STOMSO0"#; 
  
  
# 
***   *TDAM* REQUESTS FROM A SLAVE SSEXEC ARE COMMUNICATED TO THE 
*     MASTER SSEXEC BY WRITING THE REQUESTS TO ONE OF SEVERAL 
*     REQUEST BLOCKS ON THE *STOM* FILE.  THIS FILE IS PERIODICALLY 
*     READ BY MASTER SSEXEC TO LOOK FOR *TDAM* REQUESTS.  AFTER 
*     PROCESSING A *TDAM* REQUEST FOR A SLAVE MAINFRAME, THE MASTER 
*     SSEXEC UPDATES THE *MTOS* FILE TO COMMUNICATE THE STATUS OF THE 
*     REQUEST TO THE SLAVE MAINFRAME.  THIS STATUS IS LOCATED IN THE
*     REPLY BLOCK WHICH CORRESPONDS TO THE REQUEST BLOCK. 
* 
*     THE COMPOSITE STATUS OF A REQUEST BLOCK IS DETERMINED BY A SLAVE
*     REQUEST CODE (SRC) IN THE *STOM* FILE ENTRY AND MASTER REPLY CODE 
*     (MRC) IN THE *MTOS* FILE ENTRY.  THE POSSIBLE COMBINATIONS AND
*     SEQUENCE OF TRANSFORMATIONS OF THESE FIELDS FOR AN INDIVIDUAL 
*     REQUEST/REPLY BLOCK ARE DESCRIBED BELOW.
* 
* 
*     **** NORMAL FLOW FOR A STAGE REQUEST. 
* 
*     SRC       MRC          MEANING
* 
*     AVAIL     AVAIL        REQUEST BLOCK IS AVAILABLE FOR A *TDAM*
*                            REQUEST. 
* 
*     SUBMITTED AVAIL        A *TDAM* REQUEST IS PRESENT IN THE REQUEST 
*                            BLOCK. 
* 
*     SUBMITTED ACCEPTED     THE *SSEXEC* HAS RECOGNIZED AND IS 
*                            PROCESSING THE STAGING REQUEST.
* 
*     SUBMITTED FINISHED     THE *SSEXEC* HAS FINISHED PROCESSING THE 
*                            REQUEST.  THE STATUS OF THE COMPLETED
*                            REQUEST IS IN THE REPLY FIELD OF THE REPLY 
*                            BLOCK. 
* 
*     AVAIL     FINISHED     THE *SSLVEXEC* HAS RECOGNIZED THE FINISHED 
*                            STATUS AND HAS PROCESSED THE REPLY CODE. 
* 
*     AVAIL     AVAIL        THE REQUEST BLOCK CAN BE REUSED FOR
*                            ANOTHER *TDAM* REQUEST.
* 
* 
*     **** INITIALIZATION OF THE *SSLVEXEC* CAUSES REQUEST BLOCKS WITH
*          AN *SRC* = *SUBMITTED* TO BE PROCESSED AS FOLLOWS. 
* 
*     SRC       MRC          MEANING
* 
*     SUBMITTED X            REQUEST BLOCK STATUS PRIOR TO
*                            INITIALIZATION OF THE *SSLVEXEC*.
* 
*     CANCEL    X            THE *SSLVEXEC* REQUESTS THAT THE *SSEXEC*
*                            CANCEL A PREVIOUSLY SUBMITTED REQUEST. 
* 
*     CANCEL    FINISHED     THE *SSEXEC* REPLIES THAT THE REQUEST HAS
*                            BEEN CANCELLED.
* 
*     AVAIL     FINISHED     THE *SSLVEXEC* HAS RECOGNIZED THE FINISHED 
*                            STATUS AND WILL BE READY TO USE THIS 
*                            REQUEST BLOCK AS SOON AS THE *MRC* VALUE 
*                            BECOMES *AVAIL*. 
* 
*     AVAIL     AVAIL        THE REQUEST BLOCK IS AVAILABLE FOR REUSE.
* 
* 
*     **** INITIALIZATION OF THE *SSEXEC* CAUSES REQUEST BLOCKS WITH
*          AN *MRC* = *ACCEPTED* TO BE PROCESSED AS FOLLOWS.
* 
*     SRC       MRC          MEANING
* 
*     X         ACCEPTED     REQUEST BLOCK STATUS PRIOR TO
*                            INITIALIZATION.
* 
*     X         FINISHED     THE REQUEST HAS BEEN FINISHED, AND THE 
*                            REPLY FIELD INDICATES THAT IT WAS
*                            ABANDONED. 
* 
*     AVAIL     FINISHED     THE *SSLVEXEC* HAS RECOGNIZED THE FINISHED 
*                            STATUS.
*     AVAIL     AVAIL        THE REQUEST BLOCK CAN BE REUSED. 
# 
  
  
# 
*     SLAVE REQUEST CODE STATUS VALUES. 
# 
  
      STATUS SRC                     # SLAVE REQUEST CODE # 
        AVAIL,                       # REQUEST BLOCK AVAILABLE #
        SUBMITTED,                   # REQUEST SUBMITTED #
        CANCEL,                      # CANCEL PREVIOUS REQUEST #
        SRCEND;                      # END OF STATUS LIST # 
  
# 
*     MASTER REPLY CODE STATUS VALUES.
# 
  
      STATUS MRC                     # MASTER REPLY CODE #
        AVAIL,                       # REQUEST BLOCK AVAILABLE #
        ACCEPTED,                    # REQUEST ACCEPTED # 
        FINISHED,                    # REQUEST FINISHED # 
        MRCEND;                      # END OF STATUS LIST # 
  
# 
*     REPLY ACTION STATUS LIST. 
# 
  
      STATUS REPLY                   # STATUS OF FINISHED REQUESTS #
        OK,                          # COMPLETED NORMALLY # 
        ABANDONED,                   # ABANDONED - HW DELAY # 
        CANCELLED,                   # CANCELLED PER SLAVE REQUEST #
        REPLYEND;                    # END OF STATUS LIST # 
  
# 
*     STATUS VALUES FOR MASTER AND SLAVE EXECS. 
# 
  
      STATUS EXECSTAT                # MASTER/SLAVE EXEC STATUS # 
        ACTIVE,                      # ACTIVE # 
        IDLE,                        # IDLED DOWN # 
        DEAD,                        # TIMED OUT #
        READERR,                     # READ ERROR ON STOM/MTOS FILE # 
        OMIT,                        # SLAVE NOT DEFINED #
        SMF,                         # MASTER IS IN SINGLE MF MODE #
        INITPROB,                    # *MTOS* FILE PROBLEMS DURING
                                       INITIALIZATION # 
        EXECEND;                     # END OF STATUS LIST # 
  
                                               CONTROL EJECT; 
  
  
  
# 
*     DEFINE *STOM* BUFFER IN COMMON. 
*     STOM$BFL = ((NUMRB+1) * RBSIZE + PRULEN-1) / PRULEN * PRULEN+1. 
# 
  
      DEF STOM$BFL   #144#;          # *STOM* BUFFER SIZE # 
  
      COMMON XMMFCOM; 
  
        BEGIN  # XMMFCOM #
                                     # $$ # 
        ITEM $$XMMF$$   C(20) = "****** COMXMMF *****"; 
                                     # $$ # 
  
        ITEM CHAR1      C(1);        # TEMPORARY #
        ITEM CHAR10     C(10);       # TEMPORARY #
        ITEM L$MTOS     U;           # LENGTH OF THE *MTOS* HEADER AND
                                       REPLY BLOCKS # 
        ITEM L$MTOSH    U;           # LENGTH OF THE *MTOS* HEADER #
        ITEM L$STOM     U;           # LENGTH OF THE *STOM* FILE #
  
  
# 
*     RESERVE SPACE IN LABEL COMMON FOR SLAVE COMMUNICATION FILE. 
# 
  
  
  
  
        ARRAY MTOB$FET [0:0] S(RFETL);;  # FET LENGTH # 
  
#     MTOS$BUF = (MAXSLV+1) * 3 + NUMRB * NUMSLV.                     # 
        ARRAY MTOS$BUF [0:3] S(MAXSLV);;  # MTOS BUFFER # 
  
        ARRAY MTOS$BUF1 [1:NUMRB] S(NUMSLV);; 
  
  
        ARRAY STOMM[0:0] S(SFETL);;  # *FET* FOR THE STOM FILE #
  
        ARRAY STOM$BUF [0:0] S(STOM$BFL);;  # STOM BUFFER # 
  
# 
*     *FET*S AND BUFFERS. 
# 
  
        BASED 
        ARRAY MTOSM [0:0] S(RFETL);;  # *FET* FOR THE *MTOS* FILE # 
  
        BASED 
        ARRAY STOMMBUF [0:0] S(1);;  # BUFFER FOR THE *STOM* FILE # 
  
# 
*     MESSAGES. 
# 
  
        ARRAY SLVNSTAT [0:0] S(3);   # STATUS OF SLAVE EXEC-S # 
          BEGIN 
          ITEM SLVN$TEXT  C(00,00,28)  # EXEC - SLAVE N STATUS #
            =[" EXEC - SLAVE N STATUS "]; 
          ITEM SLVN$INDX  C(01,24,01);  # N FROM *SLAVE N* #
          ITEM SLVN$STAT  C(01,36,10);  # IDLE/ACTIVE/OMITTED # 
          ITEM SLVN$END   U(02,48,12)  # END OF LINE #
            =[0]; 
          END 
  
        ARRAY MMFDETAIL [0:0] S(3);  # REASON FOR OMITTING A SLAVE #
          BEGIN 
          ITEM MMFD$TEXT  C(00,00,28)  # REASON FOR OMISSION #
            =["   - TEXT FOR REASON"];
          ITEM MMFD$PROB  C(00,30,23);  # SPECIFIC PROBLEM #
          ITEM MMFD$END   U(02,48,12)  # END OF LINE #
            =[0]; 
          END 
  
        ITEM NXTRB      U;           # IDENTIFIES THE NEXT REQUEST
                                       BLOCK FROM WHICH A STAGE REQUEST 
                                       WILL BE ACCEPTED # 
        ITEM RELOOP     B;           # CONTROLS PASS 2 OF THE *STOM*
                                       SCAN # 
        ITEM SINDX      U;           # INDEX TO THE CURRENT SLAVE # 
        ITEM SLAVECTR   U;           # NUMBER OF DEFINED SLAVE EXECS #
        ITEM STOMBUFL   U;           # LENGTH OF THE *STOM* BUFFER #
  
# 
***   THE *STOM* ARRAY IS USED TO SEND REQUESTS FROM
*     THE SLAVE EXEC TO THE MASTER EXEC.
# 
  
        BASED 
        ARRAY STOMFILE [0:NUMRB] S(RBSIZE); 
          BEGIN 
  
# 
*     ENTRY 0 CONTAINS SLAVE STATUS INFORMATION.
# 
  
          ITEM SM$SSW     U(00,00,60);  # SLAVE STATUS WORD # 
          ITEM SM$IDLE    B(00,00,01);  # SLAVE IDLE, IF TRUE # 
          ITEM SM$SWC     U(00,06,18);  # SLAVE WRITE COUNTER (SWC) # 
          ITEM SM$PDATE   U(00,24,36);  # PDATE WHEN *SWC* UPDATED #
  
          ITEM SM$MIDS    C(01,06,02);  # ID OF SLAVE MAINFRAME # 
          ITEM SM$DELAY   U(01,24,12);  # DELAY (SECONDS) FOR POLLING 
                                          THIS *STOM* # 
          ITEM SM$TIMOUT  U(01,36,24);  # MASTER TIME OUT VALUE # 
  
          ITEM SM$MSW     U(02,00,60);  # MASTER STATUS WORD #
          ITEM SM$STATM   S:EXECSTAT(02,02,04);  # MASTER STATUS, PER 
                                                   SLAVE #
          ITEM SM$MWC     U(02,06,18);  # MASTER EXEC WRITE COUNTER # 
          ITEM SM$REQCTL  U(02,42,18);  # REQUEST CONTROL # 
  
          ITEM SM$CDC1    C(03,00,30);  # RESERVED FOR CDC #
          ITEM SM$SITE1   C(06,00,20);  # RESERVED FOR SITE # 
  
# 
*     ENTRIES 1 TO *NUMRB* CONTAIN REQUEST AND CONTROL INFORMATION. 
# 
  
          ITEM SM$SRC     S:SRC(00,00,03);  # SLAVE REQUEST CODE #
          ITEM SM$CDC2    U(00,03,21);  # RESERVED FOR CDC #
          ITEM SM$PDATERB U(00,24,36);  # PDATE WHEN REQUEST ENTERED #
  
          ITEM SM$SITE2   U(01,00,60);  # RESERVED FOR SITE # 
  
          ITEM SM$TDAM    C(02,00,60);  # TDAM REQUEST #
          END 
  
                                               CONTROL EJECT; 
  
# 
***   THE *MTOS* FILE IS USED TO SEND REPLIES FROM THE
*     MASTER EXEC TO EACH SLAVE EXEC.  IT IS ORGANIZED
*     INTO 2 PARTS - THE HEADER WHICH CONTAINS MASTER 
*     AND SLAVE EXEC STATUS INFORMATION, AND THE
*     REPLY BLOCKS WHICH CONTAIN STATUS ABOUT EACH
*     REQUEST BLOCK.
# 
  
  
# 
*     HEADER PORTION OF THE *MTOS* FILE.
# 
  
        BASED 
        ARRAY MTOSHEAD [0:MAXSLV] S(3); 
          BEGIN 
  
# 
*     ENTRY 0 OF THIS ARRAY CONTAINS MASTER EXEC STATUS.
# 
  
          ITEM MSH$MSW    U(00,00,60);  # MASTER STATUS WORD #
          ITEM MSH$IDLE   B(00,00,01);  # MASTER IDLE, IF TRUE #
          ITEM MSH$MWC    U(00,06,18);  # MASTER WRITE COUNTER (MWC) #
          ITEM MSH$PDATE  U(00,24,36);  # PDATE WHEN *MWC* UPDATED #
  
          ITEM MSH$PFNM   C(01,00,07);  # PFN/LFN OF *MTOS* FILE #
          ITEM MSH$MIDX   U(01,42,06);  # INDEX OF MASTER MAINFRAME # 
          ITEM MSH$MIDM   C(01,48,02);  # ID OF THE MASTER MAINFRAME #
  
          ITEM MSH$NUMSLV U(02,42,06);  # NUMBER OF SLAVE MAINFRAMES #
          ITEM MSH$NUMRB  U(02,48,12);  # NUMBER OF REQUEST BLOCKS #
  
# 
*     ENTRIES 1, 2, AND 3 CONTAIN INFORMATION 
*     ABOUT THE POSSIBLE SLAVE EXECS. 
# 
  
          ITEM MSH$SSW    U(00,00,60);  # SLAVE STATUS WORD # 
          ITEM MSH$STATS  S:EXECSTAT(00,02,04);  # SLAVE STATUS, PER
                                                   MASTER # 
          ITEM MSH$SWC    U(00,06,18);  # SLAVE WRITE COUNTER # 
          ITEM MSH$REQCTL U(00,42,18);  # REQUEST CONTROL # 
  
          ITEM MSH$PFNS   C(01,00,07);  # PFN/LFN OF *STOM* FILE #
          ITEM MSH$MIDS   C(01,48,02);  # ID OF SLAVE MAINFRAME # 
  
          ITEM MSH$DEFD   B(02,00,01);  # SLAVE DEFINED, IF TRUE #
          ITEM MSH$TIMOUT U(02,24,36);  # SLAVE TIME OUT VALUE #
          END 
  
# 
*     REPLY BLOCK PORTION OF THE *MTOS* FILE. 
# 
  
        BASED 
        ARRAY MTOSREPBLK [1:NUMRB] P(1);  # *MTOS* REPLY BLOCK #
          BEGIN 
          ITEM MSR$MRC    S:MRC(00,00,03);  # MASTER REPLY CODE # 
          ITEM MSR$REPLY  S:REPLY(00,03,03);  # STATUS OF FINISHED
                                                REQUESTS #
          ITEM MSR$SSN    U(00,06,18);  # STAGING SEQUENCE NUMBER # 
          ITEM MSR$PDATE  U(00,24,36);  # PDATE WHEN REQUEST COMPLETE # 
          END 
  
        END  # XMMFCOM #
  
      END  # COMXMMF #
  
                                               CONTROL LIST;
