IDENT 1MB,/1MB/MEP PERIPH BASE MIXED SST SSCP *COMMENT 1MB - HARDWARE ERROR PROCESSOR. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. TITLE 1MB - HARDWARE ERROR PROCESSOR. SPACE 4,10 *** 1MB - HARDWARE ERROR PROCESSOR. * J. D. LANGE. 74/05/10. * C. R. LUND. 80/01/07. * P. J. ENGLE. 84/09/10. * M. S. PESCHMAN 85/07/24. SPACE 4,30 *** EITHER *1MB* OR *1SC* IS CALLED BY THE SYSTEM MONITOR * TO PERFORM FUNCTIONS WHICH CAN NOT BE PROCESSED BY THE * MONITOR. * FOR MAINFRAMES WITH MAINTENANCE REGISTERS, ERRORS ARE * PROCESSED BY *1MB* IN ROUTINE *MEP*. CORRECTED MEMORY * ERRORS ARE HANDLED COMPLETELY BY *1MB* WHO BUILDS THE TABLE * OF UNIQUE ID-S AS IS DONE FOR SECDED ERRORS. * *1SC* PERFORMS SCR PROCESSING ON FATAL SCR ERRORS * AND ON UNIQUE SECDED ERRORS ONLY. *1SC* FIRST CHECKS FOR * FATAL ERRORS, AND (IF NONE HAVE OCCURRED) THEN INCREMENTS * THE APPROPRIATE COUNTER IN CM WORD *SCRL* FOR UNIQUE * SECDED ERRORS, CLEARS THE ERROR BIT IN THE SCR, AND DROPS * THE PP. IF MONITOR HAS DETERMINED THAT A SECDED ERROR * WAS NOT UNIQUE (I.E. - THE ERROR WAS CAUSED BY THE SAME * MEMORY LOCATION PREVIOUSLY THAT HOUR), MONITOR WILL * INCREMENT THE APPROPRIATE COUNTERS IF THOSE COUNTERS HAVE * NOT EXCEEDED THEIR THRESHOLDS. WHEN MONITOR HAS * FINISHED PROCESSING NON-UNIQUE ERRORS, IT WILL CLEAR * THE SECDED ERROR BIT AND CONTINUE IN ITS PROCESSING LOOP. * IN A SYSTEM EXPERIENCING FREQUENT SINGLE BIT SECDED * ERRORS, THIS PROCESS OF CHECKING FOR ERROR UNIQUENESS IN * MONITOR WILL REDUCE THE NUMBER OF CALLS TO *1SC* TO A * MAXIMUM OF *UIDL* PER HOUR (SEE *COMSSCR*). * FOR CYBER 176 MACHINES, LCME SINGLE BIT SECDED * ERRORS ARE PROCESSED IN A SIMILAR MANNER. * FOR MAINFRAMES WITH AN ESM MAINTENANCE PORT * DEFINED, *2TH* WILL LOG THE CONTENTS OF THE ESM * SECDED LOG TO THE BML AT THE END OF EVERY HOUR. * SCR PROCESSING AND TERMINOLOGY IS ALSO USED TO * REFER TO CYBER 170 - 865/875 MAINTENANCE REGISTERS. SPACE 4,10 **** DIRECT LOCATION ASSIGNMENTS. T8 EQU 16 TEMPORARY T9 EQU 17 TEMPORARY CN EQU 20 - 24 CM BUFFER (5 LOCATIONS) WB EQU CN - CN+4 FOR *COMPIMB* COMPATIBILITY MF EQU 25 MACHINE FLAG NB EQU 26 NUMBER OF PP BYTES IN *BML* MESSAGE PN EQU 27 PP NUMBER * 100B SC EQU 30 - 34 S/C PARAMETER WORD *SCRL* (5 LOCATIONS) MI EQU 60 - 64 MAINFRAME IDENTIFICATION EM EQU 65 LAST MASS STORAGE EST ORDINAL + 1 ** DIRECT CELLS FOR STATUS AND CONTROL REGISTER PROCESSING. QUAL 1SC CH EQU 40 - 41 S/C REGISTER CHANNELS ER EQU 42 NUMBER OF S/C REGISTER ERRORS NP EQU 43 NUMBER OF PP-S IN SYSTEM NW EQU 44 NUMBER OF CM WORDS IN *BML* MESSAGE QUAL * ** DIRECT CELLS FOR MAINTENANCE REGISTER PROCESSING. QUAL 1MB BP EQU 40 NEXT WORD IN *BML* MESSAGE TO USE EC EQU 41 ELEMENT ACCESS CODE MB EQU 42 - 43 M/R BUFFER CONTROL WORD ADDRESS MS EQU 44 - 45 M/R BUFFER ADDRESS RN EQU 46 REGISTER NUMBER DC EQU 60 - 64 *DFT* CONTROL WORD QUAL * **** SPACE 4,10 * ASSEMBLY CONSTANTS. QUAL$ EQU 0 DO NOT QUALIFY COMMON DECKS MF70 EQU 0 CYBER 70 ERRNZ MF70 CODE DEPENDS ON ZERO VALUE MF170 EQU 1 CYBER 170 MF700 EQU 2 CYBER 170 - 700 SERIES MF865 EQU 3 CYBER 170 - 865 MF875 EQU 4 CYBER 170 - 875 MF180 EQU 5 CYBER 180 CLASS MACHINE MF176A EQU 6 CYBER 176 LEVEL A MF176B EQU 7 CYBER 176 LEVEL B MFMAX EQU 10B MAXIMUM MAINFRAME TYPE + 1 TITLE COMMON SUBROUTINES. COMMON SPACE 4,10 ** COMMON - COMMON CODE FOR *1MB* AND *1SC*. * * THIS MACRO PROVIDES SIMILAR CODE FOR *1MB* AND *1SC*. COMMON MACRO COMMON RMT CKC SPACE 4,10 ** CKC - CHECK FOR *1CK* COMPLETE. * * ENTRY (SC+2) = *1CK* IR ADDRESS. * * EXIT *1CK* COMPLETE. * * USES CM - CM+4. CKC SUBR ENTRY/EXIT CKC1 LDD SC+2 READ *1CK* IR CRD CM LDD CM+1 SCN 77 SHN 6 LMD CM LMC 3RK1C NJN CKCX IF *1CK* COMPLETE UJN CKC1 LOOP CKP SPACE 4,15 ** CKP - CHECKPOINT SYSTEM. * * ENTRY (SC+2) = *1CK* IR ADDRESS. * * EXIT EXITS TO *1CK* ON INITIAL CALL. * CHECKPOINT IN PROGRESS BIT SET IN *EICB*. * * USES CM - CM+4, SC+2. * * CALLS /1MB/DSP, *1CK*. * * MACROS EXECUTE. CKP SUBR ENTRY/EXIT LDD SC+2 CHECK FOR *1CK* ALREADY CALLED NJN CKPX IF *1CK* ALREADY CALLED .A IFC EQ,/"QUAL"/1MB/ RJM /1MB/DSP GET *EICB* POINTER ZJN CKP1 IF NO *EICB* ADN D7ST CRD CM READ STATUS WORD LDD CM SCN 4 LMN 4 SET CHECKPOINT IN PROGRESS STD CM RJM /1MB/DSP ADN D7ST CWD CM .A ENDIF CKP1 EXECUTE 1CK,= LDD IA CALL *1CK* CWM CKPA,ON SCN 7 STD SC+2 LDM CKPA+2 LMN 10 CKP2 ZJP DPP3 IF TO RECALL *1MB* LMN 11&10 ZJN CKP2 IF TO RECALL *1MB* LMN 13&11 ZJN CKP2 IF TO RECALL *1MB* LJM DPP2 EXIT TO *1CK* AND ENABLE *1MB* CALL CKPA VFD 18/0L1CK,6/0,12/1,24/0 SYSTEM CHECKPOINT CALL CSH SPACE 4,10 ** CSH - CHECKPOINT SYSTEM, SET STEP, AND HANG. * * ENTRY AT *CSH1* FOR CYBER 176 DOUBLE BIT *SECDED* ERROR. * * CALLS CKC, CKP, RSM. CSH SUBR ENTRY (DOES NOT RETURN) .A IFC EQ,/"QUAL"/1MB/ RJM /1MB/DPR DUMP PP REGISTERS .A ENDIF RJM CKP ATTEMPT SYSTEM CHECKPOINT LDD CP ADN MS2W DISPLAY * FATAL ERROR.* MESSAGE CWM CSHM,TR CSHA EQU *-1 (MESSAGE ADDRESS) RJM CKC WAIT FOR *1CK* TO FINISH .A IFC EQ,/"QUAL"/1MB/ RJM /1MB/DPR DUMP PP REGISTERS .A ENDIF CSH1 RJM RSM STEP SYSTEM CSH2 LDD CP DISPLAY *FATAL ERROR* MESSAGE AGAIN ADN MS2W CWM CSHM,TR CSHB EQU *-1 (MESSAGE ADDRESS) DELAY 5*8D DELAY 5 SECONDS (FOR OTHER MESSAGES) UJN CSH2 DISPLAY MESSAGE AGAIN DPP SPACE 4,20 ** DPP - DROP PP. * * ENTRY (SC - SC+4) = *SCRL* WORD WITH MONITOR LOCK-OUT BIT * SET. * * EXIT (SC - SC+4) = *SCRL* WORD WITH MONITOR LOCK-OUT BIT * CLEARED. * = WRITTEN TO CENTRAL MEMORY. * PP DROPPED. * 16-BIT INSTRUCTIONS CLEARED, IF PRESENT. * EXIT TO *PPR*. * * NOTE THE *DPPM* FUNCTION IN THIS ROUTINE IS * EXECUTED OUT OF NORMAL ORDER TO PREVENT * PP SATURATION WHEN *1MB* IS STEPPED * ON A *DPPM*. .A IFC EQ,/"QUAL"/1MB/ DPP5 LJM LED RELOAD DFT FOR SECOND TOP OF HOUR .A ENDIF DPP MONITOR DPPM DROP PP DPPA EQU DPP * UJN DPP5 (SECOND PASS TOP OF HOUR) DPP1 LDN 0 CLEAR *1CK* IR ADDRESS STD SC+2 DPP2 LDD SC CLEAR MONITOR LOCK-OUT BIT LPC 3777 STD SC DPP3 LDC SCRL UPDATE *SCRL* CWD SC .A IFC EQ,/"QUAL"/1MB/ DPPB LDN 0 * LDN 1 (16-BIT INSTRUCTIONS PRESENT) ZJN DPP4 IF NO 16-BIT INSTRUCTIONS RJM CPM CLEAR PP MEMORY LDC 400000B+LINS ADDRESS OF INSTRUCTION TABLE RJM DLI CLEAR 16-BIT INSTRUCTIONS .A ENDIF DPP4 LJM PPR EXIT TO PP RESIDENT IBM SPACE 4,10 ** *BML* MESSAGE BUFFER. IBMF VFD 12/0,12/0,6/0,6/0,24/0 MESSAGE ID/SYMPTOM CODE IBMG VFD 12/0,9/0,1/0,2/0,36/0 MESSAGE CONTINUATION BIT IBMH VFD 60/0 BML MESSAGE BUFFER (4 CM WORDS) VFD 60/0 VFD 60/0 VFD 60/0 IBMHL EQU * END OF BML BUFFER RSM SPACE 4,10 ** RSM - REQUEST STEP MODE. * * ENTRY (SC - SC+4) = (SCRL). * * EXIT STEP MODE SET. * * USES CM - CM+4, SC - SC+4. * * MACROS MONITOR. RSM SUBR ENTRY/EXIT LDD SC SHN 21-11 MJN RSMX IF STEP ALREADY REQUESTED LDD TH SET REQUEST BIT AND WRITE SCRL RAD SC LDC SCRL CWD SC LDD SC SHN 21-10 MJN RSMX IF STEP SET LDN 0 CLEAR EJT ORDINAL STD CM+2 LDN DPPM STEP ON DROP PP STD CM+3 LMD TH STD CM+4 LDN ESPS SET EMERGENCY STEP SUBFUNCTION STD CM+1 MONITOR DSRM SET STEP MODE LDC SCRL READ *SCRL* CRD SC UJN RSMX RETURN COMMON RMT COMMON ENDM SPACE 4,10 * MACROS. TBLM SPACE 4,10 ** TBLM - CREATE TABLE ENTRY MACRO. * *NAM TBLM * * ENTRY NAM = TABLE NAME. * * EXIT NAM_E MACRO DEFINED. PURGMAC TBLM MACRO TBLM,NAM PURGMAC NAM_E NAM_E MACRO ADDR LOCAL A MACREF NAM_E NOREF A A EQU ADDR T_NAM RMT CON A RMT TBLM ENDM EMBE SPACE 4,10 ** EMBE - ERROR MESSAGE TABLE ENTRY. * * THIS MACRO GENERATES AN ENTRY IN REMOTE LIST *TEMB* * THAT CONTAINS THE ADDRESS OF AN INSTRUCTION WHICH * REQUIRES THE FWA OF THE ERROR MESSAGE TABLE. * * EMBE ADDR * * ENTRY (ADDR) = ADDRESS OF INSTRUCTION. * * EXIT ADDRESS IS ADDED TO THE REMOTE BLOCK *TEMB*. EMB TBLM SPACE 4,10 RPTR SPACE 4,15 ** RPTR - CONVERT ADDRESS FROM R-REGISTER FORMAT. * * RPTR DC,ADDR * * ENTRY *DC* = DIRECT CELL LOCATION OF R-REGISTER FORMAT * ADDRESS (R-UPPER IN *DC*+1 IS ASSUMED = 0). * *ADDR* = LOCATION TO STORE CONVERTED ADDRESS. * * EXIT (ADDR - ADDR+1) = CONVERTED ADDRESS. * (A) = CONVERTED ADDRESS, IF *ADDR* NOT SPECIFIED. PURGMAC RPTR RPTR MACRO D,A LDD D+2 R-LOWER SHN 6 LMD D OFFSET .A IFC NE,$A$$ STM A+1 SHN -14 RAM A .A ENDIF RPTR ENDM ** COMMON DECKS. *CALL COMPMAC RICHI$ BSS 0 *CALL COMPCHI *CALL COMPIOU *CALL COMPMRM *CALL COMSCPS *CALL COMSDFS LIST X *CALL COMSDFT LIST * QUAL DSL *CALL COMSDSL QUAL * *CALL COMSDST *CALL COMSEVT *CALL COMSIOU *CALL COMSMSC QUAL MSP *CALL COMSMSP QUAL * *CALL COMSMST *CALL COMSPIM *CALL COMSREM QUAL SSD *CALL COMSSSD QUAL * LIST X *CALL COMSSCR LIST * QUAL 1DS *CALL COMS1DS QUAL * TITLE MAINTENANCE REGISTER PROCESSING. *** MEP - MAINTENANCE CHANNEL ERROR PROCESSOR. * * *MEP* IS THE MAIN DRIVER THAT PROCESSES THE LOGGING OF ERRORS * THAT WERE DETECTED BY *DFT*. *1MB* IS CALLED BY *MTR* TO * LOAD *DFT* IN THE NON-DEDICATED CASE. *1MB* WILL REACT TO * THE OS ACTION CODES SUPPLIED BY *DFT* AND LOG THE MAINTENANCE * REGISTERS TO THE *BML*. SPACE 4,10 *** DAYFILE MESSAGES. * * * * 1MB - CALL ERROR.* = *1MB* WAS CALLED WITH AN ILLEGAL * FUNCTION BIT CODE. SPACE 4,20 *** SYSTEM CONTROL POINT MESSAGES. * * * HH.MM.SS ERR=DEMMXXXXXXXX * * HH.MM.SS = TIME THE ERROR WAS DETECTED, IF VERSION 4 OR ABOVE * *DFT* AND THE TIME WAS AVAILABLE FROM THE WALL * CLOCK CHIP. * = TIME THE ERROR WAS LOGGED BY *1MB*, IF *DFT* * VERSION 3, OR THE TIME WAS NOT AVAILABLE TO *DFT*. * * E = ELEMENT SPECIFIER. * = C, FOR PROCESSOR 0. * = D, FOR PROCESSOR 1. * = I, FOR IOU 0. * = J, FOR IOU 1. * = M, FOR MEMORY. * = A, FOR *DFT* INTERNAL ERROR. * * MM = MODEL NUMBER OF THE SPECIFIED ELEMENT. * THIS FIELD IS NOT PRESENT IF THE ELEMENT SPECIFIER IS * *A*. * * XXXXXXXX = MODEL DEPENDENT DATA FURTHER DESCRIBING THE ERROR. * THIS NORMALLY CONSISTS OF THE THREE CHARACTER * *DFT* ANALYSIS CODE. * * * IN THE FOLLOWING MESSAGES, THE HEXADECIMAL NUMBER IN THE * MESSAGE IS THE *DFT* ANALYSIS CODE WHICH CAUSED THE MESSAGE. * * *(204) FATAL CPU ERROR* * *(215) FATAL MCH ERROR* * * THE FOLLOWING MESSAGE IS POSTED WHEN A POWER OR ENVIRONMENT * WARNING HAS CLEARED. * * *POWER/ENVIRONMENT NORMAL* SPACE 4,10 ORG PPFW QUAL 1MB MEP BSS 0 ENTRY LJM MEP1 PRESET * GLOBAL STORAGE. DFTV CON 0 *DFT* VERSION (0 = VERSION 3) SSCW CON 0,0 SUPPORTIVE STATUS CONTROL WORD ADDRESS SPACE 4,10 ** COMMON SUBROUTINES. COMMON LIST D COMMON HERE LIST * SPACE 4,10 * COMMON DECKS WITH NO 16-BIT INSTRUCTIONS. *CALL COMPMRA *CALL COMPACS *CALL COMT8AD SPACE 4,10 * SYSTEM CONTROL POINT MESSAGES. MSFS DATA 28C HH.MM.SS.ERR=XXXXXXXXXXXX CSHM EQU MSFS DEFAULT *CSHM* MESSAGE MSCP DATA C*(204) FATAL CPU ERROR* MSME DATA C*(215) FATAL MCH ERROR* MSPN DATA C*POWER/ENVIRONMENT NORMAL* TOSC SPACE 4,10 ** TABLE OF OS ACTION CODES. TOSC INDEX INDEX EWAC,ENW ENVIRONMENT WARNING INDEX LPAC,LPW LONG POWER WARNING INDEX SPAC,SPW SHORT POWER WARNING INDEX WCAC,WCL WARNING CLEAR INDEX FIAC,FIE FATAL IOU ERROR INDEX NVAC,NIE NOS/VE IOU ERROR INDEX UMAC,MEP6 FATAL CM ERROR INDEX MBAC,MOB MULTIPLE ODD BIT ERROR INDEX UPAC,MEP6 FATAL CPU ERROR INDEX UIAC,FIE UNCORRECTED IOU ERROR INDEX MXAC TDFA SPACE 4,10 ** TDFA - TABLE OF *DFT* ANALYSIS CODES. * *T 12/ *DFT* CODE, 12/ ACTION, 12/ ROUTINE * * FOR *DFT* VERSION 4, OR ABOVE THE PROCESSING ROUTINE IS * SELECTED BY FINDING A TABLE ENTRY WITH A *DFT* ANALYSIS CODE * AND OS ACTION CODE MATCHING THOSE PASSED BY *DFT*. IF NO * MATCH IS FOUND, ROUTINE *MSC* WILL BE SELECTED. THE TABLE * MUST BE IN ASCENDING ORDER BY ANALYSIS CODE. TDFA BSS 0 CON 4,S7AC,FIE C170 UNCORRECTED IOU ERROR (NIO PP) CON 4,S8AC,NIE C180 UNCORRECTED IOU ERROR (NIO PP) CON 6,SSAC,FIE FATAL IOU ERROR (NIO PP) CON 0#8,SSAC,FIE FATAL IOU ERROR (CIO PP) CON 0#9,S7AC,FIE C170 UNCORRECTED IOU ERROR (CIO PP) CON 0#9,S8AC,NIE C180 UNCORRECTED IOU ERROR (CIO PP) CON 0#105,SSAC,MOB MULTIPLE ODD BIT MEMORY ERROR CON 0#106,SSAC,MOB PARTIAL WRITE PARITY ERROR CON 0#21E,SSAC,MOB PARTIAL WRITE PARITY ERROR (990) CON 0#701,ISAC,ENW ENVIRONMENT WARNING CON 0#702,ISAC,LPW LONG POWER WARNING CON 0#703,SSAC,SPW SHORT POWER WARNING CON 0#704,RSAC,WCL ENVIRONMENT WARNING CLEAR CON 0#705,RSAC,WCL LONG POWER WARNING CLEAR CON 0#706,USAC,WCL SHORT POWER WARNING CLEAR CON 0#FFF END OF TABLE CNR SPACE 4,15 ** CNR - CHECK FOR NOS REQUEST. * * THIS ROUTINE IS CALLED IF *DFT* IS IN DEDICATED MODE AND * THERE IS A NOS REQUEST PRESENT. IT RESERVES THE CIP * CHANNEL, SETS THE REQUEST STATUS = *ACTIVE*, WAITS FOR THE * REQUEST TO BE PROCESSED, AND RELEASES THE CIP CHANNEL. * * USES CM - CM+4, T1 - T1+4. * * CALLS CRQ, SDA. * * MACROS DCHAN, DELAY, RCHAN. CNR SUBR ENTRY/EXIT RJM SDA READ NOS REQUEST HEADER CRD T1 LDD T1+4 CHECK REQUEST STATUS LMN STRY NJN CNRX IF NOT STATUS = *READY* LDN DSAL LOCATE CIP CHANNEL CRD CM LDD CM+4 RESERVE CIP CHANNEL LPN 77 STM CNRA RCHAN RJM CRQ CHECK REQUEST FOR SPECIAL PROCESSING LDN STAC SET STATUS = *ACTIVE* STD T1+4 RJM SDA REWRITE NOS REQUEST HEADER CWD T1 * WAIT FOR REQUEST TO BE PROCESSED BY *DFT*. CNR1 DELAY RJM SDA READ NOS REQUEST HEADER CRD T1 LDD T1+4 LMN STAC ZJN CNR1 IF STATUS = *ACTIVE* STILL PRESENT LDC ** RELEASE CIP CHANNEL CNRA EQU *-1 DCHAN LJM CNRX RETURN CRQ SPACE 4,10 ** CRQ - CHECK *DFT* REQUEST FOR SPECIAL PROCESSING. * * EXIT *UADM/FRAS* ISSUED IF NECESSARY. * * CALLS SDA. * * USES CM - CM+4. * * MACROS MONITOR. CRQ SUBR ENTRY/EXIT * THE FOLLOWING CODE ASSUMES THERE IS ONLY ONE REQUEST BUFFER * WHICH IMMEDIATELY FOLLOWS THE REQUEST HEADER. RJM SDA READ REQUEST ADN 1 CRM CRQA,ON LDM CRQA CHECK REQUEST LMN RQSF NJN CRQX IF NO *UADM* NEEDED LDC FRAS SET *UADM* SUBFUNCTION STM CRQA LDD MA WRITE REQUEST TO MESSAGE BUFFER CWM CRQA,ON LDN ZERL SET *UADM* PARAMETERS CRD CM LDN 1 SET REQUEST COUNT STD CM+1 * STD CM+2 (NO DROP FLAG IGNORED) MONITOR UADM ALERT *CPUMTR* OF PENDING *FRC* UPDATE UJN CRQX RETURN CRQA BSS 5 MEP SPACE 4,20 * MAIN PROGRAM. ** PROGRAMMING NOTE. * * WHENEVER A CALL TO *DFM* IS MADE, IT MAY BE NECESSARY FOR * *1DD* TO BE INVOKED TO FLUSH THE DAYFILE BUFFER. *1DD* * OVERLAYS A PART OF THE PP, WHICH IT RESTORES WHEN COMPLETE. * HOWEVER, SINCE ONLY 12-BIT DATA CAN BE RESTORED BY THIS * PROCESS, *1MB* MUST NEVER DEPEND ON 16-BIT DATA BEING * PRESERVED ACROSS A *DFM* CALL IN THE PART OF THE PP USED BY * *1DD*. FIRST, ANY *1MB* CODE CONTAINING LONG INSTRUCTIONS * MUST NOT START BEFORE LOCATION *DDLW*, DEFINED IN *COMSMSC* * AS THE LAST WORD USED BY *1DD*. SECOND, SINCE ANY DIRECT * CELLS CONTAINING 16-BIT DATA WILL NOT BE INTACT AFTER *1DD* * IS COMPLETE, CARE SHOULD BE TAKEN EITHER TO STORE 16-BIT DATA * IN THE PROTECTED AREA OF *1MB*, OR TO RE-READ THE DATA FROM * CM AFTER THE *DFM* CALL. .MEP MAX *,DDLW ORG .MEP MEP1 RJM PRS PRESET FOR *1MB* LDK EIBP READ *EICB* POINTER CRD CN ADN INWL-EIBP CHECK *MCH* ERROR BIT CRD CM LDD CN+3 SAVE *EICB* ADDRESS RAM DSPA LDD CN+4 RAM DSPA+1 LDD CM+4 SHN 21-5 MJP MRER IF MCH ERROR IN PROGRESS LDC LINS DEFINE LONG INSTRUCTIONS RJM DLI AOM DPPB RJM SBA SET BUFFER ADDRESSES RJM CTP CHECK FOR TIME PROCESSING LDDL DC+3 SHN 21-DCE7 MJN MEP2 IF ERRORS LOGGED IN M/R BUFFER LJM LED LOAD AND EXECUTE *DFT* MEP2 LCN 0 CLEAR C170 ERROR PRESENT FLAG STDL CN STDL CN+1 STDL CN+2 SCBN DCE7 STDL CN+3 RJM DOB ADK DFCW RDCL CN MEP3 LDN 1 SET INTERVAL BETWEEN CONTROL WORDS STD T2 RJM SCA SET ADDRESS OF CONTROL WORDS LDD DC+2 SET NUMBER OF M/R BUFFER CONTROL WORDS LPC 377 RJM FOM FIND OLDEST M/R BUFFER CONTROL WORD STM FSSB SAVE M/R CONTROL WORD OFFSET STM LMRD SET NON-REGISTER FLAG ZJN MEP4 IF NO ENTRIES PRESENT RJM FSS FIND SUPPORTIVE STATUS DATA UJN MEP5 DETERMINE OS ACTION MEP4 RJM FNR FIND NON-REGISTER DATA NJN MEP5 IF DATA PRESENT LDC ** MEPA EQU *-1 AUTORESTART PENDING FLAG ZJP DPP IF AUTORESTART NOT PENDING LDD IA LOAD *1DS* TO ISSUE *AUTO* CWM MEPD,ON LJM DPP1 CALL *1DS* AND ENABLE *1MB* CALL MEP5 LDD CN+1 SET SYMPTOM CODE IN *BML* STM IBMF+1 LDDL CN+2 SET SEQUENCE NUMBER IN *BML* SHN -10 STM IBMG+4 RJM DOA DETERMINE OS ACTION * OS ACTION ROUTINES WILL RETURN HERE. MEP6 RJM CTH CHECK THRESHOLD EXCEEDED RJM LMR LOG MAINTENANCE REGISTERS * CLEAR C170 VALID DATA FLAG, LOGGING ACTION FLAG, INTERLOCK * FLAG AND THRESHOLD EXCEEDED FLAG IN M/R BUFFER CONTROL WORD. LDD MB READ CONTROL WORD SHN 14 LMD MB+1 CRDL CN LDDL CN+2 CLEAR FLAGS MEPC SCBN (MRV7,MRIL,MRLG,MRTH) * SCBN (MRV7,MRIL) (180 LOGGING) STDL CN+2 LDD MB REWRITE M/R BUFFER CONTROL WORD SHN 14 LMD MB+1 CWDL CN LJM MEP3 PROCESS NEXT M/R ENTRY MEPD VFD 18/0L1DS,6/0,2/0,1/0,3/0,6//1DS/IASF,12/0,12/0 TITLE OS ACTION CODE PROCESSING ROUTINES. SPACE 4,10 *** OS ACTION CODE PROCESSING ROUTINES. * * ENTRY (MB - MB+1) = ADDRESS OF M/R CONTROL WORD. * (DC - DC+3) = *DFT* CONTROL WORD. * (CN - CN+3) = M/R BUFFER CONTROL WORD. * * EXIT TO *MEP6* TO LOG MAINTENANCE REGISTERS. * TO *CSH* TO CHECKPOINT AND HANG. ENW SPACE 4,10 ** ENW - ENVIRONMENT WARNING. * * EXIT TO *WWC* TO WAIT FOR WARNING CLEAR. * * USES CM - CM+3. * * CALLS CCI, CCM, CKC, CKP, DOB, LMR, RSM. ENW BSS 0 ENTRY RJM CCM CREATE CONSOLE MESSAGE LDD SC+2 NJN ENW1 IF *1CK* ALREADY CALLED RJM LMR LOG MAINTENANCE REGISTERS ENW1 LDN ZERL SET C170 ERROR FLAG CRDL CM AOD CM+3 ERRNZ DCE7 CODE DEPENDS ON VALUE RJM DOB ADK DFCW RDSL CM RJM CCI CLEAR M/R CONTROL WORD INTERLOCK ENWC LDN 10 SET *1CK* TO RECALL *1MB* * LDN 13 (LONG POWER WARNING) STM CKPA+2 LDN SPLG SET *1MB* FUNCTION CODE STM CKPA+3 RJM CKP LOAD AND EXECUTE *1CK* RJM CKC WAIT FOR *1CK* TO COMPLETE RJM RSM REQUEST STEP MODE LDD CP DISPLAY OPERATOR MESSAGE ADN MS2W CWM MSFS,TR LJM WWC WAIT FOR WARNING CLEAR LPW SPACE 4,10 ** LPW - LONG POWER WARNING. LPW BSS 0 ENTRY LDN 13-10 CHANGE *1CK* CALL TO LONG POWER WARNING RAM ENWC LJM ENW PROCESS AS ENVIRONMENT WARNING SPW SPACE 4,10 ** SPW - SHORT POWER WARNING. * * EXIT TO *WWC* TO WAIT FOR WARNING CLEAR. * * CALLS CCM, LMR, RSM. SPW BSS 0 ENTRY RJM CCM CREATE CONSOLE MESSAGE RJM LMR LOG MAINTENANCE REGISTERS RJM RSM REQUEST STEP MODE LJM WWC WAIT FOR WARNING TO CLEAR WCL SPACE 4,10 ** WCL - WARNING CLEAR. * * EXIT TO *MEP6* TO LOG MAINTENANCE REGISTERS. * (SCRL) UPDATED. * * USES CM - CM+4, SC - SC+4. * * MACROS DELAY, MONITOR. WCL LDD CP DISPLAY *POWER/ENVIRONMENT NORMAL* ADN MS2W CWM MSPN,TR LDN SSTL CHECK AUTORESTART CRD CM LDD CM SHN 21-13 MJN WCL2 IF AUTORESTART DISABLED LDD SC SHN 21-11 MJN WCL1 IF *1MB* REQUEST BIT SET LDD TH RAD SC LDC SCRL STORE *SCRL* WITH REQUESTED FLAG SET CWD SC WCL1 LDN ZERL CRD CM LDN 4 SET *DSRM* SUBFUNCTION TO CLEAR STEP STD CM+1 STM MEPA SET AUTORESTART PENDING MONITOR DSRM WCL2 LDC SCRL ENABLE *UNSTEP* COMMAND CRD SC LDD SC LPC 6777 STD SC LDC SCRL CWD SC WCL3 DELAY LDC SCRL CHECK STEP MODE CRD SC LDD SC SHN 21-10 MJN WCL3 IF STEP STILL SET LJM MEP6 LOG MAINTENANCE REGISTERS FIE SPACE 4,10 ** FIE - FATAL IOU ERROR. * * EXIT TO *CSH* TO CHECK POINT DEVICES AND THEN HANG. * * USES CM - CM+3. * * CALLS CCI, CCM, CSH, DOB. FIE BSS 0 ENTRY RJM CCM CREATE CONSOLE MESSAGE LDN 11 CHECK POINT DEVICES AND RECALL *1MB* STM CKPA+2 LDN SPLG SET *1MB* FUNCTION CODE STM CKPA+3 LDN ZERL SET C170 ERROR FLAG CRDL CM AOD CM+3 ERRNZ DCE7 CODE DEPENDS ON VALUE RJM DOB ADK DFCW RDSL CM RJM CCI CLEAR M/R CONTROL WORD INTERLOCK RJM CSH CHECKPOINT AND HANG NIE SPACE 4,10 ** NIE - NOS/VE IOU ERROR. * * EXIT TO *MEP6* TO LOG MAINTENANCE REGISTERS. * * CALLS CCM. NIE BSS 0 ENTRY RJM CCM CREATE CONSOLE MESSAGE LJM MEP6 LOG MAINTENANCE REGISTERS MOB SPACE 4,10 ** MOB - MULTIPLE ODD BIT ERROR. * * CALLS CCI, CCM, RSM. MOB RJM CCI CLEAR M/R INTERLOCK RJM CCM CREATE CONSOLE MESSAGE RJM RSM REQUEST STEP MODE UJN * HANG TITLE OS ACTION CODE SUBROUTINES. CCI SPACE 4,10 ** CCI - CLEAR M/R CONTROL WORD INTERLOCK. * * ENTRY (MB - MB+1) = ADDRESS OF OLDEST M/R CONTROL WORD. * * USES CM - CM+3. CCI SUBR ENTRY/EXIT LCN 0 CLEAR M/R CONTROL WORD INTERLOCK STDL CM STDL CM+1 STDL CM+3 SCBN MRIL STDL CM+2 LDD MB SHN 14 LMD MB+1 RDCL CM UJN CCIX RETURN CCM SPACE 4,15 ** CCM - CREATE CONSOLE MESSAGE. * * ENTRY (SSCW - SSCW+1) = ADDRESS OF SUPPORTIVE STATUS DATA. * (DFTV) = *DFT* VERSION. * (CN - CN+3) = M/R BUFFER CONTROL WORD. * * EXIT TIME AND FAULT SYMPTOM CODE BUILT INTO MESSAGE. * MESSAGE ISSUED TO SYSTEM CONTROL POINT. * * CALLS ACS, CTC, CTD, RER, SCM. * * USES T1, T3, T5, CM - CM+3. CCM SUBR ENTRY/EXIT LDM DFTV ZJN CCM1 IF NOT *DFT* VERSION 4 OR ABOVE LDN 2 STD T1 LDM SSCW SHN 14 LMM SSCW+1 ADN 1 CRDL CM READ DATE/TIME ADN 1 CRML CCMB,T1 READ FAULT SYMPTOM CODE LDD CM SHN 21-10 MJN CCM1 IF NO VALID DATA NJN CCM2 IF NOT MODEL 20 IOU CCM1 LDK TIML GET TIME CRM MSFS,ON LDC MSFS+5 SET ADDRESS FOR ASSEMBLY STD T1 LDN 0 SET END OF ASSEMBLY FOR *ACS* STM MSFS+5 UJN CCM3 CONVERT FAULT SYMPTOM CODE * CONVERT TIME FROM SUPPORTIVE STATUS DATA. CCM2 LDC 2L . SET END OF STRING FOR *ACS* STD T5 LDC 2L SET END OF ASSEMBLY FOR *ACS* STM MSFS LDC MSFS SET ADDRESS FOR ASSEMBLY STD T1 LDDL CM+2 CONVERT HOURS SHN -10 RJM CTD RJM ACS LDD CM+2 CONVERT MINUTES LPC 377 RJM CTD RJM ACS LDDL CM+3 CONVERT SECONDS SHN -10 RJM CTD RJM ACS CCM3 LDC CCMA ADD *ERR=* TO MESSAGE RJM ACS LDM MSFS+4 SCN 77 ADN 1R STM MSFS+4 LDD CN+1 LPC 3777 SBK 0#707 PJN CCM4 IF NOT WARNING ADK 0#707-0#701 PJN CCM5 IF WARNING CCM4 LDM DFTV NJN CCM6 IF *DFT* VERSION 4 OR ABOVE * BUILD MESSAGE FOR ALL *DFT* VERSION 3 ERRORS, AND WARNING * ERRORS FOR *DFT* VERSION 4 AND ABOVE. CCM5 RJM RER READ *EID* REGISTER RJM SCM SET ANALYSIS CODE IN MESSAGE LDN 0 ADD TERMINATOR STM MSFS+13 UJN CCM8 DISPLAY OPERATOR MESSAGE * CONVERT FAULT SYMPTOM CODE DATA FOR *DFT* VERSION 4 AND * ABOVE (EXCEPT FOR WARNING ERRORS). CCM6 LDN 0 SET END OF STRING FOR *ACS* STD T5 LDC CCMB+2 SET START OF FAULT SYMPTOM CODE STD T3 CCM7 RJM CTC CONVERT TWO CHARACTERS RJM ACS AOD T3 LMC CCMB+10 NJN CCM7 IF MORE TO CONVERT CCM8 LDD CP DISPLAY OPERATOR MESSAGE ADN MS2W CWM MSFS,TR * HH.MM.SS ERR=XXXXXXXXXXXX* LJM CCMX RETURN CCMA DATA C*ERR=* CCMB BSS 2*4 FAULT SYMPTOM CODE CHC SPACE 4,10 ** CHC - CONVERT HEXADECIMAL CHARACTER TO DISPLAY CODE. * * ENTRY (A) = VALUE TO CONVERT. * * EXIT (A) = DISPLAY CODE. CHC1 ADN 10D+1R0 CONVERT TO DISPLAY CODE CHC SUBR ENTRY/EXIT LPN 17 MASK ONE CHARACTER SBN 10D MJN CHC1 IF DECIMAL CHARACTER ADN 1RA SET HEX CHARACTER UJN CHCX RETURN CTC SPACE 4,10 ** CTC - CONVERT TWO CHARACTERS. * * ENTRY (T3) = ADDRESS OF TWO 8-BIT ASCII CHARACTERS. * * EXIT (A) = ADDRESS OF TWO DISPLAY CODE CHARACTERS. * (T4 - T5) = TWO CHARACTERS PLUS ZERO TERMINATOR. * * USES T4, T6. CTC SUBR ENTRY/EXIT LDIL T3 CONVERT FIRST CHARACTER SHN -10 SBN 40 STD T6 LDM T8AD,T6 SHN 6 STD T4 LDI T3 CONVERT SECOND CHARACTER LPC 377 SBN 40 STD T6 LDM T8AD,T6 RAD T4 LDN T4 SET ADDRESS OF STRING UJN CTCX RETURN CTD SPACE 4,10 ** CTD - CONVERT TWO DIGITS. * * ENTRY (A) = TWO 4-BIT DIGITS. * * EXIT (A) = ADDRESS OF STRING TO ADD TO MESSAGE. * (T4) = STRING TO ADD TO MESSAGE. * (CALLER MUST SUPPLY TERMINATOR IF NECESSARY). * * USES T3, T4. CTD SUBR ENTRY/EXIT STD T3 SHN -4 CONVERT FIRST CHARACTER ADN 1R0 SHN 6 STD T4 LDD T3 CONVERT SECOND CHARACTER LPN 17 ADN 1R0 RAD T4 LDN T4 SET ADDRESS OF STRING UJN CTDX RETURN RER SPACE 4,15 ** RER - READ *EID* REGISTER. * * ENTRY (CN - CN+3) = M/R BUFFER CONTROL WORD. * *DFT* INDICATES CPU 1 OR IOU 1 BY LOGGING ELEMENT CODE * 10(16) OR 12(16) IN THE *EID* REGISTER (INSTEAD OF 0 * OR 2). * (MB - MB+1) = THE ADDRESS OF THE CURRENT NON REGISTER * STATUS BUFFER (*NRSB*) ENTRY. * * EXIT ELEMENT CODE AND MODEL NUMBER SET IN MESSAGE. * * USES T1, CM - CM+3. * * CALLS CTD, MRB. RER SUBR ENTRY/EXIT LDM IBMG CHECK FOR *DFT* VERSION 5 OR ABOVE SBN 5 MJN RER0 IF LESS THAN VERSION 5 * FOR *DFT* VERSION 5 OR ABOVE, GET THE ELEMENT ID (*EID*) * FROM THE *NRSB* ENTRY. LDD MB GET ADDRESS OF *NRSB* ENTRY SHN 14 ADD MB+1 ADN 5 OFFSET TO *EID* REGISTER ENTRY CRDL CM READ IN *EID* REGISTER UJN RER1.1 PROCESS THE *EID* RER0 LDN 0 INITIALIZE OFFSET STD T1 RER1 AOD T1 SBN 5 ZJN RER1 IF SECOND HEADER WORD SBN 10-5 ZJN RER2 IF END OF BUFFER (USE ZERO DATA) RJM MRB GET ADDRESS OF M/R BUFFERS ADD CN+3 ADD OFFSET ADD T1 SKIP TO NEXT WORD CRDL CM READ *EID* REGISTER LDDL CM ADDL CM+1 ADDL CM+2 ADDL CM+3 ZJN RER1 IF *EID* NOT FOUND YET RER1.1 LDDL CM+2 GET ELEMENT CODE SHN -10 ADN 1 RER2 STD T1 SHN -2 INCLUDE CPU 1/IOU 1 FLAG RAD T1 LDM RERA,T1 GET MESSAGE CHARACTERS STM MSFS+7 LDD CM+2 GET MODEL NUMBER LPC 377 RJM CTD CONVERT DIGITS LDD T4 ADD MODEL NUMBER TO MESSAGE STM MSFS+10 UJP RERX RETURN ** RERA - TABLE OF MESSAGE CHARACTERS. * * INDEXED BY ELEMENT CODE. RERA BSS 0 DATA 2R00 UNKNOWN ELEMENT DATA 2RDC PROCESSOR 0 DATA 2RDM MEMORY DATA 2RDI IOU 0 DATA 2R UNUSED DATA 2RDD PROCESSOR 1 DATA 2R UNUSED DATA 2RDJ IOU 1 SCM SPACE 4,15 ** SCM - SET ANALYSIS CODE IN MESSAGE. * * THE *DFT* ANALYSIS CODE FROM THE CONTROL WORD IS CONVERTED * TO HEXADECIMAL DISPLAY CODE AND PLACED IN THE CONSOLE * MESSAGE. * * ENTRY (CN - CN+3) = CONTROL WORD. SCM SUBR ENTRY/EXIT LDD CN+1 GET *DFT* ANALYSIS CODE RJM CHC CONVERT THIRD CHARACTER SHN 6 STM MSFS+12 LDD CN+1 CONVERT SECOND CHARACTER SHN -4 RJM CHC STM MSFS+11 LDD CN+1 CONVERT FIRST CHARACTER SHN -10 RJM CHC SHN 6 RAM MSFS+11 UJP SCMX RETURN WWC SPACE 4,10 ** WWC - WAIT FOR WARNING CLEAR. * * EXIT TO *LED* TO LOAD *DFT* IF *DFT* NOT DEDICATED. * TO *WCL* TO PROCESS WARNING CLEAR IF *DFT* DEDICATED. * * USES CN - CN+3. * * CALLS CCI. * * MACROS DELAY. WWC RJM CCI CLEAR M/R CONTROL WORD INTERLOCK LDDL DC+3 CHECK IF DEDICATED *DFT* SHN 21-DCDM PJN WWC1 IF *DFT* DEDICATED LJM LED LOAD *DFT* WWC1 DELAY LDD MB READ M/R CONTROL WORD SHN 14 LMD MB+1 CRDL CN LDD CN CHECK FOR WARNING CLEAR LPC 377 LMK WCAC ZJN WWC2 IF WARNING CLEAR LMK RSAC&WCAC ZJN WWC2 IF SYSTEM RESUME LMK USAC&RSAC NJN WWC1 IF NOT SYSTEM UNSTEP WWC2 LDD CN+1 PUT SYMPTOM CODE IN *BML* STM IBMF+1 LJM WCL PROCESS WARNING CLEAR TITLE MAINTENANCE REGISTER PROCESSING SUBROUTINES. CBM SPACE 4,10 ** CBM - COMPLETE *BML* MESSAGES. * * ENTRY ALL DATA PRESENT IN *BML* BUFFER AND TRAILER WORD. * * EXIT *BML* BUFFER PADDED WITH SUFFICIENT ZERO WORDS. * THE BUFFER IS FLUSHED IF NECESSARY. * FINAL *BML* MESSAGE ISSUED. * * USES BP. * * CALLS PMB, WLB. CBM SUBR ENTRY/EXIT LDN ZERL CRML BDMR,ON USE ZERO AS REGISTER NUMBERS LDN ZERL CRM BCMR,ON CLEAR M/R BUFFER LDN ZERL CRM BCMR+7-4,ON CBM1 LDD T5 ZJN CBM2 IF WRITE COMPLETE RJM PMB PACK AND WRITE FAKE M/R UJN CBM1 CONTINUE PROCESSING CBM2 LDN 5 UPDATE POINTER TO *BML* BUFFER RAD BP STM CBMA ADC -IBMHL PJN CBM3 IF READ COMPLETE LDN ZERL CLEAR BUFFER CRM **,ON CBMA EQU *-1 UJN CBM2 CHECK AGAIN CBM3 LDN 6 SET MESSAGE LENGTH STD T4 RJM WLB WRITE LAST *BML* MESSAGE UJP CBMX RETURN CPM SPACE 4,10 ** CPM - CLEAR PP MEMORY. * * ENTRY (DC - DC+3) = *DFT* CONTROL WORD. * * USES T0. * * CLEARS ALL PP MEMORY FROM LWA OF *1MB* CODE TO THE END OF * THE PP. THIS INSURES THAT ALL 16-BIT INSTRUCTIONS USED BY * *DFT* ARE CLEARED BEFORE THE PP IS RETURNED TO NOS. CPM SUBR ENTRY/EXIT LDDL DC+3 SHN 21-DCDM PJN CPMX IF DEDICATED *DFT* LDC L1MB FIRST WORD TO CLEAR STD T0 LDN 0 CPM1 STI T0 AOD T0 SHN -14 ZJN CPM1 IF MORE MEMORY TO CLEAR UJN CPMX RETURN CTH SPACE 4,10 ** CTH - CHECK THRESHOLD EXCEEDED. * * ENTRY (CN - CN+3) = M/R BUFFER CONTROL WORD. * * USES CM - CM+4, T1, T2. * * CALLS DFM. * * MACROS MONITOR. CTH SUBR ENTRY/EXIT LDDL CN+2 SHN 21-MRTH PJN CTHX IF NOT THRESHOLD EXCEEDED LDDL CN+1 GET *DFT* ANALYSIS CODE SHN 0-14 LMN 3 STD T1 (1 = CORRECTED, 0 = UNCORRECTED) LDD CN+1 GET TYPE OF ERROR SHN 0-10 LPN 3 SHN 1 STD T2 (0 = IOU, 2 = CM, 4 = CPU) LDM CTHA,T2 BUILD APPROPRIATE MESSAGE TEXT STM CTHB,T1 LDM CTHA+1,T2 STM CTHB+1,T1 LDC CTHB+ERLN ISSUE ERROR LOG MESSAGE ADD T1 RJM DFM LDN ZERL ISSUE OPERATOR EVENT CRD CM LDK ELAE STM CM+4 MONITOR EATM UJP CTHX RETURN CTHA DATA 4HIOU DATA 4HCM DATA 4HCPU CTHB DATA 6H UN DATA C*CORRECTED ERROR THRESHOLD EXCEEDED.* CTP SPACE 4,10 ** CTP - CHECK FOR TIME AND CHECKPOINT PROCESSING. * * ENTRY (IR+2) = FUNCTION CALL. * * EXIT TO *CSH* IF CHECKPOINT REQUEST. * TO *LED* IF TIME REQUEST AND *DFT* NOT DEDICATED. * TO *DPP* IF TIME REQUEST AND *DFT* DEDICATED. * * USES CM - CM+3, DC - DC+3, IR+2. * * CALLS CCO, CRC, CSH, DOB, PES, UCC, *2TH*. * * MACROS EXECUTE. CTP SUBR ENTRY/EXIT LDD IR+2 CHECK FOR TIME PROCESSING LPN SPCP NJP CTP2 IF CHECKPOINT REQUEST LMD IR+2 LPN SPTP ZJN CTPX IF NOT TIME PROCESSING RJM UCC UPDATE CTI CLOCK EXECUTE 2TH LOAD TOP-OF-HOUR ROUTINES RJM /IHD/CRC CLEAR RELOAD COUNT IN CONTROLWARE TABLE RJM /IHD/CCO CLEAR COUNTS IN EST/MST ENTRIES RJM /IHD/PES PROCESS ESM SECDED LOGGING CTPA LDC ZERL SET LOG COUNTERS AND SECDED TABLE FLAG * LJM CTPX (IF NOS/VE LOGGING) CRDL CM LDBC DCZC STDL CM+3 RJM DOB ADK DFCW RDSL CM CRDL DC LDDL DC+3 CHECK DEDICATED FLAG SHN 21-DCDM PJP DPP IF DEDICATED *DFT* CTP1 LDN SPLG SET LOGGING FUNCTION CODE CTPB EQU *-1 * LDN SPTH (IF TOP OF HOUR PART TWO) STD IR+2 LDD IA CWD IR LJM LED LOAD *DFT* CTP2 LDN 10 SET *1CK* TO RECALL *1MB* STM CKPA+2 LDN SPCP SET *1MB* FUNCTION CODE STM CKPA+3 LDC MSCP *(204) FATAL CPU ERROR* STM CSHA STM CSHB RJM CSH CHECKPOINT AND HANG C9E SPACE 4,15 ** C9E - CHECK SPECIAL MODEL 990 ERRORS. * * ENTRY (IBMF+1) = *DFT* ANALYSIS CODE. * (T4) = CURRENT OFFSET INTO M/R BUFFER. * * EXIT (A) = 0, IF SPECIAL 990 ERROR PRESENT. * *BML* DATA PLACED IN BUFFER, IF (A) = 0. * * USES T4, T6. * * CALLS GPB, RMR. C9E SUBR ENTRY/EXIT LDM IBMF+1 LPC 3777 MASK MULTIPLE OCCURRANCE FLAG LMC 0#206 ZJN C9E1 IF REPAIRED ERROR LMK 0#207&0#206 ZJN C9E1 IF UNREPAIRED ERROR LMK 0#205&0#207 ZJN C9E1 IF RETRY IN PROGRESS ERROR LMK 0#21B&0#205 ZJN C9E1 IF RETRY CONVERTED TO UNCORRECTED ERROR LMK 0#21C&0#21B ZJN C9E1 IF RETRY EXHAUSTED ERROR LMK 0#21D&0#21C NJN C9EX IF NOT RETRY EXHAUSTED ERROR C9E1 LDD T4 SBN 5 NJN C9EX IF NOT LAST M/R BUFFER STD T4 STD T6 INITIALIZE SUMMARY STATUS FLAG * PROCESS LAST BUFFER FOR SPECIAL 990 ERRORS. RJM GPB READ DATA WORD INTO *BML* MESSAGE LDD BP STM C9EA LDD MS SHN 14 LMD MS+1 CRM **,ON C9EA EQU *-1 LDC LDNI+0 SET *RMR* TO NOT USE *STATUS SUMMARY* FLAG STM RMRA LDN ZERL USE ZERO AS REGISTER NUMBERS CRML BDMR,ON RJM RMR LOG FAILING ADDRESS WORDS AS REGISTERS LDC LDNI+1 RESTORE *RMR* USE OF *STATUS SUMMARY* FLAG STM RMRA LDN 0 SET EXIT FLAG LJM C9EX RETURN DOA SPACE 4,10 ** DOA - DETERMINE OS ACTION. * * ENTRY (CN - CN+3) = CONTROL WORD. * * EXIT TO OS ACTION ROUTINE. * NORMAL RETURN, IF NO OS ACTION CODE OR VERSION 3 * AND NO VALID OS ACTION CODE. * * USES T1, T2. DOA3 LDD T1 SBN MXAC PJN DOAX IF NOT A VALID ACTION CODE LDM TOSC,T1 SET OS ACTION ROUTINE ADDRESS UJN DOA5 EXIT TO ROUTINE DOA4 LDC MOB ROUTINE FOR NO MATCH FOUND DOA5 STM DOAA LJM ** PROCESS OS ACTION DOAA EQU *-1 DOA SUBR ENTRY/EXIT LDD CN LPC 377 STD T1 ZJN DOAX IF NO OS ACTION CODE LDD CN+2 CHECK VALID 170 DATA FLAG LPBC MRV7 ZJN DOAX IF NO VALID 170 DATA FLAG LDM DFTV ZJN DOA3 IF *DFT* VERSION 3 LDN 0 STD T2 UJN DOA2 ENTER LOOP DOA1 LDN 3 ADVANCE TO NEXT ENTRY RAD T2 DOA2 LDD CN+1 GET *DFT* ANALYSIS CODE LPC 3777 SBM TDFA,T2 MJN DOA4 IF ENTRY NOT IN TABLE NJN DOA1 IF NO MATCH LDD T1 GET OS ACTION CODE LMM TDFA+1,T2 NJN DOA1 IF ACTION CODE DOES NOT MATCH LDM TDFA+2,T2 SET OS ACTION CODE ADDRESS UJP DOA5 EXIT TO ROUTINE DOB SPACE 4,10 ** DOB - GET DFT/OS BUFFER ADDRESS. * * EXIT (A) = ADDRESS OF DFT/OS BUFFER. DOB SUBR ENTRY/EXIT DOBA LDC ** UJN DOBX RETURN DPR SPACE 4,10 ** DPR - DUMP PP REGISTERS. * * EXIT A, P, Q AND K REGISTERS OF EACH PP * DUMPED TO *PRGB*. * * USES EC, T2, T3, T4, CM - CM+4, CN - CN+4. * * MACROS EXITMR, LOCKMR, READMR, WRITMR. DPR SUBR ENTRY/EXIT EXITMR DPRX MODIFY ERROR EXIT ADDRESS LDK PPUL GET NUMBER OF PP-S CRD CN ADK EABL+2-PPUL GET IOU CONNECT CODE CRD CM LDD CM+3 STD EC READMR BCMR,,DEMR READ EC REGISTER LDN 0 INITIALIZE BUFFER POINTER STD T3 STD T4 INITIALIZE REGISTER NUMBER STD T2 INITIALIZE PP NUMBER DPR1 LDM BCMR+4 SET PP NUMBER SCN 77 LMD T2 LMN 40 SET AUTO MODE BIT STM BCMR+4 LDM BCMR+6 MERGE REGISTER NUMBER SCN 3 LMD T4 STM BCMR+6 LOCKMR SET GET LONG TERM INTERLOCK WRITMR BCMR,,DEMR WRITE EC REGISTER READMR BDMR,,ISTR READ STATUS REGISTER LOCKMR CLEAR CLEAR LONG TERM INTERLOCK LDM BDMR+4 FETCH REGISTER LPN 3 SHN 10 LMM BDMR+5 SHN 10 LMM BDMR+6 STM PRGB+1,T3 STORE IN BUFFER SHN -14 STM PRGB,T3 LDN 2 INCREMENT BUFFER POINTER RAD T3 AOD T4 INCREMENT REGISTER NUMBER SBN 4 MJN DPR2 IF NOT END OF REGISTERS FOR THIS PP LDN 0 RESET REGISTER NUMBER STD T4 SOD CN+2 DECREMENT NUMBER OF PP-S ZJN DPR3 IF END OF PP-S AOD T2 INCREMENT PP NUMBER SBN 12 NJN DPR2 IF NOT PP 20 ADN 12+6 STD T2 DPR2 LJM DPR1 READ NEXT REGISTER DPR3 LDC PRGB SET BUFFER ADDRESS IN INPUT REGISTER STD IR+4 LDD IA CWD IR LJM DPRX RETURN DSP SPACE 4,10 ** DSP - GET *EICB* ADDRESS. * * ENTRY (DSPA) = ADDRESS OF *EICB*. * * EXIT (A) = ADDRESS OF *EICB*. DSP SUBR ENTRY/EXIT DSPA LDC ** UJN DSPX RETURN FNR SPACE 4,15 ** FNR - FIND NON-REGISTER DATA. * * ENTRY (FNRA - FNRA+1) = FWA OF NON-REGISTER DATA. * * EXIT (A) = 0, IF NO ENTRY TO PROCESS. * (MB - MB+1) = ADDRESS OF CONTROL WORD FOR ENTRY. * (CN - CN+3) = CONTROL WORD TO PROCESS. * (CN+3) = SIZE OF ENTRY TO LOG. * * USES T1, T2, CM - CM+3, MB - MB+1. * * CALLS FOM. FNR SUBR ENTRY/EXIT FNRA LDC ** (FWA OF NON-REGISTER DATA) ZJN FNRX IF *DFT* VERSION 3 CRDL CM READ HEADER WORD ADN 1 STD MB+1 SAVE ADDRESS OF START OF FIRST ENTRY SHN -14 STD MB LDD CM+3 SET INTERVAL BETWEEN CONTROL WORDS STD T2 LDD CM+2 SET NUMBER OF CONTROL WORDS TO SEARCH RJM FOM FIND OLDEST ENTRY ZJN FNR1 IF NO ENTRY TO PROCESS LDD MB READ SIZE OF DATA TO LOG SHN 14 LMD MB+1 ADN 1 CRDL CM LDD CM+3 SAVE SIZE OF DATA TO LOG FNR1 STD CN+3 UJN FNRX RETURN FOM SPACE 4,10 ** FOM - FIND OLDEST M/R BUFFER ENTRY. * * ENTRY (A) = NUMBER OF CONTROL WORDS TO SEARCH. * (T2) = INTERVAL BETWEEN CONTROL WORDS. * (MB - MB+1) = ADDRESS OF FIRST CONTROL WORD. * * EXIT (A) = (T7) = OFFSET OF OLDEST CONTROL WORD. * = 0, IF NO ENTRY FOUND TO PROCESS. * (CN - CN+3) = OLDEST M/R CONTROL WORD. * (MB - MB+1) = ADDRESS OF OLDEST M/R CONTROL WORD. * * USES CN - CN+3, MB - MB+1, T1, T6, T7, T8. * INTERLOCK SELECTED ENTRY. IF UNABLE TO DO SO, *DFT* IS IN * THE PROCESS OF OVERWRITING IT AND A NEW ENTRY MUST BE * SELECTED. IF THE INTERLOCK IS OBTAINED, BUT THE SEQUENCE * NUMBER IS DIFFERENT, *DFT* HAS OVERWRITTEN IT. A NEW ENTRY * MUST BE SELECTED. FOM6 LDD T7 ZJN FOMX IF NO ENTRY SELECTED LDN ZERL SET UP INTERLOCK WORD CRDL CN LDBC MRIL STD CN+2 LDD MB SHN 14 LMD MB+1 ADD T7 RDSL CN SET INTERLOCK ON OLDEST CONTROL WORD LDDL CN+2 SHN 21-MRIL MJN FOM1 IF INTERLOCKED BY *DFT* LDDL CN+2 SHN -10 CHECK SEQUENCE NUMBER SBD T8 ZJN FOM7 IF SAME SEQUENCE NUMBER LDD MB CLEAR INTERLOCK SHN 14 LMD MB+1 ADD T7 CWDL CN UJN FOM1 RESTART SEARCH FOM7 LDD T7 SET OLDEST BUFFER CONTROL WORD ADDRESS RAD MB+1 SHN -14 RAD MB LDD T7 FOM SUBR ENTRY/EXIT STM FOMB SAVE NUMBER OF CONTROL WORDS FOM1 LDN 0 STD T6 COUNTER FOR M/R BUFFER ENTRIES STD T7 OFFSET OF OLDEST M/R BUFFER STD T8 SEQUENCE NUMBER OF OLDEST M/R BUFFER LDC ** FOMB EQU *-1 (NUMBER OF CONTROL WORDS TO SEARCH) STD T1 UJN FOM3 ENTER LOOP FOM2 LDD T2 ADVANCE TO NEXT CONTROL WORD RAD T6 SOD T1 ZJP FOM6 IF SEARCH COMPLETE FOM3 LDD MB READ NEXT M/R CONTROL WORD SHN 14 LMD MB+1 ADD T6 CRDL CN LDDL CN+2 CHECK VALID DATA FLAG AND INTERLOCK FLAG FOMA LPBC (MRV7,MRIL,MRLG) * LPBC (MRV7,MRIL) (IF 180 LOGGING) SHN 21-MRIL MJN FOM2 IF INTERLOCKED BY *DFT* ZJN FOM2 IF NOT A POTENTIAL EARLIEST ENTRY LDD T7 ZJN FOM5 IF NO ENTRY SELECTED YET LDDL CN+2 GET SEQUENCE NUMBER SHN -10 SBD T8 SUBTRACT OLDEST SEQUENCE NUMBER MJN FOM4 IF LOWER THAN PREVIOUS SBN 40 PJN FOM5 IF WRAP AROUND FOM3.1 UJP FOM2 PROCESS NEXT ENTRY FOM4 ADN 40 MJN FOM2 IF NOT AN EARLIER ENTRY FOM5 LDDL CN+2 SET NEW OLDEST SEQUENCE NUMBER SHN -10 STD T8 LDD T6 SET NEW OLDEST OFFSET STD T7 UJN FOM3.1 PROCESS NEXT ENTRY FSS SPACE 4,10 ** FSS - FIND SUPPORTIVE STATUS DATA. * * ENTRY (FSSA) = FWA OF SUPPORTIVE STATUS BUFFER. * (FSSB) = OFFSET OF ENTRY IN M/R BUFFER CONTROL WORDS. * (MUST BE NON-ZERO) * * EXIT (SSCW - SSCW+1) = ADDRESS OF CONTROL WORD FOR * SUPPORTIVE STATUS DATA. * * USES T1, CM - CM+4, MS - MS+1. FSS SUBR ENTRY/EXIT FSSA LDC ** GET START OF SUPPORTIVE STATUS BUFFERS ZJN FSSX IF *DFT* VERSION 3 CRDL CM ADN 1 ADVANCE TO START OF FIRST ENTRY STD MS+1 SHN -14 STD MS LDC * SET OFFSET FSSB EQU *-1 STD T1 FSS1 LDD CM+3 ADVANCE TO NEXT ENTRY RAD MS+1 SHN -14 RAD MS SOD T1 NJN FSS1 IF NOT YET AT CORRECT ENTRY LDD MS SAVE ADDRESS OF CONTROL WORD FOR ENTRY STM SSCW LDD MS+1 STM SSCW+1 UJN FSSX RETURN GPB SPACE 4,10 ** GPB - GET POINTER TO *BML* BUFFER. * * ENTRY (BP) = PREVIOUS POINTER INTO *BML* BUFFER. * * EXIT (BP) UPDATED. * *BML* MESSAGE ISSUED. * * USES BP, CM - CM+4. * * CALLS DFM. GPB SUBR ENTRY/EXIT LDN 5 RAD BP UPDATE POINTER TO *BML* BUFFER ADC -IBMHL MJN GPBX IF STILL WITHIN BUFFER LDN ZERL CRD CM FORM *BML* PARAMETERS LDN 6*5 SET BYTE COUNT STD CM+1 LDM IBMG+1 UNCONDITIONALLY SET CONTINUATION BIT SCN 4 LMN 4 STM IBMG+1 LDC IBMF+BMLN SEND *BML* MESSAGE RJM DFM LDC IBMH STD BP LDM IBMG+1 SET NOT FIRST BLOCK FLAG SCN 10 LMN 10 STM IBMG+1 UJN GPBX RETURN IMD SPACE 4,10 ** IMD - ISSUE MODEL DEPENDENT DATA *BML* MESSAGE. * * ENTRY MESSAGE BUILT AT *BHDR*. * (A) = LENGTH OF MESSAGE TO ISSUE. * * CALLS IMB. IMD SUBR ENTRY/EXIT ADN 1 STM BHDR+3 LDC BHDR RJM IMB ISSUE MESSAGE TO BUFFER LDM MBUF+1*5+1 SET NOT FIRST BLOCK FLAG SCN 10 LMN 10 STM MBUF+1*5+1 UJP IMDX RETURN LDT SPACE 4,15 ** LDT - LOG DATA STRUCTURE. * * *LDT* LOGS THE SUPPORTIVE STATUS BUFFER AND NON-REGISTER * DATA. * * ENTRY (T4) = NUMBER OF WORDS TO LOG. * (MS - MS+1) = ADDRESS-1 OF FIRST WORD TO LOG. * * USES BP, T4, T5, CN - CN+3, MS - MS+1. * * CALLS CMB, PMB, PMR. LDT SUBR ENTRY/EXIT LDN 0 CLEAR CONTINUATION/NOT FIRST BLOCK FLAGS STM IBMG+1 STD T5 SET UP FOR *PMB* LDC IBMH-5 STD BP LDN ZERL USE ZERO AS REGISTER NUMBERS CRML BDMR,ON LDT1 AOD MS+1 READ NEXT WORD OF DATA SHN -14 RAD MS SHN 14 LMD MS+1 CRDL CN RJM PMR PACK DATA INTO *BCMR* BUFFER RJM PMB PACK DATA INTO *BML* MESSAGE NJN LDT2 IF NOT AT END OF BLOCK LDM IBMG+1 SET NOT FIRST BLOCK FLAG SCN 10 LMN 10 STM IBMG+1 LDT2 SOD T4 NJN LDT1 IF MORE WORDS TO LOG RJM CBM COMPLETE *BML* MESSAGES UJP LDTX RETURN LED SPACE 4,10 ** LED - LOAD AND EXECUTE *DFT*. * * EXIT *DFT* IS LOADED INTO THIS PP. * * USES DC - DC+1, CM - CM+3, CN - CN+4, SC, T0, T7. * * CALLS DOB. LED BSS 0 ENTRY RJM DOB READ *DFT* CONTROL WORD ADK DFCW CRDL DC LDDL DC+3 CHECK DEDICATED MODE SHN 21-DCDM PJP LED1 IF *DFT* IS IN DEDICATED MODE * SAVE PP RESIDENT. SETMS NODRIVER CLEAR DRIVER PRESENT FLAG LDC DFPSL-1 SET WORD COUNT TO SAVE STD T7 LDN DFTBL TRANSFER BOOTSTRAP TO *MSFW* STD CM LDD MA CWM LEDD,CM LDD MA CRM MSFW,CM LDC MSFW-1 SET EXECUTION ADDRESS ON RETURN FROM *DFT* STD T0 RJM DOB GET *PPR* SAVE AREA BUFFER ADDRESS ADK DFPS CRDL CM RPTR CM CONVERT ADDRESS CWD T0 WRITE FIRST WORD OF *PPR* ADN 1 CWM 5,T7 WRITE REMAINDER OF *PPR* LDN DSAL RESERVE CIP CHANNEL CRD CM LDD CM+4 LPN 77 RCHAN * CHECK NOS REQUEST STATUS. RJM SDA READ NOS REQUEST HEADER CRD CM LDD CM+4 CHECK STATUS LMN STRY NJN LED3 IF NOT STATUS = *READY* LDN STAC SET STATUS = *ACTIVE* STD CM+4 RJM SDA REWRITE NOS REQUEST HEADER CWD CM UJN LED3 CONTINUE WITH LOADING *DFT* LED1 SHN 21-DCVR-21+DCDM+22 PJN LED2 IF *DFT* NOT ALREADY ACTIVATED RJM CNR CHECK FOR NOS REQUEST LJM DPP DROP PP LED2 LDD IA CHANGE *1MB* TO *DFT* IN INPUT REGISTER CRD CM LDC 2RDF STD CM LDD CM+1 LPN 77 LMC 1RT*100 STD CM+1 LDD IA CWD CM LED3 LDM IBMF+2 SET PP NUMBER IN *DFT* CONTROL WORD SHN -6 LMDL DC+1 LPN 37 LMDL DC+1 STDL DC+1 RJM DOB ADK DFCW CWDL DC UPDATE *DFT* CONTROL WORD * FIND *DFT* ENTRY IN *CTI* CM DIRECTORY. LDN 0 STD T1 LDK EIBP CRD CN LDD CN+3 SHN 14 LMD CN+4 ADK DSCM+2 READ *CTI* CM DIRECTORY POINTER CRDL CN LRD CN+1 LOAD R-REGISTER LDDL CN SAVE REMAINDER STD T2 LED4 ADC 400000 SET BIT TO USE R-REGISTER CRDL CN READ *CTI* DIRECTORY ENTRY LDDL CN LMC 2RDF NJN LED5 IF NOT *DFT* ENTRY LDDL CN+1 SHN -6 LMN 1RT ZJN LED6 IF *DFT* ENTRY LED5 LDDL CN+3 FIND NEXT DIRECTORY ENTRY RAD T2 SHN -14 RAD T1 SHN 14 LMD T2 UJN LED4 CHECK NEXT DIRECTORY ENTRY * MOVE CODE TO SAVE AREA SO *DFT* DOES NOT OVERWRITE IT. LED6 LDN .LED2 SIZE OF CODE TO MOVE STD T3 LDD MA MOVE CODE THROUGH MESSSAGE BUFFER CWML LEDA,T3 SBD T3 CRML CN,T3 LJM CN JUMP TO LOADER * LOAD AND EXECUTE *DFT*. LEDA BSS 0 START OF CODE TO MOVE LDD T1 SHN 14 LMD T2 ADC 400001 CRDL CN READ *DFT* LOAD PARAMETERS ADN 1 STD T2 SHN -14 STD T1 LDD CN SET *DFT* LOAD ADDRESS STD LEDC LDD T1 LOAD *DFT* SHN 14 LMD T2 CRML **,CN+1 LEDB EQU *-1 (*DFT* LOAD ADDRESS) LJM 100 EXECUTE *DFT* .LED1 EQU *-LEDA-1 .LED2 EQU .LED1/4+1 ERRPL .LED2-7 CODE LONGER THAN MESSAGE BUFFER LEDC EQU LEDB-LEDA+CN LOCATION TO PLUG *DFT* LOAD ADDRESS * BOOTSTRAP USED TO DROP CIP CHANNEL ON RETURN FROM *DFT*. LEDD BSS 0 LOC MSFW LDN DSAL LOCATE CIP CHANNEL CRD CM LDD CM+4 RELEASE CIP CHANNEL LPN 77 DCHAN LJM PPR RELOAD *1MB* LOC *O .LEDDL SET *-LEDD+4 ERRNG DFTBL-.LEDDL/5 *DFT* BOOTSTRAP TOO LONG LMD SPACE 4,15 ** LMD - LOG MODEL DEPENDENT BUFFER. * * ENTRY (T4) = LENGTH OF DATA TO LOG. * (MS - MS+1) = FWA - 1 OF DATA TO LOG. * * EXIT MODEL DEPENDENT DATA ISSUED TO *BML*. * * USES T1 - T5, BP, MS, CN - CN+3. * * CALLS IMD, PMR, PWB. LMD7 LDM MBUF+1*5+1 CLEAR CONTINUATION BIT SCN 4 STM MBUF+1*5+1 LMD8 LDC 18D LMDA EQU *-1 (NUMBER OF WORDS TO LOG) RJM IMD ISSUE *BML* MESSAGE LDN 18D RESET WORD COUNT STM LMDA LDD T4 NJN LMD1 IF MORE DATA TO LOG LMD SUBR ENTRY/EXIT LMD1 LDC MBUF+2*5 SET BUFFER POINTER STD T1 STD BP ADK 15D*5 SET POINTER TO ASSEMBLY FOR LAST 4 BITS STD EC LMD2 LDN 0 CLEAR BUFFER STI T1 AOD T1 LMC MBUF+50D*5 NJN LMD2 IF MORE TO CLEAR STD T5 INITIALIZE COUNTER LDN 15D NUMBER OF WORDS PER BLOCK STD T1 LMD3 AOD MS+1 READ NEXT WORD SHN -14 RAD MS SHN 14 LMD MS+1 CRDL CN RJM PMR PACK WORD INTO *BCMR* RJM PWB PACK WORD INTO BUFFER LJM LMD4,T5 POSITION LAST 4 BITS * LJM LMD4 (LEFTMOST BITS) * LJM LMD4+1 (MIDDLE BITS) * LJM LMD4+2 (RIGHTMOST BITS) LMD4 SHN 4 SHN 4 RAI EC ADD TO ASSEMBLY SOD T4 ZJP LMD7 IF NO MORE DATA TO LOG AOD T5 SBN 3 MJN LMD5 IF NOT END OF BYTE LDN 0 RESET COUNTER STD T5 AOD EC ADVANCE TO NEXT BYTE LMD5 LDN 5 ADVANCE BUFFER POINTER RAD BP SOD T1 LMD6 NJP LMD3 IF NOT END OF GROUP LDN 15D RESET GROUP COUNTER STD T1 LDC 15D*5 ADVANCE ASSEMBLY BUFFER RAD EC LDN 5 SKIP OVER ASSEMBLY BUFFER RAD BP LMC MBUF+50D*5 ZJP LMD8 IF END OF *BML* MESSAGE LDN 16D INCREMENT WORD COUNT TO LOG RAM LMDA UJN LMD6 READ NEXT WORD LMR SPACE 4,10 ** LMR - LOG MAINTENANCE REGISTERS. * * ENTRY (CN - CN+3) = M/R CONTROL WORD. * (MB - MB+1) = ADDRESS OF CONTROL WORD. * (LMRA) = SIZE OF ELEMENT COUNTER BUFFER. * (LMRB) = SIZE OF M/R BUFFER. * (LMRD) = NON-REGISTER DATA FLAG. * * EXIT MAINTENANCE REGISTERS LOGGED TO *BML*. * (MB - MB+1) UNCHANGED. * * USES BP, T4, T5, T6, CM - CM+4, MS - MS+1. * * CALLS CBM, C9E, DOB, LNR, LSS, LTE, MDB, MRB, RMR, SID, WLB. * * MACROS RPTR. LMR10 RJM LNR LOG NON-REGISTER DATA LMR SUBR ENTRY/EXIT LMRC LDD CN+2 * UJN LMRX (NOS/VE LOGGING) SHN 21-MRLG PJN LMRX IF NO LOGGING ACTION LDC ** LMRD EQU *-1 (NON-REGISTER DATA FLAG) ZJN LMR10 IF PROCESSING NON-REGISTER DATA LDM IBMG+1 CLEAR NOT FIRST BLOCK FLAG SCN 10 STM IBMG+1 * LOCATE MAINTENANCE REGISTER BUFFER. LDC ** LMRB EQU *-1 (LENGTH OF M/R BUFFER) STD T4 RJM MRB GET ADDRESS OF M/R BUFFERS ADD CN+3 ADD OFFSET STD MS+1 SHN -14 STD MS * DETERMINE ANALYSIS CODE. LDD CN+1 GET ANALYSIS CODE LMC 0#707 ZJN LMR1 IF TO LOG ELEMENT COUNTER TABLE LMK 0#708&0#707 ZJN LMR4 IF TO LOG SECDED ID TABLE SHN -10 NJN LMR5 IF NOT WARNING ANALYSIS CODE * PROCESS WARNING ANALYSIS CODE. LDN 10D SET SIZE TO LOG UJN LMR2 LOG EID REGISTERS * PROCESS ELEMENT COUNTER TABLE. LMR1 LDC MECB LMRA EQU *-1 (SIZE OF ELEMENT COUNTER BUFFER) LMR2 STD T4 LMR3 RJM LTE LOG TABLE ENTRIES RJM WLB WRITE LAST *BML* MESSAGE LJM LMR8 LOG SUPPORTIVE STATUS DATA * PROCESS SECDED ID TABLE. LMR4 RJM SID SET SECDED INFORMATION NJN LMR3 IF SECDED ID TABLE NOT EMPTY UJN LMR9 RETURN * PROCESS MAINTENANCE REGISTERS. LMR5 LDN 0 PRESET *RMR* STD T5 STD T6 LDC IBMH-5 PRESET *GPB* STD BP LMR6 LCN 5 RAD T4 MJN LMR7 IF ALL BUFFERS PROCESSED LDD MS READ M/R BUFFER HEADER WORD SHN 14 LMD MS+1 CRML BDMR,ON RJM RMR READ MAINTENANCE REGISTER BUFFER NJN LMR7 IF LOGGING COMPLETE AOD MS+1 ADVANCE TO NEXT BUFFER SHN -14 RAD MS RJM C9E CHECK SPECIAL 990 ERROR NJN LMR6 IF NOT SPECIAL 990 ERROR LMR7 RJM CBM COMPLETE *BML* MESSAGES LMR8 RJM LSS LOG SUPPORTIVE STATUS DATA RJM MDB LOG MODEL DEPENDENT BUFFER LMR9 LDM IBMG CLEAR SPECIAL FLAGS FROM *BML* LPN 77 STM IBMG LJM LMRX RETURN LNR SPACE 4,10 ** LNR - LOG NON-REGISTER DATA. * * ENTRY (MB - MB+1) = ADDRESS OF CONTROL WORD FOR ENTRY. * (CN - CN+3) = CONTROL WORD FOR ENTRY TO LOG. * * EXIT NON-REGISTER DATA LOGGED TO BML. * * USES T4, MS - MS+1. * * CALLS LDT. LNR SUBR ENTRY/EXIT LDM IBMG SET NON-REGISTER DATA FLAG LPN 77 ADC 400 STM IBMG LDD MB INITIALIZE ADDRESS OF DATA TO LOG STD MS SHN 14 LMD MB+1 STD MS+1 ADN 1 LENGTH TO LOG WORD CRD CM READ LENGTH WORD LDD CM+4 SET LENGTH OF DATA TO INCLUDE LENGTH WORD STD T4 RJM LDT LOG DATA STRUCTURE LDM IBMG CLEAR NON-REGISTER DATA FLAG LPN 77 STM IBMG UJN LNRX RETURN LSS SPACE 4,15 ** LSS - LOG SUPPORTIVE STATUS DATA. * * ENTRY (SSCW - SSCW+1) = ADDRESS OF CONTROL WORD FOR ENTRY * TO LOG. * * EXIT SUPPORTIVE STATUS BUFFER DATA LOGGED. * (MDBB) = MODEL DEPENDENT BUFFER ORDINAL. * (MDBC) = MDB DATA UNLOGGED STATUS. * * USES T4, CM - CM+3, MS - MS+1. * * CALLS LDT. LSS SUBR ENTRY/EXIT LDM DFTV ZJN LSSX IF *DFT* VERSION 3 LDM SSCW SET ADDRESS OF CONTROL WORD STD MS SHN 14 LMM SSCW+1 STD MS+1 CRDL CM READ CONTROL WORD LDD CM+1 SET LENGTH OF DATA TO LOG STD T4 ZJN LSSX IF NO DATA TO LOG LDD CM+2 SAVE MODEL DEPENDENT BUFFER ORDINAL LPC 377 STM MDBB LDDL CM+2 SAVE UNLOGGED DATA STATUS SHN -10 STM MDBC LDD HN SET SUPPORTIVE STATUS BUFFER FLAG RAM IBMG RJM LDT LOG DATA STRUCTURE UJP LSSX RETURN LTE SPACE 4,15 ** LTE - LOG TABLE ENTRIES. * * ENTRY MESSAGE ID AND SYMPTOM CODE IN *BML* HEADER. * (T4) = WORD SIZE OF *BML* MESSAGE. * (MS - MS+1) = ADDRESS OF FIRST ENTRY TO LOG. * * EXIT ENTRIES LOGGED TO *BML*. * (T4) = CM WORDS TO WRITE IN LAST *BML* MESSAGE. * * USES MS - MS+1, T1, T4. * * CALLS DFM, LMB. LTE2 LDD MS READ LAST *BML* MESSAGE DATA SHN 14 LMD MS+1 CRM IBMH,T4 AOD T4 ADD HEADER WORDS TO COUNT AOD T4 LTE SUBR ENTRY/EXIT LTE1 LDN 4 STD T1 LDM IBMG+1 SET CONTINUATION BIT SCN 4 LMN 4 STM IBMG+1 LDD T4 SBN 5 MJN LTE2 IF LAST *BML* MESSAGE TO ISSUE ADN 1 STD T4 LDD MS SHN 14 LMD MS+1 CRM IBMH,T1 READ BUFFER INTO *BML* STD MS+1 SHN -14 STD MS LDN 6*5 PP WORDS IN *BML* MESSAGE STD CM+1 LDC IBMF+BMLN ISSUE *BML* MESSAGE RJM DFM LDM IBMG+1 SET NOT FIRST BLOCK FLAG SCN 10 LMN 10 STM IBMG+1 LJM LTE1 PROCESS NEXT *BML* MESSAGE MDB SPACE 4,15 ** MDB - LOG MODEL DEPENDENT BUFFER DATA. * * ENTRY (MB - MB+1) = ADDRESS OF M/R BUFFER CONTROL WORD. * (MDBA) = ADDRESS OF MODEL DEPENDENT BUFFER. * (MDBB) = MODEL DEPENDENT BUFFER ORDINAL. * (MDBC) = MODEL DEPENDENT DATA UNLOGGED STATUS. * * EXIT MODEL DEPENDENT BUFFER DATA LOGGED. * * USES T1, T4, CM - CM+3, MS - MS+1, T8 - T9. * * CALLS LMD. * * MACROS RPTR. MDB SUBR ENTRY/EXIT LDD MB READ M/R BUFFER CONTROL WORD SHN 14 LMD MB+1 CRDL CM LDDL CM+2 SHN 21-MRMD PJN MDBX IF NO MODEL DEPENDENT DATA MDBA LDC ** (MODEL DEPENDENT BUFFER ADDRESS) ADC ** MDBB EQU *-1 (MODEL DEPENDENT BUFFER ORDINAL) CRDL CM READ MODEL DEPENDENT BUFFER POINTER LDC * MDBC EQU *-1 (DATA UNLOGGED STATUS) NJN MDBX IF DATA UNLOGGED OR OVERWRITTEN RPTR CM CONVERT ADDRESS CRDL CM READ HEADER STD MS+1 SAVE ADDRESS OF HEADER STD T9 SHN -14 STD MS STD T8 LDD CM+3 SET LENGTH TO LOG ZJN MDBX IF NO DATA TO LOG SBN 1 STD T4 LDM IBMG SET MODEL DEPENDENT DATA FLAG LPN 77 ADC 200 STM IBMG LDM IBMG+1 SCN 14 CLEAR NOT FIRST BLOCK FLAG LMN 4 SET CONTINUATION BIT STM IBMG+1 LDN 2 MOVE MESSAGE HEADER TO PP BUFFER STD T1 LDD MA CWM IBMF,T1 SBD T1 CRM MBUF,T1 LDN ZERL CLEAR *EMB* HEADER WORD CRM BHDR,ON LDK MLDY SET MESSAGE TYPE STM BHDR+4 RJM LMD LOG MODEL DEPENDENT DATA LDD T8 READ MODEL DEPENDENT HEADER SHN 14 LMD T9 CRDL CM LDDL CM CLEAR CONTROL WORD OFFSET LPC 0#FF00 STDL CM LDD T8 SHN 14 LMD T9 CWDL CM MDB1 DELAY LDK EMBP CHECK FOR *1MD* STILL ACTIVE CRD CM LDD CM+1 SHN 14 LMD CM+2 CRD CM LDD CM+4 LPN 2 NJN MDB1 IF *1MD* ACTIVE UJP MDBX RETURN MRB SPACE 4,10 ** MRB - GET M/R BUFFERS ADDRESS. * * (A) = ADDRESS OF M/R BUFFERS. MRB SUBR ENTRY/EXIT MRBA LDC ** (ADDRESS OF M/R BUFFERS) UJN MRBX RETURN MRER SPACE 4,10 ** MRER - MAINTENANCE REGISTER ERROR HANDLER. * * ENTRY FATAL MAINTENANCE REGISTER ERROR. * * EXIT TO *CSH*. * * USES CM - CM+4. * * CALLS CSH. * * MACROS MONITOR. MRER LDC MSME SET MESSAGE ADDRESS STM CSHA STM CSHB STM CKPA+2 LDN SPLG SET *1MB* FUNCTION CODE STM CKPA+3 LDN ZERL CRD CM LDN 1 SET *MCH* ERROR IN PROGRESS STD CM+1 STD CM+2 LDD MA CWM MRERA,ON MONITOR UADM RJM CSH CHECKPOINT AND HANG THE SYSTEM MRERA CON LIOS INCREMENT LOW CORE FIELD BY ONE CON INWL WORD ADDRESS CON 5*100+1 BIT ADDRESS/FIELD WIDTH CON 0 CON 0 PMB SPACE 4,15 ** PMB - PACK MAINTENANCE REGISTER TO *BML*. * * ENTRY (T5) = BYTE IN M/R HEADER WORD WITH REGISTER NUMBER. * (BCMR - BCMR+7) = CONTENTS OF REGISTER. * * EXIT REGISTER WRITTEN TO *BML*. * (A)= (T5) = 0, IF ALL REGISTERS IN THIS BLOCK * WRITTEN. * (T5) = BYTE WITH NEXT REGISTER NUMBER, OTHERWISE. * * USES T5. * * CALLS GPB, PWB. PMB SUBR ENTRY/EXIT RJM GPB GET POINTER INTO *BML* BUFFER RJM PWB PACK REGISTER INTO BUFFER SHN 10 LMML BDMR,T5 INCLUDE REGISTER NUMBER STM PMBB,T5 AOD T5 SBN 4 MJN PMB1 IF TRAILER WORD NOT FULL RJM GPB GET POINTER TO *BML* BUFFER LDD BP STM PMBA LDD MA CWM PMBB,ON COPY TRAILER WORD TO *BML* BUFFER LDD MA CRM **,ON PMBA EQU *-1 LDN 0 STD T5 PMB1 UJP PMBX RETURN PMBB VFD 4/0,8/0,4/0,8/0,4/0,8/0,4/0,8/0,12/0 PMR SPACE 4,10 ** PMR - UNPACK M/R INTO *BCMR*. * * ENTRY (CN - CN+3) = REGISTER. * * EXIT MAINTENANCE REGISTER WRITTEN TO *BML* BUFFER. * * USES T3, T7. PMR SUBR ENTRY/EXIT LDN 0 STD T3 LDN CN STD T7 PMR1 LDIL T7 SHN -10 STM BCMR,T3 AOD T3 LDIL T7 LPC 377 STM BCMR,T3 AOD T3 AOD T7 SBN CN+4 ZJN PMRX IF PACKING COMPLETE UJN PMR1 CONTINUE PACKING PWB SPACE 4,10 ** PWB - PACK WORD TO BUFFER. * * ENTRY (BCMR - BCMR+7) = DATA WORD. * (BP) = OFFSET INTO *BML* BUFFER. * * EXIT (A) = BITS 60 - 63 OF DATA WORD RIGHT JUSTIFIED. * BITS 0 - 59 OF DATA WORD MOVED TO *BML* WORD. PWB SUBR ENTRY/EXIT LDM BCMR PACK REGISTER INTO BUFFER SHN 10 LMM BCMR+1 SHN -4+22 STI BP SHN 0+4-22 SHN 10 LMM BCMR+2 STM 1,BP LDM BCMR+3 SHN 10 LMM BCMR+4 SHN -4+22 STM 2,BP SHN 0+4-22 SHN 10 LMM BCMR+5 STM 3,BP LDM BCMR+6 SHN 10 LMM BCMR+7 SHN -4+22 STM 4,BP SHN 0+4-22 UJP PWBX RETURN RMR SPACE 4,10 ** RMR - READ MAINTENANCE REGISTER. * * ENTRY (BDMR - BDMR+3) = M/R CONTROL WORD. * (MS - MS+1) = ADDRESS OF MAINTENANCE REGISTER. * (T5) = BYTE WITH NEXT REGISTER NUMBER TO LOG. * (T6) = 0 IF STATUS SUMMARY NOT YET LOGGED. * * EXIT (A) = 0, IF MORE BUFFERS TO CHECK. * * USES CN - CN+3, MS - MS+1, T5. * * CALLS PMB, PMR. RMR SUBR ENTRY/EXIT RMR1 LDML BDMR,T5 GET NEXT REGISTER NUMBER NJN RMR2 IF REGISTER IS PRESENT LDD T6 NJN RMRX IF ALL REGISTERS LOGGED RMRA LDN 1 SET STATUS SUMMARY LOGGED STD T6 RMR2 AOD MS+1 READ MAINTENANCE REGISTER SHN -14 RAD MS SHN 14 LMD MS+1 CRDL CN RJM PMR PACK REGISTER INTO *BCMR* BUFFER RJM PMB PACK M/R INTO *BML* MESSAGE ZJN RMRX IF BUFFER COMPLETE UJN RMR1 PROCESS NEXT REGISTER SCA SPACE 4,10 ** SCA - SET M/R BUFFER CONTROL WORDS ADDRESS. * * EXIT (MB - MB+1) = ADDRESS OF FIRST M/R CONTROL WORD. * * CALLS DOB. * * USES CM - CM+3, MB - MB+1. * * MACROS RPTR. SCA SUBR ENTRY/EXIT RJM DOB SCAA ADK DFHL * UJN SCA2 (*DFT* VERSION 4 OR ABOVE) SCA1 STD MB+1 SAVE ADDRESS SHN -14 STD MB UJN SCAX RETURN SCA2 ADK DFBC CRDL CM READ M/R BUFFER CONTROL WORD POINTER RPTR CM CONVERT ADDRESS UJN SCA1 SAVE ADDRESS SDA SPACE 4,10 ** SDA - SET NOS REQUEST HEADER ADDRESS. * * EXIT (A) = ADDRESS OF NOS REQUEST HEADER. SDA SUBR ENTRY/EXIT SDAA LDC ** (ADDRESS OF NOS REQUEST HEADER) UJN SDAX RETURN SID SPACE 4,10 ** SID - SET SECDED ID TABLE INFORMATION. * * ENTRY (MS - MS+1) = ADDRESS OF M/R BUFFER. * * EXIT (A) = NUMBER OF SECDED ENTRIES. * * USES CM - CM+4, MS - MS+1, T1 - T1+4. SID SUBR ENTRY/EXIT LDD MS READ MEMORY SIZE SHN 14 LMD MS+1 CRD CM ADN 1 READ MEMORY MODEL CRD T1 LDD T1+3 SHN -4 STM IBMG+2 STORE MEMORY MODEL LDDL CM ADD MEMORY SIZE TO *BML* SHN 22-4 STM IBMF+3 SHN 4-22 SHN 10 STD T1 LDDL CM+1 SHN -10 LMD T1 STM IBMF+4 LDN 2 ADVANCE TO SECDED ENTRIES RAD MS+1 SHN -14 RAD MS * CALCULATE SECDED TABLE SIZE. LDN 0 STD T4 SID1 LDD MS READ NEXT SECDED ENTRY SHN 14 LMD MS+1 ADD T4 CRD CM LDD CM CHECK IF EMPTY ENTRY ADD CM+1 ADD CM+2 ADD CM+3 ADD CM+4 SBN 1 MJN SID2 IF LAST ENTRY AOD T4 UJN SID1 CHECK NEXT ENTRY SID2 LDD T4 RETURN SECDED SIZE UJP SIDX RETURN UCC SPACE 4,10 ** UCC - UPDATE CTI CLOCK. * * ENTRY DURING TOP-OF-HOUR PROCESSING. * * EXIT *1MA* CALLED IF TIME IS MIDNIGHT. * * USES CM - CM+4. * * MACROS MONITOR. UCC SUBR ENTRY/EXIT LDN PDTL CHECK TIME CRD CM LDD CM+3 LPN 77 NJN UCCX IF NOT MIDNIGHT LDD IR+1 UPDATE CONTROL POINT NUMBER LPN 37 RAM UCCA+1 LDD MA WRITE *1MA* REQUEST TO MESSAGE BUFFER CWM UCCA,ON MONITOR RPPM REQUEST PP FOR *1MA* UJN UCCX RETURN UCCA VFD 18/3L1MA,6/**,12/6,12/,12/ WLB SPACE 4,10 ** WLB - WRITE LAST *BML* MESSAGE. * * ENTRY DATA FOR LAST *BML* MESSAGE IN BUFFER. * (T4) = WORD COUNT OF MESSAGE. * * EXIT LAST *BML* MESSAGE WRITTEN. * * CALLS DFM. * * USES CM - CM+4. WLB SUBR ENTRY/EXIT LDM IBMG+1 CLEAR CONTINUATION BIT SCN 4 STM IBMG+1 LDN ZERL CRD CM LDD T4 SET BYTE COUNT SHN 2 ADD T4 STD CM+1 LDC IBMF+BMLN SEND LAST *BML* MESSAGE RJM DFM UJN WLBX RETURN LINS SPACE 4,10 LINS BSS 0 TABLE OF LONG INSTRUCTIONS LIST16 SPACE 4,10 ** COMMON DECKS. *CALL COMPDLI QUAL COMPIMB LIST X *CALL COMPIMB LIST * QUAL * IMB EQU /COMPIMB/IMB SPACE 4,15 ** MAINTENANCE REGISTER BUFFERS. BCMR EQU * BDMR EQU BCMR+10 PRGB EQU BDMR+10 PP REGISTER BUFFER BHDR EQU PRGB *EMB* HEADER WORD MBUF EQU BHDR+5 MODEL DEPENDENT DATA *BML* BUFFER ERRPL PRGB+240B-EPFW PP REGISTER BUFFER OVERFLOW ERRPL MBUF+50D*5-EPFW MODEL DEPENDENT DATA BUFFER OVERFLOW TITLE OVERLAYABLE SUBROUTINES. * THESE SUBROUTINES ARE OVERLAYED BY THE MAINTENANCE REGISTER * AND MODEL DEPENDENT DATA BUFFERS. SBA SPACE 4,25 ** SBA - SET BUFFER ADDRESSES. * * EXIT (DC - DC+3) = *DFT* CONTROL WORD. * (DOBA - DOBA+1) = DFT/OS BUFFER ADDRESS. * (SDAA - SDAA+1) = NOS REQUEST HEADER ADDRESS. * (MRBA - MRBA+1) = ADDRESS OF M/R BUFFERS. * (LMRB) = LENGTH OF M/R BUFFER. * MACHINE ID, MESSAGE ID AND CHANNEL PLACED IN *BML* * MESSAGE BUFFER. * *DFT* VERSION PLACED IN *BML* MESSAGE BUFFER. * CODE MODIFIED TO SKIP LOGGING IF NOS/VE IS LOGGING. * * IN ADDITION, FOR *DFT* VERSION 4 OR ABOVE - * (DFTV) = *DFT* VERSION. * (LMRA) = SIZE OF ELEMENT COUNTER BUFFER. * (FNRA - FNRA+1) = NON-REGISTER DATA ADDRESS. * (LSSA - LSSA+1) = SUPPORTIVE STATUS BUFFER ADDRESS. * (MDBA - MDBA+1) = MODEL DEPENDENT BUFFER ADDRESS. * * USES CM - CM+4, CN - CN+4, DC - DC+3. * * CALLS DLI, DOB, DSP. * * MACROS ISTORE, RPTR. SBA SUBR ENTRY/EXIT LDC SBAL DEFINE LONG INSTRUCTIONS RJM DLI RJM DSP READ *DFT/OS* BUFFER POINTER ADK DSCM+3 CRDL CN RPTR CN,DOBA SET *DFT/OS* BUFFER ADDRESS RJM DOB READ *DFT* CONTROL WORD ADK DFCW CRDL DC ADK DFRQ-DFCW READ NOS REQUEST HEADER POINTER CRDL CM ADK DFMR-DFRQ READ M/R BUFFERS POINTER CRDL CN RPTR CN,MRBA SAVE FWA OF M/R BUFFERS RPTR CM,SDAA SET ADDRESS OF NOS REQUEST HEADER LDDL DC+2 SET LENGTH OF M/R BUFFER SHN -10 STM LMRB LDDL DC+1 GET *DFT* VERSION SHN -10 LPN 77 STM IBMG SET *DFT* VERSION INTO *BML* SHN -2 STM DFTV SAVE *DFT* VERSION (0 = VERSION 3) ZJP SBA2 IF *DFT* VERSION 3 ISTORE SCAA,(UJN SCA2) USE POINTER TO FIND CONTROL WORDS RJM DOB ADK DFMD READ MODEL DEPENDENT BUFFER POINTER CRDL T1 ADK DFSS-DFMD READ SUPPORTIVE STATUS BUFFER POINTER CRDL CM ADK DFNR-DFSS READ NON-REGISTER DATA POINTER CRDL CN RPTR T1,MDBA SAVE FWA OF MODEL DEPENDENT BUFFER RPTR CM,FSSA SAVE FWA OF SUPPORTIVE STATUS DATA LDM IBMG CHECK FOR *DFT* VERSION 5 AND ABOVE SBN 5 MJN SBA1 IF *DFT* VERSION 4 OR PRIOR RPTR CN,FNRA SAVE FWA OF NON-REGISTER DATA LDDL DC+3 CHECK DEDICATED MODE SHN 21-DCDM PJN SBA1 IF *DFT* IS IN DEDICATED MODE LDD IR+2 CHECK FOR TOP OF HOUR LPN SPTP ZJN SBA0 IF NOT TOP OF HOUR ISTORE CTPB,(LDN SPTH) SET TO SECOND TOP OF HOUR FUNCTION UJN SBA1 CONTINUE SBA0 LDD IR+2 CHECK FOR TOP OF HOUR PASS TWO LPN SPTH ZJN SBA1 IF NOT TOP OF HOUR PASS TWO ISTORE DPPA,(UJN DPP5) SET TO RECALL *DFT* * LPN SPTP LPN SPLG STD IR+2 LDD IA REWRITE INPUT REGISTER CWD IR SBA1 RJM DOB ADK DFEC READ ELEMENT COUNTER BUFFER POINTER CRDL CM LDD CM+3 SAVE SIZE OF BUFFER STM LMRA SBA2 LDDL DC+3 CHECK OS LOGGING FLAG SHN 21-DCLG MJN SBA3 IF 170 LOGGING ISTORE LMRC,(UJN LMRX) SKIP LOGGING LDC LJMI SET *LJM* STM CTPA LDC CTPX SET *LJM* ADDRESS STM CTPA+1 LDBC (MRV7,MRIL) STM FOMA+1 LDBC (MRV7,MRIL) LMC SCNI STM MEPC SBA3 LDC MMFL SET MACHINE ID INTO *BML* CRD CM LDD CM STM IBMG+3 LDC /COMSDFS/HM0250 SET MESSAGE ID INTO *BML* STM IBMF LDN MR SET CHANNEL NUMBER INTO *BML* RAM IBMF+2 LDC 400000B+SBAL CLEAR LONG INSTRUCTIONS RJM DLI LJM SBAX RETURN SBAL BSS 0 TABLE OF LONG INSTRUCTIONS LIST16 TITLE COMMON PRESET. PRESET SPACE 4,10 ** PRESET - COMMON PRESET CODE FOR *1MB* AND *1SC*. * * THIS MACRO PROVIDES IDENTICAL CODE FOR *1MB* AND *1SC*. * * ENTRY (IR+2) = *1MB* FUNCTION BITS. * * EXIT (MF) = MAINFRAME TYPE. * = 0 = MF70 = CYBER 70. * = 1 = MF170 = CYBER 170. * = 2 = MF700 = CYBER 170 - 700 SERIES. * = 3 = MF865 = CYBER 170 - 865. * = 4 = MF875 = CYBER 170 - 875. * = 5 = MF180 = CYBER 180 CLASS MACHINE. * = 6 = MF176A = CYBER 176 LEVEL A. * = 7 = MF176B = CYBER 176 LEVEL B. * (PN) = PP NUMBER * 100B * * ERROR EXIT TO *PPR* IF CALLED WITH INCORRECT FUNCTION CODE. * * USES MF, T1, T3, T4, CM - CM+4, MI - MI+4, SC - SC+4. * * CALLS DFM. PRESET MACRO PRESET RMT LIST D PRS SUBR ENTRY/EXIT LDK MABL READ MAINFRAME IDENTIFICATION CRD MI LDC SCRL READ *SCRL* WORD CRD SC LDN MF70 PRESET CYBER 70 MAINFRAME TYPE STD MF LDD MI+1 SHN 21-7 PJN PRS8 IF CYBER 70 SHN 21-13-21+7+22 MJN PRS3 IF NOT CYBER 180 CLASS MACHINE SHN 0-2-21+13+22 LPN 21 ZJN PRS2 IF CYBER 170 - 865 LMN 1 ZJN PRS1 IF CYBER 170 - 875 LDN MF180&MF875 PRS1 LMN MF875&MF865 PRS2 LMN MF865 UJN PRS7 SET MACHINE TYPE PRS3 SHN 0-10-21+13 LMN 17 ZJN PRS5 IF CYBER 176 LEVEL A LMN 16&17 ZJN PRS6 IF CYBER 176 LEVEL B LPN 1 ZJN PRS4 IF CYBER 170 - 700 SERIES LDN MF170&MF700 PRS4 LMN MF700&MF176A PRS5 LMN MF176A&MF176B PRS6 LMN MF176B PRS7 STD MF PRS8 LDD IR+2 CHECK FUNCTION BITS SBK SPMX MJN PRS12 IF LEGAL FUNCTION * PROCESS INCORRECT FUNCTION CODE. LDC PRSA ISSUE CALL ERROR MESSAGE RJM DFM MONITOR DPPM LJM PPR EXIT TO PP RESIDENT PRS12 LDD CP SET CONTROL POINT NUMBER IN PP CALL SHN -7 RAM CKPA+1 LDN PPCP STORE LOGICAL PP NUMBER BEING USED CRD CM LDD IA SBD CM+4 SHN -3 SBN 12 CHECK BARREL MJN PRS12.1 IF IN LOWER BARREL ADN 20-12 ADJUST FOR PP20-PP31 PRS12.1 ADN 12 SHN 6 STM IBMF+2 STD PN LJM PRS13 COMPLETE PRESET PRSA DATA C* 1MB - CALL ERROR.* LIST * PRESET RMT PRESET ENDM TITLE PRESET. SPACE 4,10 ** COMMON PRESET. PRESET PRESET HERE PRS13 LDD CP SHN -7 RAM MEPD+1 PRESET CP IN *1DS* CALL * PLUG *EMB* ADDRESSES. LDK EMBP FETCH *EMB* POINTER CRD CM .CM1 EQU CM+1 LDC .CM1*10000+TEMB RJM STA SET *EMB* ADDRESSES LJM PRSX EXIT PRESET TEMB BSS 0 TABLE OF *EMB* ADDRESSES QUAL COMPIMB TEMB HERE QUAL * CON 0 TERMINATE TABLE STA SPACE 4,10 ** STA - SET TABLE ADDRESSES. * * ENTRY (A) = 6/ TP, 12/ TA * TP = TABLE POINTER. * TA = INSTRUCTION TABLE ADDRESS. * * EXIT (A) = 0. * * USES T0, T1, T2. STA1 STD T2 SET INSTRUCTION ADDRESS LDM 1,T1 RAM 1,T2 SET LOWER 12 BITS OF ADDRESS SHN -14 ADI T1 SET UPPER 6 BITS OF ADDRESS LPN 37 RAI T2 AOD T0 ADVANCE INSTRUCTION LIST STA2 LDI T0 NJN STA1 IF NOT END OF TABLE STA SUBR ENTRY/EXIT STD T0 SHN -14 SET ADDRESS POINTER STD T1 UJN STA2 ENTER LOOP L1MB EQU * LWA+1 OF *1MB* CODE SPACE 4,10 OVERFLOW PPFW,EPFW TTL 1MB/1SC - SCR ERROR PROCESSOR. TITLE IDENT 1SC,PPFW QUAL 1SC *COMMENT 1MB - SCR ERROR PROCESSOR. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. SEP SPACE 4,10 *** SEP - SCR ERROR PROCESSOR. * * *SEP* IS THE MAIN DRIVER THAT PROCESSES ERRORS * DETECTED IN THE SCR (OR SIMULATED SCR). *1SC* IS CALLED * FOR LOGGING *UIDL* (SEE *COMSSCR*) UNIQUE SECDED ERRORS, * FOR END-OF-HOUR PROCESSING, AND FOR ALL SCR ERRORS OTHER * THAN SECDED ERRORS. * * *1SC* FIRST CHECKS FOR GROUP 1 AND GROUP 2 FATAL ERRORS (SEE * *COMSSCR*). IF ANY OF THESE BITS ARE SET, *1SC* DISPLAYS * *FATAL MAINFRAME ERROR*, CHECKPOINTS THE DEVICES (IF NOT A * IAF ERROR), REQUESTS STEP MODE, AND HANGS THE PP. IF NO * FATAL ERROR BITS ARE DETECTED, *1SC* CONTINUES CHECKING FOR * OTHER ERRORS. * * *1SC* THEN CHECKS THE S/C REGISTER FOR BITS 36 AND/OR * 37 SET. IF BIT 36 (POWER FAILURE) IS SET, THE STEP * REQUEST BIT IN CM WORD *SCRL* IS SET AND A STEP FUNCTION * IS ISSUED. THE S/C REGISTER(S) ARE READ ALONG WITH THE * TIME OF DAY. IF ONLY BIT 36 IS SET, THE MESSAGE * *POWER FAILURE.* IS DISPLAYED AT THE SYSTEM CONTROL * POINT. IF BOTH BITS 36 AND 37 ARE SET, THE MESSAGE * *POWER DOWN.* IS DISPLAYED. IF BIT 37 ALONE IS SET, *1CK* * IS CALLED TO PERFORM A SYSTEM CHECKPOINT AND THE MESSAGE * *SHUTDOWN IMMINENT.* IS ENTERED IN THE ERROR LOG AND * DISPLAYED AT THE SYSTEM CP. THEN THE STEP REQUEST BIT * IS SET AND A STEP FUNCTION IS ISSUED. DURING THIS TIME * AND SUBSEQUENTLY, BITS 36 AND 37 ARE MONITORED AND THE * CONTROL POINT MESSAGE KEPT UP TO DATE. IF BIT 36 BECOMES * SET, STEP MODE IS IMMEDIATELY REQUESTED. IF BOTH BITS * BECOME CLEAR, THE MESSAGE *POWER/ENVIRONMENT NORMAL.* * IS DISPLAYED AT THE SYSTEM CONTROL POINT, THE S/C * REGISTER(S) AND THE TIME OF DAY ARE READ, AND THE STEP * REQUEST BIT IS CLEARED, ENABLING THE ENTERING OF THE * *DSD* COMMAND *UNSTEP.* BY THE OPERATOR. WHEN *UNSTEP.* * IS EXECUTED, *1SC* ENTERS INTO THE ERROR LOG AS * APPROPRIATE, THE MESSAGE *SR HH.MM.SS. POWER FAILURE.* * OR *SR HH.MM.SS. POWER DOWN.*. THE LAST MESSAGE SEQUENCE * IN THE ERROR LOG BEFORE *1MB* DROPS WILL BE * *SR HH.MM.SS. POWER/ENVIRONMENT NORMAL.*. * (ON A CYBER 70, BIT 0 OF THE INTERLOCK REGISTER INDICATES * POWER FAILURE. THERE IS NO SHUTDOWN IMMINENT BIT. THE * POWER FAILURE PROCEDURE DESCRIBED ABOVE IS FOLLOWED * EXCEPT THE MESSAGE PREFIX BECOMES *IR* INSTEAD OF *SR*.) * * IF S/C REGISTER BITS 36 AND/OR 37 ARE NOT SET, * *1SC* S/C REGISTER(S) PROCESSING WILL, FOR EACH * AVAILABLE S/C REGISTER, CLEAR APPROPRIATE ERROR * BITS, AND ISSUE ERROR INFORMATION TO THE BML. * * FOR PP MEMORY PARITY ERRORS, *1SC* WILL DISPLAY A * *PP MEMORY PARITY ERROR* MESSAGE AT THE SYSTEM * CONTROL POINT. * * EACH SINGLE BIT SECDED ERROR DETECTED IN THE SCR (OR * SIMULATED SCR) WILL BE COUNTED. THE FIRST *UIDL* UNIQUE * PER HOUR WILL BE LOGGED (SUBSEQUENT SINGLE BIT SECDED * ERRORS DETECTED BY MONITOR WILL MERELY INCREMENT THE COUNTS * AND CLEAR THE ERROR BITS IN MONITOR ITSELF). AT THE END OF * EACH HOUR, THE *TIME PROCESSING* CALL TO *1SC* WILL CAUSE * THE CURRENT SINGLE BIT SECDED ERROR COUNT TO BE LOGGED TO * THE ERROR LOG. THE CM AND LCME SECDED ID TABLES AND COUNTS * WILL ALSO BE LOGGED TO THE BML. THESE TABLES AND COUNTS * WILL THEN BE CLEARED AFTER LOGGING. THE ESM SECDED * ERROR LOG IS ALSO LOGGED TO THE BML, IF AN ESM * MAINTENANCE PORT IS DEFINED. * * FOR CYBER 176 MACHINES, LCME SINGLE BIT SECDED * ERRORS ARE HANDLED IN A SIMILAR MANNER. THE * THRESHOLD VALUE FOR LCME IS ALSO DEFINED BY *UIDL*. * * ALL DETECTED DOUBLE BIT SECDED ERRORS WILL BE LOGGED. * * NOTE - *1SC* IS, TO AN EXTENT, FUNCTION-DRIVEN BY BITS. ONE * BIT IN THE PARAMETER LIST DENOTES WHETHER OR NOT MONITOR HAS * DETECTED A CM SINGLE BIT SECDED ERROR. A SECOND BIT * SPECIFIES IF AN LCME SINGLE BIT SECDED ERROR HAS BEEN * DETECTED. A THIRD BIT DENOTES IF END-OF-HOUR PROCESSING HAS * BEEN SPECIFIED. THUS, AN OPEN WINDOW FOR SECDED ERRORS * EXISTS FROM THE TIME MONITOR CALLS *1SC* UNTIL *1SC* BEGINS * PROCESSING. THIS PRESENTS NO MAJOR CONCERN, HOWEVER, SINCE * *1SC* WILL NOT PROCESS ANY SECDED ERRORS NOT DETECTED BY * MONITOR. THOSE SECDED BITS WILL REMAIN SET UNTIL MONITOR * DETECTS THE ERROR IN ITS NEXT CYCLE. * WHEN *1SC* IS FINISHED, IT WILL CLEAR BIT 59 IN * CM LOCATION *SCRL*, SET BY *MTR*, TO RE-ENABLE * S/C REGISTER ERROR LOGGING. SPACE 4,10 *** CALL. * * *T IR 18/ *1SC*,1/0,5/ CP,9/0,1/ C,1/ L,1/ T,24/0 * CP CONTROL POINT NUMBER. * C SET IF CM SINGLE BIT SECDED ERROR. * L SET IF LCME SINGLE BIT SECDED ERROR (176 ONLY). * T SET IF TIME PROCESSING SPECIFIED. SPACE 4,10 *** DAYFILE MESSAGES. * * * * 1SC - CALL ERROR.* = *1SC* WAS CALLED WITH AN ILLEGAL * FUNCTION BIT CODE. * * * 1SC - ESM CHANNEL HANG.* = THE ESM MAINTENANCE * CHANNEL HUNG ACTIVE WHILE WAITING TO FUNCTION THE * ESM TO READ THE ESM SECDED LOG. * * * 1SC - INCOMPLETE ESM SECDED READ.* = *1SC* DETECTED * THAT NOT ALL OF THE ESM SECDED LOG WAS READ OFF THE * ESM MAINTENANCE CHANNEL. SPACE 4,20 *** SCR PROCESSING SYSTEM CONTROL POINT MESSAGES. * * * * FATAL MAINFRAME ERROR.* * * * POWER FAILURE.* * BIT 36 OF S/C REGISTER SET. * BIT 0 OF INTERLOCK REGISTER SET (CYBER 70) * * * SHUTDOWN IMMINENT.* * BIT 37 OF S/C REGISTER SET. * * * POWER DOWN.* * BOTH BITS 36 AND 37 OF S/C REGISTER SET. * * * POWER/ENVIRONMENT NORMAL.* * BOTH BITS 36 AND 37 OF S/C REGISTER CLEAR. SPACE 4,40 *** SCR PROCESSING ERROR LOG MESSAGES. * * * *SR HH.MM.SS. POWER FAILURE.* * *IR HH.MM.SS. POWER FAILURE.* (CYBER 70) * * *SR SHUTDOWN IMMINENT.* * * *SR HH.MM.SS. POWER DOWN.* * * *SR HH.MM.SS. POWER/ENVIRONMENT NORMAL.* * *IR HH.MM.SS. POWER/ENVIRONMENT NORMAL.* (CYBER 70) * * WHERE HH.MM.SS. IS TIME OF DAY. * ABOVE MESSAGES ARE FOLLOWED BY S/C REGISTER(S) * CONTENTS READ AT TIME HH.MM.SS. IN FORMAT * SHOWN ABOVE. ORG PPFW SEP RJM PSC PRESET FOR *1SC* RJM RSC READ S/C REGISTER(S) SEPA RJM CFE CHECK FOR FATAL ERRORS * UJN *+2 (IF CYBER 70 AND NO SIMULATION) RJM PEF CHECK FOR POWER OR ENVIRONMENTAL FAILURE RJM TEB CLEAR TEST ERROR BITS IN S/C RJM PSB PROCESS SINGLE BIT ERRORS RJM IBM ISSUE BML MESSAGE RJM PTP PERFORM TIME PROCESSING LJM DPP DROP PP SPACE 4,10 ** COMMON SUBROUTINES. COMMON LIST D COMMON HERE LIST * BIS SPACE 4,10 ** BIS - BUILD ID SUMMARY TABLE ADDRESS. * * ENTRY (SC - SC+4) = SCR PARAMETER WORD *SCRL*. * * EXIT (T3) = ID TABLE LENGTH. * * USES T3, T6, T7. BIS SUBR ENTRY/EXIT LDD SC BUILD ID SUMMARY TABLE ADDRESS LPN 77 SHN 14 LMD SC+1 BISA ADN UIDL * ADN UIDL*2 (ADD OFFSET FOR LCME ID TABLE) STD T7 SHN -14 STD T6 LDN UIDL GET ID TABLE LENGTH STD T3 UJN BISX RETURN CFE SPACE 4,10 ** CFE - CHECK FOR FATAL ERRORS. * * ENTRY (MF) = MAINFRAME TYPE FLAG. * * EXIT IF ANY FATAL ERROR BITS SET, HANGS WITH STEP MODE * SET, FORCING DEADSTART. OTHERWISE, EXIT IS NORMAL. * * USES T2, CM - CM+4, CN - CN+4. * * CALLS CSH, TRB. CFE SUBR ENTRY/EXIT LDM TSCR+20 TEST SCR FOR GROUP ONE FATAL ERRORS LPC FEM0 (CYBER 170) * LPC FEM6 (CYBER 176) * LPC FEM7 (CYBER 170 - 700 SERIES) * LPC FEM8 (CYBER 170 - 865/875) CFEA EQU *-1 NJN CFE1 IF FATAL ERROR LDM TSCR+17 NJN CFE1 IF FATAL ERROR LDD CH+1 ZJN CFE2 IF DONE WITH SCR REGISTERS LDM TSCR+40 ZJN CFE2 IF NO GROUP ONE FATAL ERRORS CFE1 LJM CFE7 PROCESS FATAL ERROR CFE2 LDN CMCE CHECK FOR *CMC* ERROR (BIT CLEAR ON 176) RJM TRB TEST BIT NJN CFE6 IF *CMC* INPUT ERROR CFE3 LDN SECD RJM TRB ZJN CFE4 IF NO SECDED ERROR LDC SDSC CHECK IF DOUBLE BIT ERROR RJM TRB ZJN CFE4 IF NO DOUBLE BIT ERROR LDD MF SBN MF176A MJN CFE6 IF NOT A CYBER 176 LJM CSH1 REQUEST STEP AND HANG CFE4 LDD MF GET MACHINE TYPE SBN MF176A MJN CFE5 IF NOT CYBER 176 LDN LSCD CHECK FOR LCME SECDED ERROR RJM TRB ZJN CFE5 IF NO LCME SECDED ERROR LDC LDSC CHECK IF DOUBLE BIT ERROR RJM TRB NJN CFE6 IF DOUBLE BIT LCME ERROR CFE5 LJM CFEX RETURN CFE6 LDD CP CHECK SYSTEM CONTROL POINT FOR *PEET* ADN STSW CRD CM LDD CM+1 LMN PEET ZJN CFE7 IF PROGRAM MODE CPUMTR ENCOUNTERED ERROR LDC VCPT*200+STSW CHECK FOR *IAF* ERROR CRD CM ADN JCIW-STSW-1 CRD CN LDD CN+2 LMC /SSD/IFSI NJN CFE8 IF NOT *IAF* LDD CM+1 LMN PEET NJN CFE8 IF ERROR NOT IN *IAF* FL CFE7 AOM CKPA+2 SET FUNCTION TO CHECKPOINT DEVICES CFE8 RJM CSH CHECKPOINT, STEP, AND HANG CSHM DATA C* FATAL MAINFRAME ERROR.* DEFAULT *CSH* MESSAGE IBM SPACE 4,10 ** IBM - ISSUE BML MESSAGE. * * ENTRY (IR+2) = *1MB* FUNCTION BITS. * (MF) = MAINFRAME TYPE. * (SC - SC+4) = SCR PARAMETER WORD *SCRL*. * * USES T3, T5 - T7, CM - CM+4, CN - CN+4, NW. * * CALLS BIS, DFM, OLB. IBM SUBR ENTRY/EXIT LDM TMID,MF GET MESSAGE ID STM IBMF LDC MMFL GET MACHINE ID CRD CM LDD CM STM IBMG+3 LDD MF CHECK FOR CYBER 70 ZJN IBMX IF INTERLOCK REGISTER LDN CHSC STORE SCR CHANNEL RAM IBMF+2 LDD ER ZJN IBM3 IF NO ERRORS IN SCR RJM OLB OUTPUT LOG TO BML IBM3 LDD IR+2 LPN SPTP ZJN IBMX IF NOT TIME PROCESSING * OUTPUT SECDED ERROR SUMMARY TABLE TO BML. IBM4 LDM IBMH+2 RESET FIRST SCR CHANNEL SCN 77 LMD CH STM IBMH+2 LDC /COMSDFS/HS0102 (CM SUMMARY TABLE) * LDC /COMSDFS/HS0104 (LCME SUMMARY TABLE) IBMA EQU *-1 STM IBMF+1 LDN ZERL SAVE 5 WORDS OF ZEROES CRD CN RJM BIS BUILD ID SUMMARY TABLE ADDRESS LDN 0 INITIALIZE TOTAL MESSAGE WORD COUNT STD NW IBM5 SOD T7 DECREMENT NEXT TABLE ENTRY ADDRESS PJN IBM6 IF NO UNDERFLOW SOD T6 AOD T7 IBM6 LDD T6 READ NEXT ID TABLE ENTRY SHN 14 ADD T7 CRD CM LDD CM+4 CHECK IF ERROR COUNT .GT. 0 ZJN IBM7 IF REMAINING TABLE ENTRIES EMPTY AOD NW INCREMENT UNIQUE SECDED ERROR COUNT SOD T3 NJN IBM5 IF ENTIRE ID TABLE NOT SEARCHED IBM7 RJM BIS REBUILD LWA+1 OF TABLE RAM BISA IBM8 LDD NW NJN IBM10 IF SECDED ERRORS OCCURRED THIS HOUR LDD MF SBN MF176A MJN IBM9 IF NOT CYBER 176 LDN /COMSDFS/HS0104-/COMSDFS/HS0102 LCME ERRORS ID RAM IBMA LMC /COMSDFS/HS0104 NJN IBM9 IF LCME ERRORS REPORTED LJM IBM4 PROCESS LCME SECDED SUMMARY TABLE IBM9 LJM IBMX RETURN IBM10 LDN 12 INITIALIZE BML MESSAGE BYTE COUNT STD T5 LDC IBMH INITIALIZE MESSAGE BUFFER POINTER STM IBME IBM11 SOD T7 DECREMENT NEXT TABLE ENTRY ADDRESS PJN IBM12 IF NO UNDERFLOW SOD T6 AOD T7 IBM12 LDD NW ZJN IBM13 IF TIME TO ISSUE DAYFILE MESSAGE SOD NW DECREMENT UNIQUE SECDED ERROR COUNT LDD T6 READ NEXT TABLE ENTRY INTO MESSAGE BUFFER SHN 14 ADD T7 CRM IBMH,ON IBME EQU *-1 * CRM IBMH+5,ON * CRM IBMH+12,ON * CRM IBMH+17,ON SBN 1 RESET CURRENT ID TABLE ADDRESS CWD CN CLEAR ID SUMMARY TABLE ENTRY LDN 5 INCREMENT MESSAGE BUFFER POINTER RAM IBME LDN 5 INCREMENT MESSAGE BYTE COUNT RAD T5 SBN 36 ZJN IBM13 IF BML MESSAGE BUFFER FULL LJM IBM11 PROCESS MORE TABLE ENTRIES * ISSUE DAYFILE MESSAGE. IBM13 LDN ZERL CLEAR CM REGISTERS FOR DAYFILE CALL CRD CM LDD T5 SET BYTE COUNT OF MESSAGE STD CM+1 LDD NW ZJN IBM14 IF END OF BML MESSAGE LDM IBMG+1 SET CONTINUATION BIT STATUS SCN 4 LMN 4 UJN IBM15 STORE STATUS IBM14 LDM IBMG+1 STORE MESSAGE STATUS SCN 4 IBM15 STM IBMG+1 LDC IBMF+BMLN ISSUE DAYFILE MESSAGE RJM DFM LDM IBMG+1 SET NOT FIRST BLOCK FLAG SCN 10 LMN 10 STM IBMG+1 LJM IBM8 CONTINUE PROCESSING SPACE 4,10 TMID INDEX TABLE OF MESSAGE IDS INDEX MF170,/COMSDFS/HM0200 CYBER 170 INDEX MF700,/COMSDFS/HM0201 CYBER 170 - 700 SERIES INDEX MF865,/COMSDFS/HM0204 CYBER 170 - 865 INDEX MF875,/COMSDFS/HM0205 CYBER 170 - 875 INDEX MF176A,/COMSDFS/HM0202 CYBER 176 LEVEL A INDEX MF176B,/COMSDFS/HM0203 CYBER 176 LEVEL B INDEX MFMAX ODW SPACE 4,10 ** ODW - OUTPUT DESCRIPTOR WORD TO SCR. * * ENTRY (A) = DESCRIPTOR WORD. * CHANNEL INSTRUCTION SET. * * EXIT (A) = SCR REPLY WORD. ODW SUBR ENTRY/EXIT OAN CHSC OUTPUT DESCRIPTOR WORD * OAN CHSC+20 (SECOND SCR) * OAN 15 (INTERLOCK REGISTER) ODWA EQU *-1 IAN CHSC INPUT SCR REPLY WORD * IAN CHSC+20 (SECOND SCR) * IAN 15 (INTERLOCK REGISTER) ODWB EQU *-1 UJN ODWX EXIT OLB SPACE 4,10 ** OLB - OUTPUT LOG TO *BML*. * * ENTRY (CH+1) = 0, IF ONLY ONE SCR REGISTER. * TABLE *TSCR* CONTAINS SCR SECDED DATA. * * USES CM - CM+4, T3 - T5. * * CALLS DFM. OLB8 LDN ZERL CLEAR FOR DAYFILE CALL CRD CM LDN 6*5 SET MESSAGE LENGTH STD CM+1 LDC IBMF+BMLN ISSUE DAYFILE MESSAGE RJM DFM LDM IBMG+1 CHECK CONTINUATION BIT LPN 4 ZJN OLBX IF COMPLETE, RETURN LDN 14 SET NOT FIRST BLOCK FLAG STM IBMG+1 UJN OLB1 ISSUE NEXT MESSAGE OLB SUBR ENTRY/EXIT LDC /COMSDFS/HS0100 STM IBMF+1 LDN 0 PRESET INPUT TABLE INDEX STD T3 OLB1 LDN 0 PRESET *BML* MESSAGE INDEX STD T4 OLB2 LDM TSCR,T3 SCR ERROR LOG TABLE STM IBMH,T4 MOVE ONE BYTE FROM INPUT TABLE TO *BML* AOD T3 INCREMENT INPUT TABLE INDEX AOD T4 INCREMENT *BML* MESSAGE INDEX LMN 4*5 ZJN OLB4 IF AT END OF *BML* MESSAGE BUFFER LDD T3 ADC -NSCB (FIRST SCR ERROR LOG) OLBA EQU *-1 * ADC -NSCB-NSCB (SECOND SCR ERROR LOG) NJN OLB2 IF NOT AT END OF ERROR LOG OLB3 LDN 0 CLEAR BYTES AT END OF ERROR LOG STM IBMH,T4 AOD T4 LMN 4*5 NJN OLB3 IF MORE BYTES TO CLEAR LDM IBMG+1 CHECK CONTINUATION BIT LPN 4 NJN OLB5 IF PROCESSING SECOND SCR *BML* MESSAGE LDD CH+1 ZJN OLB6 IF ONLY ONE SCR *BML* MESSAGE LDC -NSCB-NSCB RESET FOR END OF SECOND SCR *BML* MESSAGE STM OLBA OLB4 LDM IBMG+1 SET CONTINUATION BIT SCN 4 LMN 4 UJN OLB7 STORE STATUS OLB5 LDM IBMF+2 CHANGE TO SECOND SCR CHANNEL SCN 77 LMD CH+1 STM IBMF+2 OLB6 LDM IBMG+1 CLEAR CONTINUATION BIT SCN 4 OLB7 STM IBMG+1 LJM OLB8 CONTINUE PTP SPACE 4,15 ** PTP - PERFORM TIME PROCESSING. * * ENTRY (IR+2) = *1MB* FUNCTION BITS. * (MF) = MAINFRAME TYPE. * * EXIT THE ESM SECDED ERROR LOG IS LOGGED TO THE * BML FOR A *TIME PROCESSING* CALL, IF AN ESM * MAINTENANCE PORT IS DEFINED. * * USES CM - CM+4, T3. * * CALLS CCO, CRC, DFM, PES, *2TH*. * * MACROS EXECUTE. PTP SUBR ENTRY/EXIT LDD IR+2 CHECK FOR *TIME PROCESSING* FUNCTION LPN SPTP ZJN PTPX IF NOT *TIME PROCESSING* FUNCTION EXECUTE 2TH LOAD TOP-OF-HOUR ROUTINES LDC CECL READ ERROR COUNTERS CRD CM CRM IBMG,ON LDD CM ADD CM+1 ADD CM+2 ADD CM+3 ADD CM+4 NJN PTP1 IF ERRORS TO REPORT LJM PTP2 CLEAR COUNTS PTP1 LDN ZERL CLEAR MESSAGE BUFFER CRD CM CRM IBMF,ON SBN 1 CRM IBMH,ON SBN 1 CRM IBMH+5,ON LDC CECL CLEAR ERROR COUNTERS CWD CM LDD T3 IOU CORRECTED ERROR COUNT STM IBMH+4 PLACE IN BML MESSAGE LDC /COMSDFS/HM0410 SET MESSAGE ID STM IBMF LDC /COMSDFS/HS0101 SET MESSAGE SYMPTOM STM IBMF+1 LDN 3*5 SET BYTE COUNT FOR BML MESSAGE STD CM+1 LDC IBMF+BMLN ISSUE BML MESSAGE RJM DFM LDN ZERL CLEAR BML BUFFER CRM IBMG,ON PTP2 RJM /IHD/CRC CLEAR RELOAD COUNT IN CONTROLWARE TABLE RJM /IHD/CCO CLEAR COUNTS IN EST/MST ENTRIES LDD MF CHECK FOR CYBER 70 ZJN PTP3 IF PROCESSING INTERLOCK REGISTER RJM /IHD/PES PROCESS ESM SECDED LOGGING PTP3 LJM PTPX RETURN RSC SPACE 4,15 ** RSC - READ S/C REGISTER(S). * * READS THE CONTENTS OF THE S/C REGISTER(S) FROM * CHANNEL 16 AND/OR CHANNEL 36. * * ENTRY (MF) = MAINFRAME TYPE. * * EXIT TABLE *TSCR* CONTAINS HARDWARE COPY OF SCR. * * USES T1, T2, T3, T4. * * CALLS CHN, ODW. RSC SUBR ENTRY/EXIT * READ S/C REGISTER. LDC TSCR SET BUFFER ADDRESS * LDC TSCR+50 (POWER FAILURE) RSCA EQU *-1 STD T1 STD T2 LDD CH+1 SECOND SCR CHANNEL SHN 0-4 CONVERT 0 TO 0, 36 TO 1 STD T4 RSC1 LDN NSCB-1 SET S/C WORD TO READ STD T3 RSC2 LDD T3 READ WORD (T3) OF S/C REGISTER RJM ODW OUTPUT DESCRIPTOR WORD STI T2 SAVE S/C CONTENTS AOD T2 INCREMENT *TSCR* BUFFER ADDRESS SOD T3 DECREMENT WORD COUNT FOR S/C PJN RSC2 IF NOT FINISHED WITH S/C SOD T4 NJN RSC3 IF FINISHED WITH BOTH S/C,S LDN CHSC+20 CHANNEL 36 RJM CHN CHANGE TO CHANNEL 36 S/C UJN RSC1 LOOP FOR CHANNEL 36 S/C RSC3 LDD CH FIRST SCR CHANNEL RJM CHN RESET CHANNEL FOR BITS 36 AND 37 LDM 20,T1 CLEAR FIRST SCR BYTE 0 INACTIVE BITS LPC ABM0 CYBER 170 ACTIVE BIT MASK * LPC ABM6 (CYBER 176) * LPC ABM7 (CYBER 170 - 700 SERIES) * LPC ABM8 (CYBER 170 - 865/875) RSCB EQU *-1 STM 20,T1 LDM 17,T1 CLEAR FIRST SCR BYTE 1 INACTIVE BITS RSCC SCN 0 * SCN INB6 (CYBER 176) * SCN INB1 (CPU 1 OFF) * SCN INB0 (CPU 0 OFF) STM 17,T1 LDM 40,T1 CLEAR SECOND SCR BYTE 1 INACTIVE BITS RSCD SCN 0 * SCN INB6 (CYBER 176) * SCN INB1 (CPU 1 OFF) * SCN INB0 (CPU 0 OFF) STM 40,T1 LJM RSCX RETURN PEF SPACE 4,15 ** PEF - CHECK FOR POWER OR ENVIRONMENTAL FAILURE. * * EXIT NORMAL IF POWER FAILURE OR ENVIRONMENTAL BITS NOT SET. * NO EXIT TAKEN IF POWER FAILURE AND/OR ENVIRONMENTAL * BITS REMAIN SET. * EXIT THROUGH *UBS* OTHERWISE. * * USES T2. * * CALLS CKC, CKP, DFM, IEL, RSC, RSM, TPE, UBS. PEF SUBR ENTRY/EXIT RJM TPE TEST POWER FAILURE AND ENVIRONMENTAL BITS ZJN PEFX IF NEITHER SET LPN 1 ZJN PEF2 IF NO POWER FAILURE * ENTRY HERE FROM *UBS* IF POWER FAILURE SET FOR FIRST TIME. PEF1 RJM RSM REQUEST STEP LDM UBSC,T1 SET MESSAGE SBN 5 STM PEFA SBN 1 STM UBSB LDN TIML READ TIME CRM *,ON PEFA EQU *-1 (TIME MESSAGE ADDRESS) LDC TSCR+50 SET BUFFER ADDRESS STM RSCA LDC LDNI+1 SET POWER FAILURE PREVIOUSLY PROCESSED STM UBSD RJM RSC READ S/C REGISTER(S) LDC TSCR RESET BUFFER ADDRESS STM RSCA UJN PEF3 WAIT FOR CONDITION TO CHANGE PEF2 RJM CKP CALL *1CK* IF NOT ALREADY CALLED LDC MSGF-1+ERLN RJM DFM RJM CKC CHECK FOR *1CK* COMPLETE RJM RSM REQUEST STEP MODE PEF3 RJM UBS UPDATE BIT STATUS UJN PEF3 WAIT UNTIL CLEAR PSB SPACE 4,15 ** PSB - PROCESS SINGLE BIT SECDED ERRORS. * * ENTRY (IR+2) = FUNCTION BITS. * (MF) = MAINFRAME TYPE. * * EXIT SECDED ERROR BITS ARE CLEARED IN THE SCR IF THEIR * CORRESPONDING FUNCTION BITS IN IR+2 WERE SET. * * USES ER. * * CALLS ODW. PSB SUBR ENTRY/EXIT LDD IR+2 CHECK FOR CM SECDED FUNCTION BIT SET LPN SPCS ZJN PSB2 IF CM SECDED FUNCTION BIT NOT SET AOD ER SET ERROR FLAG LDC FCCL+SECD CLEAR SECDED ERROR RJM ODW LDD MF TEST FOR CYBER 176 SBN MF176A MJN PSBX IF NOT CYBER 176 LDC FCSB+CCRT SET CM RANK II CLEAR RJM ODW LDC FCCL+CCRT CLEAR CM RANK II CLEAR RJM ODW PSB2 LDD IR+2 CHECK FOR LCME SECDED FUNCTION BIT SET LPN SPLS ZJN PSBX IF LCME SECDED FUNCTION BIT NOT SET PSB3 AOD ER SET ERROR FLAG LDC FCCL+LSCD CLEAR LCME SECDED ERROR RJM ODW LDC FCSB+LCRT SET LCME RANK II CLEAR RJM ODW LDC FCCL+LCRT CLEAR LCME RANK II CLEAR RJM ODW LJM PSBX EXIT TEB SPACE 4,15 ** TEB - CLEAR TEST/ERROR BITS IN S/C. * * ENTRY (CH) = SCR CHANNEL NUMBER. * (MF) = MAINFRAME TYPE. * (CH+1) = 0, IF ONLY ONE SCR CHANNEL. * (TSCR) = TABLE CONTAINING COPY OF THE SCR(S). * * EXIT ERROR BITS THAT ARE SET IN *TSCR* ARE CLEARED FROM * THE SCR WITH THE EXCEPTION OF BIT 3. ON A CYBER 176 * BIT 11 IS ALSO NOT CLEARED. BIT 3 (AND BIT 11 ON A * CYBER 176) IS PROCESSED IN ROUTINE *PSB*. * * USES ER, T4, T5. * * CALLS CHN, ODW, TRB. TEB3 SOD T5 PJN TEB1 IF SECOND CHANNEL TEB SUBR ENTRY/EXIT LDD CH+1 SHN 0-4 CONVERT 0 TO 0, 36 TO 1 STD T5 LDD MF SBN MF176A PJN TEB1 IF CYBER 176 LDN PSNI ENABLE CLEARING OF BIT 11 STM TEBA TEB1 LDM CH,T5 SET REGISTER CHANNEL RJM CHN CHANGE CHANNEL LDN NTEB SET MAXIMUM ERROR BIT STD T4 TEB2 SOD T4 TEST NEXT BIT MJN TEB3 IF END OF BITS LMN SECD ZJN TEB2 IF BIT 3 LMN LSCD&SECD TEBA ZJN TEB2 IF BIT 11 * PSN (NON-CYBER 176 MAINFRAMES) LMN LSCD RESTORE CONTENTS RJM TRB ZJN TEB2 IF NOT SET AOD ER SET ERROR FLAG LDC FCCL LMD T4 RJM ODW CLEAR BIT UJN TEB2 LOOP FOR NEXT BIT CHN SPACE 4,10 ** CHN - CHANGE S/C REGISTER CHANNEL. * MODIFIES CHANNEL INSTRUCTIONS IN SUBROUTINE *ODW*. * * ENTRY (A) = S/C REGISTER CHANNEL. CHN SUBR ENTRY/EXIT LMC OANI STM ODWA LMC IANI&OANI STM ODWB LPN 77 LMN 36 ZJN CHN1 IF CHANNEL 36 LCN NSCB CHN1 ADC LDNI+NSCB*2 STM TRBA UJN CHNX RETURN TPE SPACE 4,20 ** TPE - TEST POWER FAILURE AND ENVIRONMENTAL BITS. * * EXIT IF POWER FAILURE BIT SET, (T1) = (A) = 1. * IF ENVIRONMENTAL BIT SET, (T1) = (A) = 2. * IF BOTH BITS SET, (T1) = (A) = 3. * IF NEITHER BIT SET, (T1) = (A) = 0. * * USES T1, T5. * * CALLS ODW. * * MACROS DELAY. * * NOTE - A *TEST* FUNCTION IS USED FOR THE FIRST CALL AND A * *TEST/CLEAR* FUNCTION IS USED FOR ALL FURTHER CALLS. * THIS PREVENTS A TRANSIENT SETTING OF BITS 36,37 FROM * CAUSING A SYSTEM CHECKPOINT IN ROUTINE *PEF* BUT CLEARING * BEFORE *1MB* CAN BE RECALLED TO LOG THE ERROR MESSAGES. TPE SUBR ENTRY/EXIT LDC 600 PRESET DELAY LOOP COUNT STM TPEF TPEA UJN TPE1 TEST BIT 36 * PSN IF CYBER 70 LDC FCTB TEST BIT 0 OF INTERLOCK REGISTER * LDC FCTC (SUBSEQUENT CALLS) TPEB EQU *-1 RJM ODW OUTPUT DESCRIPTOR WORD STD T1 SET RETURN CODE LDC FCTC CHANGE TO TEST/CLEAR FUNCTION STM TPEB TPEC UJN TPE3 RESTORE EXIT VALUE * PSN IF SIMULATOR REQUESTED TPE1 LDC FCTB+MAPF TEST MAINS POWER FAILURE * LDC FCTC+MAPF (SUBSEQUENT CALLS) TPED EQU *-1 RJM ODW OUTPUT DESCRIPTOR WORD STD T1 SET RETURN CODE LDC FCTB+SHIM TEST SHUTDOWN IMMINENT * LDC FCTC+SHIM (SUBSEQUENT CALLS) TPEE EQU *-1 RJM ODW OUTPUT DESCRIPTOR WORD SHN 1 SET RETURN CODE RAD T1 TPE1.1 UJN TPE4 CHANGE FUNCTION CODES * ZJN TPEX IF NO ERROR DETECTED TPEG EQU *-1 LPN 1 NJN TPE3 IF MAINS POWER FAILURE LDN 77 INNER LOOP DELAY COUNT STD T5 TPE2 DELAY SOD T5 NJN TPE2 IF NOT END OF INNER DELAY LOOP SOM TPEF NJN TPE1 IF NOT END OF DELAY PERIOD TPE3 LDD T1 GET RETURN CODE LJM TPEX RETURN TPE4 LDC FCTC+MAPF CHANGE TO TEST/CLEAR FUNCTION STM TPED ADN SHIM-MAPF STM TPEE ISTORE TPEG,(ZJN TPEX) LDD T1 UJN TPE1.1 ENTER LOOP TPEF CON 0 DELAY LOOP COUNT TRB SPACE 4,10 ** TRB - TEST S/C REGISTER BIT. * * ENTRY (A) BIT TO BE TESTED. * * EXIT (A) = 0 BIT CLEAR. * (A) = 1 BIT SET. * * USES T0, T1. TRB SUBR ENTRY/EXIT STD T0 TRBA LDN NSCB SET WORD INDEX * LDN NSCB*2 (CHANNEL 36) STD T1 TRB1 SOD T1 LCN 14 RAD T0 PJN TRB1 IF WORD NOT FOUND ADN 14 LMC SHNI+77 STM TRBB LDM TSCR,T1 TRBB SHN -0 LPN 1 UJN TRBX RETURN UBS SPACE 4,25 ** UBS - UPDATE BIT STATUS. * CHECKS S/C REGISTER FOR STATUS OF POWER FAILURE (BIT 36) AND * SHUTDOWN IMMINENT (BIT 37), UPDATES CONTROL POINT MESSAGE IF * NECESSARY, EXITS TO POWER FAILURE ROUTINE IF BIT 36 SET FOR * THE FIRST TIME, AND TERMINATES IF BOTH BITS CLEAR * AFTER UNSTEP IS ENTERED BY OPERATOR. * * ENTRY (T2) = 77 IF FIRST ENTRY. * = PREVIOUS EXIT CONDITION OF *UBS*. * (T1) = OUTPUT OF *TPE*. * * EXIT (T2) = CONDITION CODE. * 1, IF POWER FAILURE (BIT 36) SET. * 2, IF SHUTDOWN IMMINENT (BIT 37) SET. * 3, IF BOTH BITS SET. * IF BOTH BITS CLEAR, WAITS FOR OPERATOR *UNSTEP* * COMMAND, THEN EXITS TO *DPP*. * * USES SC - SC+4. * * CALLS DFM, DPP, IEL, RSC, RSM, TPE. UBS9 LDD T2 NJN UBS10 IF PREVIOUS CONDITION NOT ALL CLEAR RJM RSM RESTORE STEP MODE UBS10 LDD T1 SET CONDITION HISTORY STD T2 UBS SUBR ENTRY/EXIT UBS1 RJM TPE TEST POWER FAILURE AND ENVIRONMENTAL BITS LMD T2 NJN UBS2 IF CONDITION CHANGED LDD T1 NJN UBSX IF NOT BOTH CLEAR LJM UBS5 CHECK STEP MODE UBS2 LDM UBSC,T1 GET MESSAGE ADDRESS STM UBSA LDD CP DISPLAY STSTEM CONTROL POINT MESSAGE ADN MS2W CWM *,TR UBSA EQU *-1 (MESSAGE ADDRESS) LDD T1 ZJN UBS4 IF ALL CLEAR LPN 1 ZJN UBS9 IF NOT POWER FAILURE UBSD LDN 0 * LDN 1 (POWER FAILURE PREVIOUSLY PROCESSED) NJN UBS9 IF POWER FAILURE PREVIOUSLY PROCESSED LJM PEF1 PROCESS POWER FAILURE/ENVIRONMENTAL BITS UBS4 LDN TIML READ TIME OF DAY CRM TIMA,ON LDD SC CLEAR STEP REQUEST LPC 6777 STD SC LDC SCRL WRITE SCRL CWD SC RJM RSC READ S/C REGISTER(S) UBS5 LDC SCRL CHECK STEP MODE CRD SC LDD SC SHN 21-10 PJN UBS6 IF STEP NOT SET LDN 0 SET CONDITION HISTORY STD T2 LJM UBS1 TEST POWER/ENVIRONMENTAL BITS UBS6 LDC 0 LOG PRELIMINARY MESSAGE UBSB EQU *-1 (MESSAGE ADDRESS) NJN UBS8 IF TWO MESSAGES TO BE LOGGED UBS7 LDN 0 CLEAR TWO MESSAGE INDICATION STM UBSB LDC MSGD-6 UBS8 ADC ERLN RJM DFM LDM UBSB NJN UBS7 IF ALL MESSAGES NOT LOGGED STD CM+2 CLEAR INPUT FILE SCHEDULING FLAG MONITOR RSJM REQUEST SCHEDULER RJM PTP PERFORM TIME PROCESSING LJM DPP DROP PP * MESSAGE ADDRESS TABLE UBSC CON MSGD CON MSGE CON MSGF CON MSGG * ERROR LOG MESSAGES. MIDA CON 2RSR MESSAGE ID TIMA VFD 60/0 MSGD DATA C* POWER/ENVIRONMENT NORMAL.* MIDB CON 2RSR MESSAGE ID VFD 60/0 TIME (READ BY ROUTINE *PEF*) MSGE DATA C* POWER FAILURE.* MIDC CON 2RSR MESSAGE ID MSGF DATA C* SHUTDOWN IMMINENT.* MIDD CON 2RSR MESSAGE ID VFD 60/0 TIME (READ BY ROUTINE *PEF*) MSGG DATA C* POWER DOWN.* SPACE 4,10 ** TSCR - TABLE FOR THE CONTENTS OF THE S/C REGISTERS. * * THIS TABLE CONTAINS THE CONTENTS OF THE S/C REGISTER(S). * THE CHANNEL 16 REGISTER, WORDS 16 - 0, FIRST AND THE * CHANNEL 36 REGISTER, WORDS 16 - 0, NEXT. TSCR EQU * S/C REGISTER TABLE TSCRL EQU TSCR+4*NSCB LWA+1 OF S/C REGISTER TABLES PSC SPACE 4,10 ** PCS - PRESET FOR 1SC. * * USES CH, CH+1, ER, NP, CM - CM+4. * * CALLS CFP, PRS. * CYBER 70 INITIALIZATION. PSC7 SOD CH CHANGE TO INTERLOCK REGISTER SOM ODWA SOM ODWB LDN PSNI ENABLE CYBER 70 POWER FAILURE CHECKING STM TPEA LDN SSTL CHECK FOR SCR SIMULATION CRD CM LDD CM+3 SHN 21-3 MJN PSC8 IF NOT SIMULATING SCR LDN PSNI ENABLE SIMULATED ENVIRONMENT CHECKING STM TPEC UJN PSCX RETURN PSC8 LDC 2RIR CHANGE MESSAGE IDENTIFICATION STM MIDA STM MIDB STM MIDC STM MIDD LDC UJNI+2 DISABLE FATAL ERROR CHECKING STM SEPA PSC SUBR ENTRY/EXIT LDC 2RSC * 1SC - CALL ERROR.* STM PRSA+1 RJM PRS COMMON PRESET LDN CHSC SET SCR CHANNELS STD CH LDN 0 STD CH+1 STD ER CLEAR SCR ERROR FLAG STD NP INITIALIZE PHYSICAL PP COUNT LDN EABLL ELEMENT ATTRIBUTE BLOCK LENGTH STD T1 LDK EABL READ MAINFRAME ATTRIBUTE BLOCK CRM EABB,T1 LDN 2 READ I/O SYSTEM ENTRY STD T1 LDM EABB+IOEI*5+1 GET ADDRESS OF VARIABLE IOU ENTRY SCN 77 SHN 6 ADM EABB+IOEI*5+0 SHN 6 CRM VMAB,T1 LDN 0 STD T1 PSC0.1 LDN 12 INITIALIZE INDEX FOR BYTE STD T3 LDM VMAB+1*5,T1 TEST BYTE FOR PP COUNT STD T4 PSC0.2 LDD T4 SHN 21-0 STD T4 MJN PSC0.3 IF PHYSICAL PP NOT PRESENT AOD NP INCREMENT PHYSICAL PP COUNT PSC0.3 SOD T3 NJN PSC0.2 IF MORE PP BITS TO TEST AOD T1 LMN 1 ZJN PSC0.1 IF NEXT BYTE TO PROCESS LDM TFEM,MF SET SCR FATAL ERROR MASK STM CFEA LDM TABM,MF SET SCR ACTIVE BIT MASK STM RSCB LDD MF NJN PSC1 IF NOT CYBER 70 LJM PSC7 CONTINUE CYBER 70 PRESET * CYBER 170, 700, 865/875 INITIALIZATION. PSC1 LDD MF SBN MF176A MJN PSC2 IF NOT CYBER 176 RJM CFP CHECK FOR *FLPP* ERROR LDN INB6 CLEAR INACTIVE BITS IN SCR BYTE 2 UJN PSC4 CHECK NUMBER OF S/C REGISTERS PSC2 LDD MI+1 LPN 3 ZJN PSC5 IF DUAL CPU PRESENT LPN 1 ZJN PSC3 IF CPU 0 ON, CPU 1 OFF OR UNDEFINED LDN INB0&INB1 CLEAR INACTIVE BIT IN SCR FOR CPU 0 PSC3 LMN INB1 CLEAR INACTIVE BIT IN SCR FOR CPU 1 PSC4 RAM RSCD STM RSCC PSC5 LDD NP CHECK NUMBER OF S/C REGISTERS SBN 13 MJN PSC6 IF ONLY 1 S/C REGISTER LDN 36 ENABLE SECOND REGISTER CHECKING STD CH+1 PSC6 LJM PSCX RETURN SPACE 4,10 ** COMMON PRESET. PRESET PRESET HERE PRS13 LJM PRSX EXIT PRESET CFP SPACE 4,10 ** CFP - CHECK FOR *FLPP* ERROR. * * EXIT SCANNER POSITIONED TO *FLPP* WITH ERROR. * * USES T1 - T3. CFP2 LDD T3 CHECK NEXT BIT SHN -1 CFP3 STD T3 LPN 1 ZJN CFP4 IF BIT TO BE CLEARED LDC FCSB&FCCL CFP4 LMD T2 OAN CHSC+40 IAN CHSC+40 AOD T2 ADVANCE BIT NUMBER LMC FCCL+SCSL+4 NJN CFP2 IF NOT END OF BITS LDN FCRD+FLPW READ *FLPP* STATUS OAN CHSC+40 IAN CHSC+40 LPN 37 NJN CFPX IF ERROR DETECTED AOD T1 ADVANCE *FLPP* NUMBER LMN 20 NJN CFP1 IF NOT END OF *FLPP-S* CFP SUBR ENTRY/EXIT LDN 1 SET STARTING *FLPP* NUMBER STD T1 CFP1 LDC FCCL+SCSL PRESET FUNCTION AND BIT NUMBER STD T2 LDD T1 SELECT *FLPP* UJN CFP3 ENTER LOOP SPACE 4,10 TABM INDEX TABLE OF SCR ACTIVE BIT MASKS INDEX MF70,ABM0 CYBER 70 INDEX MF170,ABM0 CYBER 170 INDEX MF700,ABM7 CYBER 170 - 700 SERIES INDEX MF865,ABM8 CYBER 170 - 865 INDEX MF875,ABM8 CYBER 170 - 875 INDEX MF176A,ABM6 CYBER 176 LEVEL A INDEX MF176B,ABM6 CYBER 176 LEVEL B INDEX MFMAX SPACE 4,10 TFEM INDEX TABLE OF SCR FATAL ERROR MASKS INDEX MF70,FEM0 CYBER 70 INDEX MF170,FEM0 CYBER 170 INDEX MF700,FEM7 CYBER 170 - 700 SERIES INDEX MF865,FEM8 CYBER 170 - 865 INDEX MF875,FEM8 CYBER 170 - 875 INDEX MF176A,FEM6 CYBER 176 LEVEL A INDEX MF176B,FEM6 CYBER 176 LEVEL B INDEX MFMAX EABB BSS EABLL*5 ELEMENT ATTRIBUTE BLOCK VMAB BSS 5*2 BUFFER FOR I/O SYSTEM ENTRY SPACE 4,10 OVERFLOW PPFW,EPFW TTL 1MB/1MP - PROCESS SCR CHANNEL ERRORS. TITLE IDENT 1MP,PPFW QUAL CCE *COMMENT 1MB - CHANNEL ERROR PROCESSOR. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. SPACE 4,10 *** 1MP - PROCESS SCR CHANNEL ERRORS. * * P. D. HAAS. 82/11/30. SPACE 4,10 *** *1MP* IS CALLED BY *MTR* TO PERFORM PRELIMINARY * CHECKS ON THE SCR. IT RESIDES IN THE RPL TO ENSURE A * SUCCESSFUL LOAD IN CASE OF CHANNEL ERRORS ON A SYSTEM * DEVICE, AND AS SUCH SHOULD BE KEPT AS SMALL AS POSSIBLE. * * *1MP* CHECKS THE SCR FOR CHANNEL ERRORS, AND IF * NONE ARE FOUND OR IF NO SCR EXISTS, CALLS *1MB*. IF * CHANNEL ERRORS ARE INDICATED, *1MP* SCANS THE EST TO * DETERMINE IF SAID CHANNEL IS ASSOCIATED WITH MASS STORAGE * EQUIPMENT. IF SO, *1DS* WILL BE CALLED TO REMOVE THE CHANNEL * FROM SYSTEM USE. * * UPON COMPLETION, *1MP* LOADS *1MB*. CHANNEL * ERRORS ASSOCIATED WITH NON MASS STORAGE EQUIPMENT ARE * IGNORED. SPACE 4,10 ** COMMON DECKS. *CALL COMS1DS SPACE 4,10 **** DIRECT CELL USAGE. CH EQU IR+3 CHANNEL NUMBER **** TITLE MAIN PROGRAM. ORG PPFW CCE RJM PRS PRESET PROGRAM IJM CCE2,CHSC IF NO SCR LCN 0 CHANNEL 00 IS LEAST SIGNIFICANT BIT STD CH LDN FCRD+CPEW READ CHANNEL STATUS OAN CHSC IAN CHSC ZJN CCE1 IF NO PARITY ERRORS RJM CMC CHECK MASS STORAGE CHANNELS CCE1 IJM CCE2,CHSC+20 IF NO UPPER CHANNEL BANK LDN 20-1 CHANNEL 20 IS LEAST SIGNIFICANT BIT STD CH LDN FCRD+CPEW READ CHANNEL STATUS OAN CHSC+20 IAN CHSC+20 ZJN CCE2 IF NO PARITY ERRORS RJM CMC CHECK MASS STORAGE CHANNELS CCE2 LDD IA STORE INPUT REGISTER CWD IR LJM PPR LOAD AND EXECUTE TITLE SUBROUTINES. CMC SPACE 4,15 ** CMC - CHECK MASS STORAGE CHANNEL. * * ENTRY (A) = CHANNEL STATUS WORD (BYTE) FROM SCR. * (CH) = INITIAL CHANNEL VALUE FOR BANK 0 OR 1. * (EM) = LAST MASS STORAGE EST ORDINAL + 1. * * USES T1, T4, T5, CM - CM+4, CN - CN+4. * * MACROS EXECUTE, MONITOR, SFA. CMC2 SFA EST,T5 READ EST ENTRY ADK EQDE CRD CN LDD CN SHN 21-13 PJN CMC6 IF NOT MASS STORAGE LDD CN+1 SHN 21-13 PJN CMC3 IF PRIMARY CHANNEL ACCESS IS DISABLED SHN 13-21 LMD CH LPN 37 ZJN CMC4 IF CHANNEL MATCH CMC3 LDD CN+2 SHN 21-13 PJN CMC6 IF SECONDARY CHANNEL NOT PRESENT/DISABLED SHN 13-21 LMD CH NJN CMC6 IF NOT A MATCH * CALL *1DS* TO GLOBALLY DOWN THE CHANNEL. CMC4 LDD MA PLACE *1DS* CALL IN MESSAGE BUFFER CWM CMCA,ON LDN 0 INITIALIZE RETRY COUNT STD T1 CMC5 STD CM+1 EXECUTE 1DS,= MONITOR RPPM CALL *1DS* LDD CM+1 NJN CMC7 IF PP ASSIGNED AOD T1 INCREMENT RETRY COUNT SHN -3 ZJN CMC5 IF RETRY LIMIT NOT REACHED UJN CMCX RETURN CMC6 AOD T5 ADVANCE EST ORDINAL LMD EM NJP CMC2 IF MORE DEVICES TO PROCESS CMC7 LDD T4 NJN CMC1 IF MORE CHANNELS WITH ERROR CMC SUBR ENTRY/EXIT STD T4 CMC1 AOD CH ADJUST CHANNEL NUMBER STM CMCA+3 STORE CHANNEL NUMBER IN *1DS* CALL LDD T4 SHN 21-0 CHECK CHANNEL FLAG STD T4 PJN CMC1 IF NOT CHANNEL WITH ERROR LDN NOPE INITIALIZE EST ORDINAL FOR SEARCH STD T5 UJP CMC6 BEGIN EST SCAN CMCA VFD 18/3R1DS,6/,6/0,6/DWNF,12/0,12/0 TITLE PRESET PROGRAM. PRS SPACE 4,10 ** PRS - PRESET PROGRAM. * * EXIT (EM) = LAST MASS STORAGE EST ORDINAL + 1. * * USES EM, CM - CM+4, IR - IR+1, MI - MI+4. * * MACROS MONITOR. PRS3 LDK ESTP CRD CM LDD CM+3 SET LAST MASS STORAGE EST ORDINAL + 1 STD EM PRS SUBR ENTRY/EXIT LDN NCPL CRD CM ADN MABL-NCPL CRD MI AOD CM+1 CHECK CONTROL POINT SHN 7 LMD CP ZJN PRS1 IF CALLED BY SYSTEM MONITOR ABTM ABORT JOB LJM PPR EXIT TO PP RESIDENT PRS1 LDD MI+1 SHN -6 LPN 41 LMN 1 ZJN PRS2 IF LOWER 800 SERIES MACHINE LDN 1RS-1RM RAD IR LDN 1RC-1RB PRS2 SBN 1RP-1RB SHN 6 RAD IR+1 UJP PRS3 CONTINUE SPACE 4,10 OVERFLOW PPFW,EPFW,CMR TTL 1MB/2TH - PROCESS COMMON TOP-OF-HOUR FUNCTIONS. TITLE QUAL IHD IDENT 2TH,IHDX *COMMENT 1MB - TOP-OF-HOUR PROCESSOR. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. SPACE 4,10 *** 2TH - TOP-OF-HOUR PROCESSOR. * * J. M. MAREK 87/11/24. SPACE 4,10 *** *2TH* IS CALLED BY *1MB* AND *1SC* TO PERFORM * THE FOLLOWING TOP-OF-HOUR TASKS - * * - ISSUE HOUR AND DAY MESSAGES TO THE DAYFILES. * - CLEAR THE RELOAD COUNT IN THE CONTROLWARE TABLE. * - CLEAR COUNTS IN THE EST AND MST. * - LOG ESM AND STORNET SECDED AND STATUS INFORMATION. SPACE 4,10 * ASSEMBLY CONSTANTS. FRDL EQU 1010B FUNCTION - READ ESM SECDED LOG FRST EQU 1011B FUNCTION - RESET ESM SECDED LOG FRSP EQU 1040 FUNCTION - READ SIDE DOOR PORT STATUS FCSP EQU 1203 FUNCTION - CLEAR SIDE DOOR PORT STATUS DCSP EQU 1000 DATA - CLEAR SIDE DOOR PORT STATUS NESB EQU 83D NUMBER OF ESM SECDED LOG BYTES OVLO MAX /1MB/BCMR+5,/1SC/TSCRL+5 ORG OVLO IHD SPACE 4,10 ** IHD - ISSUE HOUR AND DATE TO DAYFILES. * * EXIT HOUR AND DATE MESSAGE ISSUED TO DAYFILES. * * USES CM+1. * * CALLS DFM. IHD SUBR ENTRY/EXIT LDN DTEL SET DATE IN DAYFILE MESSAGES CRM IHDA+7,ON SBN 1 CRM IHDB+3,ON LDC IHDA ISSUE MESSAGE TO SYSTEM DAYFILE RJM DFM LDC ERLN+IHDA ISSUE MESSAGE TO ERROR LOG RJM DFM LDC ACFN+IHDB ISSUE MESSAGE TO ACCOUNT FILE RJM DFM UJN IHDX RETURN IHDA DATA C*SYSTEM DATE: NNNNNNNNNN* IHDB DATA C*SIDT, NNNNNNNNNN* CCO SPACE 4,10 ** CCO - CLEAR COUNTS IN EST/MST ENTRIES. * * EXIT RELOAD COUNTS IN CONTROL MODULE EST ENTRIES CLEARED * IF NOT EQUAL TO RELOAD LIMIT. * RECOVERED AND UNRECOVERED ERROR COUNTS CLEARED IN EACH * MST IN WHICH THE *1SJ* PROCESSED BIT IS NOT SET. * * USES CM - CM+4, CN - CN+4, T0 - T7. * * MACROS MONITOR, SFA. CCO SUBR ENTRY/EXIT LDN ESTP INITIALIZE FOR EST SEARCH CRD T0 CCO1 SOD T0+2 DECREMENT EST ORDINAL STD CM+1 ZJN CCOX IF END OF EST * CLEAR CONTROL MODULE RELOAD COUNT IN EST. SFA EST READ EST ENTRY ADK EQDE CRD T3 ADK EQAE-EQDE CRD CN LDD T3+3 LMC 2RCM NJN CCO2 IF NOT *CM* DEVICE STD CM+4 LDD CN+2 SHN -6 LPN 7 ZJN CCO2 IF NO RELOAD COUNT SBN /MSP/CRTH ZJN CCO2 IF RELOAD LIMIT LDN SB2S STD CM+2 LDC 7077 STD CM+3 MONITOR SEQM CLEAR RELOAD COUNT * CLEAR THRESHOLD COUNTS IN MST. CCO2 LDD T3 SHN 21-13 PJN CCO1 IF NOT MASS STORAGE DEVICE LDD T3+4 SET MST ADDRESS SHN 3 STD CM+4 SHN -14 STD CM+3 LDN 2 SET NUMBER OF REQUESTS STD CM+1 LDD MA CWM CCOA,CM+1 MONITOR UTEM LDD T3+4 SET MST ADDRESS SHN 3 STD CM+4 SHN -14 STD CM+3 LDN 2 SET NUMBER OF REQUESTS STD CM+1 LDD MA CWM CCOB,CM+1 MONITOR UTEM LJM CCO1 PROCESS NEXT EST ENTRY CCOA VFD 1/1,5/CTLL,6/1,6/11D,42/0 VERIFY *1SJ* BIT NOT SET VFD 1/0,5/CTLL,6/11D,6/0,42/0 CLEAR ERROR COUNT CCOB VFD 1/1,5/CTLL,6/1,6/23D,42/0 VERIFY *1SJ* BIT NOT SET VFD 1/0,5/CTLL,6/11D,6/12D,42/0 CLEAR ERROR COUNT CRC SPACE 4,10 ** CRC - CLEAR RELOAD COUNTS IN CONTROLWARE TABLE. * * USES CM - CM+4, CN - CN+4, T2 - T7. * * MACROS MONITOR. CRC SUBR ENTRY/EXIT LDN ZERL CRD CN ADN CHTP-ZERL FETCH CHANNEL TABLES POINTER CRD T3+1 LDN 1 PARAMETER COUNT FOR *UTEM* REQUEST STD T4 LDN CTALL SET CONTROLWARE TABLE LENGTH STD T3 SHN 1 CONTROLWARE TABLE OFFSET RAD T7 SHN -14 SET CONTROLWARE TABLE ADDRESS RAD T6 SHN 14 LMD T7 READ CONTROLWARE TABLE CRM IBMH,T3 LDN 0 INITIAL CHANNEL VALUE STD T5 LDC IBMH-1 PRESET BYTE ADDRESS FOR TABLE SCAN STD T2 LDN 3 RELOAD COUNT FIELD WIDTH STD CN CRC1 AOD T2 ADVANCE CONTROLWARE TABLE SEARCH LDI T2 SHN -6 POSITION RELOAD COUNT FIELD LPN 7 ZJN CRC2 IF NO COUNT LMN /MSP/CRTH ZJN CRC2 IF RELOAD LIMIT LDM CRCA,T5 STD CN+1 DEFINE RELOAD COUNT FIELD IN WORD LDD MA CWD T3 *UTEM* REQUEST TO (CM - CM+4) CRD CM CWD CN STORE PARAMETER WORD MONITOR UTEM CRC2 AOD T5 ADVANCE CHANNEL BYTE INDEX LMN 5 NJN CRC1 IF NOT 5 CHANNELS CHECKED STD T5 AOD T7 ADVANCE CONTROLWARE TABLE ADDRESS SHN -14 RAD T6 SOD T3 NJN CRC1 IF MORE CHANNELS TO CHECK LJM CRCX RETURN CRCA BSS 0 RELOAD COUNT FIELD BIT POSITIONS CON 54DS6 CON 42DS6 CON 30DS6 CON 18DS6 CON 6DS6 PES SPACE 4,10 ** PES - PROCESS ESM SECDED ERROR LOG. * * ENTRY (MF) = MAINFRAME TYPE. * * USES T1, T2, T5, CM - CM+4, CN - CN+4. * * CALLS C2D, DFM, OLB, PCI, WCF. * * MACROS DCHAN, RCHAN, RICHI, RSTC, SFA. PES SUBR ENTRY/EXIT LDN NOPE-1 SEARCH FOR EM DEVICE WITH MAINTENANCE PORT STD T5 PES1 AOD T5 ADVANCE EST ORDINAL LMD EM ZJN PESX IF END OF MASS STORAGE DEVICES SFA EST,T5 READ EST ENTRY ADK EQDE CRD CN ADK EQAE-EQDE CRD CM LDD CN+3 LMC 2RDE ZJN PES3 IF EXTENDED MEMORY ENTRY LMN 2RDP&2RDE PES2 NJN PES1 IF NOT EXTENDED MEMORY ENTRY PES3 LDD CM+2 SAVE MAINTENANCE PORT CHANNEL NUMBER LPN 37 ZJN PES1 IF NO MAINTENANCE PORT DEFINED STD CN LMD PN SET PP NUMBER AND CHANNEL NUMBER STM IBMF+2 * REQUEST MAINTENANCE PORT CHANNEL. RJM PCI PRESET CHANNEL INSTRUCTIONS RICHI REDEFINE I/O INSTRUCTIONS LDC 4000+0 REQUEST CHANNEL, RETURN IF DOWN CHTE *-1 RCHAN LDD CM+1 SHN 0-13 NJN PES2 IF CHANNEL DOWN LDD CN+4 CHECK EM TYPE SHN 3 ADN DILL CRD CM LDD CM+3 SHN -6 LPN 7 LMN 5 ZJN PES3.1 IF ESM LDK /COMSDFS/HM0173-/COMSDFS/HM0211 STORNET MESSAGE ID PES3.1 ADC /COMSDFS/HM0211 ESM MESSAGE ID STM IBMF LDD T5 SET EST ORDINAL STM IBMG SHN -3 RJM C2D CONVERT UPPER TWO DIGITS STM PESA+1 STM PESB+1 LDD T5 CONVERT LOWER DIGIT LPN 7 SHN 6 ADC 2R0, STM PESA+2 STM PESB+2 * READ MAINTENANCE CHANNEL STATUS. AJM PES5,0 IF CHANNEL IS ACTIVE FNC FRSP,0 LDN 77 PES4 IJM PES6,0 IF ESM MAINTENANCE CHANNEL INACTIVE SBN 1 NJN PES4 IF NOT TIMED OUT ON INACTIVE PES5 DCN 40 LDC PESA ISSUE ERROR MESSAGE TO SYSTEM DAYFILE RJM DFM LDC PESA+ERLN ISSUE ERROR MESSAGE TO ERROR LOG RJM DFM LDD CN DROP CHANNEL DCHAN LJM PES1 RETURN PES6 ACN 0 RJM WCF WAIT FOR CHANNEL FULL LDN 4 STD NB IAM IBMH,0 DCN 40 FNC FCSP,0 CLEAR SIDE DOOR PORT STATUS LDK DCSP ACN 0 OAN 0 LDC /COMSDFS/HS0101 STM IBMF+1 RJM OLB OUTPUT LOG TO *BML* LDN 77 FJM PES5,0 IF CLEAR OPERATION NOT COMPLETE DCN 40 * READ MAINTENANCE CHANNEL STATUS. FNC FRDL,0 ISSUE ESM READ FUNCTION ACN 0 RJM WCF WAIT FOR CHANNEL FULL LDC NESB STD NB IAM IBMH,0 READ LOG TO ESM SECDED TABLE DCN 40 ZJN PES8 IF ALL SECDED DATA READ STD T1 SAVE COUNT OF WORDS NOT READ LDC NESB-1 PRESET INDEX TO BEGIN CLEARING TABLE STD T2 PES7 LDN 0 CLEAR NEXT ESM TABLE BYTE STM IBMH,T2 SOD T2 DECREMENT ESM TABLE INDEX SOD T1 DECREMENT COUNT OF WORDS TO BE CLEARED NJN PES7 IF MORE WORDS TO CLEAR LDC PESB ISSUE ERROR MESSAGE TO SYSTEM DAYFILE RJM DFM LDC PESB+ERLN ISSUE ERROR MESSAGE TO ERROR LOG RJM DFM PES8 FNC FRST,0 ISSUE ESM RESET FUNCTION LDD CN DROP CHANNEL DCHAN LDC /COMSDFS/HS0100 STM IBMF+1 RJM OLB OUTPUT LOG TO *BML* LJM PES1 RETURN PESA DATA C*EQ000, MAINTENANCE CHANNEL ERROR.* PESB DATA C*EQ000, INCOMPLETE SECDED READ.* OLB SPACE 4,15 ** OLB - OUTPUT LOG TO *BML*. * * ENTRY (NB) = NUMBER OF BYTES TO WRITE TO *BML*. * (IBMF) = *BML* MESSAGE ID. * (IBMF+1) = *BML* SYMPTOM CODE. * (IBMF+2) = 6/ PP NUMBER, 6/ EM MAINTENANCE CHANNEL. * BUFFER *IBMH* CONTAINS *BML* DATA. * * USES T3, T4, CM - CM+4. * * CALLS DFM. OLB SUBR ENTRY/EXIT LDN 0 STM IBMG+1 CLEAR NOT FIRST MESSAGE/CONTINUATION LDN ZERL CLEAR FOR DAYFILE CALL CRD CM LDD NB STD T4 SBN 4*5+1 PJN OLB3 IF MESSAGE CONTINUES OLB1 LDD T4 SET BYTE COUNT ADN 2*5 STD CM+1 OLB2 LDN 0 CLEAR REMAINDER OF MESSAGE STM IBMH,T4 AOD T4 SBN 4*5 MJN OLB2 IF MORE BYTES TO CLEAR LDM IBMG+1 CLEAR CONTINUATION BIT SCN 4 UJN OLB5 STORE CONTINUATION BIT OLB3 LDN 4*5 INITIALIZE MESSAGE OFFSET STD T3 OLB4 LDN 6*5 SET MESSAGE LENGTH STD CM+1 LDM IBMG+1 SET CONTINUATION BIT SCN 4 LMN 4 OLB5 STM IBMG+1 LDC IBMF+BMLN ISSUE DAYFILE MESSAGE RJM DFM LDM IBMG+1 CHECK CONTINUATION BIT LPN 4 ZJP OLBX IF COMPLETE, RETURN LDN 14 STM IBMG+1 LDN 0 PRESET *BML* MESSAGE INDEX STD T4 OLB6 LDM IBMH,T3 MOVE ONE BYTE FROM INPUT TABLE TO *BML* STM IBMH,T4 AOD T4 INCREMENT BUFFER INDEX AOD T3 INCREMENT MESSAGE INDEX LMD NB ZJP OLB1 IF AT END OF MESSAGE LDD T4 LMN 4*5 NJN OLB6 IF NOT AT END OF BUFFER UJP OLB4 OUTPUT BUFFER WCF SPACE 4,10 ** WCF - WAIT FOR CHANNEL FULL. * * *WCF* WAITS 250 MICROSECONDS FOR THE CHANNEL TO BECOME FULL. * * EXIT TO *PES5* IF CHANNEL TIMES OUT. WCF SUBR ENTRY/EXIT LDM .DLY GET DELAY COUNT WCF1 FJM WCFX,0 IF MAINTENANCE CHANNEL FULL SBN 1 NJN WCF1 IF NOT TIMED OUT LJM PES5 ISSUE ERROR MESSAGE RSTC RESTORE I/O INSTRUCTIONS PCI SPACE 4,10 ** PCI - PRESET CHANNEL INSTRUCTIONS. * * ENTRY (CN) = MAINTENANCE CHANNEL NUMBER. * (CTABLE) = FWA OF CHANNEL TABLE. * * EXIT MAINTENANCE CHANNEL NUMBER IS ADDED TO ALL * CHANNEL INSTRUCTIONS IN SUBROUTINE *PES*. * * USES T1, T2. * * MACROS CHTB. PCI SUBR ENTRY/EXIT LDC CTABLE SET START OF CHANNEL TABLE STD T1 PCI1 LDI T1 ZJN PCIX IF AT END OF CHANNEL TABLE STD T2 LDI T2 GET NEXT CHANNEL INSTRUCTION SCN 37 LMD CN SET MAINTENANCE CHANNEL STI T2 AOD T1 UJN PCI1 CHECK NEXT TABLE ENTRY CTABLE CHTB TABLE TO PRESET ESM I/O INSTRUCTIONS COMMON SPACE 4,10 * COMMON DECKS. *CALL COMPC2D IBM SPACE 4,10 * *BML* MESSAGE BUFFER. IBMF VFD 12/0,12/0,6/0,6/0,24/0 MESSAGE ID/SYMPTOM CODE IBMG VFD 12/0,9/0,1/0,2/0,36/0 MESSAGE CONTINUATION BIT IBMH BSS 0 *BML* MESSAGE BUFFER (4 CM WORDS) IBMHL EQU 4*5 END OF *BML* BUFFER SPACE 4,10 .1 MAX IBMHL,NESB,CTALL*5 ERRNG EPFW-IBMH-.1 BUFFER OVERFLOWS ERROR PROCESSOR OVERFLOW IHDX,EPFW SPACE 4,10 TTL 1MB - HARDWARE ERROR PROCESSOR. END