IDENT 1MS,TMSO PERIPH BASE MIXED SST BFMS,FNSS,EQSS,FTSS,NSSS,FASS,DTSS,EISS,GQSS QUAL$ EQU 1 DEFINE UNQUALIFIED COMMON DECKS *COMMENT 1MS - MASS STORAGE INPUT/OUTPUT. COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. TITLE 1MS - MASS STORAGE INPUT/OUTPUT. SPACE 4,10 *** 1MS - MASS STORAGE INPUT/OUTPUT. * * G. R. MANSFIELD. 72/03/16. * J. C. BOHNHOFF. 72/11/01. * J. J. EIKUM. 79/06/18. * J. L. LARSON. 80/08/01. SPACE 4,10 *** *1MS* PROCESSES INPUT/OUTPUT REQUESTS TO MASS STORAGE * FILES FOR CPU PROGRAMS. THE *CIO* SYSTEM REQUEST ISSUED BY * THE USER CPU PROGRAM IS PRE-PROCESSED BY THE *CPUCIO* * SECTION OF *CPUMTR*. *1MS* PROCESSES *RETURN*, *UNLOAD*, * AND *EVICT* FUNCTIONS FOR ALL EQUIPMENT TYPES (CALLS * *0DF* TO DROP FILE). *1MS* ALSO ISSUES ERROR MESSAGES FOR * ERRORS DETECTED BY *CPUCIO* ON ANY EQUIPMENT TYPE. * *1MS* COMPLETES NON-READ/WRITE FUNCTIONS FOR *TT* EQUIPMENT. * ALL OTHER FUNCTIONS PROCESSED BY *1MS* ARE ON MASS * STORAGE OR NULL EQUIPMENT. SPACE 4,10 *** CALL. * * *T IR 18/ *1MS*, 1/A, 5/ CP, 18/ SKIP, 18/ FET * A SET IF AUTO RECALL REQUESTED. * CP CONTROL POINT NUMBER. * SKIP COUNT FOR SKIP OPERATIONS, DATA PATTERN SELECTIONS * FOR OVERWRITE OPERATION. * FET ADDRESS OF FET. * *T MB 1/S, 5/RF, 6/RC, 5/0, 1/F, 6/EC, 12/ORD, 4/LV, 8/XC, 12/IC * S SET IF *1MS* RESTARTED FROM RECALL STACK. * RF RESTART FLAGS = 1/TIF, 1/OPF, 1/SDT, 1/BDF, 1/DTF. * TIF = TRACK INTERLOCK FLAG. * OPF = ORIGINAL POSITION FLAG FOR SKIP BACKWARD/OPEN. * SDT = SKIP DATA TRANSFER FLAG FOR *READSKP*. * BDF = BUFFERED DEVICE FUNCTION FLAG. * DTF = DATA TRANSFERRED FLAG. * RC REASON CODE FOR RECALL STACK ENTRY. * F IF SET, BUILD FNT ENTRY AND RESTART *CPUCIO*. * EC ERROR CODE, IF NONZERO. * ORD RELATIVE ADDRESS OF FNT ENTRY IN NEGATIVE FL, * IF NONZERO. * LV LEVEL NUMBER, IF NO ERROR. * XC EXTERNAL *CIO* FUNCTION CODE, IF NO ERROR. * IC INTERNAL *CIO* FUNCTION CODE (AS DEFINED IN * *COMSCIO*), IF NO ERROR. * *T MB+1 12/ 0, 24/ IN, 24/ OUT *T MB+2 1/R, 5/0, 6/ FETL, 24/ FIRST, 24/ LIMIT * R SET IF RANDOM FILE. * FETL FET LENGTH - 5. * FET POINTERS ARE TRANSFERRED ONLY IF *1MS* IS * NOT RESTARTED FROM THE RECALL STACK. SPACE 4,10 *** SYSTEM SECTOR PROCESSING. * * *1MS* WILL READ AND WRITE THE SYSTEM SECTOR TO/FROM THE * CIRCULAR BUFFER BASED ON THE SYSTEM SECTOR OPERATION FLAG * IN THE FST (BYTE 4, BIT 13B). TO READ THE SYSTEM SECTOR, THE * FORMAT OF THE FST SHOULD BE * *T FST 12/ EQ,12/ FIRST TRACK,12/ FIRST TRACK,12/ 0,12/4005 * * TO WRITE THE SYSTEM SECTOR, THE FORMAT OF THE FST SHOULD BE * *T 6/ ,6/ EQ,12/ FIRST TRACK,12/ 0,12/ 0,12/ 4005 * THE EQUIPMENT AND FIRST TRACK ARE OPTIONAL AND MAY BE 0 IN * WHICH CASE *1MS* WILL ASSIGN A MASS STORAGE DEVICE. * * SYSTEM SECTOR OPERATIONS ARE ONLY SUPPORTED FOR CONTROL WORD * READS AND WRITES AND *INCORRECT I/O REQUEST* WILL BE ISSUED * IF A NON-CONTROL WORD READ OR WRITE IS ISSUED AND THE SYSTEM * SECTOR OPERATION BIT IS SET IN THE FST. THE SYSTEM SECTOR * OPERATION BIT IS CLEARED BY *1MS* AFTER THE CONTROL WORD * READ OR WRITE. SPACE 4,10 *** DAYFILE MESSAGES. * * * *ASSIGNED FOR DIAGNOSTICS, FILE FFF AT NNN.* * A *MALET* USER ATTEMPTED A *CIO* OPERATION OTHER * THAN RETURN/UNLOAD ON A PREASSIGNED TAPE WITH * FILE NAME FFF AND FET ADDRESS NNN. * * *BUFFER ARGUMENT ERROR ON FFF AT NNN.* * A BUFFER POINTER DOES NOT CONFORM TO THESE CONSTRAINTS * FIRST .LE. IN * FIRST .LE. OUT * OUT .LT. LIMIT * IN .LT. LIMIT * LIMIT .LE. FL * * *BUFFER CONTROL WORD ERROR ON FFF AT NNN.* * BLOCK LENGTH AS SPECIFIED DURING A *WRITECW* OPERATION * IS GREATER THAN ALLOWABLE PRU SIZE FOR DEVICE. * * *DEVICE ERROR ON FILE FFF AT NNN.* * AN UNRECOVERED ERROR OCCURRED ON THE MASS STORAGE * DEVICE CONTAINING THE FILE. * * *ERROR FLAG TERMINATION, FILE FFF AT NNN.* * A SPECIAL ERROR FLAG WAS SET DURING PROCESSING OF THE * OPERATION AND THE OPERATION WAS NOT COMPLETED. * * *FET ADDRESS OUT OF RANGE AT NNN.* * FET ADDRESS .LE. 1 OR FET EXTENDS PAST FL. * * *FET PARAMETER ERROR ON FFF AT NNN.* * ONE OF THE PARAMETERS IN THE FET IS INCORRECT (IE. THE * LIST ADDRESS IS .GT. THE JOBS FL) OR THE FET IS NOT * LONG ENOUGH FOR THE PARAMETER. * * *FILE ACCESS LEVEL CONFLICT, FFF AT NNN.* * THE ACCESS LEVEL SPECIFIED FOR FILE FFF * IS NOT WITHIN THE JOB VALIDATIONS. * * *FILE TOO LONG, FILE FFF AT NNN.* = DIRECT ACCESS PERMANENT * FILE FFF HAS EXCEEDED THE DIRECT ACCESS FILE SIZE * LIMIT. * * *INCORRECT EQUIPMENT ON FILE FFF AT NNN.* * THE EQUIPMENT IN THE FST ENTRY FOR THE FILE IS NOT * SUPPORTED FOR *CIO* FUNCTIONS. * * *INCORRECT FILE NAME FFF AT NNN.* * THE FILE NAME DOES NOT CONFORM TO ESTABLISHED RULES. * * *INCORRECT I/O REQUEST ON FILE FFF AT NNN.* * THE FUNCTION CODE IS NOT RECOGNIZED OR THE FUNCTION * IS NOT ALLOWED ON THE FILE IN ITS CURRENT STATE. * * *INCORRECT MODIFICATION OF FFF AT NNN.* * EITHER THE FUNCTION WOULD RESULT IN SHORTENING A * MODIFY-ONLY FILE OR THE FILE HAS MODIFY LOCK-OUT. * * *INDEX ADDRESS OUT OF RANGE FOR FFF AT NNN.* * RANDOM ADDRESS RETURN ADDRESS IS .GT. FL. * * *INDEX TOO LARGE ON OPEN, FILE FFF AT NNN.* * FOR OPEN FUNCTION, THE RANDOM INDEX LENGTH EXCEEDED * THE INDEX BUFFER SIZE. * * *I/O ON EXECUTE-ONLY FILE FFF AT NNN.* * FUNCTION IS NOT ALLOWED BY JOB ON EXECUTE-ONLY FILE. * * *I/O SEQUENCE ERROR ON FILE FFF AT NNN.* * MULTIPLE CONCURRENT FUNCTIONS WERE ATTEMPTED ON A * SINGLE FILE. * * *JOB ACCESS LEVEL CONFLICT, FFF AT NNN.* * THE ACCESS LEVEL OF THE JOB IS NOT VALID FOR * THE DEVICE ON WHICH FILE FFF RESIDES. * * *M.T. NOT AVAILABLE ON FILE FFF AT NNN.* * THE MAGNETIC TAPE EXECUTIVE IS NOT EXECUTING. * * *PRU LIMIT, FILE FFF AT NNN.* * WRITING ON FILE FFF WOULD EXCEED THE JOBS PRU LIMIT. * * *RANDOM ADDRESS NOT ON FILE FFF AT NNN.* * THE RANDOM ADDRESS EXCEEDS THE NUMBER OF ADDRESSES ON * THE FILE. * * *REQUEST UNDEFINED ON DEVICE, FFF AT NNN.* * THE FUNCTION CANNOT BE PERFORMED ON THE DEVICE UPON * WHICH THE FILE RESIDES. * * *UNNECESSARY CIO FCT. 000 ON FFF AT NNN.* * THE SPECIFIED *CIO* READ OR WRITE FUNCTION WAS * UNNECESSARY, SINCE THE USER I/O BUFFER WAS ALREADY * FULL (FOR READ) OR EMPTY (FOR WRITE) AND NO DATA * COULD BE TRANSFERRED FOR THIS *CIO* CALL. * * *WRITE ON READ-ONLY FILE FFF AT NNN.* * A WRITE WAS ATTEMPTED ON A FILE WITH WRITE LOCK-OUT. * * *WRITEDOWN PROHIBITED ON FILE FFF AT NNN.* * THE ACCESS LEVEL OF THE JOB IS HIGHER THAN THE * CURRENT ACCESS LEVEL OF FILE FFF, AND THE FILE * IS A TAPE FILE OR A DIRECT ACCCESS PERMANENT FILE. * * IN THE ABOVE MESSAGES, FFF REPRESENTS THE FILE NAME AS GIVEN * IN THE FET AND NNN REPRESENTS THE FET ADDRESS. SPACE 4,10 *** OPERATOR MESSAGES. * * * *EQXXX, TRACK LIMIT.* = *1MS* IS WAITING FOR MASS STORAGE * SPACE TO BECOME AVAILABLE ON EST ORDINAL XXX. * * * TRACK LIMIT.* = *1MS* IS WAITING FOR MASS STORAGE SPACE TO * BECOME AVAILABLE ON A TEMPORARY FILE DEVICE. * * * TRACK LIMIT, LVLX.* = *1MS* IS WAITING FOR TEMPORARY * FILE MASS STORAGE SPACE ON ANY MASS STORAGE DEVICE * WITH ACCESS LEVEL LVLX. SPACE 4,10 *** HANG CONDITIONS. * * *1MS* WILL HANG ISSUING THE *MXFM* MONITOR FUNCTION * IN THE FOLLOWING CASES - * * 1. *WMS* TRIES TO WRITE A DATA SECTOR ON THE LAST SECTOR * OF A TRACK WITH NO NEXT TRACK RESERVED. * 2. *WMS* TRIES TO WRITE AN EOF SECTOR ON THE LAST SECTOR * OF A TRACK WITH NO NEXT TRACK RESERVED. * 3. *PMS* CALLED TO PROCESS FUNCTION OTHER THAN * SKIP, OPEN, OR RANDOM READ/WRITE. * 4. HANG ERROR CODE WAS PASSED TO *1MS* FROM *CPUCIO* * (DEFINED IN *COMSCIO*). * 5. *0DQ* WAS UNABLE TO LOCATE GLOBAL ENTRY ASSOCIATED * WITH QUEUED FILE FOR *EVICT* PROCESSING. * 6. ERROR CODE PASSED IN MESSAGE BUFFER PARAMETER WORD IS * INCORRECT. SPACE 4,10 ** ROUTINES USED. * * * 0BF - BEGIN FILE. * 0DF - DROP FILE. SPACE 4,10 ** SYSTEM SECTOR BUFFER ASSIGNMENTS. BFMS EQU 6776-2*5 ALLOW FOR CONTROL WORDS SPACE 4,10 ** COMMON DECKS. *CALL COMPMAC LIST X *CALL COMSCIO LIST * *CALL COMSCPS *CALL COMSEVT *CALL COMSMLS QUAL COMSHIO *CALL COMSHIO QUAL * *CALL COMSMSP QUAL PFM *CALL COMSPFM QUAL * *CALL COMSPIM *CALL COMSSCD *CALL COMSSRU *CALL COMSSSD *CALL COMSSSE *CALL COMSWEI *CALL COMSZOL TITLE DIRECT LOCATION ASSIGNMENTS. SPACE 4,10 ** DIRECT LOCATION ASSIGNMENTS. T8 EQU 16 TEMPORARY (DESTROYED BY OVL LOAD) T9 EQU 17 TEMPORARY (DESTROYED BY OVL LOAD) EN EQU 17 ERROR NUMBER * THE FOLLOWING DIRECT CELLS (MB - MB2) ARE READ IN BY *PPR* * FROM *MB* THROUGH *MB*+2 IMMEDIATELY AFTER PP ASSIGNMENT * SO THAT THE INFORMATION IS NOT DESTROYED BY LOADING THE PP. MB EQU 20 - 24 MESSAGE BUFFER PARAMETERS ERRNZ MB-MP ADDRESSES MUST MATCH MB1 EQU 25 - 31 MB + 1 PARAMETERS ERRNZ MB1-MP-5 ADDRESS MUST BE CONSECUTIVE MB2 EQU 32 - 36 MB + 2 PARAMETERS ERRNZ MB2-MP-10D ADDRESS MUST BE CONSECUTIVE FS EQU 20 - 24 FST ENTRY (5 LOCATIONS) PC EQU 25 PHYSICAL RECORD COUNT RC EQU 26 *DRCM* REQUEST CODE FO EQU 27 FET OPTIONS DP EQU 30 - 34 DATA POINTER (5 LOCATIONS) * 35 USED BY OVERLAYS * 36 USED BY OVERLAYS * 37 USED BY OVERLAYS BS EQU 40 - 44 BUFFER STATUS (5 LOCATIONS) FN EQU BS FILE NAME (5 LOCATIONS) FC EQU 45 FUNCTION CODE * 46 USED BY OVERLAYS * 47 USED BY OVERLAYS FA EQU 57 FNT ENTRY RELATIVE ADDRESS IN NFL FT EQU 60 - 61 FIRST ADDRESS OF BUFFER (2 LOCATIONS) LM EQU 62 - 63 LIMIT ADDRESS OF BUFFER (2 LOCATIONS) IN EQU 64 - 65 NEXT INPUT ADDRESS (2 LOCATIONS) OT EQU 66 - 67 NEXT OUTPUT ADDRESS (2 LOCATIONS) TITLE MACRO DEFINITIONS. SPACE 4,10 ** MACRO DEFINITIONS. CFET SPACE 4,10 ** CFET - COMPUTE FET ADDRESS. * CFET N * * ENTRY *N* = FET WORD NUMBER. * * COMPUTES ABSOLUTE FET ADDRESS USING (IR+3 - IR+4). * * CALLS CAF. CFET MACRO W RJM CAF IFC NE,$W$$,1 ADN W ENDM ERROR SPACE 4,10 ** ERROR - PROCESS ERROR. * * ERROR EC * * *EC* = ERROR CODE. ERROR MACRO EC .1 IFC EQ,$EC$UCF$ LDN SSTL CRD CM LDD CM+3 LPN 20 NJP CFN IF LOGGING DISABLED .1 ENDIF LDN /CIOERR/EC LJM ERR ENDM MSG SPACE 4,10 ** MSG - DEFINE ERROR MESSAGE. * *ERR MSG (TEXT),EF,CODE * * ENTRY *ERR* = ERROR CODE. * *TEXT* = ERROR MESSAGE. * *EF* = ERROR FLAG. * *CODE* = OPTION CODE. MACRO MSG,ERR,TEXT,EF,CODE LOCAL A ORG TEPO+/CIOERR/ERR .A IFC NE,$EF_CODE_TEXT$$ LOC /CIOERR/ERR VFD 6/EF,6/CODE LOC *O ORG TMSG+/CIOERR/ERR .B IFC NE,$TEXT$$ CON =Z*_TEXT_* .B ELSE CON 0 .B ENDIF A MICRO 1,,$TEXT$ A MICCNT A ERRNG 31D-A .A ENDIF ENDM OVERLAY SPACE 4,10 ** OVERLAY - DEFINE OVERLAY. * * *NAME OVERLAY (TITLE),ORG * * ENTRY *NAME* = OVERLAY NAME. * *TITLE* = OVERLAY TITLE. * *ORG* = ORIGIN ADDRESS. NOREF .N .N SET 0 OVERLAY NUMBER PURGMAC OVERLAY MACRO OVERLAY,NAME,TEXT,ORIG QUAL .1 SET .N/1R4 .1 MICRO .1+1,1 M .N MICRO .N-.1*1R4+1,1, ABCDEFGHIJKLMNOPQRSTUVWXYZ01234 .N MICRO 1,, ".1"".N" NAME EQU 2R".N" .N SET .N+1 TTL 1MS/4".N" - TEXT TITLE USE QUAL NAME IDENT 4".N",ORIG TEXT ORG ORIG *COMMENT 1MS - TEXT COMMENT COPYRIGHT CONTROL DATA SYSTEMS INC. 1992. ENDM TITLE MAIN PROGRAM. ORG PPFW TMSO LJM PRS PRESET PROGRAM * GLOBAL DATA. FACF EQU *-2 FILE ACCESS FLAGS FETL EQU *-1 FET LENGTH PMFF CON 1 PERMANENT FILE FLAG MSFF CON 0 MASS STORAGE FILE FLAG FSAL CON 0 FILE SECURITY ACCESS LEVEL JSAL CON 0 JOB SECURITY ACCESS LEVEL OSSM CON 0 OPERATING SYSTEM SECURITY MODE * THE FOLLOWING 5 CONSECUTIVE LOCATIONS SAVE *1MS* * MESSAGE BUFFER PARAMETERS. RCRF CON 0 REASON CODE AND RESTART FLAGS ERCF CON 0 ERROR CODE AND FUNCTION FLAGS FNTA CON 0 FNT ENTRY RELATIVE ADDRESS LVXC CON 0 LEVEL NUMBER AND EXTERNAL FUNCTION CODE ICFC CON 0 INTERNAL *CIO* FUNCTION CODE ERRNZ /CIO/RDF CODE DEPENDS ON INTERNAL READ FUNCTION ERRNZ /CIO/WTF-1 CODE DEPENDS ON INTERNAL WRITE FUNCTION TMS SPACE 4,10 ** TMS - TRANSFER MASS STORAGE DATA. * * EXIT TO *MSP*. * * CALLS EXR. TMS BSS 0 ENTRY LDC 0 * LDC 1 (RANDOM READ/WRITE) TMSA EQU *-1 ZJN TMS1 IF NOT RANDOM READ/WRITE LDC 1L4+PMS LOAD POSITION OVERLAY RJM EXR TMS1 LDC 1L4+PMS LOAD POSITION OVERLAY * LDC 1L4+RMS (READ) * LDC 1L4+WMS (WRITE) * LDC 1L4+CMS (CLOSE) * LDC 1L4+OMS (OVERWRITE) TMSB EQU *-1 RJM EXR EXECUTE FUNCTION PROCESSOR * UJN MSP COMPLETE MASS STORAGE PROCESSING TITLE TERMINATION. ** TERMINATION PROCESSORS. MSP SPACE 4,15 ** MSP - COMPLETE MASS STORAGE PROCESSING. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (FO) = FET OPTIONS. * (PC) = SECTOR COUNT FOR RANDOM INDEX UPDATE. * (BS - BS+4) = (FET+0). * (FS - FS+4) = FST ENTRY. * * EXIT RANDOM ADDRESS IN FET+6 UPDATED. * TO *COC*. * * USES CM - CM+4. * * MACROS CFET. MSP BSS 0 ENTRY LDD FC CHECK FUNCTION SHN -7 LPN 7 NJN COC IF NOT READ/WRITE LDD FO CHECK PROCESSING BITS SHN 21-13 PJN COC IF NOT RANDOM FET CFET 6 READ RANDOM ACCESS CONTROL CRD CM LDD PC ADVANCE SECTOR COUNT SHN 6 RAD CM+2 SHN -14 RAD CM+1 SHN -14 RAD CM CFET 6 CWD CM STORE RANDOM ACCESS CONTROL * UJN COC CHECK OPERATION COMPLETE COC SPACE 4,10 ** COC - CHECK OPERATION COMPLETE. * * EXIT TO *CFN* IF TO ENTER RECALL STACK OR * RESTART *CPUCIO*. * TO *UFS* IF FUNCTION COMPLETE. COC BSS 0 ENTRY LDC 0 CHECK FOR ENTRY TO RECALL STACK * LDC 1 (ENTER RECALL STACK) * LDC 4000 (RESTART *CPUCIO*) COCA EQU *-1 ZJN UFS IF FUNCTION COMPLETE SHN 21-13 MJN COC1 IF *CPUCIO* RESTART SOM CFNA LEAVE FILE SET BUSY COC1 LDN 0 PREVENT SETTING FET COMPLETE STM CFNC STM CFNE PREVENT FUNCTION CHARGE STM CFNE+1 LJM CFN COMPLETE FUNCTION CLS SPACE 4,10 ** CLS - CLOSE MASS STORAGE COMPLETION. * * EXIT TO *CFN* IF *CLOSE/NO REWIND* FUNCTION. * TO *DRF* IF *CLOSE/RETURN* OR *CLOSE/UNLOAD*. * TO *REW* IF *CLOSE/REWIND* FUNCTION. CLS BSS 0 ENTRY LDM CFNB CLEAR FILE OPENED AND WRITTEN BITS LPN 71 STM CFNB CLSA LDN 0 SET RETURN FLAG FOR *DRF* * LDN 1 (SET UNLOAD FLAG FOR *DRF*) LJM REW REWIND FILE * LJM DRF (CLOSE/RETURN OR UNLOAD) * LJM CFN (CLOSE/NO REWIND) CLSB EQU *-1 UFS SPACE 4,15 ** UFS - UPDATE FET STATUS FOR READ OR POSITION FUNCTION. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (BS - BS+4) = (FET+0). * (FS - FS+4) = FST ENTRY. * * EXIT (BS - BS+4) = (FET+0) UPDATED WITH TERMINATION * STATUS. * TO *CFN* FOR FUNCTION OTHER THAN *CLOSE*. * TO *CLS* FOR *CLOSE* FUNCTION. * * USES T1. UFS BSS 0 ENTRY LDD FC CHECK FUNCTION SHN -6 LPN 17 ZJN UFS1 IF READ FUNCTION LMN /CIO/CLO ZJN CLS IF CLOSE FUNCTION LMN /CIO/SKP&/CIO/CLO NJN UFS3 IF NOT SKIP FUNCTION LDC 6742 STM UFSB UFS1 LDD FS+4 CHECK TERMINATION CONDITION LPN 14 UFSA SHN -2 * LDN 0 (TERMINATION CONDITION NOT REACHED) ZJN UFS3 IF NOT EOR/EOF/EOI STD T1 LDD FC SHN 21-13 MJN UFS2 IF SKIP BACKWARD FUNCTION LDD BS+4 LPC 6002 * LPC 6742 (SKIP FORWARD) UFSB EQU *-1 LMM UFSC-1,T1 SET EOR/EOF/EOI INDICATOR STD BS+4 UFS2 LDD BS+3 SCN 74 LMM UFSD-1,T1 SET LEVEL NUMBER STD BS+3 UFS3 UJN CFN COMPLETE FUNCTION UFSC BSS 0 READ/POSITION FUNCTION RETURNS LOC 1 CON 20 EOR CON 30 EOF CON 1030 EOI LOC *O UFSD BSS 0 LEVEL NUMBER RETURNS LOC 1 CON 0 EOR CON 74B EOF CON 74B EOI LOC *O RRF SPACE 4,15 ** RRF - RESET RANDOM FET POINTERS. * * ENTRY (FO) = FET OPTIONS. * (FS - FS+4) = FST ENTRY. * * EXIT (FS+4) = FST STATUS. * TO *CFN*. * * USES DP - DP+4. * * MACROS CFET. RRF BSS 0 ENTRY LDD FS CHECK DEVICE TYPE LMN TEEQ ZJN RRF1 IF *TE* LDN 4 SET EOR FST STATUS RRF1 STD FS+4 LDD FO CHECK FOR RANDOM FILE SHN 21-13 PJN CFN IF NOT RANDOM FILE CFET 6 READ RANDOM INDEX WORD CRD DP LDN 0 SET *CRI* TO 1 STD DP STD DP+1 LDD HN STD DP+2 CFET 6 REWRITE FET+6 CWD DP * UJN CFN COMPLETE FUNCTION CFN SPACE 4,20 ** CFN - COMPLETE FUNCTION. * * ENTRY (FA) = FNT ORDINAL. * (FC) = INTERNAL *CIO* FUNCTION CODE. * (PC) = PRU COUNT. * (BS - BS+4) = (FET+0). * (FS - FS+4) = FST ENTRY. * * EXIT TO *PPR* IF FUNCTION COMPLETE. * TO *CRC* IF TO ENTER RECALL STACK OR RESTART * *CPUCIO*. * * USES T1, CM+1, CM+2. * * CALLS CIT. * * MACROS CFET, MONITOR, NFA. CFN BSS 0 ENTRY RJM CIT CLEAR TRACK INTERLOCK LDD FA CHECK FNT ADDRESS ZJN CFN1 IF NO FNT ENTRY AOD FS+4 SET FILE NOT BUSY CFNA LPN 77 * LPN 76 (ENTER RECALL STACK, LEAVE FILE BUSY) SHN 14 LMC ** RESET UPPER STATUS CFNB EQU *-1 (UPPER 6 BITS OF PREVIOUS FST STATUS) SHN 6 STD FS+4 NFA FA,R ADN FSTL CWD FS CFN1 AOD BS+4 SET FET COMPLETE * PSN (ENTER RECALL STACK/RESTART *CPUCIO*) CFNC EQU *-1 CFET STORE FET STATUS CFND CWD BS * PSN (ERROR PROCESSING) * UPDATE ACCOUNTING CHARGES AND MASS STORAGE PRU COUNT. * DROP PPU. LDM CFNJ CHECK FOR MASS STORAGE PRU COUNT UPDATE ADM CFNJ+1 ZJN CFN2 IF NO FILE SIZE CHANGE LDN 1 * ENTRY FROM *PRS* IF ERROR CODE INCORRECT. CFN2 ADN 1 SET *UADM* PARAMETER COUNT STD CM+1 LDD FC GET FUNCTION CODE SHN -6 LPN 17 STD T1 LDD PC CHARGE FOR PRUS TRANSFERRED SHN IMPT CFNE ADM TACC,T1 CHARGE FOR FUNCTION * PSN (ENTER RECALL STACK/RESTART *CPUCIO*) * PSN (ENTER RECALL STACK/RESTART *CPUCIO*) RAM CFNH+1 SHN -14 RAM CFNH ADM CFNH+1 NJN CFN3 IF ACCOUNTING CHARGE SOD CM+1 ZJN CFN4 IF NO FILE SIZE UPDATE LDN CFNI-CFNG RAM CFNF CFN3 LDD MA STORE *UADM* PARAMETER WORDS CWM CFNG,CM+1 * CWM CFNI,CM+1 (FILE SIZE UPDATE ONLY) CFNF EQU *-1 CFN4 LDM COCA CHECK FOR RECALL NJN CRC IF FUNCTION NOT COMPLETE LDD IR+1 CHECK AUTO RECALL SHN 1-5 LPN 2 LMN 2 RECALL CPU FOR NON-AUTO RECALL REQUEST STD CM+2 SET TO DROP PPU AND RECALL CPU MONITOR UADM LJM PPR EXIT TO PP RESIDENT * MESSAGE BUFFER STRUCTURE FOR UADM FUNCTION. * (THE FOLLOWING 2 CM WORDS MUST BE CONTIGUOUS.) CFNG CON AISS INCREMENT I/O ACCUMULATOR CON IOAW I/O ACCUMULATOR WORD CON 40D*100+20D POSITION AND WIDTH OF FIELD CFNH CON 0 PRU COUNT CON 0 CFNI CON CDCS DECREMENT CONTROL POINT AREA FIELD CON ACLW MASS STORAGE PRU LIMIT CON 0D*100+18D POSITION AND WIDTH OF LIMIT FIELD CFNJ CON 0 18 BIT SECTOR COUNT (RIGHT-JUSTIFIED) CON 0 TACC SPACE 4,10 ** TACC - TABLE OF ACCOUNTING CHARGES. * * INDEXED BY INTERNAL *CIO* FUNCTION CODE. TACC INDEX INDEX /CIO/RDF,IMRD READ INDEX /CIO/WTF,IMWT WRITE INDEX /CIO/SKP,IMSK SKIP INDEX /CIO/OPE,IMOP OPEN INDEX /CIO/CLO,IMCL CLOSE INDEX /CIO/RET,IMRU RETURN/UNLOAD INDEX /CIO/EVI,IMRU EVICT INDEX /CIO/OVW,IMWT OVERWRITE INDEX /CIO/MFC CRC SPACE 4,10 ** CRC - CHECK FOR RESTART OF *CPUCIO*. * * ENTRY (CM+1) = *UADM* PARAMETER WORD COUNT. * * EXIT TO *ERS* IF TO ENTER RECALL STACK. * TO *PPR* IF *CPUCIO* RESTARTED. * * USES CM+1 - CM+2, IR - IR+1. * * MACROS MONITOR. CRC BSS 0 ENTRY LDD CM+1 CHECK IF *UADM* NECESSARY ZJN CRC1 IF *UADM* NOT NECESSARY LDN 1 SET NO DROP OF PP STD CM+2 MONITOR UADM UPDATE ACCOUNTING CRC1 LDM COCA SHN -13 NJN CRC2 IF NOT TO ENTER RECALL STACK LJM ERS ENTER RECALL STACK CRC2 LDC 2RCI RESET *CIO* CALL STD IR LDD IR+1 LPN 77 ADC 1RO*100 STD IR+1 LDN ZERL CRD CM LDD MA CWD IR ADN 1 CLEAR MB+1 CWD CM CRCA LDN 2 SET DROP PP FLAG * LDN 0 (NO DROP FOR TERMINAL EQUIPMENT) STD CM+1 MONITOR RPPM RESTART CIO CRCB UJN CRC3 EXIT TO PP RESIDENT * PSN (DROP PPU REQUIRED) LDD IA CLEAR AUTO RECALL FLAG CRD IR LDD IR+1 SCN 40 STD IR+1 LDD IA CWD IR MONITOR DPPM DROP PP CRC3 LJM PPR EXIT TO PP RESIDENT ERS SPACE 4,10 ** ERS - ENTER RECALL STACK. * * ENTRY (PC) = PRU COUNT. * (FS - FS+4) = FST ENTRY. * * EXIT TO *PPR*. * TO *1RJ* IF RECALL DUE TO MASS STORAGE ERROR. * * USES BS - BS+4, CM - CM+4, DP - DP+4. * * CALLS CBD. * * MACROS EXECUTE, MONITOR. ERS BSS 0 ENTRY LDD PC ZJN ERS1 IF NO PRUS TRANSFERRED LDM RCRF SET DATA TRANSFERRED FLAG LPC 3600 ADD HN UJN ERS2 SET RECALL STACK REASON ERS1 LDM RCRF LPC 3700 ERS2 LMN PTLR SET PRU TRANSFER LIMIT RECALL REASON CODE * LMN TRLR (TRACK LIMIT REASON CODE) * LMN TIRR (TRACK INTERLOCK REJECT REASON CODE) * LMN NFIR (NFL INCREASE PENDING REASON CODE) * LMN LBBR (WAIT FOR BUFFER FLUSH REASON CODE) * LMN WFOR (WAIT FOR INACCESSABLE DEVICE REASON CODE) ERSA EQU *-1 STM RCRF LPN 77 LMN PTLR NJN ERS3 IF NOT PRU TRANSFER LIMIT RJM CBD CHECK FOR BUFFERED DEVICE RAM ERSC INCREASE ACTIVITY FOR BUFFERED DEVICE LDD CM+4 SHN 3 ADN PFGL GET NUMBER OF UNITS ON EQUIPMENT CRD BS ADN DALL-PFGL GET DEVICE ACTIVITY CRD DP LDD DP EXTRACT ACTIVITY ONLY FROM DALL LPN 77 STD DP LDD BS+4 LPN 7 ADN 1 ERSC SHN 1 * SHN 3 (BUFFERED DEVICE) SBD DP PJN ERS3 IF NOT EXCESSIVE DEVICE ACTIVITY LDK ACRT SET DEVICE ACTIVITY RECALL TIME PERIOD UJN ERS4 ENTER RECALL STACK ERS3 LDC IORT SET I/O RECALL TIME PERIOD * LDC TLRT (TRACK LIMIT RECALL TIME PERIOD) * LDC TIRT (TRACK INTERLOCK REJECT RECALL TIME) ERSB EQU *-1 ERS4 STD CM+4 SET RECALL TIME SHN -14 STD CM+3 LDN 0 STD CM+2 LDD IA STORE *1MS* CALL CWD IR ADN 2 CWD IR ADN 1 STORE *1MS* RECALL PARAMETERS CWM RCRF,ON LDM RCRF CHECK IF WAITING FOR SUSPECT EQUIPMENT LPN 77 LMN WFOR ZJN ERS5 IF WAITING FOR SUSPECT DEVICE - CALL 1RJ* LDN PTMF SET TIMED RECALL CRITERION STD CM+1 MONITOR RECM LJM PPR EXIT TO PP RESIDENT * CALL *1RJ* TO RECALL THE PP AND ROLL THE JOB. ERS5 LDC 0 SET EST ORDINAL IN *1RJ* CALL ERSD EQU *-1 NJN ERS6 IF ERROR RETURNED FROM *0DF* LDD FS ERS6 STD IR+4 LDD MA READ RECALL PARAMETERS FOR *1RJ* ADN 1 CRD MB EXECUTE 1RJ ERR SPACE 4,10 ** ERR - PROCESS ERROR. * * ENTRY (A) = ERROR NUMBER. * * EXIT (ERRA) = ERROR NUMBER. * TO *CFN* IF NO LOGGING NEEDED FOR UNNECESSARY * *CIO* FUNCTION. * * CALLS EXR. ERR BSS 0 ENTRY STM ERRA SET ERROR NUMBER LDC 1L4+ERP RJM EXR ERRA CON 0 ERROR NUMBER CHG SPACE 4,10 ** CHG - CONDITIONALLY HANG PP. * * ENTRY (A) = ERROR FLAG TO BE SET OR ZERO. * * EXIT (A) = 0. * * USES CM - CM+4. * * MACROS MONITOR. CHG SUBR ENTRY/EXIT STD CM+2 STORE ERROR FLAG IN REQUEST LDM CHG GET ADDRESS WHERE ERROR DETECTED STD CM+1 MONITOR CHGM CONDITIONALLY HANG PP UJN CHGX RETURN TITLE RESIDENT PROCESSORS. CDA SPACE 4,15 ** CDA - CHECK DEVICE ACCESSIBILITY. * * THIS ROUTINE CHECKS THE RETURN STATUS FROM THE DRIVER, THE * REAL TIME FLAG IN THE FET, AND THE SUBSYSTEM INDICATION * TO DETERMINE IF THE JOB SHOULD BE ROLLED OUT. * * ENTRY (RDCT), (MSD) = STATUS FROM THE DRIVER. * * EXIT TO *MSR*, IF REAL TIME FLAG SET, UNRECOVERABLE ERROR, * SUBSYSTEM, OR CONTROL POINT ERROR FLAG * SET. * TO *COC*, IF JOB SHOULD BE ROLLED. * * NOTE IN SOME CASES, THE ERROR PROCESSOR JUMPS TO THE * *CDA* RETURN ADDRESS. CDA CON 0 LDM RDCT SHN 21-12 MJN CDA1 IF UNRECOVERABLE ERROR LDD FO SHN 21-7 MJN CDA1 IF REAL TIME FLAG SET LDM MSD SHN 21-13 PJN CDA5 IF SUBSYSTEM LDD CP CHECK ERROR FLAG ADN STSW CRD CM LDD CM+1 CDA1 NJN CDA5 IF ERROR FLAG SET CDAA LDD FC * UJN CDA4 (ERROR SETTING TRACK INTERLOCK) SHN -6 CHECK FOR WRITE OPERATION LPN 17 LMN /CIO/WTF ZJN CDA2 IF WRITE FUNCTION LMN /CIO/CLO&/CIO/WTF NJN CDA3 IF NOT CLOSE FUNCTION CDA2 RJM /WMS/WEI ATTEMPT TO WRITE EOI ON FILE CDA3 LDM ERSD ZJN CDA4 IF NOT ERROR RETURN FROM *0DF* LDN 0 STD FA CDA4 LDN WFOR-PTLR ADJUST REASON CODE RAM ERSA LDN 1 SET TO RECALL PP STM COCA LJM COC COMPLETE AND RECALL PP * LJM /SMR/SLS (*READLS*/*RPHRLS*) CDAB EQU *-1 CDA5 LDM RDCT SAVE DRIVER RETURN CODE STD T4 LDD MA SAVE DIRECT CELLS CWD T3 CRM DCSA,ON ERROR DRE *DEVICE ERROR ON FILE* DRF SPACE 4,15 ** DRF - DROP FILE. * * ENTRY (A) = 0 IF RETURN FUNCTION. * = 1 IF UNLOAD FUNCTION. * (FA) = RELATIVE FNT ADDRESS IN NFL. * * EXIT (FA) = 0. * TO *CDA*, IF ERROR FROM *0DF*. * TO *REW1*. * * CALLS CIT. * * MACROS EXECUTE. DRF BSS 0 ENTRY STM OVL-1 SAVE RETURN/UNLOAD FLAG FOR *0DF* LDD FA ZJN DRF2 IF NO FNT ENTRY * CHANGE TO RETURN FUNCTION IN CASE RECALL IS NECESSARY DUE TO * AN ERROR FROM *0DF*. THIS ALSO PREVENTS ERROR PROCESSING FROM * ATTEMPTING TO WRITE AN EOI ON THE FILE AFTER A *0DF* ERROR * ON A CLOSE/RETURN FUNCTION. LDD FC LPC 6077 LMC /CIO/RET*100 STD FC STM ICFC RJM CIT CLEAR TRACK INTERLOCK EXECUTE 0DF,OVL DROP FILE DRF2 PJN REW1 IF NO ERROR LDD T5 STM ERSD RJM CDA CHECK DEVICE REW SPACE 4,10 ** REW - REWIND MASS STORAGE. * * ENTRY (FS - FS+4) = FST ENTRY. * * EXIT (FS - FS+4) = UPDATED FST ENTRY. * TO *RRF*. REW BSS 0 ENTRY LDM CFNB CLEAR SYSTEM SECTOR OPERATION FLAG SCN 40 STM CFNB LDM MSFF GET MASS STORAGE FILE FLAG NJN REW1 IF NOT MASS STORAGE FILE LDD FS+2 CHECK CURRENT TRACK ZJN REW1 IF FILE NOT USED LDD FS+1 SET FIRST TRACK STD FS+2 LDN FSMS SET FIRST SECTOR STD FS+3 REW1 LJM RRF RESET POINTERS TITLE RESIDENT SUBROUTINES. SPACE 4,10 ** COMMON DECKS. *CALL COMPCTI CAF SPACE 4,10 ** CAF - COMPUTE ABSOLUTE FET ADDRESS. * * ENTRY (IR+3 - IR+4) = RELATIVE FET ADDRESS. * * EXIT (A) = ABSOLUTE FET ADDRESS. CAF SUBR ENTRY/EXIT LDD IR+3 CALCULATE ABSOLUTE FET ADDRESS LPN 37 SHN 6 ADD RA SHN 6 ADD IR+4 UJN CAFX RETURN CBD SPACE 4,10 ** CBD - CHECK FOR BUFFERED DEVICE. * * ENTRY (FS) = EQUIPMENT. * * EXIT (A) = 0 IF NOT BUFFERED DEVICE. * (A) = 2 IF BUFFERED DEVICE. * (CM - CM+4) = EST ENTRY IF EQUIPMENT ASSIGNED. * * USES CM - CM+4. * * MACROS SFA. CBD1 LDN 0 INDICATE NOT BUFFERED DEVICE CBD SUBR ENTRY/EXIT LDD FS ZJN CBDX IF NO EQUIPMENT SFA EST READ EST ENTRY ADK EQDE CRD CM LDD CM SHN 21-13 PJN CBD1 IF NOT MASS STORAGE SHN 1-5-21+13 CHECK BUFFERED DEVICE FLAG LPN 2 UJN CBDX RETURN FWB SPACE 4,15 ** FWB - FLUSH WRITE DATA FOR BUFFERED DEVICE. * * ENTRY (FA) = RELATIVE ADDRESS OF FNT ENTRY IN NFL. * (FS - FS+4) = FST ENTRY. * * EXIT (A) = 0 IF NO FLUSH REQUIRED. * (A) = 1 IF FLUSH IN PROGRESS. * * USES CM - T9, T0 - T4. * * CALLS CBD. * * MACROS MONITOR, NFA. FWB SUBR ENTRY/EXIT RJM CBD CHECK FOR BUFFERED DEVICE ZJN FWBX IF NOT BUFFERED DEVICE NFA FA,R GET CONTROL BUFFER INDEX FROM FNT ENTRY ADN FUTL CRD T9-4 LDK BIOL GET BUFFERED I/O TABLES FWA CRD CM LDD CM+1 SHN 14 ADD CM+2 ADK /COMSHIO/CBTP GET CONTROL BUFFERS FWA CRD CM LDD T9 ZJN FWBX IF NO CONTROL BUFFER INDEX SHN /COMSHIO/CBTLS ADD CM+4 SHN 6 ADD CM+3 SHN 14 ADN /COMSHIO/LSLK CRD T0 SBN -/COMSHIO/IOLK+/COMSHIO/LSLK CRD CM SBN -/COMSHIO/FSTC+/COMSHIO/IOLK CRD CM+1 LDD T0 NJN FWB1 IF BUFFER BEING ACCESSED LDD CM+1 COMPARE FST INFORMATION LMD FS LPC 777 NJN FWB1 IF BUFFER NOT FOR SAME EQUIPMENT LDD CM+2 ZJN FWB3 IF NO FIRST TRACK LMD FS+1 ZJN FWB3 IF SAME TRACK FWB1 LDN 0 INDICATE NO FLUSH REQUIRED FWB2 LJM FWBX RETURN FWB3 LDD CM SHN 21-11 PJN FWB1 IF NOT WRITE DATA SHN 21-13-21+11+22 MJN FWB4 IF I/O INTERLOCK SET LDD FA SET FNT RELATIVE ADDRESS STD CM+4 LDC FLBS*100 REQUEST BUFFER FLUSH STD CM+1 MONITOR PIOM FWB4 LDN 1 INDICATE FLUSH IN PROGRESS UJN FWB2 RETURN SCF SPACE 4,10 ** SCF - SET CONTROL BUFFER INDEX INTO FNT. * CONTROL BUFFER INDEX IS TAKEN FROM THE PP LINK TABLE * FOR BUFFERED DEVICES. * * USES CM - CM+5. * * CALLS CBD. * * MACROS NFA. SCF SUBR ENTRY/EXIT RJM CBD CHECK FOR BUFFERED DEVICE ZJN SCFX IF NOT BUFFERED DEVICE LDK PPCP GET PP COMMUNICATION BUFFER FWA CRD CM+1 LDK BIOL GET PP LINK TABLE ADDRESS CRD CM LDD CM+1 SHN 14 ADD CM+2 ADN /COMSHIO/PLTP CRD CM LDD IA CALCULATE PP NUMBER SBD CM+1+4 SHN -3 ADD CM+4 SHN 6 ADD CM+3 SHN 14 CRD CM+1 READ CONTROL BUFFER INDEX NFA FA,R UPDATE LINK IN FNT ENTRY ADN FUTL CRD CM LDD CM+1+4 STD CM+4 NFA FA,R ADN FUTL CWD CM LJM SCFX RETURN CIT SPACE 4,10 ** CIT - CLEAR TRACK INTERLOCK. * * ENTRY (FS - FS+4) = FST ENTRY. * * USES T5. * * CALLS CTI. CIT SUBR ENTRY/EXIT LDM RCRF CHECK TRACK INTERLOCK FLAG SHN 21-12 PJN CITX IF TRACK INTERLOCK NOT SET LDC -2000 CLEAR TRACK INTERLOCK FLAG RAM RCRF LDD FS SET EST ORDINAL STD T5 LDD FS+1 SET FIRST TRACK RJM CTI CLEAR TRACK INTERLOCK UJN CITX RETURN DCC SPACE 4,10 ** DCC - DROP CHANNEL WHEN OUTPUT REGISTER CLEAR. * * EXIT (A) = 0. * * USES CM - CM+4. * * MACROS ENDMS. DCC2 ENDMS END MASS STORAGE OPERATION DCC SUBR ENTRY/EXIT DCC1 LDD OA WAIT OUTPUT REGISTER CLEAR CRD CM LDD CM ZJN DCC2 IF OUTPUT REGISTER CLEAR LDN 77 SBN 1 NJN *-1 DELAY UJN DCC1 REREAD OUTPUT REGISTER VAL SPACE 4,10 ** VAL - VALIDATE FILE ACCESS LEVEL. * * ENTRY (A) = 0 IF VALIDATE FILE READ. * (A) = 1 IF VALIDATE FILE WRITE. * * ERROR TO *ERR* IF VALIDATION ERROR DETECTED. * * USES T1, CM - CM+7. * * MACROS ERROR, MONITOR. VAL SUBR ENTRY/EXIT STD T1 LDM OSSM CHECK O/S SECURITY MODE ZJN VALX IF UNSECURED SYSTEM LDD CP CHECK FOR SUBSYSTEM ADK JCIW CRD CM+3 ADK SEPW-JCIW CHECK FOR SSJ= CRD CM LDD CM SHN 21-2 MJN VALX IF SSJ= LDD CM+3+2 SBK LSSI+1 PJN VALX IF SUBSYSTEM LDM JSAL COMPARE JOB AND FILE ACCESS LEVELS SBM FSAL VAL1 ZJN VALX IF FILE IS AT JOB ACCESS LEVEL PJN VAL3 IF JOB LEVEL .GT. FILE LEVEL LDD T1 NJN VALX IF WRITE TO FILE LDM FSAL RAISE JOB LEVEL TO FILE LEVEL FOR READ STD CM+4 LDN VJAS VAL2 STD CM+1 MONITOR VSAM LDD CM+1 ZJN VAL1 IF ACCESS LEVEL CHANGED ERROR LNJ *JOB ACCESS LEVEL CONFLICT.* VAL3 LDD T1 ZJN VAL1 IF READ FILE LDD CP CHECK WRITE DOWN VALIDATION ADK JSCW CRD CM LDD CM LPN 40 LMN 40 ZJN VAL1 IF USER ALLOWED TO WRITE TO LOWER LEVEL LDM PMFF ZJN VAL4 IF PERMANENT FILE LDD FA GET FNT ADDRESS STD CM+3 LDM JSAL RAISE FILE TO JOB ACCESS LEVEL FOR WRITE STD CM+4 LDN VSFS UJN VAL2 ISSUE *VSAM* MONITOR FUNCTION VAL4 ERROR WDP *WRITEDOWN PROHIBITED ON FILE.* SPACE 4,10 DCSA BSSZ 5 T3, RDCT, T5, T6, T7 SAVE AREA SPACE 4,10 MSDO EQU *+5 MASS STORAGE DRIVER ORIGIN SPACE 4,10 OVL EQU *+5 ZERO LEVEL OVERLAY LOAD ADDRESS ERRNG BFMS-OVL-ZDFL CHECK LENGTH OF *0DF* TITLE INITIALIZATION. CFE SPACE 4,15 ** CFE - CREATE FNT ENTRY. * * ENTRY (FN - FN+3) = FILE NAME. * * EXIT TO *ERS1* IF NFL INCREASE REJECTED. * TO *CRC2* IF FNT ENTRY CREATED. * * ERROR TO *ERR* IF ERROR DETECTED. * * USES FA, FS, FS+4, CM - CM+4. * * CALLS VFN, *0BF*. * * MACROS CFET, ERROR, EXECUTE, NFA, MONITOR. CFE BSS 0 ENTRY LDD FN+3 CLEAR LEVEL NUMBER SCN 77 STD FN+3 RJM VFN VALIDATE FILE NAME NJN CFE1 IF NO FILE NAME ERROR ERROR FLN *INCORRECT FILE NAME* CFE1 LDN 6 RETURN ON NFL INCREASE/LOCAL FILE LIMIT STM CFO-1 LDM JSAL SET DEFAULT FILE ACCESS LEVEL STM FSAL LDD FO SHN 21-3 PJN CFE1.1 IF NO ACCESS LEVEL PROCESSING CFET 4 GET FILE ACCESS LEVEL CRD CM LDD CM+1 LPN 7 STD CM+1 STM FSAL ADN 10 SHN 6 RAM CFO-1 LDM OSSM CHECK O/S SECURITY MODE ZJN CFE1.1 IF UNSECURED SYSTEM LDD MA VALIDATE FILE ACCESS LEVEL FOR JOB CWD CM LDN 1 STD CM+4 LDN VAJS STD CM+1 MONITOR VSAM LDD CM+1 NJN CFE1.2 IF FILE ACCESS LEVEL NOT VALID CFE1.1 LDC 2000 PREVENT MS TRACK ASSIGNMENT STD FS EXECUTE 0BF,CFO UJN CFE2 CHECK RETURN STATUS * ADVANCE EXIT IF FNT ENTRY FOUND. LDN 0 STD FA ERROR FSQ *I/O SEQUENCE ERROR* CFE1.2 ERROR LNF *FILE ACCESS LEVEL CONFLICT.* CFE2 ZJN CFE4 IF FNT ENTRY CREATED LMN 4 NJN CFE3 IF NOT LOCAL FILE LIMIT ERROR LFL *LOCAL FILE LIMIT* CFE3 LCN PTLR-NFIR SET NFL INCREASE PENDING REASON CODE RAM ERSA LJM ERS1 ENTER RECALL STACK * SET FNT POINTER IN FET. SET FST NOT BUSY. * ENTER RECALL STACK TO REISSUE *CIO* CALL TO *CPUCIO*. CFE4 CFET 4 SET FNT POINTER IN FET CRD CM LDD FA STD CM CFET 4 CWD CM AOD FS+4 SET FST NOT BUSY NFA FA,R ADN FSTL CWD FS LDD FS CHECK FOR TERMINAL EQUIPMENT LPC 777 ZJN CFE5 IF NO EQUIPMENT ASSIGNED LCN 2 SET FOR NO DROP OF PP ON *RPPM* RAM CRCA LDN 0 SET TO ISSUE *DPPM* STM CRCB CFE5 LJM CRC2 RESTART *CPUCIO* CFO EQU *+1 *0BF* LOAD ADDRESS FOR *CFE* ERRNG BFMS-CFO-ZBFL CHECK *0BF* LENGTH PRS SPACE 4,45 ** PRS - PRESET. * * ENTRY (IR - IR+4) = *1MS* CALL. * (MB - MB+4) = MESSAGE BUFFER PARAMETERS. * (MB1 - MB1+4) = MESSAGE BUFFER + 1 PARAMETERS. * (MB2 - MB2+4) = MESSAGE BUFFER + 2 PARAMETERS. * * EXIT (FA) = RELATIVE ADDRESS OF FNT ENTRY. * = 0 IF NO FNT ENTRY. * (FC) = INTERNAL *CIO* FUNCTION CODE. * (FO) = SPECIAL FET OPTIONS. * (RC) = *DRCM* MONITOR FUNCTION CODE. * (BS - BS+4) = FILE NAME AND EXTERNAL REQUEST. * (DP - DP+4) = (FET+6) IF RANDOM FILE. * (FS - FS+4) = FST ENTRY. * (FT - FT+1) = FIRST. * (IN - IN+1) = IN. * (LM - LM+1) = LIMIT. * (OT - OT+1) = OUT. * (PC) = 0. * (CFNB) = UPPER STATUS BITS OF FST ENTRY. * (ERCF) = ERROR CODE AND FUNCTION FLAGS. * (FACF) = FILE ACCESS FLAGS. * (FETL) = FET LENGTH - 5. * (FNTA) = RELATIVE ADDRESS OF FNT ENTRY, IF NONZERO. * (ICFC) = INTERNAL *CIO* FUNCTION CODE. * (LVXC) = LEVEL NUMBER. * (MSFF) = MASS STORAGE FILE, IF ZERO. * (PMFF) = DIRECT ACCESS PERMANENT FILE, IF NONZERO. * (RCRF) = RECALL REASON CODE AND RESTART FLAGS. * TO *CFE* IF FNT ENTRY TO BE CREATED. * TO *CFN* IF WRITE OF NON-MASS STORAGE FILE. * TO *CFN2* IF ERROR CODE NOT CORRECT. * TO *DRF* TO DROP FILE. * TO *ERS1* IF TO WAIT FOR WRITE BUFFER FLUSH. * TO *TMS* IF SKIP, OPEN, CLOSE, READ, OR WRITE * FUNCTION PROCESSOR TO BE LOADED. * TO *UFS* IF READ OF NULL FILE. * * ERROR TO *ERR* IF PRESET ERROR DETECTED. * * USES EN, CM - CM+4, T1 - T5. * * CALLS CHG, /SRP/EVF, EXR, FWB, STI. * * MACROS CFET, ERROR, MONITOR, NFA, SFA. PRS BSS 0 ENTRY LDD MA RESET FET PARAMETERS IN MESSAGE BUFFER CWD MB SAVE MESSAGE BUFFER PARAMETERS CRM RCRF,ON ADN 1 CWD MB1 ADN 1 CWD MB2 LDD MB+3 GET EXTERNAL *CIO* FUNCTION CODE SHN 1 REPOSITION EXTERNAL *CIO* CODE STD FO LDD MB+4 GET INTERNAL *CIO* FUNCTION CODE STD FC LDN ZERL CRD FS LDM FNTA GET FNT RELATIVE ADDRESS STD FA ZJN PRS1 IF NO FNT ENTRY NFA FA,R READ FNT ENTRY CRD DP ADN FSTL READ FST ENTRY CRD FS ADN FUTL-FSTL READ FUT ENTRY CRD CM LDD CM+2 SAVE FILE SECURITY ACCESS LEVEL LPN 7 STM FSAL LDD FS+4 SAVE UPPER STATUS BITS SHN -6 STM CFNB LDD DP+4 SAVE FILE TYPE FLAG SHN -6 LMN PMFT STM PMFF LDD DP+3 SAVE FILE ACCESS FLAGS LPN 77 STM FACF PRS1 LDN DRCM SET DRIVER RECALL MONITOR FUNCTION STD RC LDD CP GET JOB SECURITY ACCESS LEVEL ADK JSCW CRD CM LDD CM+1 SHN -11 STM JSAL LDK SSML GET O/S SECURITY MODE CRD CM LDD CM LPN 77 STM OSSM LDN 0 STD PC CLEAR PRU COUNT STD CM+1 CLEAR *VFPM* ERROR FLAG LDM ERCF GET ERROR CODE LPN 77 STD EN SAVE ERROR CODE SBN /CIOERR/ARG ZJN PRS3 IF INCORRECT FET ADDRESS SBN /CIOERR/MEC-/CIOERR/ARG MJN PRS2 IF ERROR CODE VALID LDK PPET SET PPU ABORT ERROR FLAG RJM CHG CONDITIONALLY HANG PP LJM CFN2 COMPLETE FUNCTION * REVALIDATE FET PARAMETERS IF RESTARTED FROM RECALL STACK. PRS2 LDM RCRF GET RECALL STACK FLAG SHN 21-13 PJN PRS4 IF FET PARAMETERS PASSED IN CALL LDD FC GET VALIDATION FLAGS LPN 3 STD CM+1 LDD IR+3 SET FET ADDRESS LPN 77 STD CM+3 LDD IR+4 STD CM+4 MONITOR VFPM LDD CM+1 LMN 1 NJN PRS4 IF NOT INCORRECT FET ADDRESS PRS3 ERROR ARG *FET ADDRESS OUT OF RANGE* PRS4 CFET GET FILE NAME AND EXTERNAL FUNCTION CODE CRD BS ADN 1 CRD T1 GET SPECIAL OPTIONS LDD FC NJN PRS5 IF INTERNAL CODE SET LDD BS+3 CLEAR ERROR FIELD SCN 3 STD BS+3 LDD BS+4 STD FO UJN PRS6 SET EXTERNAL CODE PRS5 LDD BS+3 CLEAR LEVEL NUMBER FROM FET SCN 77 STD BS+3 LDM LVXC RESET LEVEL NUMBER IN FET SHN -6 LPN 74 RAD BS+3 PRS6 LDD FO GET EXTERNAL *CIO* CODE LPC 776 CLEAR COMPLETE BIT AND ERROR FIELD STD BS+4 * GET BUFFER POINTERS. LDD MA ADN 2 CRD IN-1 *IN* AND *OUT* ADN 1 CRD FT-1 RANDOM FLAG, FET LENGTH, *FIRST*, *LIMIT* LDD FT-1 GET FET LENGTH - 5 LPN 77 STM FETL LDD FT-1 GET RANDOM FLAG LPC 4000 STD FO ZJN PRS7 IF NOT RANDOM FILE LDD FC CHECK FUNCTION CODE SHN -7 LPN 7 NJN PRS7 IF NOT READ/WRITE LDM RCRF CHECK DATA TRANSFERRED FLAG LPC 100 NJN PRS7 IF PRIOR DATA TRANSFER CFET 6 READ RANDOM REQUEST WORD CRD DP LDD DP+3 CHECK RANDOM REQUEST ADDRESS ADD DP+4 ZJN PRS7 IF RANDOM REQUEST ADDRESS NOT SET AOM TMSA SET RANDOM FUNCTION FLAG PRS7 LDD T1+1 SET FET OPTIONS LPC 3777 RAD FO LDM FNTA RESET FNT RELATIVE ADDRESS STD FA LDD EN CHECK FOR ERROR ZJN PRS8 IF NO ERROR LJM ERR PROCESS ERROR PRS8 LDD CM+1 CHECK *VFPM* REPLY ZJN PRS9 IF NO ERROR ERROR BUF *BUFFER ARGUMENT ERROR* PRS9 LDD FA NJN PRS10 IF FNT ENTRY PRESENT LDM ERCF CHECK IF TO CREATE FNT ENTRY SHN 21-6 PJN PRS10 IF NOT TO CREATE FNT ENTRY LJM CFE CREATE FNT ENTRY PRS10 LDD FS CHECK FOR MASS STORAGE ZJN PRS11 IF NO EQUIPMENT ASSIGNED SFA EST READ EST ENTRY ADK EQDE CRD CM LDD CM SHN -13 LMN 1 PRS11 STD T1 SAVE MASS STORAGE FLAG STM MSFF LDD FC SHN -6 LPN 17 LMN /CIO/RET ZJN PRS12 IF RETURN/UNLOAD FUNCTION LMN /CIO/EVI&/CIO/RET NJN PRS13 IF NOT EVICT FUNCTION LDD T1 NJN PRS12 IF NOT MASS STORAGE FILE LDD FA ZJN PRS12 IF NO FNT ENTRY LDC 1L4+SRP LOAD SPECIAL PROCESSOR OVERLAY RJM EXR RJM /SRP/EVF EVICT MASS STORAGE FILE PRS12 LDD FC GET UNLOAD FLAG FOR *DRF* SHN -12 LPN 1 LJM DRF DROP FILE SRPO EQU *+5 SPECIAL REQUEST PROCESSOR ORIGIN PRS13 LDD T1 GET MASS STORAGE FLAG ADM PMFF CHECK FILE TYPE NJN PRS14 IF NOT DIRECT ACCESS PERMANENT FILE LDM TMSA NJN PRS13.1 IF RANDOM READ/WRITE LDD FC SHN -6 LPN 17 LMN /CIO/WTF ZJN PRS13.2 IF WRITE PRS13.1 RJM FWB FLUSH WRITE BUFFER ZJN PRS13.2 IF NO FLUSH IN PROGRESS LDN LBBR-PTLR SET BUFFER BUSY REJECT RAM ERSA LJM ERS1 ENTER RECALL STACK PRS13.2 LDM FACF CHECK FILE ACCESS MODE LPN 20 ZJN PRS14 IF NOT M, A, RM, OR RA MODE RJM STI SET TRACK INTERLOCK * DETERMINE FUNCTION PROCESSOR. PRS14 LDD FC SHN -6 LPN 17 NJN PRS17 IF NOT READ LDD FS+2 CHECK FOR NULL READ ZJN PRS15 IF NO CURRENT TRACK LCN WMS-RMS LOAD READ OVERLAY UJN PRS18 SET READ OVERLAY NAME * PROCESS READ OF NULL FILE. PRS15 LDN /CIO/EOI SET EOI FST STATUS STD FS+4 LDD FO SHN 21-13 PJN PRS16 IF NOT RANDOM FILE LDN ZERL SET RANDOM INDEX = 1 CRD CM LDD HN STD CM+2 CFET 6 CWD CM PRS16 LJM UFS UPDATE FET STATUS * PROCESS WRITE OF FILE ASSIGNED TO NULL EQUIPMENT. PRS17 LMN /CIO/WTF NJN PRS19 IF NOT WRITE LDM MSFF ZJN PRS18 IF MASS STORAGE FILE LDN 0 SET OUT = IN STD IN-1 STD IN-2 STD IN-3 CFET 3 CWD IN-3 LJM CFN COMPLETE FUNCTION PRS18 ADC WMS SET WRITE OVERLAY NAME UJN PRS20 EXECUTE FUNCTION PROCESSOR PRS19 LMN /CIO/CLO&/CIO/WTF NJN PRS22 IF NOT CLOSE LDC CMS SET CLOSE OVERLAY NAME PRS20 STM TMSB PRS21 LJM TMS LOAD AND EXECUTE FUNCTION PROCESSOR PRS22 LMN /CIO/OVW&/CIO/CLO NJN PRS21 IF NOT OVERWRITE LDC OMS SET OVERWRITE OVERLAY NAME UJN PRS20 EXECUTE FUNCTION PROCESSOR STI SPACE 4,15 ** STI - SET TRACK INTERLOCK. * * ENTRY (FS - FS+4) = FST ENTRY. * * EXIT (A) = 0. * * ERROR TO *ERS1* IF INTERLOCK REJECT. * TO *ERR* IF ERROR FLAG SET. * * USES CM - CM+4. * * MACROS ERROR, MONITOR. STI2 LDC 2000 SET TRACK INTERLOCK FLAG RAM RCRF STI SUBR ENTRY/EXIT LDM RCRF CHECK TRACK INTERLOCK FLAG SHN 21-12 MJN STIX IF TRACK INTERLOCK ALREADY SET LDD FS SET EQUIPMENT ADD TH IMMEDIATE RETURN IF INACCESSIBLE DEVICE STD CM+1 LDD FS+1 SET FIRST TRACK STD CM+2 LDN STIS STD CM+3 MONITOR STBM SET TRACK INTERLOCK LDD CM+1 SHN 21-11 PJN STI0 IF FUNCTION PROCESSED ISTORE CDAA,(UJN CDA4) SKIP EOI WRITE LDD FS SET EST ORDINAL STM ERSD RJM CDA CHECK DEVICE ACCESSIBILITY STI0 ZJP STI2 IF INTERLOCK SET LDD CP ADN STSW CRD CM LDD CM+1 SBN SPET MJN STI1 IF ERROR FLAG NOT ABOVE THRESHOLD ERROR EFT *ERROR FLAG TERMINATION* STI1 LDN TIRR-PTLR SET TRACK INTERLOCK REJECT REASON CODE RAM ERSA LDN TIRT SET TRACK INTERLOCK REJECT RECALL TIME STM ERSB LJM ERS1 ENTER RECALL STACK SPACE 4,10 ** COMMON DECKS. *CALL COMPVFN SPACE 4,10 OVERFLOW PPFW SRP OVERLAY (SPECIAL REQUEST PROCESSOR.),SRPO SPACE 4,10 ** DIRECT LOCATION ASSIGNMENTS. QA EQU 26 DEQUEUE GLOBAL FNT ENTRY INDICATOR SRP SPACE 4,10 ** SRP - SPECIAL REQUEST PROCESSOR. SRP SUBR ENTRY/EXIT UJN SRPX RETURN EVF SPACE 4,15 ** EVF - EVICT MASS STORAGE FILE. * * ENTRY (FA) = RELATIVE ADDRESS OF FNT ENTRY IN NFL. * (DP - DP+4) = LOCAL FNT ENTRY. * (FS - FS+4) = LOCAL FST ENTRY. * * EXIT (FS - FS+4) = UPDATED FST ENTRY. * TO *RRF* IF FILE SUCCESSFULLY EVICTED. * TO *RRF* IF ERROR CLEARING GLOBAL QUEUE ENTRY. * TO *CDA*, IF ERROR FROM *0DQ*. * * USES T1, T5, T6, T7, CM+1 - CM+3. * * CALLS CHG, MSR, WEI, *0DQ*. * * MACROS ENDMS, EXECUTE, MONITOR, NFA, SETMS. EVF SUBR ENTRY/EXIT LDD DP+3 CHECK WRITE LOCKOUT LPN 1 NJN EVFX IF WRITE LOCKOUT SET LDD FS+2 CHECK CURRENT TRACK ZJN EVF1 IF FILE NOT USED LDD DP+4 GET FILE TYPE SHN -6 STD T1 LDM TFTY,T1 SET PROCESSOR ADDRESS ZJN EVFX IF NO PROCESSING FOR FILE TYPE STD T1 LJM 0,T1 JUMP TO PROCESSOR EVF1 LJM RRF RESET POINTERS * EVICT QUEUED FILE. EVF2 LDN 0 FORCE QFT SEARCH STD QA LDN 1 SELECT NO RELEASE OF DISK SPACE STM DQLA-1 EXECUTE 0DQ,DQLA RETURN QFT ENTRY MJP EVF5.0 IF DEVICE IS INACCESSIBLE LDD QA NJN EVF3 IF GLOBAL ENTRY FOUND AND CLEARED * LDN 0 SET NO ERROR FLAG RJM CHG CONDITIONALLY HANG PP LJM RRF RESET RANDOM FET POINTERS EVF3 LDD DP+4 CHANGE FILE TYPE IN LOCAL FNT LPN 77 LMC LOFT*100 STD DP+4 NFA FA,R REWRITE LOCAL FNT ENTRY CWD DP * EVICT LOCAL FILE. EVF4 LDN 0 CLEAR SECTOR STD T7 STD FS+3 CLEAR CURRENT SECTOR STD FS+2 CLEAR CURRENT TRACK EVF5 LDD FS SET EQUIPMENT ADD TH IMMEDIATE RETURN IF INACCESSIBLE DEVICE ADC 0 SET DEVICE CHECKPOINT * ADC 4000 (DIRECT ACCESS PERMANENT FILE) EVFA EQU *-1 STD CM+1 LDD FS+1 SET FIRST TRACK LPC 3777 STD CM+2 LDD T7 SET SECTOR STD CM+3 MONITOR DTKM DROP TRACKS LDD CM+1 CHECK STATUS SHN 21-11 PJN EVF5.1 IF FUNCTION PROCESSED NFA FA,R RESTORE (FS - FS+4) ADN 1 CRD FS EVF5.0 LDD FS SET EST ORDINAL STM ERSD RJM CDA CHECK DEVICE ACCESSIBILITY * INCREMENT PRU LIMIT FIELD IN CONTROL POINT AREA. * ACTUAL COUNT OF SECTORS RETURNED VIA DTKM IS IN CM+3 - CM+4 EVF5.1 LDD CM+3 MOVE SECTOR COUNT TO RESIDENT CIO BUFFER STM CFNJ LDD CM+4 STM CFNJ+1 LDN CICS CHANGE TO INCREMENT FUNCTION STM CFNI LJM RRF RESET POINTERS DQLA EQU *+1 *0DQ* LOAD ADDRESS ERRNG 10000-DQLA-ZDQL CHECK *0DQ* LENGTH * EVICT PERMANENT FILE OR PRIMARY FILE. EVF6 LDC 4000 SET DEVICE CHECKPOINT FLAG STM EVFA EVF7 LDD FS+1 SET FIRST TRACK STD T6 STD FS+2 LDD DP+3 CHECK WRITE RESTRICTIONS LPN 30 ZJN EVF8 IF NOT MODIFY OR APPEND MODE LJM EVFX RETURN EVF8 LDD FS SET EST ORDINAL STD T5 LDN FSMS SET FIRST SECTOR STD FS+3 STD T7 SETMS IO RJM WEI WRITE EOI SECTOR PJN EVF9 IF NO ERROR RJM CDA CHECK DEVICE EVF9 ENDMS END MASS STORAGE OPERATION LDM CFNB SET FILE MODIFIED LPN 74 LMN 03 STM CFNB LJM EVF5 DROP TRACKS TFTY SPACE 4,10 ** TFTY - TABLE OF FILE TYPE PROCESSORS. * ENTRY 1 WORD. * INDEXED BY FILE TYPE. * *T, 12/ ADDR * ADDR ADDRESS OF FILE PROCESSOR TFTY INDEX INDEX PTFT,EVF7 PRIMARY INDEX PMFT,EVF6 PERMANENT INDEX LOFT,EVF4 LOCAL INDEX QFFT,EVF2 QUEUED INDEX MXFT SPACE 4,10 ** COMMON DECKS. *CALL COMPWEI SPACE 4,10 OVERFLOW SRPO RMS OVERLAY (READ MASS STORAGE.),MSDO RMS SPACE 4,10 ** DIRECT LOCATION ASSIGNMENTS. OP EQU 16 - 17 *OUT* POINTER FOR RECALL CALCULATION TC EQU 35 TRACK COUNT BP EQU 37 BUFFER SPACE IN PRUS RMS SPACE 4,10 ORG *+2 LJM PRS PRESET FOR READ LSO SPACE 4,10 ** LSO - LOAD SPECIAL READ OVERLAY. * * EXIT TO *RMS*. * * CALLS EXR. LSO BSS 0 ENTRY LDC 1L4+SMR LOAD SPECIAL READ OVERLAY RJM EXR * UJN RMS PROCESS READ RMS SPACE 4,15 ** RMS - READ MASS STORAGE MAIN ROUTINE. * * EXIT (T1) = 0 FOR CONTROL WORD INITIAL SECTOR LENGTH. * (T3) = 0 FOR CONTROL WORD HEADER USE. * (T5) = EQUIPMENT. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * TO *BRD* FOR NON-CONTROL WORD READ. * TO *CRD* FOR CONTROL WORD READ. * * USES CM - CM+4. * * CALLS SBA, SCA. * * MACROS PAUSE, SETMS. RMS BSS 0 ENTRY * INITIALIZE FOR MASS STORAGE DEVICE. LDD FS SET EST ORDINAL STD T5 LDD FS+2 SET TRACK STD T6 LDD FS+3 SET SECTOR STD T7 * INITIALIZE READ PARAMETERS. LDN 0 SET IN POINTER WORD STD DP STD DP+1 STD DP+2 STD TC INITIALIZE TRACK COUNT LDD IN STD DP+3 LDD IN+1 STD DP+4 * BEGIN READ. SETMS IO LDD CM SHN 21-12 PJN RMS1 IF NOT SYSTEM DEVICE LDN FNTP READ FNT POINTER CRD CM LDD CM READ SYSTEM FST ENTRY SHN 14 ADD CM+1 ERRNZ SYFO CHECK SYSTEM FILE POSITION IN FNT ADN FSTG CRD CM LDD CM+1 CHECK MATCHING FIRST TRACK LMD FS+1 NJN RMS1 IF NOT SYSTEM FILE * *CIO* IS USED TO ACCESS THE SYSTEM FILE FOR THE LOADER, CCL, * ETC. THE READSYS OPTION CAUSES THE DRIVER TO SELECT THE * SYSTEM DEVICE WITH THE LEAST ACTIVITY. IT ALSO CAUSES THE * DRIVER ERROR PROCESSOR TO AUTOMATICALLY TRY A DIFFERENT * SYSTEM DEVICE WHEN AN ERROR IS ENCOUNTERED. SETMS READSYS SYSTEM SELECTION OF SYSTEM DEVICE RMS1 LDC RWPC SET DEFAULT PRU COUNT ADD T7 ADJUST BY CURRENT SECTOR RMS2 STD T1 AOD TC INCREMENT TRACK COUNT LDD T1 SBM SLM PJN RMS2 IF MORE TRACKS TO PROCESS LDD OT SAVE *OUT* STD OP LDD OT+1 STD OP+1 PAUSE NE LDD FC CHECK FOR CONTROL WORD OPERATION SHN 21-5 MJN RMS3 IF *READCW* RJM SBA SET ADDRESSES LJM BRD ENTER BUFFER READ LOOP * LJM RSK9 (*READSKP* SKIP PROCESSING) RMSA EQU *-1 RMS3 RJM SCA SET ADDRESSES LDN 0 PRESET CONTROL WORD STD T3 STD T1 STM BFMS+2-5 STM BFMS+2-3 LDD HN STM BFMS+2-4 LJM CRD ENTER CONTROL WORD READ LOOP EOF SPACE 4,10 ** EOF - TERMINATE ON EOF. * * ENTRY (T2) = LINKAGE BYTE. * (FS - FS+4) = FST ENTRY. * * EXIT (FS+4) = EOF STATUS. * TO *CPR* TO COMPLETE FUNCTION. * TO */SMR/ALS* TO ADVANCE LIST PROCESSING. EOF BSS 0 ENTRY LDD T2 ADVANCE TO NEXT SECTOR STD T7 SHN 6 PJN EOF1 IF NOT TRACK POINTER SHN -6 STD T6 LDN 0 STD T7 EOF1 LDN /CIO/EOF SET EOF FST STATUS STD FS+4 LJM CPR COMPLETE READ PROCESSING * LJM /SMR/ALS (*READLS*/*RPHRLS*) * LJM CPR (CLEANUP AFTER MS ERROR) EOFA EQU *-1 CPR SPACE 4,15 ** CPR - COMPLETE READ. * * ENTRY (DP - DP+4) = IN POINTER. * * EXIT (FS - FS+4) = UPDATED FST ENTRY. * TO *MSP* TO COMPLETE PROCESSING. * TO */SMR/SLS* TO SET READ LIST STATUS. * * USES CM-2 - CM+4. * * CALLS DCC. CPR BSS 0 ENTRY RJM DCC DROP CHANNEL WHEN OUTPUT REGISTER CLEAR LDD T6 UPDATE TRACK STD FS+2 LDD T7 UPDATE SECTOR STD FS+3 CPRA LDC 0 GET POINTER TO BAD DATA BLOCK ZJN CPR1 IF NO PARITY ERROR STD CM+4 WRITE BAD DATA POINTER AT *IN* SHN -14 STD CM+3 LDN ZERL CRD CM-2 LDD DP+3 SHN 6 ADD RA SHN 6 ADD DP+4 CWD CM CPR1 LJM MSP PROCESS MASS STORAGE EXIT * LJM /SMR/SLS (*READLS*/*RPHRLS*) CPRB EQU *-1 TITLE BUFFER READ. BRD SPACE 4,25 ** BRD - BUFFER READ LOOP. * * ENTRY (BP) = BUFFER SPACE IN PRUS. * (PC) = 0. * (RC) = *DRCM* MONITOR FUNCTION CODE. * (T6) = TRACK. * (T7) = SECTOR. * (DP - DP+4) = *IN* POINTER. * (FS - FS+4) = FST ENTRY. * ADDRESS REFERENCES SET. * AT *BRD11* IF PROCESSING TRANSFER OF PARTIAL * SECTOR FOR *READSKP*. * * EXIT (FS+4) = READ STATUS. * (PC) = COUNT OF PRUS TRANSFERRED. * (T6) = UPDATED CURRENT TRACK. * (T7) = UPDATED CURRENT SECTOR. * (DP - DP+4) = ADVANCED *IN* POINTER. * TO *CPR* TO COMPLETE PROCESSING. * TO *CDA*, IF MASS STORAGE ERROR. * * USES BP, OT+1, T1, T2, CM - CM+4, OP-3 - OP+1. * * CALLS CRT, MSR, RDS, SBA. * LOOP TO PROCESS NEXT SECTOR. BRD BSS 0 ENTRY BRDA LDC ** (OUT + RA) CRD OP-3 READ OUT LDD OP LENGTH = OUT - IN - 1 SBD DP+3 SHN 14 ADD OP+1 SBD DP+4 SBN 1 PJN BRD1 IF IN+1 .LT. OUT BRDB ADC ** (LIMIT - FIRST) BRD1 SHN -6 STD BP BRDC NJN BRD5 IF BUFFER NOT FULL * PSN (TIME TO ENTER RECALL STACK) LDC LDNI CLEAR SETTING OF FET TERMINATION STATUS STM UFSA BRD2 LDC 7777 CHECK FOR EOF BRDD EQU *-1 LMD PC ZJN BRD3 IF LAST SECTOR READ WAS AN EOF LDM BFMS+1 CHECK FOR EOR LMD HN ZJN BRD4 IF LAST SECTOR READ WAS FULL SECTOR LDN /CIO/EOR&/CIO/EOF SET EOR STATUS BRD3 LMN /CIO/EOF BRD4 STD FS+4 LJM CPR COMPLETE READ * LJM RSK2 (*READSKP*) * LJM CPR (CLEANUP AFTER MS ERROR) BRDE EQU *-1 * READ NEXT SECTOR. BRD5 AOD PC INCREMENT PRU COUNT LDC BFMS READ SECTOR RJM RDS PJN BRD6 IF NO ERROR LDD T6 SET CURRENT TRACK STD FS+2 LDD T7 SET CURRENT SECTOR STD FS+3 RJM CDA CHECK DEVICE BRD6 LDM BFMS CHECK FIRST CONTROL BYTE NJN BRD8 IF NOT EOF/EOI LDM BFMS+1 NJN BRD7 IF NOT EOI SOD PC LDN /CIO/EOI SET EOI STATUS STD FS+4 LJM CPR COMPLETE READ * LJM /SMR/ALS (*READLS*/*RPHRLS*) * LJM CPR (CLEANUP AFTER MS ERROR) BRDF EQU *-1 * PROCESS EOF. BRD7 STD T2 BRDG LJM EOF PROCESS EOF * UJN *+2 (*READEI*) LDN 0 SET WORD COUNT STM BFMS+1 LDD PC SAVE SECTOR NUMBER STM BRDD LDD T2 BRD8 STD T7 SET NEXT SECTOR SHN 6 PJN BRD9 IF NOT NEW TRACK SHN -6 SET NEXT TRACK STD T6 LDN 0 CLEAR SECTOR STD T7 SOD TC DECREMENT TRACK COUNT BRDY NJN BRD9 IF NOT TIME TO RECALL * UJN BRD9 (*READLS*/*RPHRLS*/*RPHR*) STM BRDC SET TO ENTER RECALL STACK LDM BFMS+1 SHN -6 BRDZ ZJN BRD9 IF EOR/EOF * PSN (*READNS*/*READEI*) AOM COCA BRD9 LDD RA CHECK RA CHANGED LMC ** (RA) BRDH EQU *-1 ZJN BRD10 IF RA NOT CHANGED RJM SBA SET BUFFER ADDRESSES BRD10 LDM BFMS+1 SET SECTOR WORD COUNT STD T1 NJN BRD11 IF NOT EMPTY SECTOR LJM BRD16 PROCESS EMPTY PRU * ENTRY FROM *READSKP* PROCESSOR TO TRANSFER PARTIAL SECTOR. BRD11 ADD DP+4 CHECK IN + WORD COUNT SHN 6 ADD DP+3 SHN 14 BRDI ADC -** (-LIMIT) MJN BRD12 IF NOT WRAP AROUND SECTOR NJN BRD14 IF SECOND PART TO TRANSFER SBD T1 STORE PRU BRDJ ADC ** (LIMIT + RA) CWM BFMS+2,T1 BRDK LDC ** (FIRST) UJN BRD13 STORE *IN* POINTER * PROCESS NORMAL SECTOR. BRD12 SBD T1 STORE PRU BRDL ADC ** (LIMIT + RA) CWM BFMS+2,T1 * ADVANCE *IN* POINTER. BRDM ADC -** (-RA) BRD13 STD DP+4 ADVANCE *IN* SHN -14 STD DP+3 * THE FOLLOWING LINE OF CODE IS MODIFIED VIA *RJM*. LJM BRD15 UPDATE *IN* IF NOT BUFFERED OPERATION * LJM BRD18 (CHECK OUT) * LJM BRD19 (RECALL CPU) BRDN EQU *-1 UJN BRD15 UPDATE *IN* * PROCESS WRAP AROUND SECTOR. BRD14 STD CM+1 SET SECOND PART WORD COUNT LDD T1 SET FIRST PART WORD COUNT SBD CM+1 STD CM SHN 2 SET PPU ADDRESS OF SECOND PART ADD CM ADC BFMS+2 STM BRDQ LDD DP+3 STORE FIRST PART SHN 14 ADD DP+4 BRDO ADC ** (RA) CWM BFMS+2,CM BRDP LDC ** (FIRST + RA) STORE SECOND PART CWM BFMS+2,CM+1 BRDQ EQU *-1 (PP ADDRESS OF SECOND PART) BRDR ADC -** (-RA) STD DP+4 SHN -14 STD DP+3 * UPDATE *IN*. BRD15 LDC ** (IN+RA) BRDS EQU *-2 CWD DP STORE IN * CHECK TERMINATIONS. BRD16 LDD T1 CHECK SECTOR WORD COUNT * LJM BRD (*READNS*) * LJM BRD (*READEI*) * LJM BRD2 (AFTER MS ERROR) BRDT EQU *-1 SHN -6 ZJN BRD17 IF SHORT SECTOR LJM BRD CONTINUE DATA TRANSFER BRDU EQU *-1 * LJM BRD2 (*RPHR*) * LJM /SMR/RSK7 (*READSKP* PARTIAL SECTOR TRANSFER) * LJM /SMR/ALS (*RPHRLS* ADVANCE LIST) BRD17 LJM BRD2 TERMINATE TRANSFER * LJM /SMR/RSK7 (*READSKP* PARTIAL SECTOR TRANSFER) * LJM /SMR/ALS (*READLS*/*RPHRLS*) BRDV EQU *-1 * WAIT FOR *OUT* TO CHANGE FOR BUFFERED OPERATION. * ONLY 12 BITS OF *OUT* IS CHECKED DUE TO TIMING * CONSIDERATIONS. BRD18 RJM BRDN MODIFY INSTRUCTION LDD BP SHN -3 NJN BRD15 IF .GE. 8 SECTORS OF FREE SPACE LDD OP+1 SBD OT+1 ZJN BRD15 IF *OUT* NOT CHANGED RAD OT+1 SAVE NEW *OUT* * RECALL CPU ON THE NEXT SECTOR IF JOB IS IN *X* STATUS. RJM BRDN MODIFY INSTRUCTION * THE FOLLOWING CHECK MINIMIZES OVERHEAD ON TRACK SWITCH * AND PREVENTS A *DRCM* BEING ISSUED JUST PRIOR * TO THE DRIVER NEEDING TO DO AN *LDAM*. BRD19 LDD T7 ZJN BRD15 IF TRACK SWITCH LDC **+CWQW CHECK CPU RECALL REQUIRED BRDW EQU *-1 CRD CM LDD CM+1 SHN 21-12 MJN BRD18 IF RECALL NOT REQUIRED LDD OA RECALL CPU CWD RC UJN BRD18 RESET TO CHECK *OUT* SBA SPACE 4,10 ** SBA - SET BUFFER ADDRESSES. * PRESETS ADDRESSES IN *BRD*. * ENTER IF (RA) CHANGES. * * ENTRY (FT - FT+1) = *FIRST* POINTER. * (LM - LM+1) = *LIMIT* POINTER. * * MACROS CFET. SBA SUBR ENTRY/EXIT LDD RA CHECK RA CHANGED LMM BRDH ZJN SBAX IF BUFFER ADDRESSES CORRECT LDD RA RA STM BRDH SHN 6 STM BRDO+1 LMC 7777 STM BRDM+1 STM BRDR+1 SHN -14 LMC ADCI STM BRDO LMN 77 STM BRDM STM BRDR LDD FT FIRST + RA SHN 6 ADD RA SHN 6 ADD FT+1 STM BRDP+1 SHN -14 LMC LDCI STM BRDP CFET 2 IN + RA STM BRDS+1 STM BRDA+1 SHN -14 LMC LDCI STM BRDS STM BRDA AOM BRDA+1 OUT + RA SHN -14 RAM BRDA LDD LM LIMIT + RA SHN 6 ADD RA SHN 6 ADD LM+1 STM BRDL+1 STM BRDJ+1 SHN -14 LMC ADCI STM BRDL STM BRDJ LJM SBAX RETURN SPACE 4,10 QUAL SMRO EQU *+5 SPECIAL READ OVERLAY LOAD ADDRESS QUAL * TITLE CONTROL WORD READ. CRD SPACE 4,20 ** CRD - CONTROL WORD READ LOOP. * * ENTRY (PC) = 0. * (RC) = *DRCM* MONITOR FUNCTION CODE. * (T5) = EQUIPMENT. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (DP - DP+4) = *IN* POINTER. * (FS - FS+4) = FST ENTRY. * ADDRESS REFERENCES SET. * * EXIT (PC) = PRU COUNT. * (T6) = UPDATED CURRENT TRACK. * (T7) = UPDATED CURRENT SECTOR. * (FS+4) = READ STATUS. * (DP - DP+4) = ADVANCED *IN* POINTER. * TO *CDA*, IF MASS STORAGE ERROR. * * USES BP, T0, T1, T2, CM - CM+4, OT+1, OP-3 - OP+1. * * CALLS CRT, MSR, RDS, SCA. CRD BSS 0 ENTRY * *OUT* NOT READ HERE EACH PASS DUE TO TIMING CONSIDERATIONS. LDD OP LENGTH = OUT - IN - 1 SBD DP+3 SHN 14 ADD OP+1 SBD DP+4 SBN 1 PJN CRD1 IF IN+1 .LT. OUT CRDA ADC ** (LIMIT - FIRST) CRD1 ADC -102 CRDB PJN CRD4 IF BUFFER NOT FULL * PSN (TIME TO ENTER RECALL STACK) * PSN (CLEANUP AFTER MS ERROR) LDC LDNI CLEAR SETTING OF FET TERMINATION STATUS STM UFSA LDC 7777 CHECK FOR EOF CRDC EQU *-1 LMD PC ZJN CRD2 IF LAST SECTOR READ WAS AN EOF LDM BFMS+2-1 CHECK FOR EOR LMC 500 ZJN CRD3 IF LAST SECTOR READ WAS FULL SECTOR LDN /CIO/EOR&/CIO/EOF CRD2 LMN /CIO/EOF CRD3 UJN CRD7 COMPLETE READ * READ NEXT SECTOR. CRD4 SHN -6 SAVE APPROXIMATE NUMBER OF SECTORS STD BP AOD PC INCREMENT PRU COUNT LDC BFMS READ SECTOR RJM RDS PJN CRD5 IF NO ERROR LDD T6 SET CURRENT TRACK STD FS+2 LDD T7 SET CURRENT SECTOR STD FS+3 RJM CDA CHECK DEVICE CRD5 LDD RA CHECK RA CHANGED LMC ** (RA) CRDD EQU *-1 ZJN CRD6 IF RA NOT CHANGED RJM SCA SET BUFFER ADDRESSES CRD6 LDD MA SAVE CONTROL WORD TRAILER CWD T3 LDM BFMS CHECK FIRST CONTROL BYTE NJN CRD10 IF NOT EOF/EOI LDM BFMS+1 NJN CRD8 IF NOT EOI SOD PC LDN /CIO/EOI SET EOI STATUS CRD7 STD FS+4 LJM CPR COMPLETE READ * PROCESS EOF. CRD8 STD T2 LDD FC CHECK TERMINATION CONDITION LPN 14 LMN /CIO/EOF NJN CRD9 IF NOT TERMINATE ON EOF LJM EOF TERMINATE READ CRD9 LDN 17 SET LEVEL NUMBER STD T3 LDD MA UPDATE CONTROL WORD TRAILER CWD T3 LDC CRD19 CHANGE LOOP STM CRDQ LDN 0 STM BFMS+1 LDD T2 * UPDATE SECTOR AND TRACK. CRD10 STD T7 SHN 6 PJN CRD11 IF NOT NEW TRACK SHN -6 STD T6 LDN 0 RESET SECTOR STD T7 SOD TC NJN CRD11 IF NOT TIME TO ENTER RECALL STACK STM CRDB SET TO ENTER RECALL STACK AOM COCA * WRITE SECTOR TO BUFFER. CRD11 LDM BFMS+1 SET SECTOR WORD COUNT STD T1 SHN 2 SET WORD COUNT ADD T1 STM BFMS+2-1 ADC BFMS+2 STM CRDE LDN 0 STM BFMS+2-2 LDD MA CRM **,ON MOVE TRAILER CONTROL WORD CRDE EQU *-1 LDN 2 RAD T1 ADD DP+4 CHECK IN + WORD COUNT SHN 6 ADD DP+3 SHN 14 CRDF ADC -** (-LIMIT) MJN CRD12 IF NOT WRAP AROUND SECTOR NJN CRD14 IF A SECOND PART SBD T1 CRDG ADC ** (LIMIT + RA) CWM BFMS+2-5,T1 CRDH LDC ** (FIRST) UJN CRD13 STORE *IN* POINTER * PROCESS NORMAL SECTOR. CRD12 SBD T1 STORE PRU CRDI ADC ** (LIMIT + RA) CWM BFMS+2-5,T1 * ADVANCE *IN* POINTER. CRDJ ADC -** (-RA) UPDATE IN CRD13 STD DP+4 SHN -14 STD DP+3 * THE FOLLOWING CHECK MINIMIZES OVERHEAD ON TRACK SWITCH * AND PREVENTS A *DRCM* BEING ISSUED JUST PRIOR * TO THE DRIVER NEEDING TO DO AN *LDAM*. LDD T7 ZJN CRD15 IF TRACK SWITCH * THE FOLLOWING LINE OF CODE IS MODIFIED VIA *RJM*. LJM CRD15 UPDATE *IN* IF NOT BUFFERED OPERATION * LJM CRD17 (RECALL CPU) * LJM CRD18 (WAIT FOR OUT TO CHANGE) CRDK EQU *-1 UJN CRD15 UPDATE IN * PROCESS WRAP AROUND SECTOR. CRD14 STD CM+1 SET SECOND PART WORD COUNT LDD T1 SET FIRST PART WORD COUNT SBD CM+1 STD CM SHN 2 SET PPU ADDRESS OF SECOND PART ADD CM ADC BFMS+2-5 STM CRDN LDD DP+3 WRITE FIRST PART SHN 14 ADD DP+4 CRDL ADC ** (RA) CWM BFMS+2-5,CM CRDM LDC ** (FIRST + RA) CWM **,CM+1 WRITE SECOND PART CRDN EQU *-1 (PPU ADDRESS OF SECOND PART) CRDO ADC -** (-RA) STD DP+4 UPDATE *IN* POINTER SHN -14 STD DP+3 * UPDATE *IN*. CRD15 LDC ** UPDATE *IN* POINTER CRDP EQU *-2 (IN + RA) CWD DP LJM CRD CONTINUE DATA TRANSFER * LJM CRD19 (EOF READ) * LJM CRD20 (SYSTEM SECTOR READ) CRDQ EQU *-1 * RECALL CPU ON THE NEXT SECTOR IF JOB IS IN *X* STATUS. CRD16 RJM CRDK MODIFY INSTRUCTION CRD17 LDC **+CWQW CHECK CPU RECALL REQUIRED CRDR EQU *-1 CRD CM LDD CM+1 SHN 21-12 MJN CRD18 IF RECALL NOT REQUIRED LDD OA RECALL CPU CWD RC * READ *OUT* AND CHECK IF *OUT* HAS CHANGED. CRD18 RJM CRDK MODIFY INSTRUCTION LDD BP SHN -3 NJN CRD15 IF .GT. 8 SECTORS OF SPACE LDC ** (OUT+RA) CRDS EQU *-2 CRD OP-3 LDD OP+1 SBD OT+1 ZJN CRD15 IF *OUT* NOT CHANGED RAD OT+1 SAVE NEW *OUT* UJN CRD16 SET TO RECALL CPU * EOF POST PROCESSING CODE. CRD19 LDN 0 RESET LEVEL NUMBER STD T3 LDD PC SAVE EOF SECTOR NUMBER STM CRDC UJN CRD21 RESTORE LOOP * SYSTEM SECTOR POST PROCESSING CODE. CRD20 LDN FSMS SET FIRST DATA SECTOR STD T7 LDM CFNB LPN 37 STM CFNB CRD21 LDC CRD RESTORE LOOP STM CRDQ LJM CRD LOOP SCA SPACE 4,10 ** SCA - SET CONTROL WORD READ ADDRESSES. * PRESETS ADDRESSES IN *CRD*. * ENTER IF (RA) CHANGES. * * ENTRY (FT - FT+1) = *FIRST* POINTER. * (LM - LM+1) = *LIMIT* POINTER. * * MACROS CFET. SCA SUBR ENTRY/EXIT LDD RA RA AND -RA STM CRDD SHN 6 STM CRDL+1 LMC 7777 STM CRDJ+1 STM CRDO+1 SHN -14 LMC ADCI STM CRDL LMN 77 STM CRDJ STM CRDO LDD FT FIRST + RA SHN 6 ADD RA SHN 6 ADD FT+1 STM CRDM+1 SHN -14 LMC LDCI STM CRDM CFET 2 IN + RA STM CRDP+1 STM CRDS+1 SHN -14 LMC LDCI STM CRDP STM CRDS AOM CRDS+1 OUT + RA SHN -14 RAM CRDS LDD LM LIMIT + RA SHN 6 ADD RA SHN 6 ADD LM+1 STM CRDI+1 STM CRDG+1 SHN -14 LMC ADCI STM CRDI STM CRDG LJM SCAX RETURN SPACE 4,10 QUAL ERMS EQU *+5 END OF MASS STORAGE READ OVERLAY QUAL * TITLE READ MASS STORAGE PRESET. PRS SPACE 4,20 ** PRS - READ MASS STORAGE PRESET. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (FT - OT+1) = BUFFER POINTERS. * (FS - FS+4) = FST ENTRY. * * EXIT (BP) = BUFFER SPACE IN PRUS FOR NON-CONTROL WORD * READ, IN WORDS FOR CONTROL WORD READ. * (OP - OP+1) = (OT - OT+1). * TO *RMS* IF SYSTEM SECTOR WRITE REQUIRED. * TO *RMS1* IF SYSTEM SECTOR WRITE NOT REQUIRED. * TO *UFS* IF INSUFFICIENT BUFFER SPACE FOR * CONTINUATION FUNCTION. * * ERROR TO *ERR* IF ERROR OR UNNECESSARY FUNCTION. * * USES T1, CM - CM+4. PRS BSS 0 ENTRY LDD OT CHECK BUFFER SPACE SBD IN LENGTH = OUT - IN - 1 SHN 14 ADD OT+1 SBD IN+1 SBN 1 PJN PRS1 IF NO WRAP AROUND SHN 6 LENGTH = LIMIT - IN - 1 + OUT - FIRST ADD LM SBD FT SHN 14 ADD LM+1 SBD FT+1 PRS1 STD T1 SAVE FREE WORD COUNT SHN -6 STD BP SAVE BUFFER SPACE / 100B NJN PRS3 IF BUFFER NOT FULL LDD FC CHECK REQUEST SHN 21-12 MJN PRS3 IF *READSKP* LDM RCRF SHN 21-6 MJN PRS2 IF DATA TRANSFERRED PREVIOUSLY ERROR UCF *UNNECESSARY CIO FUNCTION* PRS2 LJM UFS UPDATE FET STATUS * SET UP RECALL LOGIC. PRS3 LDD IR+1 CHECK RECALL STATUC SHN 21-5 MJN PRS4 IF AUTO RECALL LDD CP SET CONTROL POINT ADDRESS RAM BRDW STM CRDR LDC BRD19 SET TO RECALL CPU AFTER FIRST SECTOR STM BRDN LDC CRD17 STM CRDK * SET BUFFER RELATED ADDRESSES. PRS4 LDD LM LIMIT - FIRST SBD FT SHN 14 ADD LM+1 SBD FT+1 STM BRDB+1 STM CRDA+1 SHN -14 RAM BRDB STM CRDA LDC ADCI+77 -LIMIT LMD LM STM BRDI STM CRDF LDC 7777 LMD LM+1 STM BRDI+1 STM CRDF+1 LDD FT+1 FIRST STM BRDK+1 STM CRDH+1 LDD FT RAM BRDK STM CRDH * CHECK FOR SYSTEM SECTOR READ. LDD FS+4 SHN 21-13 PJN PRS5 IF NOT SYSTEM SECTOR READ LDD FC SHN 21-5 PJN PRS7 IF NOT *READCW* LDC CRD20 CHANGE LOOP STM CRDQ PRS5 LDN 0 STD FS+4 LDD FC SHN 21-12 MJN PRS6 IF *READSKP* SHN 21-4-21+12 PJN PRS8 IF NOT READ LIST LDK UJNI-NJNI PREVENT ENTERING RECALL STACK RAM BRDY PRS6 LJM LSO LOAD SPECIAL READ OVERLAY PRS7 ERROR IRQ *INCORRECT I/O REQUEST* PRS8 SHN 21-5-21+4+22 MJN PRS11 IF *READCW* SHN -21+5+22 LPN 14 GET TERMINATION CONDITION NJN PRS9 IF NOT *RPHR* LDC BRD2 SET STOP ON PRU STM BRDU LDK UJNI-NJNI PREVENT ENTERING RECALL STACK RAM BRDY UJN PRS11 PROCESS READ PRS9 LMN /CIO/EOF ZJN PRS10 IF *READNS* LMN /CIO/EOI&/CIO/EOF NJN PRS11 IF NOT *READEI* LDC UJNI+2 CLEAR STOP ON EOF STM BRDG PRS10 LDD HN+LJMI* CLEAR EOR CHECK STM BRDT LDC BRD STM BRDT+1 LDK PSNI PREVENT EOR/EOF CHECK STM BRDZ PRS11 LJM RMS PROCESS READ SPACE 4,10 OVERFLOW MSDO SMR OVERLAY (SPECIAL MASS STORAGE READS.),SMRO SMR SPACE 4,10 ** DIRECT LOCATION ASSIGNMENTS. OP EQU 16 - 17 *OUT* POINTER LE EQU 30 - 31 LIST ENTRY (2 LOCATIONS) RI EQU 32 - 33 RANDOM INDEX (2 LOCATIONS) LP EQU 34 - 35 LIST POINTER (2 LOCATIONS) TC EQU 35 TRACK COUNT LI EQU 36 LIST INDEX BP EQU 37 BUFFER SPACE IN PRUS LS EQU 46 - 47 LIST ADDRESS (2 LOCATIONS) SMR SPACE 4,10 ** SMR - SPECIAL MASS STORAGE READS MAIN ROUTINE. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * * EXIT TO *RLS* IF *READLS*. * TO *RPL* IF *RPHRLS*. * TO *RSK* IF *READSKP*. SMR SUBR ENTRY/EXIT LDD FC SHN 21-12 MJN RSK IF *READSKP* SHN -21+12+22 GET TERMINATION CONDITION LPN 14 ZJN SMR1 IF *RPHRLS* LJM RLS PROCESS *READLS* SMR1 LJM RPL PROCESS *RPHRLS* TITLE READ SKIP PROCESSOR. RSK SPACE 4,15 ** RSK - READ SKIP (*READSKP*) PROCESSOR (FUNCTION 020). * * ENTRY (BS - BS+4) = (FET+0). * (FS - FS+4) = FST ENTRY. * (FT - FT+1) = *FIRST* POINTER. * (OP - OP+1) = *OUT* POINTER. * * EXIT (PC) = COUNT OF PRUS TRANSFERRED. * (FS - FS+4) = ADVANCED FST ENTRY. * TO */RMS/CPR*. * TO *SMRX* AFTER PRESET FOR REENTRY. * TO *CDA*, IF MASS STORAGE ERROR. * * CALLS /RMS/BRD, CRT, RNS, /RMS/SBA. * * USES T1, T3. RSK BSS 0 ENTRY LDM RCRF CHECK FOR SKIP PROCESSING SHN 21-10 PJN RSK1 IF NOT SKIP PROCESSING LDC RSK9 SET TO CONTINUE SKIP PROCESSING STM /RMS/RMSA RSK1 LDC RSK2 SET LOAD BUFFER EXIT STM /RMS/BRDE LDD HN PRESET FULL SECTOR FOR *READSKP* STM BFMS+1 UJN SMRX RETURN * REENTRY AFTER TRACK COUNT EXHAUSTED OR WHEN USER * BUFFER FULL (LESS THAN ONE PRU OF SPACE REMAINS) * OR EOR/EOF/EOI ENCOUNTERED. RSK2 LDM COCA NJN RSK3 IF TO ENTER RECALL STACK LDC SHNI+77-2 FORCE SETTING OF FET TERMINATION STATUS STM UFSA LDD FS+4 CHECK FET STATUS LPN 14 ZJN RSK4 IF NOT EOR/EOF/EOI LPN 10 NJN RSK3 IF EOF OR EOI ENCOUNTERED LDC 400 SET SKIP FLAG RAM RCRF LJM RSK11 CHECK FOR SKIP TO EOF RSK3 LJM /RMS/CPR EXIT TO COMPLETE READ * PROCESS PARTIAL SECTOR TRANSFER TO USER BUFFER. RSK4 AOD PC INCREMENT PRU COUNT LDC RSK7 SET STOP ON PRU STM /RMS/BRDU STM /RMS/BRDV LDC 400 SET SKIP FLAG RAM RCRF LDC BFMS READ NEXT SECTOR RJM RNS ZJN RSK7.2 IF EMPTY SECTOR STM RSKA LDD OP CHECK BUFFER SPACE SBD DP+3 LENGTH = OUT - IN - 1 SHN 14 ADD OP+1 SBD DP+4 SBN 1 PJN RSK5 IF NO WRAP AROUND SHN 6 LENGTH = LIMIT - IN - 1 + OUT - FIRST ADD LM SBD FT SHN 14 ADD LM+1 SBD FT+1 RSK5 STD T3 SET BUFFER LENGTH SBD T1 PJN RSK6 IF ROOM FOR SECTOR LDD T3 SET BUFFER WORD COUNT STD T1 ZJN RSK7 IF FULL BUFFER RSK6 RJM /RMS/SBA RESET BUFFER ADDRESSES LDD T1 LJM /RMS/BRD11 WRITE DATA TO BUFFER * PROCESS SKIP TO EOR/EOF/EOI. RSK7 LDC ** CHECK SECTOR WORD COUNT RSKA EQU *-1 RSK7.1 SHN -6 RSK7.2 ZJN RSK11 IF SHORT SECTOR RSK8 LDD T7 CHECK FOR NEW TRACK * LDN 0 (MASS STORAGE ERROR) RSKB EQU *-1 RSKC NJN RSK9 IF NOT NEW TRACK * LJM RSK13 (MASS STORAGE ERROR) RJM CRT CHECK RECALL TIME MJN RSK10 IF PROCESSING TIME EXCEEDED LDD PC ADM SLM SHN -14 NJN RSK10 IF PRU COUNT WILL EXCEED 12 BITS RSK9 AOD PC LDC BFMS+DTSF READ NEXT SECTOR HEADER WORDS RJM RNS UJN RSK7.1 CONTINUE SKIP TO SHORT SECTOR RSK10 AOM COCA SET RECALL STACK FLAG UJN RSK14 COMPLETE READ PROCESSING RSK11 LDM BFMS CHECK TERMINATION ZJN RSK12 IF EOF/EOI LDD BS+3 CHECK SKIP TO EOF LPN 74 LMN 74 ZJN RSK8 IF SKIP TO EOF LDN /CIO/EOR UJN RSK13 SET EOR READ STATUS RSK12 LDN /CIO/EOF SET EOF STD FS+4 LDM BFMS+1 NJN RSK14 IF NOT EOI SOD PC LDN /CIO/EOI RSK13 STD FS+4 RSK14 LJM /RMS/CPR EXIT TO COMPLETE READ CRT SPACE 4,10 ** CRT - CHECK RECALL TIME. * * ENTRY FIRST CALL STARTS TIMING. ELAPSED TIME OF EACH * INTERVAL IS KEPT TO MINIMIZE CLOCK OVERFLOW. * * EXIT (A) .LT. 0 IF PROCESSING TIME EXCEEDED. * * USES CM - CM+4. CRT2 AOM CRTA INDICATE TIME ACCUMULATION STARTED CRT3 LDD CM+4 SAVE CURRENT CLOCK VALUE STM CRTB CRT SUBR ENTRY/EXIT LDC RTCL READ REAL TIME CLOCK CRD CM LDC 0 ELAPSED TIME CRTA EQU *-1 ZJN CRT2 IF FIRST CALL LDD CM+4 CALCULATE TIME SINCE LAST CALL SBM CRTB PJN CRT1 IF NO OVERFLOW ADC 10000 CRT1 RAM CRTA ACCUMULATED PROCESSING TIME ADC -RSPT MJN CRT3 IF TIME NOT EXCEEDED LCN 0 SET TIME EXCEEDED UJN CRTX RETURN CRTB CON 0 PREVIOUS CLOCK VALUE TITLE READ LIST PROCESSOR. RPL SPACE 4,10 ** RPL - READ PRUS WITH LIST (*RPHRLS*) (FUNCTION 230). * * EXIT TO *RLS*. RPL BSS 0 ENTRY LDC ALS SET LIST ADVANCE AT EACH PRU STM /RMS/BRDU * LJM RLS PROCESS LIKE *READNS* RLS SPACE 4,20 ** RLS - READ RECORDS WITH LIST (*READLS*) (FUNCTION 210). * * ENTRY (FO) = FET OPTIONS. * (FS - FS+4) = FST ENTRY. * * EXIT (LI) = LIST INDEX (IN *TLSA* TRACK/SECTOR TABLE). * (FS - FS+4) = ADVANCED FST AENTRY. * (LS - LS+1) = LIST ADDRESS. * TO *SLS* IF EMPTY LIST. * TO *SMRX* AFTER PRESET FOR REENTRY. * * USES T5, CM - CM+4, LP - LP+1. * * CALLS CLI. * * MACROS CFET, ERROR, SETMS. RLS BSS 0 ENTRY LDM FETL CHECK FET LENGTH NJN RLS1 IF FET CONTAINS THE LIST ADDRESS WORD ERROR FPE *FET PARAMETER ERROR* RLS1 LDC ALS SET LIST ADVANCE ON EOR STM /RMS/BRDV STM /RMS/BRDF STM /RMS/EOFA LDC SLS SET LIST COMPLETION STM /RMS/CPRB STM CDAB LDC TLSA SET LIST INDEX STD LI CFET 5 READ LIST POINTER CRD CM LDD CM+3 SET LIST POINTER LPC 4037 STD LS STM SLSC LPN 37 STD LP LDD CM+4 STD LS+1 STD LP+1 LDD FS SET EST ORDINAL STD T5 SETMS STATUS LDD CM+4 READ TRT POINTER SHN 3 ADN TRLL CRD CM LDD CM+3 EXTRACT TRT ADDRESS LPN 77 SHN 14 LMD CM+4 ADC -4000/4 STM CLIA+1 STM CLIB+1 STM CLIC+1 SHN -14 RAM CLIA STM CLIB STM CLIC RJM CLI CONVERT LIST INDICES LDN 0 TERMINATE LIST STI LI LDC TLSA RESET LIST INDEX STD LI LDI LI SET TRACK ZJN RLS3 IF EMPTY LIST LDD LS SHN 21-13 MJN RLS2 IF CONTINUATION OF PREVIOUS OPERATION LDC 4000 SET CONTINUATION FLAG RAD LS LDI LI STD FS+2 LDM 1,LI SET SECTOR STD FS+3 RLS2 LJM SMRX RETURN RLS3 LDD FO CLEAR RANDOM FILE FLAG LPC 3777 STD FO LDN /CIO/EOF SET EOF STATUS RAM SLSA * LJM SLS SET LIST STATUS SLS SPACE 4,15 ** SLS - SET LIST STATUS. * * ENTRY (FO) = FET OPTIONS. * (PC) = ACCUMULATED PRU COUNT. * (LS - LS+1) = LIST ADDRESS AND CONTINUATION FLAG. * * EXIT (FS+4) = LIST STATUS. * TO *MSP* IF NOT RANDOM FILE OR IF ALL PROCESSING * DONE FOR SAME CONTINUATION LIST ENTRY. * TO *COC* IF NEW LIST ENTRY PROCESSED. * * USES CM - CM+4. * * MACROS CFET. SLS BSS 0 ENTRY CFET 5 UPDATE LIST POINTER CRD CM LDD LI UPDATE LIST ADDRESS ADC -TLSA SHN -1 RAD LS+1 STD CM+4 SHN -14 RAD LS STD CM+3 SHN -13 COMPLEMENT CONTINUATION FLAG * IF CONTINUATION, CRI UPDATE IS BASED ON ENTRY POINTED TO. * OTHERWISE *CRI* IS SET BASED ON PREVIOUS ENTRY. LMN 1 STD T2 CFET 5 CWD CM SLSA LDN 0 SET FST STATUS * LDN /CIO/EOF (END OF LIST - SET EOF STATUS) STD FS+4 LDC 0 CALCULATE PRUS TRANSFERRED FOR LIST ENTRY SLSB EQU *-1 NJN SLS2 IF LIST HAS BEEN ADVANCED LDC 0 (ORIGINAL LIST POINTER CONTINUATION FLAG) SLSC EQU *-1 SHN 21-13 PJN SLS3 IF NOT CONTINUATION OPERATION INITIALLY SLS1 LJM MSP COMPLETE MASS STORAGE PROCESSING * CALCULATE I/O PENALTY. SLS2 LDD LI ADC -TLSA SHN -1 STD T1 LDM TLAA,T1 ADD I/O PENALTY RAM CFNH+1 SHN -14 RAM CFNH LCN 2 RAD LI LMC TLSA NJN SLS2 IF NOT AT BEGINNING OF LIST * RETURN RANDOM ADDRESS TO FET. SLS3 LDD FO SHN 21-13 PJN SLS1 IF NOT RANDOM FET CFET 6 CRD CM * USE PREVIOUS ENTRY UNLESS CONTINUATION, THEN USE CURRENT * ENTRY. LDD LS LPN 37 SHN 6 ADD RA SHN 6 ADD LS+1 SBD T2 CRD DP LDD CM+2 LPN 77 STD CM+2 LDD PC ADVANCE RANDOM ADDRESS SBM SLSB RAD DP+4 SHN -14 RAD DP+3 LDD DP+4 SHN 6 RAD CM+2 LMD CM+2 ADD DP+3 SHN 6 STD CM+1 SHN -14 STD CM CFET 6 CWD CM LJM COC COMPLETE MASS STORAGE PROCESSING ALS SPACE 4,20 ** ALS - ADVANCE LIST. * * ENTRY (LI) = LIST INDEX. * (PC) = ACCUMULATED PRU COUNT. * (LS - LS+1) = LIST ADDRESS AND CONTINUATION FLAG. * (TC) = TRACKS TO PROCESS COUNT. * * EXIT (LI) = ADVANCED LIST INDEX. * (T6) = NEW LIST ENTRY CURRENT TRACK. * (T7) = NEW LIST ENTRY CURRENT SECTOR. * (LS) = CONTINUATION CLEARED IF RECALL OR END OF LIST. * (TC) = DECREMENTED IF TRACK SWITCH. * (SLSC) = (PC) IF NORMAL EXIT. * TO */RMS/BRD* TO PROCESS READ FOR NEXT LIST ENTRY. * TO */RMS/CPR* TO COMPLETE READ PROCESSING. * TO *CDA*, IF MASS STORAGE ERROR. * * USES CM - CM+4. * * CALLS RNS. * * MACROS SETMS. ALS BSS 0 ENTRY LDN 2 ADVANCE LIST INDEX RAD LI LDI LI CHECK TRACK NJN ALS4 IF NOT END OF TABLE LDD LI CHECK LIST INDEX ADC -TLSAE MJN ALS2 IF END OF REQUEST LIST ENCOUNTERED ALS1 AOM COCA SET RECALL STACK FLAG UJN ALS3 COMPLETE READ PROCESSING ALS2 LDN /CIO/EOF SET EOF STATUS RAM SLSA ALS3 LDC -4000 CLEAR CONTINUATION FLAG RAD LS LJM /RMS/CPR COMPLETE READ PROCESSING ALS4 LMD T6 ZJN ALS6 IF SAME TRACK SOD TC DECREMENT TRACK COUNT NJN ALS5 IF NOT TIME TO RECALL LDD PC SBD HN PJN ALS1 IF 100 OR MORE SECTORS READ LDN 2 RESET TRACK COUNT STD TC ALS5 LDI LI SET NEW TRACK STD T6 SETMS POSITION UJN ALS7 EXIT ALS6 LDM 1,LI SBD T7 * TIMING OF THIS ROUTINE WHEN PROCESSING CONSECUTIVE SECTORS IS * CRITICAL. ADDITIONAL CODE MAY CAUSE LOST REVOLUTIONS. ZJN ALS8 IF NEXT SECTOR IS DESIRED ONE MJN ALS7 IF ADDRESSES NOT ASCENDING SBN 5 PJN ALS7 IF ENOUGH TIME TO RESEEK * READING OF UP TO 5 SECTORS IS DONE INSTEAD OF ISSUING A SEEK * AS MOST CONTROLLERS ARE NOT FAST ENOUGH TO PROCESS THE SEEK * AND BE ABLE TO ACCESS THE NEXT SECTOR OR THE ONE FOLLOWING. LDC BFMS+DTSF READ HEADER WORDS ONLY OPTION RJM RNS READ NEXT SECTOR UJN ALS6 LOOP TO DESIRED SECTOR ALS7 LDM 1,LI SET SECTOR STD T7 ALS8 LDD PC SAVE SECTORS READ SO FAR STM SLSB LJM /RMS/BRD PROCESS NEXT READ CLI SPACE 4,10 ** CLI - CONVERT LIST INDICES. * * ENTRY (LI) = INITIAL LIST INDEX. * (LP - LP+1) = LIST ADDRESS. * * EXIT TRACK/SECTOR/PENALTY TABLES BUILT FOR LIST ENTRIES. * * USES CM - CM+4, LE - LE+1, RI - RI+1, T1 - T3, T6 - T7. * * MACROS ERROR. CLI SUBR ENTRY/EXIT CLI1 LDN 1 SET RANDOM INDEX STD RI+1 SHN -14 STD RI LDN FSMS SET FIRST SECTOR STD T7 LDD FS+1 SET FIRST TRACK STD T6 SHN -2 CHECK FIRST TRACK CONTAINS EOI CLIA ADC TRTS CRD CM LDD T6 LPN 3 STD T1 LDM CM,T1 STD T3 SHN 6 PJN CLI2 IF FIRST TRACK CONTAINS EOI LDM SLM STD T3 CLI2 LDD LI CHECK LIST INDEX ADC -TLSAE CLI3 PJN CLIX IF LIST FULL LDD LP CHECK POINTER ADDRESS SHN 14 LMD LP+1 SBN 2 MJN CLI4 IF LIST ADDRESS .LT. 2 ADN 2 SHN -6 SBD FL MJN CLI5 IF ADDRESS WITHIN FL CLI4 ERROR FPE *FET PARAMETER ERROR* CLI5 LDD LP READ LIST ENTRY SHN 6 ADD RA SHN 6 ADD LP+1 CRD CM LDD LI COMPUTE INDEX INTO PENALTY TABLE ADC -TLSA SHN -1 STD T2 LDC 0 (PREVIOUS POSITION) CLID EQU *-1 SBD CM+3 ZJN CLI5.1 IF THE SAME PJN CLI5.2 IF PENALTY CHARGE ADN 1 NJN CLI5.2 IF PENALTY CHARGE SBN 1 SHN 14 CLI5.1 ADC 0 (PREVIOUS POSITION) CLIE EQU *-1 SBD CM+4 PJN CLI5.2 IF PENALTY CHARGE ADC IMPL MJN CLI5.2 IF PENALTY CHARGE LDN 0 UJN CLI5.3 NO CHARGE CLI5.2 LDN IMRL SET PENALTY CLI5.3 STM TLAA,T2 LDD CM+4 SET LIST INDEX STD LE+1 ADD CM+3 NJN CLI5.4 IF NOT END OF LIST LJM CLIX RETURN CLI5.4 LDD CM+3 STD LE * SET SECTOR ADVANCE CLI6 LDD LE+1 SUBTRACT BOTTOM 12 BITS SBD RI+1 STD T2 PJN CLI7 IF NO BORROW AOD T2 END AROUND CARRY LCN 1 UJN CLI8 BORROW FROM UPPER CLI7 LDN 0 CLI8 ADD LE SUBTRACT TOP 12 BITS SBD RI STD T1 PJN CLI9 IF FORWARD LJM CLI1 RESTART CLI9 LDD T7 CHECK FOR SECTOR LIMIT RAD T2 SHN -14 ADD T1 NJN CLI10 IF SECTOR LIMIT PASSED LDD T2 STM 1,LI SBD T3 PJN CLI10 IF SECTOR LIMIT PASSED LDD T6 SET TRACK STI LI LDD LE UPDATE RANDOM INDEX STD RI STM CLID SAVE POSITION LDD LE+1 STD RI+1 STM CLIE SAVE POSITION LDM 1,LI UPDATE SECTOR NUMBER STD T7 AOD LP+1 ADVANCE LIST POINTER SHN -14 RAD LP LDN 2 ADVANCE LIST INDEX RAD LI LJM CLI2 LOOP * ADVANCE TRACK. CLI10 LDD T3 ADVANCE RANDOM INDEX SBD T7 RAD RI+1 SHN -14 RAD RI LDN 0 SECTOR = 0 STD T7 LDD T6 CHECK NEXT TRACK SHN -2 CLIB ADC TRTS CRD CM LDD T6 SET BYTE INDEX LPN 3 STD T1 LDM CM,T1 SET NEXT TRACK STD T6 SHN 6 MJN CLI11 IF NEXT TRACK FOUND ERROR RAD *RANDOM ADDRESS NOT ON FILE* CLI11 SHN -10 CLIC ADC TRTS CRD CM LDD T6 LPN 3 STD T1 LDM CM,T1 STD T3 SET SECTOR LIMIT SHN 6 PJN CLI12 IF END OF CHAIN LDM SLM STD T3 CLI12 LJM CLI6 LOOP SPACE 4,10 ** COMMON DECKS. MSR$ EQU 1 DEFINE ERROR PROCESSING MSR EQU CDA ERROR PROCESSOR FOR *COMPRNS* *CALL COMPRNS SPACE 4,10 ** READ LIST BUFFERS. USE BUFFER TLAA EQU * ACCOUNTING PENALTY INCREMENT BUFFER TLSA EQU TLAA+MRAL+1 TLSAE EQU TLSA+MRAL*2 ERRPL TLSAE+1-BFMS OVERFLOW INTO MASS STORAGE BUFFER SPACE 4,10 QUAL ERDO EQU *+5 END OF READ OVERLAYS SPACE 4,10 OVERFLOW ERMS WMS OVERLAY (WRITE MASS STORAGE.),MSDO WMS SPACE 4,10 ** DIRECT LOCATION ASSIGNMENTS. IP EQU 16 - 17 *IN* POINTER FOR RECALL CALCULATION WC EQU 35 SECTOR WORD COUNT NT EQU 36 NEXT TRACK TABLE ADDRESS BD EQU 37 WORDS OF DATA IN BUFFER SC EQU 46 SECTOR COUNT SL EQU 47 NEXT SECTOR/TRACK LINK FLAG WMS SPACE 4,10 ORG *+2 LJM PRS PRESET FOR WRITE WSY SPACE 4,10 ** WSY - WRITE SYSTEM SECTOR. * * EXIT TO *WMS*. * TO *CDA*, IF ERROR WRITING SYSTEM SECTOR. * * CALLS SBA, WSS. WSY BSS 0 ENTRY RJM WSS WRITE SYSTEM SECTOR PJN WSY1 IF NO ERROR RJM CDA CHECK DEVICE WSY1 CFET 3 UPDATE OUT POINTER CWD DP LDM CFNB CLEAR SYSTEM SECTOR OPERATION FLAG LPN 37 STM CFNB LDM WTBP LMD RA ZJN WMS IF NO MOVE RJM SBA SET BUFFER ADDRESSES * UJN WMS PROCESS WRITE WMS SPACE 4,10 ** WMS - WRITE MASS STORAGE MAIN ROUTINE. * * EXIT TO *CDA*, IF MASS STORAGE ERROR. * TO *MSP*. * * USES WC. * * CALLS WEI, WTB. WMS BSS 0 ENTRY LDD HN SET FULL SECTOR WORD COUNT STD WC STM BFMS+1 LJM WTB3 WRITE DATA * LJM WTB (*WRITECW*) * LJM WMS1 (*WRITEF*, NO DATA, OPERATION COMPLETE) * LJM WMS2 (BUFFERED DEVICE SYSTEM SECTOR WRITE) WMSA EQU *-1 * REENTRY FROM *WTB* FOR EOF WRITE. * WRITE EOF SECTOR FOR *WRITEF*/*REWRITEF*. WMS1 LDN 0 PREVENT UPDATE OF OUT POINTER STM WTBT LDC WTB18-WTBN+UJNI STM WTBN LDC WMS2 SET RETURN ADDRESS FOR *WTB* STM WTBU LJM WTB11 WRITE EOF SECTOR * REENTRY FROM *WTB*. * WRITE EOI SECTOR. WMS2 RJM WEI WRITE EOI SECTOR ZJN WMS3 IF NO ERROR RJM CDA CHECK DEVICE WMS3 LDM CFNB SET FILE MODIFIED LPN 74 * LPN 76 (REWRITE) WMSB EQU *-1 LMN 3 * LMN 1 (REWRITE) WMSC EQU *-1 STM CFNB LDN 2 SET WRITE MODE STD FS+4 LDM BFMS+2+505+4 WORD COUNT - 500 ADC -500 NJN WMS4 IF EOR/EOF ON *WRITECW* LDD BS+4 CHECK REQUEST SHN 21-4 PJN WMS5 IF NOT EOR/EOF WMS4 LDN 4 SET OPERATION COMPLETE RAD FS+4 WMS5 LJM MSP PROCESS MASS STORAGE EXIT WTB SPACE 4,30 ** WTB - WRITE BUFFER. * * ENTRY (BD) = WORD COUNT OF DATA IN BUFFER. * (FC) = INTERNAL *CIO* FUNCTION. * (PC) = 0. * (RC) = *DRCM* MONITOR FUNCTION CODE. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (DP - DP+4) = *OUT* POINTER. * (IN - IN+1) = (IP - IP+1) = *IN* POINTER. * AT *WTB* FOR *WRITECW* OF DATA. * AT *WTB3* FOR NON-CONTROL WORD WRITE OF DATA. * AT *WTB6* FOR *WRITECW* SYSTEM SECTOR OPERATION. * AT *WTB11* TO WRITE EOF SECTOR. * * EXIT (PC) = COUNT OF PRUS TRANSFERRED. * (T6) = ADVANCED CURRENT TRACK. * (T7) = ADVANCED CURRENT SECTOR. * (DP - DP+4) = ADVANCED *OUT* POINTER. * TO *CFN* IF PRESET TRACK ALLOCATION ERROR. * TO *CDA*, IF MASS STORAGE ERROR. * * ERROR TO *ERR* IF CONTROL WORD ERROR. * * USES IN+1, NT, SL, T1, T2, T3, WC, CM - CM+4, IP-3, IP+1. * * CALLS CHG, MSR, SBA, WDS, WEI. * * MACROS ERROR. WTB25 UJN WMS2 COMPLETE OPERATION WTB26 RJM WEI WRITE EOI ZJN WTB27 IF NO ERROR RJM CDA CHECK DEVICE WTB27 ERROR BLE *BUFFER CONTROL WORD ERROR* * *WRITECW* PREPROCESSING FOR DATA BLOCK. * ENTRY FOR CONTROL WORD WRITE. * LOOP FOR *WRITECW* AFTER SHORT BLOCK PROCESSED. WTB BSS 0 ENTRY LDD HN SET FULL SECTOR WORD COUNT STM BFMS+1 ADN 2 ALLOW FOR CONTROL WORDS STD WC LDC WTB1 RESET FULL BLOCK LOOP STM WTBU * LOOP FOR *WRITECW* AFTER FULL BLOCK PROCESSED. WTB1 LDD BD CHECK FOR EMPTY BUFFER ZJN WTB25 IF BUFFER EMPTY LDM BFMS+2+505+4 PREPROCESS HEADER CONTROL WORD ADC -500 ZJN WTB3 IF FULL BLOCK PJN WTB26 IF BLOCK .GT. 500 BYTES ADC 500 CALCULATE WORD COUNT STD T2 (BYTE COUNT * 103) / 512 SHN 1 ADD T2 STD T1 SHN 3 ADD T2 SHN 2 ADD T1 SHN -9D STM BFMS+1 SET SECTOR WORD COUNT ADN 2 STD WC SET CONTROL WORD BLOCK WORD COUNT SBN 2 SAVE INDEX TO END OF BLOCK STD T3 SHN 2 RAD T3 LDC WTB SET TO RESTORE FULL BLOCK WORD COUNT STM WTBU LDC WTB12+77-WTBN+UJNI STM WTBN * ENTRY FOR NON-CONTROL WORD WRITE. * CHECK AMOUNT OF DATA IN BUFFER. * *IN* IS NOT READ UP HERE DUE TO TIMING CONSIDERATIONS. WTB3 BSS 0 ENTRY LDD IP DATA LENGTH = IN - OUT SBD DP+3 SHN 14 ADD IP+1 SBD DP+4 PJN WTB4 IF NOT WRAP AROUND WTBA ADC ** (LIMIT - FIRST) WTB4 SBD WC PJN WTB5 IF SUFFICIENT DATA IN BUFFER LJM WMS2 RETURN * LJM WTB21 (PROCESS EOR FOR EOR/EOF WRITE) WTBB EQU *-1 * READ DATA FROM *CIO* BUFFER. WTB5 STD BD UPDATE BUFFER DATA WORD COUNT SHN -14 ZJN WTB6 IF .LT. 10000B WORDS OF DATA LCN 0 SET 7777B WORDS OF DATA STD BD * ENTRY FOR *WRITECW* SYSTEM SECTOR OPERATION. WTB6 LDD DP+3 CHECK FOR WRAP AROUND SECTOR SHN 14 ADD DP+4 ADD WC WTBC ADC -** (-LIMIT) * ADC -** ((-LIMIT)+1) FOR *WRITECW* MJN WTB7 IF NOT WRAP AROUND SECTOR STD T2 SET SECOND PART WORD COUNT NJN WTB9 IF SECOND PART PRESENT LDD DP+3 SHN 14 ADD DP+4 WTBD ADC ** (RA) * ADC ** (RA+1) FOR *WRITECW* CRM BFMS+2,WC WTBE LDC ** (FIRST) * LDC ** (LIMIT-1) FOR *WRITECW* UJN WTB8 UPDATE OUT * PROCESS NORMAL SECTOR. WTB7 ADC ** (LIMIT+RA) WTBF EQU *-2 SBD WC CRM BFMS+2,WC WTBG ADC -** (-RA) * ADC -** (-RA-1) FOR *WRITECW* WTB8 STD DP+4 UPDATE OUT SHN -14 STD DP+3 * THE FOLLOWING CHECK MINIMIZES OVERHEAD ON TRACK SWITCH * AND PREVENTS A *DRCM* BEING ISSUED JUST PRIOR * TO THE DRIVER NEEDING TO DO AN *LDAM*. LDD T7 ZJN WTB11 IF TRACK SWITCH * THE FOLLOWING LINE OF CODE IS MODIFIED VIA *RJM*. LJM WTB11 WRITE SECTOR WTBH EQU *-1 * LJM WTB23 (RECALL CPU AFTER FIRST SECTOR) * LJM WTB23+2 (RECALL CPU) * LJM WTB24+2 (MONITOR IN POINTER) UJN WTB11 WRITE SECTOR * PROCESS WRAP-AROUND SECTOR. WTB9 LDD WC SET FIRST PART WORD COUNT SBD T2 STD T1 ZJN WTB10 IF NO FIRST PART LDD DP+3 READ FIRST PART SHN 14 ADD DP+4 WTBI ADC ** (RA) * ADC ** (RA+1) FOR *WRITECW* CRM BFMS+2,T1 LDD T1 ADVANCE PP BUFFER ADDRESS SHN 2 ADD T1 WTB10 ADC BFMS+2 STM WTBK WTBJ LDC ** (FIRST+RA) CRM **,T2 READ SECOND PART WTBK EQU *-1 WTBL ADC -** (-RA) * ADC -** (-RA-1) FOR *WRITECW* STD DP+4 UPDATE OUT SHN -14 STD DP+3 * ENTRY TO WRITE EOF SECTOR FOR *WRITEF*/*REWRITEF*. * ADVANCE CURRENT SECTOR/TRACK. * RETURN TO *PRS* FOR *WRITECW* OF SYSTEM SECTOR. WTB11 LDD T7 SET NEXT SECTOR POINTER * LJM PRS25 (*WRITECW* SYSTEM SECTOR OPERATION) WTBM EQU *-1 ADN 1 STM BFMS * CHECK FOR END OF TRACK (IF UPDATE MODE AND/OR REWRITE, AND * IF PROCESSING ORIGINAL EOI TRACK, CHECK FOR ORIGINAL EOI * SECTOR). ONCE THE ORIGINAL EOI IS REACHED ON A BUFFERED * DEVICE, *SETMS RW* MAY NO LONGER BE USED. WRITING BEYOND * THE ORIGINAL EOI IN UPDATE MODE IS AN ERROR. LMC ** CHECK FOR END OF TRACK OR ORIGINAL EOI * LMC (SLM) (END OF TRACK) * LMC (EOI+1) (ORIGINAL EOI SECTOR) WTBZ EQU *-1 STD SL NJP WTB13 IF NOT END OF TRACK (IF NOT ORIGINAL EOI) WTBAA UJN WTB11.1 SET NEXT TRACK * PSN (UPDATE MODE AND/OR REWRITE) * CHECK FOR ORIGINAL EOI TRACK. LDM 1,NT CHECK NEXT TRACK LMC ** WTBAB EQU *-1 (ORIGINAL EOI TRACK) WTBAC NJN WTB11.2 IF NEXT TRACK IS NOT ORIGINAL EOI TRACK * NJN WTB11.3 (UPDATE MODE - IF NEXT TRACK IS NOT EOI) LDC * SET CHECK FOR ORIGINAL EOI SECTOR WTBAD EQU *-1 STM WTBZ WTB11.1 UJN WTB11.3 SET NEXT TRACK WTB11.2 LDI NT CHECK CURRENT TRACK LMM WTBAB NJN WTB11.3 IF CURRENT TRACK NOT ORIGINAL EOI TRACK SETMS IO,NF,WDSB CLEAR *RW* (REWRITE) OPTION ISTORE WTBAA,(UJN WTB11.1) DISABLE ORIGINAL EOI CHECK LDM SLM RESET SECTOR LIMIT CHECK STM WTBZ LMM BFMS STD SL NJN WTB13 IF ORIGINAL EOI IS NOT ALSO END OF TRACK * SET NEXT TRACK. WTB11.3 AOD NT SET NEXT TRACK LDI NT CHECK IF NEXT TRACK RESERVED STM BFMS NJN WTB13 IF NEXT TRACK RESERVED LJM WTB19 CHECK TERMINATION CONDITION * LJM WTB20.1 (UPDATE MODE - WRITE PAST EOI) WTBAE EQU *-1 * PROCESS *WRITECW* SHORT BLOCK. WTB12 LDC AODI+PC RESET FULL BLOCK PROCESSING STM WTBN LDM BFMS+2+5+4,T3 MOVE NEXT BYTE COUNT STM BFMS+2+505+4 LDD T3 CHECK FOR EOF BLOCK NJN WTB13 IF DATA IN BLOCK LDM BFMS+2,T3 LMN 17 ZJN WTB18 IF EOF * TRANSFER SECTOR TO DISK. WTB13 AOD PC INCREMENT PRU COUNT * UJN WTB12 (PROCESS SHORT BLOCK FOR *WRITECW*) * UJN WTB18 (PROCESS EOF SECTOR FOR EOF WRITE) WTBN EQU *-1 ERRPL WTBN-WTB12-40 JUMP OUT OF RANGE ERRPL WTB18-WTBN-40 JUMP OUT OF RANGE WTB13.1 LDC BFMS+WCSF * LDC BFMS+WLSF (*WPHR*) WTBO EQU *-2 RJM WDS WRITE SECTOR PJN WTB14 IF NO ERROR RJM CDA CHECK DEVICE WTB14 LDD RA CHECK RA LMC ** (RA) WTBP EQU *-1 ZJN WTB15 IF NO CHANGE RJM SBA SET BUFFER ADDRESSES WTB15 LDD SL CHECK FOR TRACK CHANGE ZJN WTB16 IF NEW TRACK AOD T7 INCREMENT SECTOR * *IN* IS READ UP HERE SO THAT THE OVERHEAD IS NOT ENCOUNTERED * ON LOGICAL TRACK SWITCH. WTBQ LDC ** (IN + RA) WTBR PSN (NON-BUFFERED OR UPDATE MODE FILE) * CRD IP-3 (BUFFERED) UJN WTB17 STORE OUT WTB16 STD T7 RESET SECTOR LDI NT SET NEXT TRACK STD T6 * STORE OUT POINTER. THE OUT POINTER IS NOT UPDATED BEFORE THE * WRITE SO RECOVERABLE ERRORS CAN BE RETRIED WHEN THE DEVICE * BECOMES ACCESSIBLE. WTB17 LDC ** (OUT + RA) WTBS EQU *-2 WTBT CWD DP STORE OUT * PSN (*CLOSE*) * PSN (*WRITEF*/*REWRITEF* WRITE EOF SECTOR) LJM WTB3 TRANSFER NEXT BLOCK * LJM WTB (*WRITECW* AFTER SHORT BLOCK) * LJM WTB1 (*WRITECW* AFTER FULL BLOCK) * LJM WMS1 (EOR BLOCK WRITTEN FOR EOF WRITE) * LJM WMS2 (EOR BLOCK WRITTEN FOR EOR WRITE) * LJM WMS2 (EOF BLOCK WRITTEN FOR EOF WRITE) * LJM WMS2 (*WPHR*) WTBU EQU *-1 * PROCESS EOF WRITE FOR *WRITECW* AND *WRITEF*/*REWRITEF*. WTB18 LDM BFMS SET EOF HEADER BYTES STM BFMS+1 LDN 0 STM BFMS AOD PC INCREMENT PRU COUNT UJP WTB13.1 WRITE SECTOR * PROCESS END OF TRACK TABLE. WTB19 LDD FC CHECK TERMINATION CONDITION LPN 14 LMN /CIO/EOI ZJN WTB20 IF *WRITE*/*REWRITE*/*WRITECW* * WRITE FUNCTIONS (AND *CLOSE*) OTHER THAN *WRITE*, *REWRITE*, * OR *WRITECW* SHOULD NOT REQUIRE MORE TRACKS THAN THOSE * ALLOCATED BY *RMS* IN PRESET PROCESSING. RJM WEI WRITE EOI SECTOR LDK SWET SET SYSTEM ERROR FLAG RJM CHG CONDITIONALLY HANG PP LJM CFN COMPLETE FUNCTION WTB20 AOM COCA SET TO ENTER RECALL STACK LJM WMS2 RETURN WTB20.1 ENDMS RELEASE CHANNEL ERROR IFM *INCORRECT MODIFICATION* * PROCESS EOR SECTOR FOR EOR/EOF WRITE. WTB21 RAD WC LDC WMS2 SET RETURN FOR EOR WRITE * LDC WMS1 (SET RETURN FOR EOF WRITE) WTBV EQU *-1 STM WTBU LDD WC GET EOR BLOCK LENGTH STM BFMS+1 ZJN WTB22 IF ZERO LENGTH BLOCK LJM WTB6 READ CENTRAL BUFFER WTB22 LJM WTB11 WRITE EOR SECTOR * PROCESS CPU RECALL. WTB23 RJM WTBH MODIFY INSTRUCTION LDC **+CWQW CHECK RECALL REQUIRED WTBW EQU *-1 CRD CM LDD CM+1 SHN 21-12 MJN WTB24 IF RECALL NOT REQUIRED LDD OA CWD RC * CALCULATE DATA IN THE BUFFER. WTB24 RJM WTBH MODIFY INSTRUCTION LDD BD SHN -11 NJN WTB24 IF .GE. 8 SECTORS OF DATA IN THE BUFFER LDD IP+1 SBD IN+1 ZJN WTB24 IF *IN* NOT CHANGED RAD IN+1 UJN WTB23 RECALL CPU SBA SPACE 4,10 ** SBA - SET BUFFER ADDRESSES. * PRESETS CM ADDRESSES IN *WTB*. * ENTER IF (RA) CHANGES. * * ENTRY (FT - FT+1) = *FIRST* POINTER. * (LM - LM+1) = *LIMIT* POINTER. * * MACROS CFET. SBA SUBR ENTRY/EXIT LDD RA RA STM WTBP SHN 6 SBAA ADN 0 * ADN 1 (*WRITECW*) STM WTBI+1 STM WTBD+1 LMC 7777 -RA STM WTBG+1 STM WTBL+1 SHN -14 LMC ADCI STM WTBI STM WTBD LMN 77 STM WTBG STM WTBL LDD FT FIRST + RA SHN 6 ADD RA SHN 6 ADD FT+1 STM WTBJ+1 SHN -14 LMC LDCI STM WTBJ CFET 2 IN + RA STM WTBS+1 STM WTBQ+1 SHN -14 LMC LDCI STM WTBS STM WTBQ AOM WTBS+1 OUT + RA SHN -14 RAM WTBS LDD LM LIMIT + RA SHN 6 ADD RA SHN 6 ADD LM+1 STM WTBF+1 SHN -14 LMC ADCI STM WTBF LJM SBAX RETURN SRW SPACE 4,15 ** SRW - STATUS LAST SECTOR REWRITE. * * ENTRY (MSD) = DRIVER IDENTIFIER. * (PC) = PRU COUNT WRITTEN. * (T4) = CHANNEL. * (T5) = EQUIPMENT. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * * EXIT (T7) = CURRENT SECTOR. * TO *CDA*, IF MASS STORAGE ERROR. * * USES T1, T2, T7. * * CALLS MSR, WDS. SRW SUBR ENTRY/EXIT LDD PC ZJN SRWX IF NO SECTORS WRITTEN LDM MSD LPN 77 LMN LA6DI ZJN SRW1 IF *6DI* DRIVER LMK LA6DJ&LA6DI NJN SRWX IF NOT *6DJ* DRIVER SRW1 LDM CHRV CHECK IF CHANNEL CONNECTED LPN 1 ZJN SRWX IF CHANNEL NOT CONNECTED LDD T7 CHECK TRACK SWITCH (DRIVER ISSUED *WLSF*) ZJN SRWX IF STATUS NOT NEEDED SOD T7 LDC SRW2 STM WDS LJM .DST1 ENTER DRIVER TO TAKE SECOND GENERAL STATUS SRW2 PJN SRW4 IF NO ERROR RJM CDA PROCESS ERROR SRW4 AOD T7 ADVANCE SECTOR SRW5 LJM SRWX RETURN WEI SPACE 4,25 ** WEI - WRITE EOI SECTOR. * * ENTRY (T5) = EST ORDINAL. * (T6) = TRACK. * (T7) = SECTOR. * (NT) = NEXT TRACK POINTER. * (FC) = INTERNAL *CIO* FUNCTION CODE. * (FS - FS+4) = FST ENTRY. * (WEIA) = OLD EOI TRACK TABLE ADDRESS. * (WEIB) = OLD EOI SECTOR. * (WEIC) = 1 IF ADDITIONAL TRACKS ALLOWED. * (WEID) = EOI TRACK SET BY *RTCM*. * (WEIE) = EOI SECTOR SET BY *RTCM*. * * EXIT (FS - FS+4) = UPDATED FST ENTRY. * (A) = 0 IF NO DISK ERROR. * CHANNEL RELEASED AND EXCESS TRACKS DROPPED. * * USES T1, T2, CM - CM+4. * * CALLS DCC, FWB, MSR, SCF, SRW, /WEI/WEI. * * MACROS MONITOR. WEI SUBR ENTRY/EXIT * CHECK FOR ERROR WRITING SYSTEM SECTOR. LDD T6 LMD FS+1 NJN WEI1 IF NOT IN FIRST TRACK LDD T7 ZJN WEIX IF POSITIONED AT SYSTEM SECTOR WEI1 LDD T6 SET CURRENT TRACK IN FST STD FS+2 LDD T7 SET CURRENT SECTOR IN FST STD FS+3 LDD FC CHECK FOR REWRITE SHN 21-12 PJP WEI3 IF NOT REWRITE LDC 7777 CHECK TRACK TABLE WEIA EQU *-1 SBD NT MJN WEI1.1 IF TRACK BEYOND EOI USED NJN WEI1.2 IF NOT AT EOI TRACK LDC 7777 CHECK EOI SECTOR WEIB EQU *-1 SBD T7 WEI1.1 MJN WEI3 IF SECTOR BEYOND EOI WEI1.2 RJM SRW STATUS LAST SECTOR REWRITE RJM DCC DROP CHANNEL WHEN OUTPUT REGISTER CLEAR LDN 76 ONLY SET FILE WRITTEN IN FST IF REWRITE STM WMSB LDN 1 SET FILE WRITTEN STM WMSC RJM SCF SET CONTROL BUFFER INDEX INTO FNT RJM FWB FLUSH WRITE DATA FOR BUFFERED DEVICE WEIC LDN 0 CHECK TRT MODIFIED * LDN 1 (ADDITIONAL TRACKS REQUESTED) ZJN WEI2 IF NO TRT UPDATE NEEDED LDM WEIB RESET OLD EOI SECTOR STD CM+3 LDM WEIA RESET OLD EOI TRACK STD T1 LDI T1 RESET OLD EOI TRACK UJN WEI5 RESET EOI IN TRT WEI2 LJM WEI9 RETURN WEI3 RJM /WEI/WEI WRITE EOI SECTOR SHN 0-21 RAM WEIF RJM DCC DROP CHANNEL RJM SCF SET CONTROL BUFFER INDEX INTO FNT LDM COCA SHN 21-13 MJN WEI4.1 IF TO RESTART *CPUCIO* FOR BUFFERED DEVICE RJM FWB FLUSH WRITE DATA FOR BUFFERED DEVICE WEI4.1 LDD T7 SET CURRENT SECTOR STD CM+3 LDD T6 SET CURRENT TRACK WEI5 LPC 3777 STD CM+2 LMC 0 CHECK EOI ALREADY SET CORRECTLY BY *RTCM* WEID EQU *-1 LMC 4000 NJN WEI6 IF EOI NOT ON SAME TRACK LDC 0 CHECK EOI SECTOR CORRECT IN TRT WEIE EQU *-1 LMD CM+3 ZJN WEI2 IF EOI CORRECT IN TRT WEI6 LDD T5 SET EQUIPMENT STD CM+1 LDM PMFF CHECK FILE TYPE NJN WEI7 IF NOT DIRECT ACCESS PERMANENT FILE LDC 4000 SET TO CHECKPOINT DEVICE RAD CM+1 WEI7 MONITOR DTKM DROP TRACKS AND UPDATE TRT * COMPUTE COUNT OF SECTORS EITHER ADDITIONALLY ALLOCATED, OR * RETURNED TO THE SYSTEM FOR THE CURRENT WRITE OPERATION. * ACTUAL COUNT OF SECTORS RETURNED VIA DTKM IS IN CM+3 - CM+4 LDM CFNJ COMPUTE NET STORAGE COMSUMED SBD CM+3 SHN 14 ADM CFNJ+1 SBD CM+4 SECTORS ALLOCATED MINUS SECTORS RETURNED PJN WEI8 IF MORE SECTORS USED THAN RETURNED LDN CICS CHANGE TO INCREMENT FUNCTION STM CFNI LDD CM+3 SBM CFNJ SHN 14 ADD CM+4 SBM CFNJ+1 WEI8 STM CFNJ+1 SHN -14 STM CFNJ WEI9 LDN 0 WEIF EQU *-1 * LDN 1 (ERROR OCCURRED ON THE WRITE) LJM WEIX RETURN RWF SPACE 4,10 ** RWF - REWRITE FILE ON DIFFERENT TRACK. * * IF IT IS POSSIBLE TO START THE OPERATION OVER (I.E. THE * FET POINTERS HAVE NOT BEEN CHANGED), TRY THE OPERATION * ON A DIFFERENT TRACK. THIS IS ACCOMPLISHED BY RETURNING * THE BAD TRACK AND RESTARTING THE OPERATION. IF IT CANNOT * BE RESTARTED AND THE FET POINTERS HAVE BEEN ADVANCED, THE * FILE IS RESET TO THE EMPTY STATE AND AN ERROR IS RETURNED * BECAUSE IT IS NOT POSSIBLE TO DETERMINE WHETHER OR NOT * THE SYSTEM SECTOR WAS PROPERLY WRITTEN. * * EXIT TO *CDA* IF NON-MEDIA ERROR ON PRE-ASSIGNED DEVICE. * TO *TMS* IF THE OPERATION CAN BE RESTARTED ON ANOTHER * TRACK. * * NOTE - THIS SUBROUTINE IS ONLY USED BY THE ERROR PROCESSOR. * FET POINTERS HAVE BEEN ADVANCED - DROP TRACKS, LEAVE FST * IN ORIGINAL VALUE AND CONTINUE WITH ERROR PROCESSING. RWF5 LDD FS+1 SET TRACK NUMBER STD CM+2 LDM RWFC ZJN RWF6 IF NOT PRE-ASSIGNED TO A DEVICE LDD CM+2 SET EOI LPC 3777 STD CM+2 UJN RWF7 DROP TRACKS RWF6 STD FS CLEAR EQUIPMENT ASSIGNMENT STD FS+1 RWF7 MONITOR DTKM RWF SUBR ENTRY/EXIT RWFA LDN ZERL SET UP MONITOR FUNCTION PARAMETERS * UJN RWFX (NON-MEDIA ERROR ON PRE-ASSIGNED DEVICE) CRD CM LDD T5 STD CM+1 LDD IR+1 SHN 21-5 MJN RWF1 IF AUTORECALL LDD T7 RWFB SBN FSMS+1 * SBN FSMS (SYSTEM SECTOR DATA IS IN CM BUFFER) PJN RWF5 IF OPERATION ADVANCED PAST SYSTEM SECTOR LDD T6 LMD FS+1 NJN RWF5 IF OPERATION ADVANCED PAST SYSTEM SECTOR RWF1 LDD TH IMMEDIATE RETURN IF INACCESSIBLE DEVICE RAD CM+1 LDC * RWFC EQU *-1 ZJN RWF3 IF NOT PRE-ASSIGNED TO A DEVICE LDM DCSA+1 LPN 77 LMN PARE ZJN RWF2 IF MEDIA ERROR * NON-MEDIA ERROR ON PRE-ASSIGNED DEVICE - RETURN TO *CDA* TO * RESTART THE JOB OR PROCESS THE ERROR. RWF1.1 LDM DCSA+1 SET UP TO RECALL JOB AND RESTART OPERATION LPC 5777 CLEAR UNRECOVERABLE FLAG STM RDCT ISTORE RWFA,(UJN RWFX) LJM CDA+1 REDETERMINE PROPER PROCESSING FOR ERROR * MEDIA ERROR ON PRE-ASSIGNED DEVICE - REQUEST NEW TRACK ON * SAME DEVICE, RETURN PREVIOUS TRACK, AND RESTART THE * OPERATION. RWF2 MONITOR RTCM LDD CM+1 CHECK STATUS SHN 21-11 MJN RWF1.1 IF FUNCTION CANT BE PROCESSED LDD CM+4 UJN RWF4 DROP THE OLD TRACK CHAIN * THE DEVICE WAS CHOSEN BY THIS *1MS* CALL - DROP THE TRACKS, * LEAVE THE FST FIRST TRACK = 0, AND RESTART THE OPERATION. RWF3 STD FS RWF4 STD FS+1 LDD T6 DROP TRACKS STD CM+2 MONITOR DTKM * NOTE - THE *DTKM* STATUS IS NOT CHECKED. IF TRACKS CANNOT * BE DROPPED ON AN INACCESSIBLE ISHARE DEVICE, THEY WILL JUST * BE LEFT RESERVED UNTIL THE NEXT TIME THE DEVICE IS RECOVERED * BY *MSM*. IT IS BETTER TO LEAVE THE TRACKS RESERVED AND LET * THE JOB CONTINUE THAN TO TIE UP THE PP TRYING TO DROP THEM. NFA FA,R ADK FSTL CWD FS LDC * RESTORE FLAGS RWFD EQU *-1 STM RCRF LJM TMS RESTART THE OPERATION SPACE 4,10 ** COMMON DECKS. QUAL WEI *CALL COMPWEI QUAL * WCS$ EQU 0 *CALL COMPWSS TRTK SPACE 4,10 ** TRTK - TABLE OF RESERVED TRACKS. * ENTRY = 1 WORD. * *T, 12/ TK * TK TRACK IN FILE CHAIN TRTK BSS 0 WDSB SPACE 4,10 ** WDSB - WRITE ERROR PROCESSING BUFFER. * THIS BUFFER IS USED STRICTLY BY THE DRIVER ERROR PROCESSOR * WHEN A WRITE ERROR IS ENCOUNTERED ON THE SECTOR PREVIOUS TO * A SECTOR CURRENTLY BEING WRITTEN. THIS SPACE MAY BE * OVERLAYED BY THE ERROR PROCESSING OVERLAY. WDSB EQU TRTK+202 ERRNG BFMS-WDSB-502 WDSB EXTENDS INTO BFMS SPACE 4,10 QUAL EWTO EQU /WMS/WDSB+5 END OF WRITE MASS STORAGE OVERLAY QUAL * TITLE WRITE MASS STORAGE PRESET. PRS SPACE 4,15 ** PRS - WRITE MASS STORAGE PRESET. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (FS - FS+4) = FST ENTRY. * (FT - OT+1) = BUFFER POINTERS. * * EXIT (BD) = WORD COUNT OF DATA IN BUFFER. * (DP - DP+4) = *OUT* POINTER. * (IP - IP+1) = *IN* POINTER. * * USES SC, WC. * * CALLS GNT, RMS, SBA. * * MACROS ERROR, PAUSE. PRS BSS 0 ENTRY LDC 500 SET BYTE COUNT FOR *WMS* COMPLETION CODE STM BFMS+2+505+4 LDM RCRF SAVE RESTART FLAG STATUS STM RWFD * SET BUFFER RELATED ADDRESSES. LDD LM LIMIT - FIRST SBD FT SHN 14 ADD LM+1 SBD FT+1 STM WTBA+1 STM PRSA+1 SHN -14 LMC ADCI STM WTBA STM PRSA LDC ADCI+77 -LIMIT LMD LM STM WTBC LCN 0 LMD LM+1 STM WTBC+1 LDD FC SHN 21-5 PJN PRS1 IF NOT *WRITECW* AOM WTBC+1 ADJUST FOR CONTROL WORDS SHN -14 RAM WTBC LDD LM SET LIMIT-1 SHN 14 LMD LM+1 SBN 1 UJN PRS2 SET BOUNDARY CONDITION FOR *WTB* PRS1 LDD FT SET FIRST SHN 14 LMD FT+1 PRS2 STM WTBE+1 SHN -14 RAM WTBE * CHECK AMOUNT OF DATA IN THE BUFFER. LDD IN+1 SET *IN* POINTER STD IP+1 LDD IN CHECK DATA IN BUFFER STD IP SBD OT LENGTH = IN - OUT SHN 14 ADD IN+1 SBD OT+1 PJN PRS3 IF NO WRAP AROUND PRSA ADC ** (LIMIT - FIRST) PRS3 STD BD SAVE WORD COUNT OF DATA IN BUFFER SHN 21-5 STD SC SAVE NUMBER OF PRUS OF DATA NJN PRS4 IF DATA IN BUFFER LDD FC SHN 21-5 MJN PRS5 IF *WRITECW* WITH NO DATA SHN 5-21+22 GET TERMINATION CONDITION LPN 14 LMN /CIO/EOF NJN PRS4 IF NOT EOF OPERATION LDD FS+4 CHECK LAST STATUS LPN 6 LMN 2 ZJN PRS4 IF LAST OPERATION INCOMPLETE WRITE LDC WMS1 PREVENT BUFFER WRITE STM WMSA PRS4 LDD SC NJN PRS7 IF AT LEAST ONE SECTOR IN BUFFER LDD FC CHECK TERMINATION CONDITION AND *WRITECW* LPN 54 ZJN PRS5 IF *WPHR* LMN /CIO/EOI NJN PRS7 IF NOT BUFFERED WRITE PRS5 LDM RCRF CHECK FOR DATA PREVIOUSLY TRANSFERRED SHN 21-6 MJN PRS6 IF DATA ALREADY TRANSFERRED ERROR UCF *UNNECESSARY CIO FUNCTION* PRS6 LJM CFN COMPLETE FUNCTION PRS7 LDD SC CHECK DATA WORD COUNT SHN -6 ZJN PRS8 IF LESS THAN 10000B WORDS OF DATA LCN 0 SET 7777B WORDS OF DATA STD BD PRS8 LDD FC LPN 54 NJN PRS9 IF NOT *WPHR* LDC WMS2 SET TERMINATION CONDITION STM WTBU LDC LDCI+WLSF/10000 SET WRITE LAST SECTOR STM WTBO LDN 1 LJM PRS14 SET SECTOR COUNT TO 1 FOR *WPHR* PRS9 LMN /CIO/EOI+40 ZJN PRS11 IF *WRITECW* LMN 40 ZJN PRS10 IF NOT EOR/EOF OPERATION LJM PRS15 CALCULATE PRU COUNT FOR EOR/EOF OPERATION PRS10 LDD IR+1 CHECK RECALL STATUS SHN 21-5 PJN PRS12 IF NOT AUTO RECALL LJM PRS17 CHECK FILE POSITION PRS11 AOM SBAA SET TO ALLOW FOR HEADER WORD LDC WTB SET LOOP ADDRESS STM WMSA * READ FIRST CONTROL WORD. LDD OT SHN 6 ADD RA SHN 6 ADD OT+1 CRM BFMS+2+505,ON LDD IR+1 CHECK AUTO RECALL SHN 21-5 MJN PRS13 IF AUTO RECALL PRS12 LDD CP SET CONTROL POINT ADDRESS RAM WTBW LDC CRDI+IP-3 SET TO READ IN STM WTBR LDC WTB23 SET TO RECALL CPU AFTER FIRST SECTOR STM WTBH PRS13 LDN 0 SET TO REDUCE SECTOR COUNT TO USER LIMIT STM CFSA AOM RTCA LDC RWPC SET DEFAULT PRU COUNT PRS14 STD SC UJN PRS17 CHECK FILE POSITION PRS15 LMN /CIO/EOF&/CIO/EOI NJN PRS16 IF NOT EOF OPERATION LDC WMS1 SET RETURN ADDRESS FOR EOF WRITE STM WTBV AOD SC COUNT EOF SECTOR PRS16 AOD SC COUNT EOR SECTOR LDC WTB21 STM WTBB LDD FC CHECK FOR *CLOSE* OPERATION SHN -6 LPN 17 LMN /CIO/CLO NJN PRS17 IF NOT CLOSE STM WTBT PREVENT UPDATE OF OUT POINTER * CHECK FILE CURRENT POSITION AT EOI. PRS17 AOD SC COUNT EOI SECTOR LDD FS+2 GET CURRENT TRACK ZJN PRS19 IF FILE NOT USED RJM GNT GET NEXT TRACK POINTER SHN 6 MJN PRS18 IF NOT AT EOI TRACK SHN -6 SBD FS+3 ZJN PRS19 IF AT EOI SECTOR PRS18 LDD FS+4 LPN 2 ZJN PRS20 IF LAST OPERATION NOT WRITE AOM PRSB SET REWRITE FLAG PRS19 LDD FC CLEAR REWRITE FLAG SHN 0-12+22 SCN 1 PRSB LMN 0 * LMN 1 (SET REWRITE FLAG) SHN 12-0 STD FC STM ICFC ERRNG *-TRTK-202 CHECK TRACK TABLE LENGTH PRS20 RJM RMS RESERVE MASS STORAGE * THE *LAST OPERATION WRITE* FLAG MUST BE WRITTEN TO THE * CM COPY OF THE FST BEFORE THE WRITE OPERATION BEGINS * IN CASE THE OPERATION IS INTERRUPTED BY A SYSTEM HANG. * *REC*, ON A LEVEL 3, CHECKS THIS FLAG TO DETERMINE IF IT * SHOULD VERIFY THAT FILES HAVE AN EOI AND ADD ONE TO FILES * THAT DONT. THE FST IS UPDATED AGAIN WHEN THE WRITE OPERATION * IS COMPLETE. LDD FS+4 SET THE WRITE MODE FLAG SCN 2 LMN 2 STD FS+4 NFA FA,R REWRITE THE FST ENTRY ADK FSTL CWD FS LDN 0 BUILD OUT POINTER STD DP STD DP+1 STD DP+2 LDD OT STD DP+3 LDD OT+1 STD DP+4 PAUSE NE RJM SBA SET BUFFER ADDRESSES LDD FS+2 ZJN PRS21 IF FIRST WRITE FOR NEW FILE LJM WMS PROCESS DATA WRITE PRS21 LDD FS+4 SHN 21-13 MJN PRS24 IF SYSTEM SECTOR OPERATION LJM WSY WRITE SYSTEM SECTOR PRS22 ERROR IRQ *INCORRECT I/O REQUEST* PRS23 ERROR BLE *BUFFER CONTROL WORD ERROR* * PROCESS *WRITECW* SYSTEM SECTOR OPERATION. PRS24 LDD FC SHN 21-5 PJN PRS22 IF NOT *WRITECW* LDM BFMS+2+505+4 LMC 77*5 NJN PRS23 IF WRONG WORD COUNT LDC 77+2 SET WORD COUNT OF DATA IN BUFFER STD WC LDD BD UPDATE BUFFER WORD COUNT SBD WC MJN PRS23 IF BUFFER CONTROL WORD ERROR STD BD SOM RWFB LDD HN SET RETURN TO PRESET ERRNZ 100-LJMI ADJUST IF INSTRUCTION VALUE CHANGES STM WTBM LDC PRS25 STM WTBM+1 LJM WTB6 READ CENTRAL BUFFER * COMPLETE *WRITECW* SYSTEM SECTOR OPERATION. PRS25 LDC LDDI+T7 RESET INSTRUCTIONS STM WTBM LDC ADNI+1 STM WTBM+1 LDM BFMS+2+500+4 MOVE WORD COUNT FOR NEXT PRU STM BFMS+2+505+4 LJM WSY WRITE SYSTEM SECTOR TITLE WRITE PRESET SUBROUTINES. CFL SPACE 4,10 ** CFL - CHECK FILE SIZE LIMIT. * * ENTRY (DP - DP+1) = ADDITIONAL FILE SIZE ALLOWED * IN SECTORS. * * EXIT (A) .LT. 0 IF FILE SIZE LIMIT EXCEEDED. * (DP - DP+1) = REMAINING ADDITIONAL FILE SIZE ALLOWED * IN SECTORS. CFL2 LDD DP ADD DP+1 ZJN CFL1 IF LIMIT REACHED CFL SUBR ENTRY/EXIT LDD DP+1 SBM SLM STD DP+1 PJN CFL2 IF NO UNDERFLOW AOD DP+1 SOD DP PJN CFL2 IF LIMIT NOT EXCEEDED CFL1 LCN 0 INDICATE FILE SIZE LIMIT EXCEEDED UJN CFLX RETURN CFS SPACE 4,20 ** CFS - CHECK FILE SIZE. * * ENTRY (FS - FS+4) = FST ENTRY. * (FA) = FNT ORDINAL IN NEGATIVE FL. * (SC) = ADDITIONAL SECTOR COUNT, INCLUDING EOI TRACK. * * EXIT (A) .LT. 0 IF NO ADDITIONAL TRACKS NEEDED. * .EQ. 0 IF TRACKS REQUIRED FOR BUFFERED WRITE. * .GT. 0 IF TRACKS REQUIRED FOR NON-BUFFERED WRITE. * * ERROR TO *ERR* IF FILE SIZE LIMIT EXCEEDED. * * USES SC, T2, CM - CM+4, DP - DP+2. * * CALLS CFL, GNT, RJC. * * MACROS ERROR, NFA. CFS SUBR ENTRY/EXIT LDD SC CHECK ROOM FOR WRITE SBM SLM STD SC SBN 1 MJN CFSX IF SUFFICIENT TRACKS ASSIGNED NFA FA,R GET FNT+2 WORD ADN FUTL CRD CM LDD CM+2 GET FILE LIMIT INDEX SHN -6 LPN 7 SHN 1 SET INDEX FOR TABLE STD T2 NJN CFS0 IF NON-ZERO INDEX LDM PMFF NJN CFS0 IF NOT DIRECT ACCESS PERMANENT FILE LDD CP GET JOB SERVICE CLASS ADN TFSW CRD CM SFA EJT,CM ADN SCLE CRD CM LDD CM GET VALUE FROM JOB CONTROL AREA SHN -6 RJM RJC READ JOB CONTROL AREA ZJN CFS0 IF SERVICE CLASS UNDEFINED ADN PFCT CRD CM LDD CM SET SERVICE CLASS *DS* VALUE SHN -11 LPN 7 SHN 1 STD T2 CFS0 LDM CFSB,T2 SET LIMIT STD DP LDM CFSB+1,T2 STD DP+1 ADD DP ZJN CFS2 IF UNLIMITED LDD FS+1 FIRST TRACK SHN 6 CFS1 SHN -6 RJM GNT GET NEXT TRACK RJM CFL CHECK FILE LIMIT MJN CFS6 IF FILE SIZE LIMIT EXCEEDED LDD T3 SHN 6 MJN CFS1 IF NOT EOI TRACK LDD DP CHECK IF SECTORS NEEDED WITHIN LIMIT SHN 14 ADD DP+1 SBD SC PJN CFS2 IF ADDITIONAL SECTORS WITHIN USER LIMIT LDD SC SAVE SECTOR COUNT STD DP+2 CFSA UJN CFS5 CHECK IF REQUIRED TRACKS WITHIN LIMIT * PSN (VARIABLE SECTOR COUNT) LDD DP+1 REQUEST UP TO 1 TRACK OVER LIMIT STD SC CFS2 LDM CFSA RETURN BUFFERED/NON-BUFFERED WRITE STATUS CFS3 LJM CFSX RETURN CFS4 RJM CFL CHECK FILE LIMIT MJN CFS7 IF FILE SIZE LIMIT EXCEEDED CFS5 LDD DP+2 COUNT SECTORS FOR ADDITIONAL TRACKS SBM SLM STD DP+2 SBN 1 PJN CFS4 IF MORE TRACKS NEEDED UJN CFS2 RETURN CFS6 LDM CFSA CHECK IF BUFFERED WRITE NJN CFS7 IF NOT VARIABLE SECTOR COUNT LDD FS+3 CHECK CURRENT SECTOR AT END OF TRACK ADN 1 SBM SLM MJN CFS3 IF LIMIT TRACK NOT FULL CFS7 ERROR FTL *FILE TOO LONG* CFSB BSS 0 TABLE OF DIRECT ACCESS FILE SIZE LIMITS CON 0,0 CON /PFM/DSRNG1/100,/PFM/DSRNG1*100-/PFM/DSRNG1/100*10000 CON /PFM/DSRNG2/100,/PFM/DSRNG2*100-/PFM/DSRNG2/100*10000 CON /PFM/DSRNG3/100,/PFM/DSRNG3*100-/PFM/DSRNG3/100*10000 CON /PFM/DSRNG4/100,/PFM/DSRNG4*100-/PFM/DSRNG4/100*10000 CON /PFM/DSRNG5/100,/PFM/DSRNG5*100-/PFM/DSRNG5/100*10000 CON /PFM/DSRNG6/100,/PFM/DSRNG6*100-/PFM/DSRNG6/100*10000 CON /PFM/DSRNG7/100,/PFM/DSRNG7*100-/PFM/DSRNG7/100*10000 CMA SPACE 4,10 ** CMA - CHECK FILE MODIFICATION ALLOWED. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * * ERROR TO *ERR* IF MODIFICATION NOT ALLOWED. * * MACROS ERROR. CMA SUBR ENTRY/EXIT LDM FACF CHECK FILE ACCESS FLAGS LPN 30 ZJN CMAX IF NO RESTRICTIONS SHN 21-3 PJN CMA1 IF MODIFICATION NOT ALLOWED LDD FC CHECK FOR REWRITE SHN 21-12 MJN CMAX IF REWRITE CMA1 ERROR IFM *INCORRECT MODIFICATION* GNT SPACE 4,10 ** GNT - GET NEXT TRACK POINTER. * * ENTRY (A) = CURRENT TRACK POINTER. * (FS - FS+4) = FST ENTRY. * * EXIT (A) = (T3) = NEXT TRACK POINTER. * (T2) = CURRENT TRACK POINTER. * (T5) = EQUIPMENT IF INITIAL CALL. * * USES T2, T3, CM - CM+4. * * MACROS SFA. GNT2 SHN -2 READ TRT WORD GNTB ADC ** CRD CM LDD T2 SET BYTE INDEX LPN 3 STD T3 LDM CM,T3 GET NEXT TRACK POINTER STD T3 GNT SUBR ENTRY/EXIT STD T2 SAVE CURRENT TRACK POINTER GNT1 LDD FS * UJN GNT2 (TRT ADDRESS PRESET) GNTA EQU *-1 STD T5 SFA EST GET EST ENTRY ADK EQDE CRD CM LDD CM+4 MST ADDDRESS / 10 SHN 3 ADN TRLL READ TRT POINTER CRD CM LDD CM+3 EXTRACT TRT ADDRESS LPN 77 SHN 14 LMD CM+4 SBD TH COMPENSATE FOR TRACK LINK FLAG (4000/4) STM GNTB+1 SET TRT BASE ADDRESS SHN -14 RAM GNTB ISTORE GNTA,(UJN GNT2) LDD T2 UJN GNT1 GET NEXT TRACK POINTER RTC SPACE 4,15 ** RTC - REQUEST TRACK CHAIN. * * ENTRY (A) = TRACK PARAMETER OR DEVICE SELECTION. * (T5) = EQUIPMENT IF NONZERO. * (SC) = SECTOR COUNT. * * EXIT (A) = FIRST TRACK ASSIGNED. * (CM+1) = EQUIPMENT. * * ERROR TO *ERR* IF MS PRU LIMIT OR TRACK LIMIT. * * USES CM - CM+4, DP - DP+4. * * MACROS ERROR, MONITOR. RTC6 ERROR PRL *PRU LIMIT* RTC SUBR ENTRY/EXIT STD CM+2 SET TRACK PARAMETER/DEVICE SELECTION LDD CP READ MASS STORAGE LIMIT WORD ADN ACLW CRD DP LDD DP+3 CHECK MASS STORAGE PRU LIMIT LPN 77 SHN 14 LMD DP+4 ZJN RTC6 IF JOB PRU LIMIT EXCEEDED LDD CM+2 SAVE TRACK PARAMETER/DEVICE SELECTION STD DP RTC1 LDD T5 SET EQUIPMENT ADD TH IMMEDIATE RETURN IF INACCESSIBLE DEVICE STD CM+1 LDM PMFF CHECK FILE TYPE NJN RTC2 IF NOT DIRECT ACCESS PERMANENT FILE LDC 4000 SET DEVICE CHECKPOINT RAD CM+1 RTC2 LDM FSAL GET FILE SECURITY ACCESS LEVEL ADN 40 SET ACCESS LEVEL SELECTION SHN 6 STD CM+3 LDD SC SET SECTOR COUNT STD CM+4 MONITOR RTCM ASSIGN MASS STORAGE SPACE LDD CM+1 CHECK STATUS SHN 21-11 PJN RTC2.1 IF FUNCTION PROCESSED ISTORE CDAA,(UJN CDA4) SKIP EOI WRITE LDD FS SET EST ORDINAL STM ERSD RJM CDA CHECK DEVICE ACCESSIBILITY RTC2.1 LDD CM+4 ZJN RTC4 IF NO TRACKS ASSIGNED LDD CM+2 SAVE NEW EOI TRACK STM WEID LDD CM+3 SAVE NEW EOI SECTOR STM WEIE AOM WEIC SET TRT MODIFIED FLAG LDM RCRF CHECK IF IN RECALL STACK FOR TRACK LIMIT LPN 77 LMN TRLR NJN RTC3 IF NO PRIOR TRACK LIMIT LDD CP CLEAR CONSOLE MESSAGE ADN MS2W CWD CM RTC3 LDD CM+4 RETURN FIRST TRACK ASSIGNED LJM RTCX RETURN RTC4 LDN 0 CHECK FOR BUFFERED WRITE * LDN 1 (VARIABLE SECTOR COUNT) RTCA EQU *-1 ZJN RTC5 IF NOT VARIABLE SECTOR COUNT SOM RTCA LDN 3 SET MINIMUM SECTOR COUNT STD SC LDD DP RESET TRACK PARAMETER/DEVICE SELECTION STD CM+2 LJM RTC1 RETRY REQUEST FOR ONE TRACK RTC5 ERROR TKL *TRACK LIMIT* RMS SPACE 4,20 ** RMS - RESERVE MASS STORAGE SPACE. * * ENTRY (FS - FS+4) = FST ENTRY. * (FC) = INTERNAL *CIO* FUNCTION CODE. * (SC) = SECTOR COUNT TO WRITE. * * EXIT (T5) = EQUIPMENT. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (NT) = TRACK TABLE ADDRESS. * (FS - FS+1) = EQUIPMENT AND FIRST TRACK ASSIGNED * IF NEW FILE. * (TRTK) = TABLE OF RESERVED TRACKS. * * USES SC, CM - CM+4. * * CALLS CFS, CMA, GNT, RTC. * * MACROS NFA, SETMS. * COPY EXISTING TRACKS FROM TRT TO TRACK TABLE. RMS8 STI NT ENTER TRACK TABLE RJM GNT GET NEXT TRACK TABLE SHN 6 PJN RMS10 IF EOI LINK AOD NT ADVANCE TRACK TABLE ADDRESS LDD SC CHECK SECTOR COUNT SBM SLM MJN RMS9 IF ROOM FOR WRITE ZJN RMS9 IF EXACTLY FILLS TRACK STD SC UPDATE SECTOR COUNT LDD T3 SET NEXT TRACK UJN RMS8 LOOP TO EOI OR ROOM FOR WRITE * CHECK FILE MODIFICATION ALLOWED. RMS9 RJM CMA CHECK MODIFICATION ALLOWED LJM RMS17 PROCESS EXIT * SET EOI POSITION. RMS10 AOD NT ADVANCE TRACK TABLE ADDRESS RMSB SBN 1 * LJM RMS12 (FIRST WRITE OF NEW FILE) STM WEIA SET TRACK TABLE ADDRESS LDD T3 SET ORIGINAL EOI SECTOR STM WEIB ADN 1 STM WTBAD LDM FACF CHECK FILE ACCESS FLAGS LPN 30 LMN 10 ZJN RMS10.1 IF UPDATE MODE LDD FC SHN 21-12 PJN RMS10.4 IF NOT REWRITE RMS10.1 ISTORE WTBAA,(PSN) FORCE CHECK FOR ORIGINAL EOI TRACK LDD T2 SAVE ORIGINAL EOI TRACK STM WTBAB LMD FS+2 NJN RMS10.2 IF NOT CURRENTLY AT EOI TRACK LDM WTBAD FORCE CHECK FOR ORIGINAL EOI SECTOR STM WTBZ RMS10.2 LDM FACF CHECK FILE ACCESS FLAGS LPN 30 LMN 10 NJN RMS10.4 IF NOT UPDATE MODE ISTORE WTBAC,(NJN WTB11.3) STOP TRANSFER AT ORIGINAL EOI LDC WTB20.1 SET ERROR FOR WRITE PAST EOI STM WTBAE RMS10.3 LJM RMS9 CHECK IF MODIFICATION ALLOWED RMS10.4 LDD T3 SBD SC PJN RMS10.3 IF NO FILE EXTENSION LDM FACF CHECK FILE ACCESS FLAGS LPN 30 ZJN RMS12 IF NO RESTRICTIONS LDD T2 LMD FS+2 NJN RMS11 IF NOT AT EOI TRACK LDD T3 LMD FS+3 ZJN RMS12 IF AT EOI SECTOR RMS11 RJM CMA CHECK MODIFICATION ALLOWED RMS12 LDD T2 SAVE TRACK LINK STD SL * CHECK MASS STORAGE LIMIT AND RESERVE ADDITIONAL TRACKS. RJM CFS CHECK FILE SIZE MJN RMS17 IF SUFFICIENT TRACKS ASSIGNED NJN RMS14 IF NOT BUFFERED WRITE LDD SC RMS13 SBM SLM PJN RMS13 IF MORE TRACKS NEEDED LMC 777777 RAD SC ROUND SECTOR COUNT UP TO END OF TRACK RMS14 LDD SL RJM RTC REQUEST TRACK CHAIN RMS15 SHN 6 RMS16 SHN -6 STI NT ENTER TRACK TABLE RJM GNT GET NEXT TRACK AOD NT ADVANCE TRACK TABLE LDM SLM ACCUMULATE COUNT OF SECTORS RAM CFNJ+1 SHN -14 RAM CFNJ LDD T3 CHECK NEXT LINK SHN 6 MJN RMS16 IF MORE TRACKS RMS17 LDN 0 INDICATE END OF RESERVED TRACK TABLE STI NT LDC TRTK RESET TRACK TABLE ADDRESS STD NT RMS SUBR ENTRY/EXIT LDC TRTK SET TRACK TABLE ADDRESS STD NT LDD FS+3 BIAS SECTOR COUNT WITH CURRENT SECTOR STD T7 RAD SC LDD FS+2 ZJN RMS1 IF FILE NOT USED LJM RMS5 BUILD TRACK TABLE RMS1 AOD SC COUNT SYSTEM SECTOR LDD FS GET EQUIPMENT ASSIGNMENT STM RWFC STD T5 LDD FS+1 NJN RMS2 IF FIRST TRACK ASSIGNED LDC RMS15 SET TO BYPASS TRACK LINK SEARCH STM RMSA RJM SMA SET *MSAL* PARAMETER RJM RTC REQUEST TRACK CHAIN STD FS+1 SET FIRST TRACK LDD CM+1 SET EQUIPMENT STD FS RMS2 RJM CBD CHECK FOR BUFFERED DEVICE ZJN RMS3 IF NOT BUFFERED DEVICE LDD FC CHECK TERMINATION CONDITION LPN 14 ZJN RMS3 IF *WPHR* LDM RCRF SET BUFFERED DEVICE FUNCTION FLAG LPC 7577 LMC 200 STM RCRF RMS3 LDM RCRF SHN 21-7 PJN RMS4 IF NOT BUFFERED DEVICE FUNCTION LDC WMS2 PREVENT DATA AND EOF WRITE STM WMSA LDC 4000 SET TO RESTART *CPUCIO* STM COCA LDN 2 SET SYSTEM SECTOR AND EOI SECTOR COUNT STD SC RMS4 LDC LJMI SET UP FOR FIRST WRITE OF NEW FILE STM RMSB LDC RMS12 STM RMSB+1 LDD FS+1 SET CURRENT TRACK TO FIRST TRACK RMS5 STD T6 LDD FS SET EQUIPMENT STD T5 LDD FC SHN 21-12 PJN RMS6 IF NOT REWRITE SETMS IO,RW,WDSB UJN RMS7 BUILD TRACK TABLE RMS6 SETMS IO,NF,WDSB RMS7 LDM SLM STM WTBZ LDD T6 LJM RMS8 BUILD TRACK TABLE * LJM RMS15 (BYPASS TRACK LINK SEARCH) RMSA EQU *-1 SMA SPACE 4,10 ** SMA - SET MASS STORAGE ALLOCATION (*MSAL*) PARAMETER. * * ENTRY (BS - BS+4) = FET+0. * * EXIT (A) = *MSAL* PARAMETER. * * USES T1. SMA2 MJN SMA1 IF SEARCH NAME IS BEYOND CURRENT ENTRY LDN LOCS RETURN *MSAL* SELECTION SMA SUBR ENTRY/EXIT LDC TSFN-TSFNL STD T1 SMA1 LDN TSFNL RAD T1 LDI T1 SBD BS NJN SMA2 IF NO MATCH ON FIRST TWO CHARACTERS LDM 1,T1 LMD BS+1 NJN SMA1 IF NAMES DO NOT MATCH LDM 2,T1 LMD BS+2 NJN SMA1 IF NAMES DO NOT MATCH LDM 3,T1 LMD BS+3 SCN 77 NJN SMA1 IF NAMES DO NOT MATCH LDM 3,T1 LPN 77 UJN SMAX RETURN *MSAL* SELECTION TSFN SPACE 4,10 ** TSFN - TABLE OF SPECIAL FILE NAMES. * TABLE MUST BE ARRANGED IN ASCENDING ORDER. * * ONE CM WORD PER ENTRY - *T 42/ FN,6/ MP * FN FILE NAME. * MP *MSAL* PARAMETER. TSFN BSS 0 TSFNL EQU 4 VFD 42/0LLGO,6/LGOS VFD 42/0LOUTPUT,6/OUTS VFD 42/0LPUNCH,6/OUTS VFD 42/0LPUNCHB,6/OUTS VFD 42/0LP8,6/OUTS CON 7777 TERMINATE TABLE SPACE 4,10 SPACE 4,10 ** COMMON DECKS. *CALL COMPRJC EJT$ EQU 1 DEFINE EJT ACCESS *CALL COMPGFP OVERFLOW MSDO,BFMS PMS OVERLAY (POSITION MASS STORAGE.),MSDO PMS SPACE 4,10 ** DIRECT LOCATION ASSIGNMENTS. BI EQU 35 BACKSPACE INDEX RI EQU 36 - 37 RANDOM INDEX (2 LOCATIONS) PMS SPACE 4,10 ** PMS - POSITION MASS STORAGE MAIN ROUTINE. PMS SUBR ENTRY/EXIT LJM PRS PRESET MSR SPACE 4,10 ** MSR - PROCESS MASS STORAGE ERROR FROM *COMPRNS*. MSR SUBR LDD T6 SET CURRENT TRACK STD FS+2 LDD T7 SET CURRENT SECTOR STD FS+3 RJM CDA CHECK DEVICE (ERROR PROCESSOR RETURNS) UJN MSRX RETURN SRC SPACE 4,10 ** SRC - SET RECALL CONDITIONS. * * EXIT (FS+2) = UPDATED CURRENT TRACK. * (FS+3) = UPDATED CURRENT SECTOR. * TO *PMSX* TO ENTER RECALL STACK. * TO *ERR* IF ERROR FLAG TERMINATION. * * CALLS CET. * * MACROS ENDMS. SRC BSS 0 ENTRY ENDMS END MASS STORAGE OPERATION LDD T6 SET CURRENT TRACK STD FS+2 LDD T7 SET CURRENT SECTOR STD FS+3 RJM CET CHECK ERROR FLAG TERMINATION AOM COCA SET RECALL STACK FLAG SRC1 UJN PMSX RETURN SFP SPACE 4,20 ** SFP - SET FILE POSITION. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (FO) = FET OPTIONS. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (FS - FS+4) = FST ENTRY. * (RI - RI+1) = RANDOM ADDRESS IF *SFPA* SET AND * RANDOM FET. * * EXIT (FS - FS+4) = ADVANCED FST ENTRY. * TO *PMSX*. * * USES DP - DP+4. * * CALLS SRA. * * MACROS CFET. SFP BSS 0 ENTRY LDD T6 SET CURRENT TRACK STD FS+2 LDD T7 SET CURRENT SECTOR STD FS+3 LDN ZERL CRD DP LDD FO CHECK FET STATUS SHN 6 PJN SRC1 IF NOT RANDOM FET SFPA LDN 0 NJN SFP1 IF RANDOM ADDRESS IS PRESET LDD FS+2 CHECK FILE ZJN SFP1 IF FILE NOT USED LDD FS+1 SET RANDOM ADDRESS RJM SRA SFP1 LDM ERRA CHECK MS ERROR OCCURRED ZJN SFP2 IF NO ERROR CFET 6 MERGE RANDOM ADDRESS CRD DP SFP2 LDD RI+1 ENTER CURRENT RANDOM ADDRESS SHN 6 STD DP+2 SHN -14 STD DP+1 LDD RI SHN 6 RAD DP+1 SHN -14 STD DP CFET 6 STORE RANDOM ACCESS WORD CWD DP LJM PMSX EXIT TITLE SKIP/OPEN FUNCTION PROCESSORS. BKS SPACE 4,15 ** BKS - BACKSPACE SECTOR. * * ENTRY (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (FS - FS+4) = FST ENTRY. * * EXIT (T6) = UPDATED CURRENT TRACK. * (T7) = UPDATED CURRENT SECTOR. * TO *SFS* IF BOI ENCOUNTERED. * TO *SFS2* IF PRU BACKSPACE COMPLETE. * * CALLS BOT, DSC. BKS BSS 0 ENTRY LDD T6 CHECK CURRENT TRACK LMD FS+1 NJN BKS1 IF NOT FIRST TRACK LDD T7 CHECK CURRENT SECTOR LMN FSMS ZJN SFS IF FIRST SECTOR BKS1 SOD T7 DECREMENT SECTOR PJN BKS2 IF SAME TRACK RJM BOT BACK UP ONE TRACK SBN 1 SET LAST SECTOR STD T7 BKS2 RJM DSC DECREMENT SKIP COUNT NJN BKS IF SKIP NOT COMPLETE UJN SFS2 SET FST STATUS SFS SPACE 4,10 ** SFS - SET FILE STATUS. * * ENTRY (A) = FST STATUS IF ENTRY AT *SFS2*. * AT *SFS* TO SET BOI STATUS IN FET. * AT *SFS1* TO SET EOR FST STATUS. * AT *SFS2* TO STORE FST STATUS. * * EXIT (FS+4) = FST STATUS. * TO *SFP*. SFS BSS 0 ENTRY LDD BS+4 SET REWIND FUNCTION STATUS LPN 2 ADN 50 STD BS+4 LDC LDNI DISABLE FET STATUS UPDATE STM UFSA * SET EOR STATUS IN FST. SFS1 LDN /CIO/EOR SET EOR FST STATUS * SET STATUS IN FST. SFS2 STD FS+4 STORE FST STATUS LJM SFP EXIT SKB SPACE 4,15 ** SKB - SKIP RECORD/FILE BACKWARD. * * ENTRY (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (FC) = INTERNAL *CIO* FUNCTION CODE. * (FS - FS+4) = FST ENTRY. * * EXIT (T6) = UPDATED CURRENT TRACK. * (T7) = UPDATED CURRENT SECTOR. * TO *SFS* IF BOI ENCOUNTERED. * TO *SFS1* OR *SFS2* IF SKIP COMPLETE. * * CALLS BKR, DSC, SMS. SKB BSS 0 ENTRY RJM SMS LOAD MASS STORAGE DRIVER SKB0 LDD T6 CHECK CURRENT TRACK LMD FS+1 NJN SKB1 IF NOT FIRST TRACK LDD T7 CHECK CURRENT SECTOR LMN FSMS ZJN SFS IF FIRST SECTOR SKB1 RJM BKR BACKSPACE RECORD LDD FC LPN 14 LMN /CIO/EOF NJN SKB2 IF NOT SKIP TO EOF LDD T1 SHN 21-13 PJN SKB0 IF NOT EOF SKB2 RJM DSC DECREMENT SKIP COUNT NJN SKB0 IF SKIP NOT COMPLETE LDD T1 GET EOF INDICATOR SHN 0-13 ZJN SFS1 IF NOT EOF LDN /CIO/EOF UJN SFS2 SET FST STATUS SKF SPACE 4,15 ** SKF - SKIP RECORD/FILE FORWARD. * * ENTRY (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (FC) = INTERNAL *CIO* FUNCTION CODE. * * EXIT (PC) = PRU COUNT. * TO *SFP* IF SKIP COMPLETE. * TO *SRC* TO ENTER RECALL STACK. * * CALLS CRT, DSC, RNS, SMS. * * MACROS ENDMS. SKF5 LCN 0 RESET PRU COUNT STD PC LJM SRC SET RECALL CONDITIONS SKF BSS 0 ENTRY RJM SMS LOAD MASS STORAGE DRIVER SKF0 LDD T7 CHECK FOR NEW ENTRY SKFA EQU *-1 * LJM SFP (MASS STORAGE ERROR) NJN SKF1 IF NOT NEW TRACK RJM CRT CHECK RECALL TIME SKF1 AOD PC INCREMENT PRU COUNT SHN -14 NJN SKF5 IF PRU COUNT EXCEEDS 12 BITS LDC BFMS+DTSF READ NEXT SECTOR HEADER WORD RJM RNS SHN -6 NJN SKF0 IF NOT EOR LDM BFMS ADM BFMS+1 ZJN SKF4 IF EOI LDD FC LPN 14 LMN /CIO/EOF NJN SKF2 IF NOT SKIP TO EOF LDM BFMS NJN SKF0 IF NOT EOF SKF2 RJM DSC DECREMENT SKIP COUNT NJN SKF0 IF SKIP NOT COMPLETE LDM BFMS ZJN SKF3 IF EOF LDN /CIO/EOR&/CIO/EOF SKF3 LMN /CIO/EOF&/CIO/EOI SKF4 LMN /CIO/EOI STD FS+4 SET FST STATUS ENDMS END MASS STORAGE OPERATION LJM SFP EXIT SKP SPACE 4,20 ** SKP - SKIP PROCESSOR. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (BS - BS+4) = (FET+0). * (FS - FS+4) = FST ENTRY. * * EXIT (BS+4) = REWIND STATUS IF BOI ENCOUNTERED ON * BACKWARD SKIP. * (FS - FS+4) = UPDATED FST ENTRY. * TO *BKS* IF BACKSPACE PRU FUNCTION. * TO *SKB* IF BACKSPACE RECORD/FILE FUNCTION. * TO *SKF* IF SKIP RECORD/FILE FORWARD. * TO *SFP* IF FORWARD SKIP ON NULL FILE OR *SKIPEI*. * TO *SFS* IF BACKWARD SKIP ON NULL FILE. * * USES T1. * * CALLS CET, SEI. SKP BSS 0 ENTRY LDD T6 CHECK CURRENT TRACK NJN SKP1 IF FILE USED LDD FC SHN -13 ZJN SKP3 IF FORWARD SKIP LJM SFS SET BOI STATUS SKP1 RJM CET CHECK ERROR TERMINATION LDD FC SHN -13 STD T1 0 = SKIP FORWARD, 1 = SKIP BACKWARD NJN SKP4 IF BACKWARD SKIP LDD FC CHECK FOR *SKIPEI* LPN 14 LMN /CIO/EOI NJN SKP5 IF NOT SKIP TO EOI LDD FO SHN 6 PJN SKP2 IF NOT RANDOM FET LDD FS+1 START AT FIRST TRACK TO GET FILE LENGTH STD T6 AOM SFPA INDICATE THAT *RI* IS PRESET SKP2 RJM SEI SKIP TO END OF INFORMATION LDD T2 SET RELATIVE SECTOR ADDRESS STD RI LDD T3 STD RI+1 SKP3 LDN /CIO/EOI STD FS+4 SET EOI FST STATUS LJM SFP EXIT SKP4 LDD FC CHECK TERMINATION CONDITION LPN 14 ZJN SKP5 IF BACKSPACE PRU AOD T1 2 = SKIP RECORD/FILE BACKWARD LDD FS+3 INITIALIZE BACKSPACE SECTOR STM BKRA LDD FS+2 INITIALIZE BACKSPACE TRACK STM BKRB SKP5 LDM TSPA,T1 STD T1 LJM 0,T1 PROCESS SKIP FUNCTION TSPA BSS 0 TABLE OF SKIP PROCESSOR ADDRESSES LOC 0 CON SKF SKIP FORWARD CON BKS BACKSPACE PRU CON SKB SKIP RECORD/FILE BACKWARD LOC *O OPE SPACE 4,15 ** OPE - OPEN FILE. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (FO) = FET OPTIONS. * * EXIT TO *REW* IF OPEN/REWIND. * TO *SFP* IF OPEN/NO REWIND. * * USES CM - CM+4. * * CALLS LRI. * * MACROS CFET. OPE BSS 0 ENTRY LDD FO CHECK SPECIAL PROCESSING SHN 6 PJN OPE1 IF NOT RANDOM FILE LDM FETL CHECK FET LENGTH SBN 3 MJN OPE1 IF NO INDEX WORD IN FET RJM LRI LOAD RANDOM INDEX OPE1 CFET 4 READ LIMIT CRD CM LDN 1 SET PRU SIZE STD CM+2 LDD CM+3 LPN 37 STD CM+3 CFET 4 STORE LIMIT CWD CM LDM CFNB CLEAR FILE OPENED AND WRITTEN BITS LPN 71 LMN 04 SET FILE OPENED STATUS STM CFNB LDD FC CHECK FOR OPEN/REWIND OPERATION SHN 21-13 PJN OPE2 IF NO REWIND LJM REW REWIND FILE OPE2 LJM SFP RETURN TITLE SKIP/OPEN SUBROUTINES. BKR SPACE 4,20 ** BKR - BACKSPACE RECORD. * * ENTRY (T4 - T7) = MS PARAMETERS. * (BI) = BACKSPACE INDEX. * (FS - FS+4) = FST ENTRY. * DRIVER PRESET. * * EXIT (BIT 13B OF T1) = 1 IF EOF. * (T6 - T7) UPDATED. * (BI) = ADVANCED BACKSPACE INDEX. * (PC) = ACCUMULATED PRUS TRANSFERRED COUNT. * (FS - FS+4) = UPDATED FST ENTRY. * TO *SRC* IF PRU TRANSFER LIMIT. * TO *CDA*, IF MASS STORAGE ERROR. * * USES T1. * * CALLS BOT, CET, CRT, RNS. * * MACROS ENDMS. BKR SUBR ENTRY/EXIT * SET PREVIOUS END OF RECORD POSITION FROM BUFFER IF POSSIBLE. LDD BI ZJN BKR5 IF BACKSPACE INDEX EMPTY LDD T7 SET CURRENT SECTOR STD FS+3 BKR1 SOD BI DECREMENT INDEX LDM BKRB SET TRACK STD T6 LDM BBUF,BI SET EOF STATUS STD T1 LPC 3777 SET SECTOR STD T7 NJN BKR2 IF NOT FIRST SECTOR OF NEXT TRACK LDD FS+2 SET NEXT TRACK STD T6 BKR2 LDD FS+3 COUNT PRUS TRANSFERRED NJN BKR3 IF NOT NEXT TRACK LDM SLM SECTORS PER TRACK BKR3 SBD T7 RAD PC UJN BKRX RETURN BKR4 LJM SRC ENTER RECALL STACK * BACKSPACE UP TO *MPTB* SECTORS OR BEGINNING OF TRACK. BKR5 LDC 0 SET PRIOR TRACK/SECTOR POSITION BKRA EQU *-1 STD T7 STD FS+3 LDC 0 BKRB EQU *-1 STD T6 STD FS+2 RJM CET CHECK ERROR TERMINATION RJM CRT CHECK RECALL TIME LDD PC ADC MPTB SHN -14 NJN BKR4 IF PRU TRANSFER LIMIT LDD T7 CHECK SECTOR NJN BKR6 IF NOT FIRST SECTOR RJM BOT BACK UP ONE TRACK BKR6 ADC -MPTB CHECK NUMBER OF SECTORS PJN BKR7 IF NUMBER OF SECTORS .GT. BUFFER SIZE LDN 0 POSITION TO FIRST SECTOR BKR7 STD T7 SET SECTOR STM BKRA LDD T6 SAVE CURRENT TRACK STM BKRB LMD FS+1 NJN BKR8 IF NOT FIRST TRACK LDD T7 NJN BKR8 IF NOT FIRST SECTOR LDN FSMS SET FIRST SECTOR STD T7 STM BKRA STM BBUF,BI AOD BI UJN BKR10 CONTINUE PROCESSING AT BOI * SCAN TRACK AND SET END OF RECORD POSITIONS. BKR8 LDC BFMS+DTSF READ NEXT SECTOR HEADER WORDS RJM RNS SHN -6 CHECK WORD COUNT NJN BKR10 IF FULL SECTOR LDD T7 SET SECTOR STM BBUF,BI LDM BFMS CHECK CONTROL BYTE NJN BKR9 IF EOR LDM BFMS+1 CHECK FOR EOI ZJN BKR11 IF EOI ENCOUNTERED LDC 4000 SET EOF STATUS RAM BBUF,BI BKR9 AOD BI ADVANCE BACKSPACE INDEX BKR10 LDD T7 CHECK CURRENT POSITION LMD FS+3 NJN BKR8 IF CURRENT POSITION NOT REACHED LDD T6 LMD FS+2 NJN BKR8 IF CURRENT POSITION NOT REACHED LDM RCRF SHN 21-11 MJN BKR11 IF NOT AT ORIGINAL POSITION * IGNORE END OF RECORD IF CURRENT POSITION REACHED LDD T1 CHECK WORD COUNT OF SECTOR SHN -6 NJN BKR11 IF NOT END OF RECORD SOD BI DECREMENT INDEX BKR11 ENDMS END MASS STORAGE OPERATION LDM RCRF SET POSITION CHANGED FLAG LPC 6777 LMD TH STM RCRF LDD BI ZJN BKR12 IF BACKSPACE INDEX EMPTY LJM BKR1 RETURN NEXT RECORD LOCATION BKR12 LDD FS+3 COUNT PRUS TRANSFERRED NJN BKR13 IF NOT NEXT TRACK LDM SLM SECTORS PER TRACK BKR13 SBM BKRA RAD PC LJM BKR5 CONTINUE BACKSPACE BOT SPACE 4,15 ** BOT - BACK ONE TRACK. * * ENTRY (T6) = CURRENT TRACK. * (FS+1) = FIRST TRACK. * * EXIT (T6) = PREVIOUS TRACK. * (A) = SECTOR LIMIT FOR TRACK. * * USES T3. * * CALLS SNT. BOT1 LMD T3 SET NEXT TRACK BOT2 STD T6 RJM SNT LMD T3 NJN BOT1 IF NEXT TRACK NOT EQUAL TO CURRENT TRACK LDM SLM BOT SUBR ENTRY/EXIT LDD T6 SAVE CURRENT TRACK STD T3 LDD FS+1 SET FIRST TRACK UJN BOT2 ENTER LOOP CET SPACE 4,10 ** CET - CHECK ERROR TERMINATION. * * EXIT TO *ERR* IF ERROR FLAG TERMINATION. * * USES CM - CM+4. CET SUBR ENTRY/EXIT LDD CP CHECK ERROR FLAG ADN STSW CRD CM LDD CM+1 SBN SPET MJN CETX IF NOT SPECIAL ERROR ERROR EFT *ERROR FLAG TERMINATION* CRT SPACE 4,10 ** CRT - CHECK RECALL TIME. * * ENTRY FIRST CALL STARTS TIMING. ELAPSED TIME OF EACH * INTERVAL IS KEPT TO MINIMIZE CLOCK OVERFLOW. * * EXIT TO *SRC* IF PROCESSING TIME EXCEEDED. * * USES CM - CM+4. CRT2 AOM CRTA INDICATE TIME ACCUMULATION STARTED CRT3 LDD CM+4 SAVE CURRENT CLOCK VALUE STM CRTB CRT SUBR ENTRY/EXIT LDC RTCL READ REAL TIME CLOCK CRD CM LDC 0 ELAPSED TIME CRTA EQU *-1 ZJN CRT2 IF FIRST CALL LDD CM+4 CALCULATE TIME SINCE LAST CALL SBM CRTB PJN CRT1 IF NO OVERFLOW ADC 10000 CRT1 RAM CRTA ACCUMULATED PROCESSING TIME ADC -RSPT MJN CRT3 IF TIME NOT EXCEEDED LJM SRC SET RECALL CONDITIONS CRTB CON 0 PREVIOUS CLOCK VALUE DSC SPACE 4,10 ** DSC - DECREMENT SKIP COUNT. * * EXIT (A) = 0, IF SKIP COMPLETE. * SKIP COUNT IN (IR+2 - IR+3) DECREMENTED BY ONE. * * USES T0. DSC SUBR ENTRY/EXIT LDD IR+3 GET SKIP COUNT SCN 77 STD T0 SHN 6 LMD IR+2 SHN 6 SBN 1 ZJN DSCX IF SKIP COMPLETE SHN 14 RESET SKIP COUNT STD IR+2 SHN -6 SCN 77 LMD T0 LMD IR+3 STD IR+3 LDN 1 INDICATE SKIP NOT COMPLETE UJN DSCX RETURN LRI SPACE 4,15 ** LRI - LOAD RANDOM INDEX. * * ENTRY (FS - FS+4) = FST ENTRY. * * EXIT (FS - FS+4) UPDATED. * (PC) = ACCUMULATED PRU COUNT TRANSFERRED. * TO *CDA*, IF MASS STORAGE ERROR. * * USES PC, T1, T2, T6, T7, CM - CM+4, LM - LM+1, IN - IN+1. * * CALLS BKR, DDT, MSR, RNS, SEI, SMS, VAL. * * MACROS CFET, ENDMS, ERROR, NFA, SFA. LRI SUBR ENTRY/EXIT CFET 7 READ (FET+7) CRD CM LDD CM+3 CHECK INDEX LENGTH SCN 77 SHN 6 LMD CM+2 ZJN LRIX IF INDEX LENGTH = 0 SHN 6 STD LM+1 SHN -14 LPN 37 STD LM LDD CM+3 CHECK FWA LPN 37 STD IN SHN 14 LMD CM+4 STD IN+1 SBN 2 PJN LRI2 IF INDEX ADDRESS .GE. 2 LRI1 ERROR FPE *FET PARAMETER ERROR* LRI2 ADN 2 SHN 6 ADD LM SHN 14 ADD LM+1 SHN -6 SBD FL PJN LRI1 IF INDEX BUFFER LWA+1 .GE. FL LDM RCRF SHN 21-6 MJN LRI6 IF CONTINUATION OF BACKSPACE LDN ZERL CRD CM LDN 0 STD T1 STD T2 * ZERO INDEX AREA. LRI3 LDD IN CLEAR INDEX AREA ADD T1 SHN 6 ADD RA SHN 6 ADD IN+1 ADD T2 CWD CM AOD T2 SHN -14 RAD T1 LMD LM NJN LRI3 IF NOT END OF INDEX AREA LDD T2 LMD LM+1 NJN LRI3 IF NOT END OF INDEX AREA LDD T6 CHECK TRACK NJN LRI5 IF FILE USED LRI4 LJM LRIX RETURN LRI5 RJM SEI SKIP FROM CURRENT POSITION TO EOI LDD T6 LMD FS+1 LRI6 NJN LRI7 IF MORE THAN ONE TRACK ON FILE LDD T7 LMN FSMS ZJN LRI4 IF FILE CONTAINS ONLY AN EOI LRI7 LDN 0 CHECK READ SECURITY RJM VAL VALIDATE FILE ACCESS LEVEL LDD T7 INITIALIZE BACKSPACE SECTOR STM BKRA LDD T6 INITIALIZE BACKSPACE TRACK STM BKRB RJM SMS LOAD MASS STORAGE DRIVER RJM BKR BACKSPACE RECORD LDD PC CHARGE FOR PRUS TRANSFERRED SHN IMPT RAM CFNH+1 SHN -14 RAM CFNH LDN 0 CLEAR PRU COUNT STD PC SFA EST,T5 CHECK IF DEVICE BUFFERED IN ECS ADK EQDE CRD CM LDD CM+4 SHN 3 ADN DILL CRD CM LDD CM+3 SHN 21-13 PJN LRI8 IF DEVICE NOT BUFFERED IN ECS LJM LRI11 PROCESS DIRECT TRANSFER * READ RANDOM INDEX AND STORE INTO BUFFER. LRI8 LDC BFMS READ NEXT SECTOR RJM RNS ZJN LRI9 IF ZERO LENGTH SECTOR AOD PC ADVANCE SECTOR COUNT LDD LM SHN 14 ADD LM+1 SBD T1 PJN LRI10 IF ROOM FOR SECTOR AOM LRIB SET INDEX TOO LARGE FLAG LDD LM+1 STD T1 NJN LRI10 IF ROOM LEFT IN INDEX AREA LRI9 LJM LRI14 COMPLETE PROCESSING LRI10 LDD IN STORE SECTOR SHN 6 ADD RA SHN 6 ADD IN+1 CWM BFMS+2,T1 LDD T1 ADVANCE ADDRESS RAD IN+1 SHN -14 RAD IN LDD LM DECREMENT LENGTH SHN 14 ADD LM+1 SBD T1 STD LM+1 SHN -14 STD LM LDD T1 SHN -6 LRIA ZJN LRI9 IF EOR * UJN LRI9 (AFTER MS ERROR) LJM LRI8 LOOP TO EOR * DIRECT TRANSFER RANDOM INDEX FOR ECS BUFFERED DEVICE. LRI11 LDD IN SET FWA INDEX AREA STD CM+3 SHN 14 ADD IN+1 STD CM+4 RAD LM+1 SET LWA INDEX AREA SHN -14 RAD LM SHN 14 ADD LM+1 SHN 14 STD CM+2 SHN -14 SHN 6 RAD CM+3 LDC RDDS*10000+7777 DIRECT READ TO EOR RJM DDT PJN LRI13 IF NO ERROR SHN 21-20 MJN LRI12 IF TRANSFER TRUNCATED RJM CDA CHECK DEVICE LRI12 AOM LRIB SET INDEX TOO LARGE FLAG LRI13 LDD T4 SET PRU TRANSFERRED COUNT STD PC * COMPLETE PROCESSING. LRI14 ENDMS END MASS STORAGE OPERATION LDD PC CHECK SECTOR COUNT NJN LRI16 IF INDEX TRANSFERRED LDD FC CHECK FOR REWIND REQUEST SHN 21-13 MJN LRI15 IF REWIND REQUESTED NFA FA,R RETAIN ORIGINAL POSITION AND STATUS ADN FSTL CRD FS LDD FS+2 RESET CURRENT POSITION STD T6 LDD FS+3 STD T7 * CLEAR RANDOM FILE BIT. LRI15 CFET 1 READ FIRST CRD CM LDD CM+1 CLEAR RANDOM BIT LPC 3777 STD CM+1 CFET 1 STORE FIRST CWD CM LJM LRIX RETURN * PROCESS INDEX TOO LARGE. LRI16 LDM BFMS+1 SET FET STATUS SHN 2-6 LPN 4 LMN 4 STD FS+4 LRIB LDN 0 * LDN 1 (INDEX TRUNCATED) ZJN LRI18 IF INDEX NOT TRUNCATED LDM ERRA CHECK FOR MASS STORAGE ERROR NJN LRI18 IF MASS STORAGE ERROR LDD FO CHECK ERROR PROCESSING SELECTED SHN 21-10 MJN LRI17 IF ERROR PROCESSING SELECTED ERROR ITL *INDEX TOO LARGE ON OPEN* LRI17 LDC 23S9 SET STATUS = 23B RAD BS+4 SHN -14 RAD BS+3 LDM FETL CHECK FET LENGTH SBN 2 MJN LRI18 IF NO DETAILED STATUS FIELD CFET 6 CLEAR DETAILED STATUS FIELD CRD CM LDN 0 STD CM+3 STD CM+4 CFET 6 CWD CM LRI18 LJM LRIX RETURN SPACE 4,10 ** COMMON DECKS. IRA$ EQU 1 SET INITIALIZATION *CALL COMPCRA LIST X *CALL COMPDDT LIST -X MSR$ EQU 1 DEFINE ERROR PROCESSING *CALL COMPRNS *CALL COMPSEI *CALL COMPSNT *CALL COMPSRA SPACE 4,10 BBUF BSS 0 BACKSPACE BUFFER ERRNG BFMS-BBUF-MPTB CHECK FOR BACKSPACE BUFFER OVERFLOW QUAL EPSO EQU *+5 END OF POSITION OVERLAY .ERPO MAX EWTO,ERDO,EPSO CALCULATE MAXIMUM OVERLAY SIZE ERPO EQU .ERPO ERROR PROCESSING OVERLAY ORIGIN QUAL * TITLE RANDOM ACCESS PROCESSORS. RRD SPACE 4,15 ** RRD - PROCESS RANDOM READ. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (DP - DP+4) = (FET+6). * (FS - FS+4) = FST ENTRY. * * EXIT (FS - FS+4) = ADVANCED FST ENTRY. * (RI - RI+1) = RANDOM ADDRESS. * TO *SFP* TO COMPLETE PROCESSING. * * ERROR TO *ERR* IF RANDOM ADDRESS ERROR. * * CALLS CRA. * * MACROS ERROR. RRD2 LDD FC LPC 1700 ZJN RRD3 IF READ LDD FS+4 SET LAST OPERATION COMPLETE WRITE SCN 16 LMN 6 STD FS+4 RRD3 LDD DP+3 RESET RANDOM ADDRESS STD RI LDD DP+4 STD RI+1 AOM SFPA INDICATE *RI* IS PRESET LJM SFP PROCESS EXIT RRD BSS 0 ENTRY LDD DP+3 SET RANDOM ADDRESS STD RI LDD DP+4 STD RI+1 LDD FS+2 ZJN RRD1 IF FILE NOT WRITTEN ON LDD FS+1 SET FIRST TRACK STD T6 RJM CRA CONVERT RANDOM ADDRESS PJN RRD2 IF SECTOR ON FILE RRD1 ERROR RAD *RANDOM ADDRESS NOT ON FILE* RWT SPACE 4,20 ** RWT - PROCESS RANDOM WRITE. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (DP - DP+4) = (FET+6). * (FS - FS+4) = FST ENTRY. * * EXIT (FC) = UPDATED INTERNAL *CIO* FUNCTION CODE. * (RI - RI+1) = RANDOM ADDRESS. * TO *RRD* IF REWRITE OPERATION. * TO *SFP* IF RANDOM WRITE AT EOI. * * USES T2, T3, T6, CM - CM+4. * * CALLS SEI. * * MACROS ERROR. RWT BSS 0 ENTRY LDD FC SHN 21-12 MJN RRD IF REWRITE FUNCTION LDD DP+2 CHECK FOR REWRITE LPN 40 ZJN RWT1 IF NOT REWRITE IN PLACE LDC 2000 SET REWRITE FLAG IN FUNCTION CODE RAD FC STM ICFC UJN RRD CONVERT RANDOM ADDRESS * RANDOM WRITE AT END OF INFORMATION. RWT1 LDD DP+3 CHECK RETURN ADDRESS LPN 37 STD DP+3 SHN 14 LMD DP+4 SBN 2 MJN RWT2 IF .LT. 2 ADN 2 SHN -6 SBD FL MJN RWT3 IF .LT. FL RWT2 ERROR RWT *INDEX ADDRESS OUT OF RANGE* RWT3 LDD FS+2 CHECK CURRENT TRACK NJN RWT4 IF FILE USED STD T2 SET FIRST SECTOR LDN FSMS STD T3 UJN RWT5 UPDATE RESPONSE WORD * SKIP FROM BEGINNING OF FILE TO EOI AND CALCULATE LENGTH. RWT4 LDD FS+1 STD T6 RJM SEI SEARCH FOR EOI RWT5 LDD DP+3 READ RESPONSE WORD SHN 6 ADD RA SHN 6 ADD DP+4 CRD CM LDD T2 SET RANDOM INDEX STD CM+3 STD RI LDD T3 STD CM+4 STD RI+1 LDD DP+3 STORE RESPONSE WORD SHN 6 ADD RA SHN 6 ADD DP+4 CWD CM AOM SFPA INDICATE *RI* IS PRESET LJM SFP EXIT TITLE POSITION MASS STORAGE PRESET. PRS SPACE 4,15 ** PRS - POSITION MASS STORAGE PRESET ROUTINE. * * ENTRY (FC) = INTERNAL *CIO* FUNCTION CODE. * (FS - FS+4) = FST ENTRY. * * EXIT (T5) = EST ORDINAL. * (T6) = CURRENT TRACK. * (T7) = CURRENT SECTOR. * (BI) = 0. * (RI - RI+1) = 1. * TO *CFN* IF INCORRECT *CIO* FUNCTION CODE. * * USES T1, CM - CM+4. * * CALLS CHG, IRA. PRS BSS 0 ENTRY LDN 0 CLEAR BACKSPACE INDEX STD BI LDD FS SET EST ORDINAL STD T5 LDD FS+2 SET TRACK STD T6 ZJN PRS1 IF FILE NOT USED RJM IRA INITIALIZE RANDOM ACCESS * IDENTIFY FUNCTION. PRS1 LDD FS+3 SET SECTOR STD T7 LDN 0 STD RI PRESET RANDOM INDEX LDN FSMS STD RI+1 LDD FC SET FUNCTION INDEX SHN -6 LPN 17 STD T1 SBN TFPAL PJN PRS2 IF FUNCTION NOT IN TABLE LDM TFPA,T1 SET PROCESSING ADDRESS ZJN PRS2 IF FUNCTION PROCESSOR NOT DEFINED STD T1 LJM 0,T1 JUMP TO PROCESSOR PRS2 LDK SWET SET SYSTEM SOFTWARE ERROR RJM CHG CONDITIONALLY HANG PP LJM CFN COMPLETE FUNCTION TFPA INDEX TABLE OF FUNCTION PROCESSOR ADDRESSES TFPAL1 MAX /CIO/RDF,/CIO/WTF,/CIO/SKP,/CIO/OPE TFPAL EQU TFPAL1+1 TABLE LENGTH INDEX /CIO/RDF,RRD RANDOM READ INDEX /CIO/WTF,RWT RANDOM WRITE INDEX /CIO/SKP,SKP SKIP INDEX /CIO/OPE,OPE OPEN INDEX TFPAL END OF TABLE SMS SPACE 4,10 ** SMS - SET MASS STORAGE DRIVER. * * ENTRY (T5) = EQUIPMENT ORDINAL. * (FS+1) = FIRST TRACK OF LOCAL FILE. * * EXIT DRIVER LOADED. * SYSTEM ACCESS SET IF FILE IS SYSTEM FILE. * * USES CM - CM+4. * * MACROS SETMS. SMS1 SETMS IO SMS SUBR SFA EST,T5 CHECK FOR SYSTEM DEVICE CRD CM LDD CM SHN 21-12 PJN SMS1 IF NOT SYSTEM DEVICE LDN FNTP READ FNT POINTER CRD CM LDD CM SHN 14 ADD CM+1 ERRNZ SYFO CHECK SYSTEM FILE POSITION IN FNT ADK FSTG CRD CM LDD CM+1 LMD FS+1 NJN SMS1 IF NOT SYSTEM FILE * *CIO* IS USED TO ACCESS THE SYSTEM FILE FOR THE LOADER, CCL, * ETC. THE READSYS OPTION CAUSES THE DRIVER TO SELECT THE * SYSTEM DEVICE WITH THE LEAST ACTIVITY. IT ALSO CAUSES THE * DRIVER ERROR PROCESSOR TO AUTOMATICALLY TRY A DIFFERENT * SYSTEM DEVICE WHEN AN ERROR IS ENCOUNTERED. SETMS READSYS UJN SMSX RETURN SPACE 4,10 ** COMMON DECKS. *CALL COMPIRA SPACE 4,10 OVERFLOW MSDO CMS OVERLAY (CLOSE MASS STORAGE.),MSDO CMS SPACE 4,10 ** DIRECT LOCATION ASSIGNMENTS. RI EQU 36 - 37 RANDOM INDEX (2 LOCATIONS) CMS SPACE 4,10 ORG *+2 CLO SPACE 4,15 ** CLO - CLOSE FILE. * * ENTRY (FO) = FET OPTIONS. * (BS - BS+4) = (FET+0). * (FS - FS+4) = FST ENTRY. * * EXIT TO *CLS*. * * USES T5, T6. * * CALLS DRI. CLO BSS 0 ENTRY LDD BS+4 GET CLOSE FUNCTION SHN -3 LPN 7 LMN 5 ZJN CLO2 IF REWIND LMN 3&5 ZJN CLO1 IF NO REWIND LDD BS+4 SET RETURN/UNLOAD FLAG FOR *0DF* SHN -2 LPN 1 LMN 1 RAM CLSA LDN IMRU CHARGE FOR RETURN/UNLOAD RAM TACC+/CIO/CLO LDC DRF&CFN SET COMPLETION ADDRESS CLO1 LMC CFN STM CLSB CLO2 LDM MSFF GET MASS STORAGE FILE FLAG NJN CLO3 IF NOT MASS STORAGE FILE LDD FS+2 ZJN CLO3 IF FILE NOT USED STD T6 SET CURRENT TRACK LDD FS SET EST ORDINAL STD T5 LDD FO CHECK SPECIAL PROCESSING SHN 6 PJN CLO3 IF NOT RANDOM FILE LDM FETL SBN 3 MJN CLO3 IF NO INDEX WORD IN FET LDD FS+4 CHECK WRITE STATUS SHN 21-7 PJN CLO3 IF NOT WRITTEN SINCE LAST OPEN LDM FACF CHECK WRITE LOCKOUT SET LPN 1 NJN CLO3 IF WRITE LOCKOUT SET RJM DRI DUMP RANDOM INDEX CLO3 LJM CLS COMPLETE CLOSE PROCESSING DRI SPACE 4,15 ** DRI - DUMP RANDOM INDEX. * * EXIT TO *WMS* OVERLAY IF RANDOM INDEX TO BE WRITTEN. * (FS+2) = EOI TRACK. * (FS+3) = EOI SECTOR. * (FS+4) = COMPLETE WRITE FST STATUS. * (IN - IN+1) = LWA+1 INDEX AREA. * (LM - LM+1) = LWA+2 INDEX AREA. * (OT - OT+1) = FWA INDEX AREA. * * USES T1, T2, CM - CM+4. * * CALLS EXR, SEI, VAL. * * MACROS ERROR. DRI SUBR ENTRY/EXIT CFET 7 READ (FET+7) CRD CM LDD CM+3 CHECK INDEX LENGTH SCN 77 SHN 6 LMD CM+2 ZJN DRIX IF INDEX LENGTH=0 - RETURN SHN 6 STD T2 SHN -14 LPN 37 STD T1 LDD CM+3 OUT = FWA LPN 37 STD OT SHN 14 LMD CM+4 STD OT+1 SBN 2 PJN DRI2 IF INDEX BUFFER ADDRESS .GE. 2 DRI1 ERROR FPE *FET PARAMETER ERROR* DRI2 ADN 2 SHN 6 ADD T1 SHN 14 ADD T2 STD IN+1 IN = FWA+LENGTH = LWA+1 SHN -6 SBD FL PJN DRI1 IF INDEX BUFFER LWA+1 .GE. FL ADD FL SHN -6 STD IN LDN 1 CHECK WRITE SECURITY RJM VAL VALIDATE FILE ACCESS LEVEL RJM SEI SEARCH FOR END OF INFORMATION LDD T6 SET TRACK STD FS+2 LDD T7 SET SECTOR STD FS+3 LDN 6 SET COMPLETE WRITE FST STATUS STD FS+4 LDD IN LIMIT = IN + 1 SHN 14 ADD IN+1 ADN 1 STD LM+1 SHN -14 STD LM LDC 1L4+WMS SET WRITE OVERLAY NAME RJM EXR EXECUTE ROUTINE SPACE 4,10 ** COMMON DECKS. *CALL COMPSEI SPACE 4,10 OVERFLOW MSDO OMS OVERLAY (OVERWRITE MASS STORAGE.),MSDO SPACE 4,10 ** DIRECT LOCATION ASSIGNMENTS. NT EQU 36 EOI/NEXT TRACK LINK TC EQU 37 TRACK COUNT BEFORE PP RELEASE SPACE 4,10 ORG *+2 OVW SPACE 4,15 ** OVW - OVERWRITE FILE. * * ENTRY (BS - BS+4) = (FET+0). * (FA) = FNT ENTRY NFL RELATIVE ADDRESS. * (FS - FS+4) = FST ENTRY. * (PC) = 0. * * EXIT TO *COC* IF TO ENTER RECALL STACK. * TO *DRF* IF TO DROP FILE AFTER OVERWRITE. * TO *REW* IF TO REWIND FILE AFTER OVERWRITE. * TO *CDA*, IF RECOVERABLE MASS STORAGE ERROR. * * CALLS GNT, IBP, WDS, WEI. * * MACROS ENDMS, SETMS. OVW BSS 0 ENTRY LDD FA ZJN OVW2 IF NO FNT ENTRY LDM FACF CHECK FILE MODE LPN 30 ZJN OVW1 IF NO RESTRICTIONS ERROR IFM *INCORRECT MODIFICATION* OVW1 LDM RCRF CHECK FOR CONTINUATION OF FUNCTION SHN 21-6 MJN OVW4 IF FUNCTION PREVIOUSLY INITIALIZED LDD FS+2 NJN OVW3 IF FILE USED OVW2 LJM OVW11 REWIND OR DROP FILE OVW3 LDN FSMS SET CURRENT SECTOR = FIRST SECTOR STD FS+3 LDD FS+1 SET CURRENT TRACK = FIRST TRACK STD FS+2 RJM GNT GET NEXT TRACK SBN FSMS ZJN OVW2 IF EOI ONLY ON FILE OVW4 RJM IBP INITIALIZE BUFFER WITH PATTERN LDD FS+3 SET CURRENT SECTOR STD T7 LDD FS+2 SET CURRENT TRACK STD T6 RJM GNT GET EOI/NEXT TRACK LINK SETMS IO,,WDSB LDN 0 STD TC CLEAR TRACK COUNT LDD PC STD T1 OVW5 AOD TC CALCULATE TRACK COUNT BEFORE PP RELEASE LDM SLM RAD T1 SBK RWPC MJN OVW5 IF ALLOWED TO WRITE MORE TRACKS OVW6 LDD T7 SET NEXT SECTOR LINKAGE ADN 1 STM BFMS STD FS+3 SBM SLM NJN OVW7 IF NOT AT END OF TRACK STD FS+3 RESET TO FIRST SECTOR LDD NT SET NEXT TRACK LINK STM BFMS STD FS+2 RJM GNT GET NEXT TRACK LINK ZJN OVW7 IF EOI IN FIRST SECTOR OF NEXT TRACK SOD TC NJN OVW7 IF NOT TRACK COUNT LIMIT AOM COCA SET TO ENTER RECALL STACK LDC LDCI+WLSF/10000 STM OVWA OVW7 LDD FS+3 SBD NT NJN OVW7.1 IF NOT LAST SECTOR BEFORE EOI LDN 77 SET EOR ON LAST SECTOR BEFORE EOI STM BFMS+1 OVW7.1 LDC BFMS+WCSF WRITE SECTOR * LDC BFMS+WLSF (ENTER RECALL STACK) OVWA EQU *-2 RJM WDS PJN OVW7.2 IF NO ERROR LPN 77 LMN PARE ZJN OVW7.2 IF MEDIA ERROR CONTINUE RJM CDA CHECK DEVICE OVW7.2 AOD PC INCREMENT PRU COUNT LDD FS+2 STD T6 LDD FS+3 STD T7 SBD NT ZJN OVW9 IF EOI ENCOUNTERED LDM COCA NJN OVW8 IF TRACK COUNT LIMIT LJM OVW6 WRITE NEXT SECTOR OVW8 ENDMS AOM COCA LDN 2 SET WRITE MODE FLAG STD FS+4 LJM COC ENTER RECALL STACK OVW9 RJM WEI WRITE EOI LDD IR+3 SHN -6 SBN 2 MJN OVW10 IF FUNCTION COMPLETE LDC -100 RAD IR+3 LDD FS+1 SET CURRENT TRACK = FIRST TRACK STD FS+2 LDN FSMS SET CURRENT SECTOR = FIRST SECTOR STD FS+3 SOD TC ZJN OVW8 IF TRACK COUNT LIMIT LJM OVW4 PROCESS NEXT DATA PATTERN OVW10 ENDMS LDM CFNB SET FILE WRITTEN FLAGS LPN 74 LMN 03 STM CFNB OVW11 LDD BS+4 CHECK OVERWRITE FUNCTION CODE LPN 10 ZJP REW IF TO REWIND FILE LDN 0 SELECT *0DF* RETURN FUNCTION LJM DRF DROP FILE GNT SPACE 4,10 ** GNT - GET NEXT TRACK POINTER. * * ENTRY (A) = CURRENT TRACK POINTER. * (FS - FS+4) = FST ENTRY. * * EXIT (A) = (NT) = NEXT TRACK POINTER. * (T2) = CURRENT TRACK POINTER. * (T5) = EQUIPMENT IF INITIAL CALL. * * USES NT, T2, CM - CM+4. * * MACROS SFA. GNT2 SHN -2 READ TRT WORD GNTB ADC ** ADD TRT BASE ADDRESS CRD CM LDD T2 SET BYTE INDEX LPN 3 STD NT LDM CM,NT GET NEXT TRACK POINTER STD NT GNT SUBR ENTRY/EXIT STD T2 SAVE CURRENT TRACK POINTER GNT1 LDD FS SET EQUIPMENT * UJN GNT2 (TRT ADDRESS PRESET) GNTA EQU *-1 STD T5 SFA EST GET EST ENTRY ADK EQDE CRD CM LDD CM+4 MST ADDDRESS / 10 SHN 3 ADN TRLL READ TRT POINTER CRD CM LDD CM+3 EXTRACT TRT ADDRESS LPN 77 SHN 14 LMD CM+4 SBD TH COMPENSATE FOR TRACK LINK FLAG (4000/4) STM GNTB+1 SET TRT BASE ADDRESS SHN -14 RAM GNTB ISTORE GNTA,(UJN GNT2) LDD T2 UJN GNT1 GET NEXT TRACK POINTER IBP SPACE 4,10 ** IBP - INITIALIZE BUFFER WITH PATTERN SELECTION. * * EXIT (BFMS+1 - BFMS+501) INITIALIZED. * * USES T1, T2. IBP SUBR ENTRY/EXIT LDC BFMS+2 STD T1 LDD IR+3 GET PATTERN SELECTION LPC 377 STD IR+3 SHN -6 STD T2 LDM TWPS,T2 STD T2 IBP1 LDD T2 INITIALIZE BUFFER STI T1 AOD T1 LMC BFMS+502 NJN IBP1 IF MORE WORDS TO INITIALIZE LDD HN SET BUFFER WORD COUNT STM BFMS+1 UJN IBPX RETURN TWPS BSS 0 TABLE OF WORD PATTERN SELECTIONS LOC 0 CON 0 CON 5252 CON 7777 CON 0 LOC *O SPACE 4,10 ** COMMON DECKS. *CALL COMPWEI WDSB SPACE 4,10 ** WDSB - WRITE ERROR PROCESSING BUFFER. * THIS BUFFER IS USED STRICTLY BY THE DRIVER ERROR PROCESSOR * WHEN A WRITE ERROR IS ENCOUNTERED ON THE SECTOR PREVIOUS TO * A SECTOR CURRENTLY BEING WRITTEN. THIS SPACE MAY BE * OVERLAYED BY THE ERROR PROCESSING OVERLAY. WDSB EQU * ERRNG BFMS-WDSB-502 WDSB EXTENDS INTO BFMS SPACE 4,10 OVERFLOW MSDO,BFMS ERP OVERLAY (ERROR PROCESSOR.),ERPO ERP SPACE 4,10 ORG *+2 UJN ERP ENTER ERROR PROCESSOR SPACE 4,35 *** RETURN OF UNRECOVERABLE MASS STORAGE ERROR STATUS. * * WHENEVER A MASS STORAGE DEVICE RETURNS AN ERROR STATUS OR THE * DEVICE DRIVER DETECTS AN ERROR, AN ERROR STATUS IS PLACED IN * THE STATUS FIELD OF THE FET. IF THE USER ERROR PROCESSING BIT * IS SET IN THE FET *SP* FIELD, FURTHER *DETAIL* STATUS IS * RETURNED TO THE USER ; IF NOT SET, A MESSAGE IS ISSUED TO THE * DAYFILE AND THE JOB IS ABORTED. * * ERROR STATUS (STATUS FIELD) * 002 END OF DEVICE (TRACK LIMIT). * 004 PARITY ERROR. * 023 RANDOM INDEX TOO LARGE FOR INDEX BUFFER. * 022 OTHER ERROR. * * DETAIL ERROR STATUS (DEC FIELD) (ONLY IF *EPR* SET) * X001 PARITY ERROR. * X002 ADDRESS ERROR. * X003 DEVICE STATUS ERROR. * X004 6681 FUNCTION REJECT. * X005 DEVICE RESERVED. * X006 DEVICE NOT READY. * 4007 TRACK LIMIT. (DEVICE FULL) * 0000 OTHER ERROR. * * IF, AFTER A READ ERROR (WITH *EPR* SET), THE SYSTEM * DETERMINES THAT THE PROPER PRU WAS READ (ALTHOUGH IT * PROBABLY CONTAINS BAD DATA) THEN *X* ABOVE IS ZERO, THE * DATA IS PLACED IN THE BUFFER, AND THE FILE IS POSITIONED * TO THE NEXT PRU OF THE FILE. IF THE PROPER PRU WAS NOT * READ THEN *X* IS 4, NO DATA IS PLACED IN THE BUFFER, AND * THE FILE IS LEFT POSITIONED AT THE OFFENDING PRU. *CRI* * IS SET AS USUAL. IMR SPACE 4,10 ** IMR - ISSUE MESSAGE AND RETURN TO MAIN PROGRAM. * * ENTRY (A) = ADDRESS TO RETURN TO. * AT *IMR* TO SET RETURN ADDRESS. * AT *IMR1* IF TO USE DEFAULT RETURN ADDRESS (*CFN*). * AT *IMR2* TO SET PP HANG. * * CALLS IDM. * ENTRY TO SET PP HANG. IMR2 LDC CHP SET HANG PP ADDRESS IMR BSS 0 ENTRY ZJN IMR1 IF NO EXIT ADDRESS SPECIFIED STM IMRA SAVE RETURN ADDRESS * ENTRY IF TO USE DEFAULT RETURN ADDRESS (*CFN*). IMR1 RJM IDM ISSUE DAYFILE MESSAGE LDD MA RESTORE T3 - T7 CWM DCSA,ON SBN 1 CRD T3 LJM CFN COMPLETE FUNCTION AND DROP PPU * LJM MSP (PROCESS WRITE OPERATION) * LJM /PMS/SFP (PROCESS POSITION ERROR) * LJM /PMS/LRIX (PROCESS OPEN ERROR - NOT CORRECT SECTOR) * LJM /PMS/LRIX (USER PROCESSING INDEX TOO LARGE ON OPEN) * LJM MSRX (PROCESS SKIP FORWARD - CORRECT SECTOR) * LJM MSRX (PROCESS OPEN ERROR - CORRECT SECTOR) * LJM MSRX (COMPLETE READ - CORRECT SECTOR) * LJM /RMS/CPR (COMPLETE READ - NOT CORRECT SECTOR) * LJM CHP (HANG MESSAGE) IMRA EQU *-1 ERP SPACE 4,20 ** ERP - MAIN ROUTINE. * * ENTRY (ERRA) = ERROR NUMBER * (FC) = INTERNAL *CIO* FUNCTION CODE. * (FO) = FET OPTIONS. * (BS - BS+4) = (FET+0). * * EXIT (BS - BS+4) = UPDATED WITH ERROR STATUS. * TO *ABJ* IF FATAL ERROR. * TO *IMR* IF ERROR PROCESSING SELECTED FOR INDEX * TOO LARGE ERROR. * TO *IMR1* IF WARNING MESSAGE. * TO *IMR2* IF HANG CONDITION. * TO *RES* IF DEVICE ERROR. * * USES EN, T1, T4 - T4+4. * * CALLS PTL, WEI. ERP BSS 0 ENTRY LDM ERRA SET ERROR NUMBER STD EN SBN /CIOERR/HMSL MJN IMR2 IF HANG CONDITION SBN /CIOERR/WMSL-/CIOERR/HMSL PJN ERP1 IF ERROR MESSAGE LDM TMSG+/CIOERR/UCF SET EXTERNAL FUNCTION IN MESSAGE ADN 10D STD T1 LDD BS+4 SHN -6 LPN 7 RAI T1 AOD T1 LDD BS+4 LPN 4 RAI T1 LDD BS+4 LPN 70 SHN 3 RAI T1 LJM IMR1 ISSUE WARNING MESSAGE ERP1 LDN 0 CLEAR RECALL STACK FLAG STM COCA * CHECK FOR EOI NEEDED. LDD EN LMN /CIOERR/DRE NJN ERP3 IF NOT DEVICE ERROR LDD MA RESTORE T3 - T7 CWM DCSA,ON SBN 1 CRD T3 LDM ERSD NJN ERP2.1 IF NO ERROR ON THE FILE LDD FC SHN -6 LPN 17 LMN /CIO/WTF ZJN ERP2 IF WRITE LMN /CIO/CLO&/CIO/WTF NJN ERP2.1 IF NOT CLOSE * WRITE EOI IF FILE WRITTEN ON. ERP2 LDD EN SAVE THE ERROR CODE STM ERPA RJM WEI WRITE AN EOI SECTOR LDC ** ERPA EQU *-1 STD EN ERP2.1 UJP RES RETURN ERROR STATUS * CHECK FOR TRACK LIMIT. ERP3 LDD EN LMN /CIOERR/TKL NJN ERP4 IF NOT TRACK LIMIT RJM PTL PROCESS TRACK LIMIT ERROR * CHECK USER PROCESSING OF ERRORS. ERP4 LDC 22S9 SET STATUS = 22 RAD BS+4 SHN -14 RAD BS+3 LDD EN LMN /CIOERR/ITL NJN ERP6 IF NOT INDEX TOO LARGE ERROR STM ERRA CLEAR ERROR CODE LDD TH SET STATUS = 23B RAD BS+4 ERP5 LJM ABJ ABORT JOB ERP6 LMN /CIOERR/FTL&/CIOERR/ITL ZJN ERP7 IF FILE TOO LONG ERROR LMN /CIOERR/LFL&/CIOERR/FTL ZJN ERP7 IF LOCAL FILE LIMIT ERROR LMN /CIOERR/PRL&/CIOERR/LFL ZJN ERP7 IF PRU LIMIT ERROR LMN /CIOERR/RAD&/CIOERR/PRL ZJN ERP7 IF RANDOM ADDRESS ERROR LMN /CIOERR/BLE&/CIOERR/RAD NJN ERP5 IF NOT BUFFER CONTROL WORD ERROR ERP7 LDD CP CHECK IF SUBSYSTEM ADK JCIW CRD CM LDD CM+2 SBK LSSI MJN ERP5 IF NOT SUBSYSTEM LJM IMR1 TREAT ERROR AS WARNING RES SPACE 4,10 ** RES - RETURN ERROR STATUS. * * ENTRY (T4) = (RDCT) AT THE TIME OF THE ERROR. * * EXIT TO *ERP5* IF ERROR PROCESSING NOT SELECTED. * TO *IMR* TO ISSUE DAYFILE MESSAGE. * * CALLS MDE, SES. * PROCESS DRIVER DETECTED DEVICE ERROR. RES BSS 0 ENTRY LDD T4 GET ERROR STATUS RJM MDE MAP DISK ERROR RJM SES ZJN ERP5 IF ERROR PROCESSING NOT SELECTED LDD FC GET PROCESSOR ADDRESS SHN -6 LPN 17 STD T1 LDM RESB,T1 STM RESA LJM * ENTER PROCESSOR RESA EQU *-1 * PROCESS SKIP ERROR. RES1 LDN 0 STD FS+4 CLEAR FST STATUS LDD FC SHN -13 NJN RES2 IF BACKWARD SKIP LDD T4 CHECK IF CORRECT SECTOR READ SHN -13 NJN RES2 IF INCORRECT DATA LDD HN+LJMI* SET TERMINATOR STM /PMS/SKFA LDC /PMS/SFP STM /PMS/SKFA+1 UJN RES5 RETURN TO CALLER * PROCESS WRITE/REWIND/RETURN/UNLOAD/EVICT ERRORS. RES2 LDM RESC,T1 GET CONTINUATION PROCESSOR RES3 LJM IMR ISSUE DAYFILE MESSAGE * PROCESS OPEN ERROR. RES4 LDD T4 SHN 21-11D PJN RES2 IF WRONG SECTOR READ LDC UJNI-ZJNI SET STOP AFTER SECTOR WRITE RAM /PMS/LRIA RES5 LDM CDA GET RETURN ADDRESS UJN RES3 ISSUE DAYFILE MESSAGE * PROCESS CLOSE/OVERWRITE ERROR. RES6 LDM ERSD ZJP RES2 IF NO ERROR ON THE FILE LDC RRF EXIT TO RESET POINTERS UJP RES3 ISSUE DAYFILE MESSAGE AND RETURN * PROCESS READ ERROR. RES7 LDC 4000 SET ERROR FLAG IN CONTROL WORD RAM BFMS+2-5 LDN 0 SET STOP FOR CONTROL WORD READ LOOP STM /RMS/CRDB UJP RES5 RETURN TO CALLER RES8 LDD T4 SHN 21-11D MJN RES2 IF WRONG SECTOR READ LDD FC CHECK READ FUNCTION SHN 21-5 MJN RES7 IF *READCW* SHN 21-12-21+5+22 PJN RES9 IF NOT *READSKP* LDC LDNI+0 STM /SMR/RSKB LDD HN+LJMI* SET TERMINATION STM /SMR/RSKC LDC /SMR/RSK13 STM /SMR/RSKC+1 RES9 LDC /RMS/CPR SET STOPS FOR BUFFER READ LOOP STM /RMS/BRDE STM /RMS/BRDF STM /RMS/EOFA LDD HN+LJMI* SET TERMINATION STM /RMS/BRDT LDC /RMS/BRD2 STM /RMS/BRDT+1 LJM RES5 ISSUE DAYFILE MESSAGE RESB INDEX TABLE OF ERROR COMPLETION PROCESSORS INDEX /CIO/RDF,RES8 READ INDEX /CIO/WTF,RES2 WRITE INDEX /CIO/SKP,RES1 SKIP INDEX /CIO/OPE,RES4 OPEN INDEX /CIO/CLO,RES6 CLOSE INDEX /CIO/REW,RES2 REWIND INDEX /CIO/RET,RES2 RETURN/UNLOAD INDEX /CIO/EVI,RES2 EVICT INDEX /CIO/OVW,RES6 OVERWRITE INDEX /CIO/MFC RESC INDEX TABLE OF FUNCTION CONTINUATION ROUTINES INDEX /CIO/RDF,/RMS/CPR READ INDEX /CIO/WTF,/WMS/WMS3 WRITE INDEX /CIO/SKP,/PMS/SFP SKIP INDEX /CIO/OPE,/PMS/LRIX OPEN INDEX /CIO/CLO,/WMS/WMS3 CLOSE INDEX /CIO/REW,RRF REWIND INDEX /CIO/RET,RRF RETURN/UNLOAD INDEX /CIO/EVI,RRF EVICT INDEX /CIO/OVW,/OMS/OVW10 OVERWRITE INDEX /CIO/MFC ABJ SPACE 4,15 ** ABJ - ABORT JOB. * * ENTRY (EN) = ERROR NUMBER. * (FC) = INTERNAL *CIO* FUNCTION CODE. * (BS - BS+4) = (FET+0). * * EXIT TO *IMR1* FOR EXIT TO *CFN*. * * USES T1, CM - CM+4. * * CALLS CTI. * * MACROS MONITOR. * SET CONTROL POINT ERROR FLAG. ABJ BSS 0 ENTRY LDM TEPO,EN SET CONTROL POINT ERROR FLAG SHN -6 ZJN ABJ1 IF NO ERROR FLAG STD CM+1 SET ERROR FLAG MONITOR CEFM ABJ1 LDD EN LMN /CIOERR/ARG NJN ABJ2 IF NOT ARGUMENT ERROR STD BS CLEAR FILE NAME STM CFND PREVENT WRITE OF FET+0 UJN ABJ3 COMPLETE ABORT PROCESSING ABJ2 LDD FO CHECK FET OPTIONS SHN 21-10 PJN ABJ3 IF ERROR PROCESSING NOT SELECTED LDN 0 CLEAR DETAILED STATUS FIELD IN FET STD T1 RJM SDS ABJ3 LDD FC NJN ABJ4 IF INTERNAL FUNCTION DEFINED STM TACC PREVENT ACCOUNTING FUNCTION CHARGE * SET UP FET DUMP REQUEST. ABJ4 LDM TEPO,EN CHECK ERROR CONTROL LPN 1 ZJN ABJ5 IF FET DUMP NOT NEEDED LDD CP READ PPDW ADC PPDW STD T1 CRD CM LDD IR+3 SET DUMP LENGTH AND FET ADDRESS LPN 77 SHN 14 LMM FETL ADN 5 SHN 6 STD CM+3 LDD IR+4 STD CM+4 LDD T1 REWRITE PPDW CWD CM ABJ5 LJM IMR1 ISSUE MESSAGE TMSG SPACE 4,10 ** TMSG - TABLE OF MESSAGE ADDRESSES. * INDEXED BY ERROR CODE. * *T, 12/ ADDR * ADDR ADDRESS OF MESSAGE TMSG EQU *-1 LOC TMSG+/CIOERR/MEC TEPO SPACE 4,10 ** TEPO - TABLE OF ERROR PROCESSING OPTIONS. * INDEXED BY ERROR CODE. * *T, 6/ EF, 5/ 0, 1/F * * EF ERROR FLAG. * F = 1 IF FET DUMP NEEDED. TEPO EQU *-1 ARG MSG (FET ADDRESS OUT OF RANGE),PPET,0 ASD MSG (ASSIGNED FOR DIAGNOSTICS, FILE ),PPET,0 BLE MSG (BUFFER CONTROL WORD ERROR ON ),PPET,0 BUF MSG (BUFFER ARGUMENT ERROR ON ),PPET,1 DRE MSG (DEVICE ERROR ON FILE ),PPET,0 EFT MSG (ERROR FLAG TERMINATION, FILE ),0,0 EXO MSG (I/O ON EXECUTE-ONLY FILE ),PPET,0 FLN MSG (INCORRECT FILE NAME ),PPET,0 FPE MSG (FET PARAMETER ERROR ON ),PPET,1 FSQ MSG (I/O SEQUENCE ERROR ON FILE ),PPET,0 FTL MSG (FILE TOO LONG, FILE ),PPET,0 IEQ MSG (INCORRECT EQUIPMENT ON FILE ),0,0 IFM MSG (INCORRECT MODIFICATION OF ),PPET,0 IRQ MSG (INCORRECT I/O REQUEST ON FILE ),PPET,1 ITL MSG (INDEX TOO LARGE ON OPEN, FILE ),PPET,1 IWR MSG (WRITE ON READ-ONLY FILE ),PPET,0 LFL MSG ,FLET,0 LNF MSG (FILE ACCESS LEVEL CONFLICT, ),SVET,0 LNJ MSG (JOB ACCESS LEVEL CONFLICT, ),SVET,0 PRL MSG (PRU LIMIT, FILE ),TKET,0 RAD MSG (RANDOM ADDRESS NOT ON FILE ),PPET,1 RUD MSG (REQUEST UNDEFINED ON DEVICE, ),PPET,1 RWT MSG (INDEX ADDRESS OUT OF RANGE FOR ),PPET,1 TKL MSG ,0,1 TNA MSG (M.T. NOT AVAILABLE ON FILE ),PPET,0 UCF MSG (UNNECESSARY CIO FCT. 000 ON ),0,0 WDP MSG (WRITEDOWN PROHIBITED ON ),SVET,0 MEC MSG BOS SPACE 4,10 ** BOS - BACKUP ONE SECTOR. * BOS1 LMD T3 SAVE TRACK NUMBER BOS2 STD T6 RJM SNT GET NEXT TRACK LMD T3 NJN BOS1 IF NOT EQUAL TO CURRENT TRACK LDM SLM SET SECTOR TO END OF TRACK SBN 1 STD T7 BOS SUBR SOD T7 DECREMENT SECTOR PJN BOSX IF SAME TRACK LDD T6 SAVE CURRENT TRACK STD T3 LDD FS+1 START WITH FIRST TRACK UJN BOS2 ENTER LOOP CHP SPACE 4,10 ** CHP - CONDITIONALLY HANG PP. * * EXIT TO *CFN*. * * CALLS CHG. CHP LDK SWET SET SYSTEM SOFTWARE ERROR FLAG RJM CHG CONDITIONALLY HANG PP LJM CFN COMPLETE FUNCTION TITLE ERROR PROCESSOR SUBROUTINES. MDE SPACE 4,15 ** MDE - MAP DISK ERROR. * * ENTRY (A) = DETAILED ERROR CODE FROM DRIVER. * 6/, 8/, 4/DC * DC = DRIVER ERROR CODE. * * EXIT (A) = 6/0,8/NC,4/CC * NC = NOT CHANGED FROM INPUT. * CC = CPU ERROR CODE EQUIVALENT TO *DC* IF *DC* * IN EQUIVALENCE TABLE, OTHERWISE *DC*. * * USES T0, T1. MDE1 LDD T0 RESTORE ORIGINAL ERROR CODE MDE SUBR ENTRY/EXIT STD T0 SAVE ORIGINAL ERROR CODE LPN 77 GET DRIVER ERROR CODE STD T1 SBN MXDE PJN MDE1 IF CODE NOT IN TABLE LDM MDEA,T1 GET EQUIVALENT CPU ERROR CODE SBD T1 MAP DRIVER CODE TO CPU CODE ADD T0 UJN MDEX EXIT LIST G MDEA CON CEC.LN ISHARED RETURN-ON-INACCESSIBLE DEVICE ECHO 1,ERRCODE=("DREC") CON CEC._ERRCODE "TXT._ERRCODE" LIST * PTL SPACE 4,20 ** PTL - PROCESS TRACK LIMIT. * * ENTRY (EN) = ERROR NUMBER. * (FO) = FET OPTIONS. * * EXIT (EN) = */ERR/EFT* IF SPECIAL ERROR FLAG SET ON CP. * TRACK LIMIT SYSTEM EVENT ISSUED. * TO *MSP* IF USER PROCESSING OF TRACK LIMIT REQUESTED * (AND NO SPECIAL ERROR FLAG SET ON CP). * TO *COC* IF NOT USER PROCESSING OF TRACK LIMIT * (AND NO SPECIAL ERROR FLAG SET ON CP). * * USES CM - CM+4. * * CALLS SES. * * MACROS MONITOR. PTL3 LDN /CIOERR/EFT *ERROR FLAG TERMINATION* STD EN STM ERRA PTL SUBR ENTRY/EXIT LDN ZERL SET TRACK LIMIT EVENT CRD CM LDN TKLE STD CM+4 MONITOR EATM LDD CP CHECK ERROR FLAG ADN STSW CRD CM LDD CM+1 SBN SPET PJN PTL3 IF SPECIAL ERROR TYPE ADN SPET-ODET ZJN PTL3 IF OPERATOR DROP ERROR FLAG ADN ODET-FSET ZJN PTL3 IF FORCED ERROR ADN FSET-TAET ZJN PTL3 IF USER BREAK TWO ADN TAET-TIET ZJN PTL3 IF USER BREAK ONE LDD FO CHECK USER PROCESSING SHN 21-11 PJN PTL1 IF NOT USER PROCESSING LDC TLME SET TRACK LIMIT ERROR STATUS RJM SES SET ERROR STATUS LJM /WMS/WMS3 COMPLETE WRITE FUNCTION PTL0 LDM OSSM ZJN PTL0.1 IF UNSECURED SYSTEM LDC PTLB+12 SET ACCESS LEVEL MESSAGE ADDRESS STD T1 LDM FSAL GET FILE ACCESS LEVEL SHN 2 ADC TALV RJM ACS MOVE ACCESS LEVEL NAME TO MESSAGE LDC =Z*.* RJM ACS LDC 2R, STM PTLB+11 LDN 0 PTL0.1 UJN PTL2 WRITE CONSOLE MESSAGE PTL1 LDD FS CONVERT UPPER TWO DIGITS OF EST ORDINAL ZJN PTL0 IF NO EQUIPMENT ASSIGNED SHN -3 STD T0 SHN 3 LMD T0 SCN 70 RAM PTLB+1 LDD FS CONVERT LOWER DIGIT OF EST ORDINAL LPN 7 SHN 6 RAM PTLB+2 LCN 3 PTL2 ADC PTLB+3 SET MESSAGE ADDRESS STM PTLA LDD CP WRITE CONSOLE *TRACK LIMIT* MESSAGE ADN MS2W CWM *,TR PTLA EQU *-1 ADDRESS OF MESSAGE AOM COCA SET RECALL STACK FLAG LDN TRLR-PTLR SET TRACK LIMIT REASON CODE RAM ERSA LDC TLRT SET TRACK LIMIT RECALL TIME PERIOD STM ERSB LJM COC SET UP TO ENTER RECALL STACK PTLB DATA C*EQ000, TRACK LIMIT.* BSSZ 4 ACCESS LEVEL NAME SDS SPACE 4,10 ** SDS - SET DETAILED STATUS FIELD IN FET. * * ENTRY (T1) = DETAILED STATUS. * * USES CM - CM+4. * * MACROS CFET. SDS SUBR ENTRY/EXIT LDM FETL CHECK FET LENGTH SBN 2 MJN SDSX IF NO DETAILED STATUS FIELD IN FET CFET 6 SET DETAILED STATUS CRD CM LDN 0 STD CM+3 LDD T1 STD CM+4 CFET 6 CWD CM UJN SDSX RETURN SES SPACE 4,15 ** SES - SET ERROR STATUS. * * ENTRY (A)= DETAIL STATUS CODE. * (FC) = INTERNAL *CIO* FUNCTION CODE. * (FO) = FET OPTIONS. * (BS - BS+4) = (FET+0). * (DP - DP+4) = *IN* POINTER FOR READ FUNCTION. * * EXIT (A) = 0 IF ERROR PROCESSING (EP) NOT SELECTED. * (BS+3 - BS+4)= ERROR STATUS. * DETAIL STATUS SET IN BITS 0-12 OF FET+6. * * USES T0, T1, CM - CM+4. * * MACROS CFET. SES4 LDN 0 SET ERROR PROCESSING NOT SELECTED SES SUBR ENTRY/EXIT LPC 6077 PRESERVE DATA TO BE RETURNED TO FET STD T1 SAVE STATUS CODE LPN 77 LMN PTYE CHECK STATUS CODE STD T0 SET/CLEAR PARITY ERROR FLAG ZJN SES1 IF PARITY ERROR LDD T1 LMC TLME ZJN SES2 IF TRACK LIMIT LDN 22-4 STATUS = 22 SES1 ADN 2 STATUS = 4 SES2 ADN 2 STATUS = 2 SHN 11 LMD BS+4 STD BS+4 SHN -11-3 LMD BS+3 STD BS+3 LDD FO CHECK ERROR PROCESSING SELECTED SHN 21-8D PJN SES4 IF NOT SELECTED LDD FC GET FUNCTION CODE LPC 1700 ADD T0 NJN SES3 IF NOT READ PARITY ERROR LDD DP+3 SAVE *IN* POINTER RAM /RMS/CPRA LDD DP+4 STM /RMS/CPRA+1 SES3 RJM SDS SET DETAILED STATUS LJM SESX RETURN WEI SPACE 4,15 ** WEI - WRITE EOI SECTOR. * * ENTRY (T5) = EST ORDINAL. * (T6) = TRACK WHERE ERROR OCCURED. * (T7) = SECTOR WHERE ERROR OCCURED. * (FS+1) = FIRST TRACK OF FILE. * * EXIT (FS+2) = CURRENT TRACK. * (FS+3) = CURRENT SECTOR. * * USES RC, T6, T7, CM - CM+4. * * CALLS FWB, SCF, SNT, /WEI/WEI. * * MACROS ENDMS, MONITOR, SETMS. WEI SUBR ENTRY/EXIT LDD FC CHECK FOR REWRITE SHN 21-12 PJN WEI1 IF NOT REWRITE LDM /WMS/WEIA CHECK TRACK TABLE STD RC SBD /WMS/NT MJP WEI3 IF TRACK BEYOND EOI USED NJN WEI2 IF NOT AT EOI TRACK LDD T7 CHECK OLD EOI SECTOR SBM /WMS/WEIB WEI1 PJN WEI3 IF EOI NOT INTACT WEI2 LDD T6 SET CURRENT TRACK IN FST STD FS+2 LDD T7 SET CURRENT SECTOR IN FST STD FS+3 LDN 76 ONLY SET FILE WRITTEN IN FST IF REWRITE STM /WMS/WMSB LDN 1 SET FILE WRITTEN STM /WMS/WMSC RJM SCF SET CONTROL BUFFER INDEX INTO FNT RJM FWB FLUSH WRITE DATA FOR BUFFERED DEVICE LDM /WMS/WEIC CHECK TRT MODIFIED LPN 77 ZJP WEIX IF NO TRT UPDATE NEEDED LDM /WMS/WEIB RESET OLD EOI SECTOR STD CM+3 LDI RC RESET OLD EOI TRACK LJM WEI10 RESET EOI IN TRT * BACK UP AND WRITE AN EOI. WEI3 LDD FS+2 NJN WEI3.1 IF SYSTEM SECTOR NOT WRITTEN THIS TIME * SINCE THIS IS THE BEGINNING OF THE FILE, TRY TO START THE * OPERATION OVER AGAIN USING A DIFFERENT TRACK OR DEVICE. RJM /WMS/RWF REWRITE FILE LJM WEIX RETURN WEI3.1 SETMS IO,NS RESET TO CORRECT DRIVER LDM DCSA+1 SHN 21-10 MJN WEI6 IF SECTORS BUFFERED IN THE HARDWARE * SINCE, FOR FULL TRACK DEVICES, THE ERROR COULD HAVE OCCURED * IN THE CURRENT SECTOR OR THE PREVIOUS SECTOR, BACK UP TWO * SECTORS AND WRITE THE EOI. LDD T6 LMD FS+1 NJN WEI4 IF NOT FIRST TRACK LDD T7 SBN FSMS ZJN WEI9 IF FIRST SECTOR SBN 1 ZJN WEI5 IF CAN ONLY BACKUP ONE SECTOR WEI4 RJM BOS BACKUP ONE SECTOR WEI5 RJM BOS BACKUP ONE SECTOR UJN WEI9 WRITE EOI SECTOR * FOR DEVICES THAT HAVE HARDWARE BUFFERING, THE EXACT POINT * AT WHICH THE ERROR OCCURED CANNOT BE DETERMINED. THE EOI * IS WRITTEN AT THE POSITION AT WHICH THE OPERATION STARTED. WEI6 LDD FS+2 RESET POSITION STD T6 LDD FS+3 WEI8 STD T7 WEI9 RJM /WEI/WEI WRITE EOI SECTOR ENDMS END MASS STORAGE OPERATION RJM SCF SET CONTROL BUFFER INDEX INTO FNT RJM FWB FLUSH WRITE DATA FOR BUFFERED DEVICE LDD T7 DROP UNUSED TRACKS STD FS+3 SET CURRENT SECTOR IN FST STD CM+3 LDD T6 STD FS+2 SET CURRENT TRACK IN FST WEI10 LPC 3777 STD CM+2 LDD T5 STD CM+1 LDM PMFF CHECK FILE TYPE NJN WEI11 IF NOT DIRECT ACCESS PERMANENT FILE LDC 4000 SET DEVICE CHECKPOINT RAD CM+1 WEI11 MONITOR DTKM RESET EOI LDM CFNJ COMPUTE NET STORAGE SBD CM+3 SHN 14 ADM CFNJ+1 SBD CM+4 PJN WEI12 IF MORE SECTOR ALLOCATED THAN RETURNED LDN CICS CHANGE TO INCREMENT FUNCTION STM CFNI LDD CM+3 SBM CFNJ SHN 14 ADD CM+4 SBM CFNJ+1 WEI12 STM CFNJ+1 SET SECTOR COUNT SHN -14 STM CFNJ LJM WEIX RETURN IDM SPACE 4,10 ** IDM - ISSUE DAYFILE MESSAGE. * * ENTRY (ERRA) = (EN) = ERROR NUMBER. * (BS - BS+4) = (FET+0). * * USES T1. * * CALLS ALS, DFM. IDM SUBR ENTRY/EXIT LDC BUFA SET BUFFER ADDRESS STD T1 LDC 1R *100 STI T1 LDM TMSG,EN MOVE MESSAGE ZJN IDMX IF NO MESSAGE RJM ACS LDD BS+3 CLEAR 8TH CHARACTER STM IDMA SCN 77 STD BS+3 LDN BS MOVE NAME RJM ACS LDC =Z* AT * ADD * AT * RJM ACS LDD IR+3 ADD FET ADDRESS LPN 77 SHN 14 ADD IR+4 RJM ANS LDC =Z*.* ADD PERIOD RJM ACS LDC BUFA ISSUE MESSAGE RJM DFM LDD EN LMN /CIOERR/LNF NJN IDM1 IF FILE ACCESS LEVEL COULD BE ADVANCED * ISSUE *MFFI* ACCOUNT FILE MESSAGE IF THE FILE ACCESS LEVEL * COULD NOT BE ADVANCED TO THE THE JOB ACCESS LEVEL. LDC SVAM+3 SET MESSAGE ADDRESS STD T1 LDN BS MOVE FILE NAME RJM ACS LDC =Z*, * RJM ACS LDM JSAL GET NAME OF JOB ACCESS LEVEL SHN 2 ADC TALV RJM ACS MOVE ACCESS LEVEL NAME LDC =Z*.* RJM ACS LDC SVAM+ACFN ISSUE ACCOUNT FILE MESSAGE RJM DFM IDM1 LDC * RESTORE STATUS FIELD IDMA EQU *-1 STD BS+3 LJM IDMX RETURN SVAM DATA 6HMFFI, BSSZ 12 SPACE 4,10 ** COMMON DECKS. *CALL COMPACS *CALL COMPANS *CALL COMPSNT VAL$ SET 1 *CALL COMPVLC SPACE 4,10 USE LITERALS BUFA BSS 0 SPACE 4,10 OVERFLOW ERPO,BFMS ERRNG BFMS-BUFA-26D TTL 1MS - MASS STORAGE INPUT/OUTPUT. TITLE 1MS - MASS STORAGE INPUT/OUTPUT. END