PROC ALT$RP; # TITLE ALT$RP - SSALTER REQUEST PROCESSOR. # BEGIN # ALT$RP # # ** ALT$RP - SSALTER REQUEST PROCESSOR. * * *ALT$RP* PROCESSES THE *SSALTER* TYPE 5 REQUESTS. * * PROC ALT$RP * * ENTRY P = ADDRESS OF TYPE 5 *UCP* REQUEST BLOCK. * * EXIT THE *UNIT DEVICE TABLE* TRANSMITTED, OR THE *UNIT * DEVICE TABLE* FIELD CHANGED. # # **** PROC ALT$RP - XREF LIST BEGIN. # XREF BEGIN PROC ABORT; # INTERFACE TO *ABORT* # PROC MESSAGE; # ABORT A *UCP* # PROC KILL$UC; # ABORT A UCP # PROC LLRQENQ; # *LLRQ* ENGUEUER # PROC UCP$RES; # ISSUE RESPONSE TO *UCP* # PROC UCP$WRI; # PASS DATA TO *UCP* # END # **** PROC ALT$RP - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMDECKS # *CALL COMBFAS *CALL COMBCPR *CALL COMBLRQ *CALL COMBUCR *CALL COMBUDT *CALL COMXCTF *CALL COMXLTC *CALL COMXMSC ITEM BYNR U; # OFF/SET BIT ADDRESS # ITEM LLRADR U; # *LLRQ* ENTRY ADDRESS # ITEM PMMR U; # STATUS BIT # ITEM RETCODE U; # RETURN CODE # ITEM STAT U; # STATUS OF *UDT* BIT # ITEM UDTQ U; # UDT ADDRESS # BASED ARRAY UDTBIT [0:0] P(1); # ALTER *UDT* AREA # BEGIN ITEM UDT$BIT U(00,00,60); END IF CPR$RQC[0] LQ REQTYP5"RES5" ## OR CPR$RQC[0] GQ REQTYP5"LSTREQTYP5" THEN BEGIN # IF REQUEST CODE IS INCORRECT # KILL$UC(KILLCODE"INVRQC"); # ABORT THE UCP # RETURN; END # * RETURN THE UNIT DEVICE TABLE TO THE UCP. # IF CPR$RQC[0] EQ REQTYP5"SSA$PUDT" ## THEN BEGIN # TRANFERS THE UDT TO THE UCP # UDTQ = UDTCADR + CPR$ADDR3[0]; UCP$WRI(CPR$ADDR2[0],CPR$ADDR4[0],UDTQ,RETCODE); IF RETCODE EQ SFRCUCPGON THEN BEGIN RETURN; END IF RETCODE EQ SFRCBDUCPA THEN BEGIN KILL$UC(KILLCODE"INVADDR"); RETURN; END IF RETCODE NQ 0 THEN BEGIN FE$RTN[0] = "ALT$RP."; MESSAGE(FEMSG[0],UDFL1); ABORT; END ELSE BEGIN IF INITIALIZE THEN BEGIN # BEFORE INITIALIZATION # LTC$RQR[LTCENTRY] = RESPTYP5"SSA$OK"; END ELSE BEGIN # AFTER INITIALIZATION # LTC$RQR[LTCENTRY] = RESPTYP5"OK5"; END UCP$RES; RETURN; END END # RETURN OF UDT # # * CHANGE A PATH NOD. # UDTQ = CPR$UDTQ[0]+UDTCADR; # UDT RELATIVE ADDRESS # BYNR = CPR$BYNR[0]; # OFF SET BIT ADDRESS # P = UDTQ; IF CPR$PMMR[0] THEN BEGIN PMMR = 1; END ELSE BEGIN PMMR = 0; END STAT = B UDT$BIT[0]; # CHECK FOR BIT ALREADY SET # IF STAT EQ PMMR THEN BEGIN LTC$RQR[LTCENTRY] = RESPTYP5"SSA$UIRC"; UCP$RES; RETURN; END ELSE BEGIN B UDT$BIT[0] = PMMR; # SET OPTION BIT # B UDT$BIT[0] = 1; # SET *ACK* FLAG # END # * CHECK FOR INITIALIZATION. # IF INITIALIZE THEN BEGIN LTC$RQR[LTCENTRY] = RESPTYP5"SSA$OK"; UCP$RES; RETURN; END # * SET UP A *LLRQ* ENTRY. # LLRQENQ(LLRADR); P = LLRADR; LLR$LTCT[0] = LTCENTRY; LLR$UCPRA[0] = UCP$ADDR[0]; LLR$WORD4[0] = CPR3[0]; LLR$WORD5[0] = CPR2[0]; LLR$PRCNME[0] = REQTYP4"INITHW"; LLR$CU[0] = CPR$CUORD[0]; LLR$UDTQ[0] = UDTQ; LLR$BYNR[0] = BYNR; LLR$PMMR[0] = PMMR; LTC$LLRQA[LTCENTRY] = LLRADR; RETURN; END # ALT$PR # TERM PROC CONNECT; # TITLE CONNECT - ESTABLISH LONG TERM CONNECTION. # BEGIN # CONNECT # # ** CONNECT - ESTABLISH LONG TERM CONNECTION. * * *CONNECT* PROCESSES *UCP* CONNECT REQUESTS. * * PROC CONNECT * * ENTRY THE CONNECT REQUEST TO BE PROCESSED IS IN ARRAY * *CPR*. THE BASE POINTER FOR *CPR* IS ALREADY SET. * * EXIT THE LONG TERM CONNECTION HAS BEEN ESTABLISHED, THE * *LTCT* ENTRY FOR THE CONNECTING *UCP* HAS BEEN BUILT, * AND A RESPONSE HAS BEEN SENT BACK TO THE *UCP*. * * MESSAGES * EXEC ABNORMAL, CONNECT.* # # **** PROC CONNECT - XREF LIST BEGIN. # XREF BEGIN PROC ABORT; # INTERFACE TO *ABORT* MACRO # PROC KILL$UC; # ABORT A *UCP* # PROC MESSAGE; # CALLS *MESSAGE* MACRO # PROC SFCALL; # INTERFACE TO *SFCALL* MACRO # PROC UCP$RES; # NOTIFY *UCP* OF REQUEST COMPLETE # END # **** PROC CONNECT - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBCPR *CALL COMBMAP *CALL COMBUCR *CALL COMXCTF *CALL COMXLTC *CALL COMXMSC ITEM J U; # COUNTER # ITEM ORD$MRFT U; # *MRFT* ORDINAL # ITEM UCPSWAPPED B; # UCP WAS SWAPPED OUT # # * ABORT *UCP* IF *DRYUP* FLAG IS SET. # IF DRYUP THEN BEGIN KILL$UC(KILLCODE"CLOSED"); RETURN; END # * REQUESTOR ID HAS TO BE IN RANGE. # IF CPR$RQI[0] EQ REQNAME"RQIFIRST" OR ## CPR$RQI[0] GQ REQNAME"RQILAST" THEN BEGIN KILL$UC(KILLCODE"NOTAUTH"); RETURN; END # * SYSTEM LONG TERM CONNECTION HAS TO BE CLEARED. # IF LTCENTRY NQ 0 THEN BEGIN KILL$UC(KILLCODE"MULCON"); RETURN; END # * 1. MULTIPLE COPIES OF *SSMOVE* CAN BE RUN AT A TIME, HOWEVER, * ONLY ONE COPY OF *SSMOVE* THAT IS IN THE PROCESS OF * DESTAGING FILES CAN BE CONNECTED AT A TIME. *MULTIPLE RUN* * * 2. MULTIPLE COPIES OF *SSLABEL*, *SSDEBUG* OR *SSVAL* CAN NOT * BE CONNECTED. *MULTIPLE RUN* * * 3. *SSLABEL*, *SSDEBUG* OR *SSVAL* CAN NOT BE CONNECTED WHILE * ANOTHER COPY OF THESE UTILITIES ARE CONNECTED. * *UTILITY CONFLICT* * * 4. *SSVAL* CAN NOT BE CONNECTED WHILE *SSMOVE* IS IN THE * PROCESS OF DESTAGING FILES. *SSMOVE* CAN NOT BE CONNECTED * WHEN *SSVAL* IS CONNECTED. *UTILITY CONFLICT* # IF CPR$RQI[0] EQ REQNAME"RQIMOVE" THEN BEGIN # *SSMOVE* REQUEST # IF DSC$FAM NQ 0 THEN BEGIN # MULTIPLE RUN # KILL$UC(KILLCODE"MULRUN"); RETURN; END # MULTIPLE RUN # IF CONIND[REQNAME"RQIVALD"] THEN BEGIN # UTILITY CONFLICT # KILL$UC(KILLCODE"UTLCONF"); RETURN; END # UTILITY CONFLICT # END # *SSMOVE* REQUEST # ELSE BEGIN # NOT *SSMOVE* REQUEST # IF CONIND[CPR$RQI[0]] THEN BEGIN # MULTIPLE RUN # KILL$UC(KILLCODE"MULRUN"); RETURN; END # MULTIPLE RUN # ELSE BEGIN # NOT MULTIPLE RUN # IF (CPR$RQI[0] EQ REQNAME"RQILABL") ## OR (CPR$RQI[0] EQ REQNAME"RQIDBUG") ## OR (CPR$RQI[0] EQ REQNAME"RQIVALD") THEN BEGIN # *SSLABEL*, *SSDEBUG* OR *SSVAL* REQUEST # IF ((CONIND[REQNAME"RQILABL"]) ## OR (CONIND[REQNAME"RQIDBUG"]) ## OR (CONIND[REQNAME"RQIVALD"])) ## OR ((CPR$RQI[0] EQ REQNAME"RQIVALD") AND (DSC$FAM NQ 0)) THEN BEGIN # UTILITY CONFLICT # KILL$UC(KILLCODE"UTLCONF"); RETURN; END # UTILITY CONFLICT # END # *SSLABEL*, *SSDEBUG* OR *SSVAL* REQUEST # END # NOT MULTIPLE RUN # END # NOT *SSMOVE* REQUEST # # * FIND AN EMPTY LONG TERM CONNECT TABLE ENTRY AND * ASSIGN THE *UCP* TO THE ENTRY. SET THE SYSTEM LONG * TERM CONNECT BIT. # FASTFOR LTCENTRY = 1 STEP 1 UNTIL LTCTCNT DO BEGIN # SEARCH *LTCT* FOR AN EMPTY SLOT # IF LTC$SFJBSN[LTCENTRY] EQ 0 THEN BEGIN # SET UP LONG TERM CONNECTION # UCPSWAPPED = TRUE; REPEAT WHILE UCPSWAPPED DO BEGIN # REPEAT WHILE SWAPPED # SFFC[0] = SFSLTC; SFCALL(SFBLKPTR,RCL); IF SFRC[0] EQ SFRCSWPOUT THEN BEGIN SFFC[0] = SFSWPI; SFCALL(SFBLKPTR,RCL); END ELSE BEGIN UCPSWAPPED = FALSE; END END # REPEAT WHILE SWAPPED # IF SFRC[0] NQ 0 THEN BEGIN # PROCESS UNEXPECTED RESPONSE # IF SFRC[0] EQ SFRCUCPGON THEN BEGIN RETURN; END ELSE BEGIN FE$RTN[0] = "CONNECT."; MESSAGE(FEMSG[0],UDFL1); ABORT; END END # PROCESS UNEXPECTED RESPONSE # LTC$WORD1[LTCENTRY] = UCP$WORD1[0]; LTC$WORD2[LTCENTRY] = 0; LTC$RQI[LTCENTRY] = CPR$RQI[0]; LTC$UCPA[LTCENTRY] = UCP$ADDR[0]; LTC$WORD3[LTCENTRY] = CPR3[0]; CONIND[CPR$RQI[0]] = TRUE; LTC$RQR[LTCENTRY] = RESPTYP1"OK1"; UCP$RES; RETURN; END # SET UP LONG TERM CONNECTION # END # SEARCH *LTCT* FOR AN EMPTY SLOT # # * ABORT IF THERE ARE NO LONG TERM CONNECT TABLE ENTRIES * AVAILABLE. # FE$RTN[0] = "CONNECT."; MESSAGE(FEMSG[0],UDFL1); ABORT; END # CONNECT # TERM PROC KILL$UC((MCODE)); # TITLE KILL$UC - ABORT A *UCP*. # BEGIN # KILL$UC # # ** KILL$UC - ABORT A *UCP*. * * *KILL$UC* ABORTS A *UCP*. * * PROC KILL$UC((MCODE)) * * ENTRY MCODE = MESSAGE CODE ORDINAL. * THE JOB SEQUEUNCE NUMBER FROM THE OFFENDING *UCP* IS * IN ARRAY *UCPR*. THE BASE POINTER FOR *UCPR* IS * ALREADY SET. * * EXIT A DAYFILE MESSAGE HAS BEEN ISSUED TO EXPLAIN WHY THE * *UCP* IS BEING ABORTED, AND AN *SF.REGR* HAS BEEN * ISSUED TO ABORT THE OFFENDING *UCP*. * * MESSAGES * EXEC ABNORMAL, KILL$UC.* * * XXXX ABORTED - NOT CONNECTED.* * * XXXX ABORTED - ALREADY CONNECTED.* * * XXXX ABORTED - MULTIPLE REQUESTS.* * * XXXX ABORTED - MULTIPLE RUN.* * * XXXX ABORTED - INCORRECT REQUEST TYPE.* * * XXXX ABORTED - INCORRECT REQUEST CODE.* * * XXXX ABORTED - UTILITY CONFLICT.* * * XXXX ABORTED - CARTRIDGE ACTIVE.* * * XXXX ABORTED - SSEXEC IS CLOSED.* * * XXXX ABORTED - INCORRECT ADDRESS.* * XXXX = JOB SEQUENCE NUMBER. * # ITEM MCODE U; # MESSAGE-CODE ORDINAL # # **** PROC KILL$UC - XREF LIST BEGIN. # XREF BEGIN PROC ABORT; # INTERFACE TO *ABORT* MACRO # PROC MESSAGE; # INTERFACE TO *MESSAGE* MACRO # PROC SFCALL; # INTERFACE TO *SFCALL* MACRO # END # **** PROC KILL$UC - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBUCR *CALL COMXLTC *CALL COMXMSC # * ABORT MESSAGE DEFINITION. # ARRAY DISPMESS [0:0] S(5); BEGIN ITEM MESSJBSN C(00,00,04); # JOB NAME # ITEM MESSFLR C(00,24,03) = [" "]; ITEM MESSABT C(00,42,10) = ["ABORTED - "]; ITEM MESSREASON C(01,42,21); ITEM MESSTERMTR C(03,48,12) = [0]; END # * REASON WHY *UCP* IS BEING ABORTED. # ARRAY ABTREASON [KILLCODE"NOTAUTH":KILLCODE"LASTCODE"] S(3); BEGIN ITEM REASONMESS C(00,00,21) = ["NOT AUTHORIZED.", "NOT CONNECTED.", "ALREADY CONNECTED.", "MULTIPLE REQUESTS.", "MULTIPLE RUN.", "INVALID REQUEST TYPE.", "INVALID REQUEST CODE.", "UTILITY CONFLICT.", "CARTRIDGE ACTIVE.", "SSEXEC IS CLOSED.", "INVALID ADDRESS.", "LAST ENTRY."]; END # * REASON CODE HAS TO BE WITHIN RANGE. # IF MCODE LS KILLCODE"NOTAUTH" OR MCODE GQ KILLCODE"LASTCODE" THEN BEGIN FE$RTN[0] = "KILLUCP."; MESSAGE(FEMSG[0],UDFL1); ABORT; END MESSJBSN[0] = UCP$JBSN[0]; MESSREASON[0] = REASONMESS[MCODE]; MESSAGE(DISPMESS,3); # * ABORT THE *UCP* VIA A *SFCALL* REQUEST. # REPEATREGR: SFFP[0] = 0; SFUCPA[0] = 2; SFSCPA[0] = LOC(DISPMESS); SFFC[0] = SFREGR; SFJBSN[0] = UCP$JBSN[0]; SFFSTA[0] = UCP$FSTA[0]; SFCALL(SFBLKPTR,RCL); # * SWAPIN *UCP* IF OUT. # IF SFRC[0] EQ SFRCSWPOUT THEN BEGIN SFFC[0] = SFSWPI; SFCALL(SFBLKPTR,RCL); GOTO REPEATREGR; END # * ABORT IF *SFERROR* NOT *UCP* ABORTED OR UNDEFINED. # IF SFRC[0] NQ 0 THEN BEGIN IF SFRC[0] NQ SFRCUCPGON THEN BEGIN FE$RTN[0] = "KILLUCP."; MESSAGE(FEMSG[0],UDFL1); ABORT; END END RETURN; END # KILL$UC # TERM PROC LINK$RP; # TITLE LINK$RP - PRELIMINARY LINKAGE PROCESSING. # BEGIN # LINK$RP # # ** LINK$RP - PRELIMINARY LINKAGE PROCESSING. * * *LINK$RP* DOES PRELIMINARY PROCESSING OF *UCP* LINKAGE * REQUESTS AND THEN CALLS THE APPROPRIATE MODULE TO DO * THE DETAILED PROCESSING OF THE REQUEST. * * PROC LINK$RP * * ENTRY THE TYPE 1 UCP REQUEST TO BE PROCESSED IS IN ARRAY * *CPR*. THE BASE POINTER FOR *CPR* IS ALREADY SET. * * EXIT THE TYPE 1 REQUEST HAS BEEN PROCESSED AND A RESPONSE * HAS BEEN SENT BACK TO THE UCP INDICATING COMPLETION * OF THE REQUEST. # # **** PROC LINK$RP - XREF LIST BEGIN. # XREF BEGIN PROC CONNECT; # ESTABLISH LONG TERM CONNECTION # PROC KILL$UC; # ABORT A *UCP* # PROC SFCALL; # INTERFACE TO *SFCALL* MACRO # PROC UCP$DON; # TERMINATE *UCP* REQUEST PROPERLY # END # **** PROC LINK$RP - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBCPR *CALL COMBUCR *CALL COMXMSC # * LIST FOR PROCESSING LINKAGE REQUESTS. # SWITCH TYP1SW:REQTYP1 PRCON:CONNECT, PRDISC:DISCONNECT; # * REQUEST CODE HAS TO BE A VALID LINKAGE REQUEST CODE. # IF CPR$RQC[0] EQ REQTYP1"RES1" ## OR CPR$RQC[0] GQ REQTYP1"LSTREQTYP1" THEN BEGIN KILL$UC(KILLCODE"INVRQC"); RETURN; END # * PROCESS THE APPROPRIATE LINKAGE REQUEST AND THEN RETURN TO * THE CALLER. # GOTO TYP1SW[CPR$RQC[0]]; PRCON: CONNECT; RETURN; PRDISC: UCP$DON; RETURN; END # LINK$RP # TERM PROC QUE$RP; # TITLE QUE$RP - QUEUABLE REQUEST PROCESSOR. # BEGIN # QUE$RP # # ** QUE$RP - QUEUABLE REQUEST PROCESSOR. * * *QUE$RP* DOES PRELIMINARY PROCESSING OF TYPE 4 *UCP* REQUESTS. * A LOW LEVEL REQUEST QUEUE ENTRY IS SET UP. FOR AN UNLOAD * CARTRIDGE REQUEST, THE UTILITY CARTRIDGE TABLE IS CLEARED. * * PROC QUE$RP * * ENTRY POINTERS TO THE UCP REQUEST BEING PROCESSED AND * THE *LTCT* ENTRY CORRESPONDING TO THE REQUEST HAVE * BEEN SET. * * EXIT IF AN INCORRECT REQUEST CODE OR A UTILITY CONFLICT IS * DISCOVERED, THE UCP WILL BE ABORTED AND CONTROL WILL * RETURN TO THE CALLER. * * NOTES *QUE$RP* MUST NOT BE CALLED IF THE *LLRQ* IS FULL. # # **** PROC QUE$RP - XREF LIST BEGIN. # XREF BEGIN PROC ADD$LNK; # ADD ENTRY TO END OF CHAIN # PROC KILL$UC; # ABORT A UCP # PROC LLRQENQ; # *LLRQ* ENQUEUER # END # **** PROC QUE$RP - XREF LIST END. # DEF LISTCON #0#; *CALL COMBFAS *CALL COMBCHN *CALL COMBCPR *CALL COMBLRQ *CALL COMXLTC *CALL COMXMSC *CALL COMBUCR ITEM LLRADR U; # *LLRQ* ENTRY ADDRESS # SWITCH REQCODE:REQTYP4 REQ1:LOAD$CART, REQ2:UNLD$CART, REQ3:CP$RAW$AU, REQ4:WRT$LAB, REQEND:LSTREQTYP4; CONTROL EJECT; IF CPR$RQC[0] LQ REQTYP4"RES4" ## OR CPR$RQC[0] GQ REQTYP4"LSTREQTYP4" THEN # IF REQUEST CODE IS INCORRECT # BEGIN KILL$UC(KILLCODE"INVRQC"); # ABORT THE UCP # RETURN; END IF CPR$RQC[0] EQ REQTYP4"LOAD$CART" THEN # IF LOAD CARTRDIGE REQUEST # BEGIN # LOAD CARTRDIGE REQUEST # IF LTC$CART[LTCENTRY] THEN # IF *UTCT* NOT EMPTY # BEGIN KILL$UC(KILLCODE"MULCART"); # CARTRIDGE ALREADY ACTIVE # RETURN; END ELSE BEGIN # SET UP *LLRQ* ENTRY # LLRQENQ(LLRADR); P = LLRADR; LLR$LTCT[0] = LTCENTRY; LLR$UCPRA[0] = UCP$ADDR[0]; LLR$WORD4[0] = CPR3[0]; LLR$WORD5[0] = CPR2[0]; LTC$LLRQA[LTCENTRY] = LLRADR; END END # LOAD CARTRIDGE REQUEST # IF CPR$RQC[0] EQ REQTYP4"UNLD$CART" THEN # IF UNLOAD CARTRIDGE REQUEST # BEGIN LTC$CART[0] = FALSE; END IF CPR$RQC[0] NQ REQTYP4"LOAD$CART" THEN BEGIN # NO BUILD OF *LLRQ* # P = LTC$LLRQA[LTCENTRY]; LLR$DR[0] = 0; # CLEAR OLD RESPONSE CODE # LLR$PRCST[0] = 0; LLR$RQC[0] = CPR$RQC[0]; # NEW REQUEST CODE # LLR$WORD4[0] = CPR3[0]; LLR$YZ[0] = CPR$YZ[0]; LLR$ADDR2[0] = CPR$ADDR2[0]; END # * SIMULATED CASE COMMAND FOR SETTING PROCESS NAME. # CORCOD: GOTO REQCODE[CPR$RQC[0]]; REQ1: # LOAD CARTRIDGE # LLR$PRCNME[0] = REQTYP4"LOAD$CART"; RETURN; REQ2: # UNLOAD CARTRIDGE # LLR$PRCNME[0] = REQTYP4"UNLD$CART"; GOTO REQEND; REQ3: # COPY RAW STREAM # LLR$PRCNME[0] = REQTYP4"CP$RAW$AU"; GOTO REQEND; REQ4: # WRITE LABEL # LLR$PRCNME[0] = REQTYP4"WRT$LAB"; GOTO REQEND; REQEND: # * END SIMULATED CASE COMMAND FOR SETTING PROCESS NAME. # ADD$LNK(LTC$LLRQA[LTCENTRY],LCHN"LL$READY",0); RETURN; END # QUE$RP # TERM PROC TYP2$RP; # TITLE TYP2$RP - TYPE 2 REQUEST PROCESSOR. # BEGIN # TYP2$RP # # ** TYP2$RP - TYPE 2 REQUEST PROCESSOR. * * *TYP2$RP* DOES PRELIMINARY PROCESSING OF TYPE 2 *UCP* REQUESTS. * THE APPROPRIATE MODULE IS CALLED TO DO DETAILED PROCESSING OF * THE REQUEST. * * PROC TYP2$RP * * ENTRY THE POINTER TO THE *UCP* REQUEST BEING PROCESSED * HAS BEEN SET (BASED ARRAY *CPR*). * * EXIT IF AN INCORRECT REQUEST CODE WAS DETECTED, THE *UCP* * HAS BEEN ABORTED, ELSE *ACTVMF* HAS BEEN CALLED. # # * PROC TYP2$RP - XREF LIST BEGIN. # XREF BEGIN PROC DSSETUP; # SETUP DESTAGE PROCESSING # PROC KILL$UC; # ABORT A *UCP* # PROC SFCALL; # INTERFACE TO *SFCALL* MACRO # PROC UCP$RES; # ISSUE RESPONSE TO A *UCP* # END # * PROC TYP2$RP - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMDECKS # *CALL COMBFAS *CALL COMBCPR *CALL COMBUCR *CALL,COMXLTC *CALL,COMXMSC ITEM STAT U; # STATUS # CONTROL EJECT; IF CPR$RQC[0] LQ REQTYP2"RES2" ## OR CPR$RQC[0] GQ REQTYP2"LSTREQTYP2" THEN # IF INCORRECT REQUEST CODE # BEGIN KILL$UC(KILLCODE"INVRQC"); # ABORT THE *UCP* # RETURN; END # * CALL *DSSETUP* TO INITIATE DESTAGE PROCESSING. * IF PROBLEMS WITH THIS INITIATION OR IF THE NO-WAIT OPTION IS * SELECTED, ISSUE AN IMMEDIATE REPLY TO *SSMOVE*. OTHERWISE, * SAVE THE LONG-TERM CONNECT TABLE ORDINAL SO A REPLY CAN * BE RETURNED UPON COMPLETION OF DESTAGING. # DSSETUP(CPR$FAM[0],STAT); IF STAT NQ 0 THEN BEGIN STAT = RESPTYP2"MRFERR"; END ELSE BEGIN STAT = RESPTYP2"OK2"; IF NOT CPR$NW[0] THEN # CAUSE *SSMOVE* TO BE ROLLED UNTIL DESTAGING IS COMPLETE # BEGIN LTC$SFUCPA[LTCENTRY] = 0; LTC$SFSCPA[LTCENTRY] = 0; LTC$SFFC[LTCENTRY] = SFSWPO; SFCALL(LOC(LTC$WORD0[LTCENTRY]),NRCL); DSC$LTCT = LTCENTRY; RETURN; END END # * REPLY IMMEDIATELY. # LTC$RQR[LTCENTRY] = STAT; UCP$RES; RETURN; END # TYP2$RP # TERM PROC UCP$DON; # TITLE UCP$DON - TERMINATE *UCP* REQUEST PROPERLY. # BEGIN # UCP$DON # # ** UCP$DON - TERMINATE *UCP* REQUEST PROPERLY. * * *UCP$DON* CLEANS UP THE LONG TERM CONNECT TABLE * ENTRY AND ANY OUTSTANDING REQUESTS WHEN A *UCP* * TERMINATES WHILE STILL HAVING A LONG TERM * CONNECTION WITH *SSEXEC*. * * PROC UCP$DON * * ENTRY THE DISCONNECT REQUEST OR TERMINATION NOTICE IS IN * ARRAY *CPR*. THE BASE POINTER FOR *CPR* IS ALREADY * SET. THE *LTCT* ENTRY FOR THE REQUESTING *UCP* IS * POINTED TO BY *LTCENTRY*. * * EXIT THE REQUEST/NOTICE HAS BEEN PROCESSED. * * MESSAGES * EXEC ABNORMAL, UCP$DON.* * * NOTE IT IS ASSUMED THAT THE *LTCENTRY* FOR THE *UCP* * IS SET ON ENTRY. THE REQUEST AREA FOR THE UCP, * AS DEFINED IN *COMBCPR*, IS USED AS A COUNTER * TO CLEAR THE TEST POINTS IF THE CONDITIONS ARE * PROPER. # # **** PROC UCP$DON - XREF LIST BEGIN. # XREF BEGIN PROC ABORT; # ABORTS PROCESSING # PROC ADD$LNK; # ADD ENTRY TO END OF CHAIN # PROC LLRQENQ; # LOW LEVEL REQUEST QUEUE ENQUEUER # PROC MESSAGE; # ISSUES DAYFILE MESSAGE # PROC SFCALL; # INTERFACE TO *SFCALL* MACRO # PROC UCP$RES; # NOTIFY *UCP* OF REQUEST COMPLETION # END # **** PROC UCP$DON - XREF LIST END. # DEF OVERRIDE #3#; # N.OVERRIDE ON UCP # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBCHN *CALL COMBCPR *CALL COMBLRQ *CALL COMBMAT *CALL COMBUCR *CALL COMXCTF *CALL COMXLTC *CALL COMXMSC ITEM I U; # COUNTER # ITEM LLRQE U; # ADDRESS OF THE *LLRQ* FROM *LLRQENQ* # ITEM MATCH B; # LOOP CONTROL FLAG # ITEM RESTRT B=FALSE; # RESTART ALL PROCESSES AT A STEP POINT # ITEM UCPSWAPPED B; # UCP WAS SWAPPED OUT # # * IF THE *UCP* HAS AN *LLRQ* ENTRY, FLAG THE *LLRQ* THAT * * THE *UCP* HAS ABORTED. IF AN CARTRIDGE IS LOADED, CLEAN-UP * WILL UNLOAD THE CARTRIDGE. # IF LTC$LLRQA[LTCENTRY] NQ 0 THEN BEGIN # SET ABORT FLAG # P = LTC$LLRQA[LTCENTRY]; LLR$UCPABT[0] = TRUE; IF LTC$CART[LTCENTRY] ## AND LLR$RS[0] EQ PROCST"COMPLETE" ## AND LTC$RQI[LTCENTRY] NQ REQNAME"RQIDBUG" THEN BEGIN # SET UNLOAD OF CARTRIDGE # LLR$RQC[0] = REQTYP4"UNLD$CART"; LLR$DR[0] = 0; # CLEAR OLD FIELDS # LLR$PRCST[0] = 0; LLR$PRCNME[0] = REQTYP4"UNLD$CART"; ADD$LNK(LTC$LLRQA[LTCENTRY],LCHN"LL$READY",0); END # END OF UNLOAD CARTRIDGE # END # END OF *LLRQ* CLEAN UP # # * CLOSE OUT THE CONNECTION. # LTC$SFSCPA[LTCENTRY] = 0; IF UCP$STAT[0] NQ 0 THEN BEGIN # PROCESS THE *UCP* TERMINATION NOTICE # LTC$SFUCPA[LTCENTRY] = -1; UCPSWAPPED = TRUE; REPEAT WHILE UCPSWAPPED DO BEGIN # PROCESS SWAPPED *UCP* # LTC$SFFC[LTCENTRY] = SFENDT; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT THEN BEGIN LTC$SFFC[LTCENTRY] = SFSWPI; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); END ELSE BEGIN UCPSWAPPED = FALSE; END END # PROCESS SWAPPED *UCP* # END # PROCESS THE *UCP* TERMINATION NOTICE # ELSE BEGIN # PROCESS THE DISCONNECT REQUEST # # * CLEAR THE LONG TERM CONNECT. # LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY]; UCPSWAPPED = TRUE; REPEAT WHILE UCPSWAPPED DO BEGIN # WAIT FOR CONNECTION TO CLEAR # LTC$SFFC[LTCENTRY] = SFCLTC; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT THEN BEGIN LTC$SFFC[LTCENTRY] = SFSWPI; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); END ELSE BEGIN UCPSWAPPED = FALSE; END END # WAIT FOR CONNECTION TO CLEAR # IF LTC$SFRC[LTCENTRY] NQ 0 THEN BEGIN GOTO SFERR; END # * RETURN THE OK1 RESPONSE. # LTC$RQR[LTCENTRY] = RESPTYP1"OK1"; UCPSWAPPED = TRUE; REPEAT WHILE UCPSWAPPED DO BEGIN # WAIT FOR RESPONSE TO BE PROCESSED # LTC$SFFC[LTCENTRY] = SFWRIT; LTC$SFSCPA[LTCENTRY] = LOC(LTC$RQR[LTCENTRY]); LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY] + 2; LTC$SFFP[LTCENTRY] = 1; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT THEN BEGIN LTC$SFFC[LTCENTRY] = SFSWPI; LTC$SFSCPA[LTCENTRY] = 0; LTC$SFFP[LTCENTRY] = 0; LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY]; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); END ELSE BEGIN UCPSWAPPED = FALSE; END END # WAIT FOR RESPONSE TO BE PROCESSED # IF LTC$SFRC[LTCENTRY] NQ 0 THEN BEGIN GOTO SFERR; END # * ACKNOWLEDGE REQUEST COMPLETION. # UCPSWAPPED = TRUE; LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY]; LTC$SFSCPA[LTCENTRY] = 0; LTC$SFFP[LTCENTRY] = 0; REPEAT WHILE UCPSWAPPED DO BEGIN # WAIT UNTIL *ENDT* IS PROCESSED # LTC$SFFC[LTCENTRY] = SFENDT; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT THEN BEGIN LTC$SFFC[LTCENTRY] = SFSWPI; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); END ELSE BEGIN UCPSWAPPED = FALSE; END END # WAIT UNTIL *ENDT* IS PROCESSED # END # PROCESS THE DISCONNECT REQUEST # SFERR: IF LTC$SFRC[LTCENTRY] EQ 0 OR LTC$SFRC[LTCENTRY] EQ SFRCUCPGON OR (LTC$SFRC[LTCENTRY] EQ SFRCUCPNET AND UCP$STAT[0] EQ OVERRIDE) THEN BEGIN # CLEAR THE *LTCT* ENTRY # CONIND[LTC$RQI[LTCENTRY]] = FALSE; LTC$WORD0[LTCENTRY] = 0; LTC$WORD1[LTCENTRY] = 0; LTC$WORD2[LTCENTRY] = 0; LTC$WORD3[LTCENTRY] = 0; RETURN; END # CLEAR THE *LTCT* ENTRY # ELSE BEGIN # UNEXPECTED *SFCALL* RESPONSE # FE$RTN[0] = "UCP$DON."; MESSAGE(FEMSG[0],UDFL1); ABORT; END # UNEXPECTED *SFCALL* RESPONSE # END # UCP$DON # TERM PROC UCP$RES; # TITLE UCP$RES - NOTIFY *UCP* OF REQUEST COMPLETE. # BEGIN # UCP$RES # # ** UCP$RES - NOTIFY *UCP* OF REQUEST COMPLETE. * * *UCP$RES* RETURNS THE REQUEST RESPONSE WORD TO THE *UCP* * AND THEN NOTIFIES THE *UCP* (AND O/S) THAT THE PROCESSING * OF THE REQUEST HAS BEEN COMPLETED. * * PROC UCP$RES * * ENTRY THE *LTCT* ENTRY POINTED TO BY *LTCENTRY* CONTAINS * ALL THE INFORMATION NEEDED. * * EXIT IF THE *UCP* WAS SWAPPED OUT, AN *SF.SWPI* REQUEST * HAS BEEN ISSUED AND THE SWAPPED-UCP FLAG IN THE *LTCT* * ENTRY HAS BEEN SET. OTHERWISE, THE RESPONSE WORD HAS * BEEN WRITTEN BACK TO THE *UCP* AND THE *UCP* HAS BEEN * NOTIFIED THAT PROCESSING OF ITS LAST REQUEST HAS BEEN * COMPLETED. * * MESSAGES * EXEC ABNORMAL, UCP$RES.* * # # **** PROC UCP$RES - XREF LIST BEGIN. # XREF BEGIN PROC ABORT; # ABORTS PROCESSING # PROC MESSAGE; # ISSUES DAYFILE MESSAGE # PROC RTIME; # GETS TIME SINCE DEADSTART # PROC SFCALL; # INTERFACE TO *SFCALL* MACRO # END # **** PROC UCP$RES - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBUCR *CALL COMXCTF *CALL COMXIPR *CALL COMXLTC *CALL COMXMSC # * RETURN REQUEST RESPONSE WORD TO THE *UCP*. # LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY] + 2; LTC$SFSCPA[LTCENTRY] = LOC(LTC$RQR[LTCENTRY]); LTC$SFFP[LTCENTRY] = 1; LTC$SFFC[LTCENTRY] = SFWRIT; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT THEN BEGIN # SWAPPED *UCP* # LTC$UCPSW[LTCENTRY] = TRUE; GLBUCPSW = TRUE; LTC$SFUCPA[LTCENTRY] = 0; LTC$SFSCPA[LTCENTRY] = 0; LTC$SFFC[LTCENTRY] = SFSWPI; SFCALL(LOC(LTC$WORD0[LTCENTRY]),NRCL); IF UCP$EXPIR EQ 0 THEN BEGIN RTIME(RTIMESTAT[0]); UCP$EXPIR = RTIMSECS[0] + UCP$INTV; END RETURN; END # SWAPPED *UCP* # ELSE BEGIN IF LTC$SFRC[LTCENTRY] NQ 0 AND LTC$SFRC[LTCENTRY] NQ SFRCUCPGON THEN # UNEXPECTED RESPONSE # BEGIN FE$RTN[0] = "UCP$RES."; MESSAGE(FEMSG[0],UDFL1); ABORT; END END # * NOTIFY THE *UCP* THAT THE REQUEST IS COMPLETE. # LTC$SFUCPA[LTCENTRY] = LTC$UCPA[LTCENTRY]; LTC$SFSCPA[LTCENTRY] = 0; LTC$SFFP[LTCENTRY] = 0; LTC$SFFC[LTCENTRY] = SFENDT; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); IF LTC$SFRC[LTCENTRY] EQ SFRCSWPOUT THEN BEGIN # *UCP* SWAPPED # LTC$UCPSW[LTCENTRY] = TRUE; GLBUCPSW = TRUE; LTC$SFUCPA[LTCENTRY] = 0; LTC$SFSCPA[LTCENTRY] = 0; LTC$SFFC[LTCENTRY] = SFSWPI; SFCALL(LOC(LTC$WORD0[LTCENTRY]),NRCL); IF UCP$EXPIR EQ 0 THEN BEGIN RTIME(RTIMESTAT[0]); UCP$EXPIR = RTIMSECS[0] + UCP$INTV; END RETURN; END # *UCP* SWAPPED # ELSE BEGIN IF LTC$SFRC[LTCENTRY] NQ 0 AND LTC$SFRC[LTCENTRY] NQ SFRCUCPGON THEN # UNEXPECTED RESPONSE # BEGIN FE$RTN[0] = "UCP$RES."; MESSAGE(FEMSG[0],UDFL1); ABORT; END END # * CLEAR THE REQUEST FROM THE LONG TERM CONNECT TABLE. # LTC$UCPSW[LTCENTRY] = FALSE; LTC$UCPA[LTCENTRY] = 0; LTC$WORD3[LTCENTRY] = 0; RETURN; END # UCP$RES # TERM PROC UCP$RP; # TITLE UCP$RP - PRELIMINARY PROCESSING OF *UCP* REQUESTS. # BEGIN # UCP$RP # # ** UCP$RP - PRELIMINARY PROCESSING OF *UCP* REQUESTS. * * *UCP$RP* DOES PRELIMINARY PROCESSING OF *UCP* REQUESTS AND CALLS * THE APPROPRIATE MODULES TO DO FURTHER PROCESSING OF THE REQUESTS. * * PROC UCP$RP * * ENTRY A NEW *UCP* REQUEST HAS BEEN RECEIVED AND IF * IT IS A TYPE 4 OR 5 REQUEST, AT LEAST ONE *LLRQ* * ENTRY IS AVAILABLE ON THE *LLRQ* FREE SPACE CHAIN. * * EXIT TYPE 4 OR 5 REQUESTS HAVE BEEN ENQUEUED IN THE * *LLRQ* FOR FUTURE PROCESSING. ALL OTHER REQUESTS HAVE * BEEN PROCESSED TO COMPLETION. * * NOTES BEFORE SUBORDINATE ROUTINES ARE CALLED, THE BASE * POINTERS FOR *CPR* AND *UCPR* ARE SET AND *LTCENTRY* * IS SET TO POINT TO THE *LTCT* ENTRY FOR THE *UCP*. # # **** PROC UCP$RP - XREF LIST BEGIN. # XREF BEGIN PROC ALT$RP; # PRELIMINARY PROCESSING OF *SSALTER* REQUESTS # PROC KILL$UC; # ABORT A *UCP* # PROC LINK$RP; # PRELIMINARY LINKAGE PROCESSING # PROC NONQ$RP; # PRELIMINARY PROCESSING OF TYPE 3 REQUEST # PROC QUE$RP; # QUEUABLE REQUEST PROCESSOR # PROC SFCALL; # ISSUES *SFCALL* REQUEST # PROC TYP2$RP; # TYPE 2 REQUEST PROCESSOR # PROC UCP$DON; # TERMINATE *UCP* REQUEST PROPERLY # END # **** PROC UCP$RP - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBCHN *CALL COMBCPR *CALL COMBLRQ *CALL COMBUCR *CALL COMXCTF *CALL,COMXJCA *CALL COMXLTC *CALL COMXMSC ITEM I U; # LOOP COUNTER # ITEM J U; # LOOP COUNTER # ITEM TESTEXIT B; # *FOR* LOOP CONTROL SWITCH # ITEM UCPSWAPPED B; # UCP WAS SWAPPED OUT # # * STATUS SWITCH LIST TO PROCESS TYPE OF REQUEST. # SWITCH TYPSW:TYP TYPE1:TYP1, TYPE2:TYP2, TYPE3:TYP3, TYPE4:TYP4, TYPE5:TYP5; P = LTCTPTR; # * THE FOLLOWING *FOR* LOOP IS THE MAIN CONTROL LOOP OF *UCP$RP*. * THIS LOOP MAINTAINS CONTROL IN THIS PROCEDURE UNTIL THERE ARE * NO MORE *UCP* REQUESTS TO BE STARTED. # SLOWFOR I=0 WHILE RA$SSCINLK[0] ## AND CHN$BOC[LCHN"LL$FRSPC"] NQ 0 DO BEGIN # PROCESS *UCP* REQUEST # P = RA$SSCAP[0]; P = RA$SSCAP[0] + 2; # * SWITCH TO ALTERNATE *UCP* REQUEST RECEIVING AREA. # RA$SSCAP[0] = LOC(UCPPARM[UCPPARMSW]); IF UCPPARMSW EQ 0 THEN BEGIN UCPPARMSW = 1; END ELSE BEGIN UCPPARMSW = 0; END RA$SSCINLK[0] = FALSE; TESTEXIT = FALSE; SFJBSN[0] = UCP$JBSN[0]; SFFSTA[0] = UCP$FSTA[0]; LTCENTRY = 0; FASTFOR J = 1 STEP 1 WHILE J LQ LTCTCNT AND NOT TESTEXIT DO BEGIN # *LTCT* SEARCH # IF UCP$JBSN[0] EQ LTC$SFJBSN[J] ## AND UCP$FSTA[0] EQ LTC$SFFSTA[J] THEN BEGIN # *UCP* HAS AN ENTRY IN THE *LTCT* # TESTEXIT = TRUE; LTCENTRY = J; END # *UCP* HAS AN ENTRY IN THE *LTCT* # ELSE BEGIN TEST J; END END # *LTCT* SEARCH # IF UCP$STAT NQ 0 THEN BEGIN # PROCESS TERMINATION NOTICE FROM O/S # IF TESTEXIT THEN BEGIN # TERMINATING *UCP* WAS CONNECTED # UCP$DON; END # TERMINATING *UCP* WAS CONNECTED # ELSE BEGIN # TERMINATING UCP NOT CONNECTED # SFUCPA[0] = -1; UCPSWAPPED = TRUE; REPEAT WHILE UCPSWAPPED DO BEGIN # WAIT UNTIL *ENDT* IS PROCESSED # SFFC[0] = SFENDT; SFCALL(SFBLKPTR,RCL); IF SFRC[0] EQ SFRCSWPOUT THEN BEGIN SFFC[0] = SFSWPI; SFCALL(SFBLKPTR,RCL); END ELSE BEGIN UCPSWAPPED = FALSE; END END # WAIT UNTIL *ENDT* IS PROCESSED # END # TERMINATING *UCP* NOT CONNECTED # TEST I; END # PROCESS TERMINATION NOTICE FROM O/S # ELSE BEGIN # PROCESS REQUEST FROM *UCP* # IF NOT TESTEXIT THEN BEGIN # NOT IN *LTCT* SO REQUIRE A CONNECT # IF CPR$RQT[0] EQ TYP"TYP1" ## AND CPR$RQC[0] EQ REQTYP1"CONNECT" THEN BEGIN LINK$RP; END ELSE BEGIN KILL$UC(KILLCODE"NOTCON"); END TEST I; END # NOT IN *LTCT* SO REQUIRE A CONNECT # IF LTC$UCPA[LTCENTRY] NQ 0 THEN BEGIN # PREVIOUS REQUEST NOT PROCESSED YET # KILL$UC(KILLCODE"MULREQ"); TEST I; END # PREVIOUS REQUEST NOT PROCESSED YET # IF CPR$RQT[0] EQ TYP"TYP0" OR CPR$RQT[0] GQ TYP"TYPLST" THEN BEGIN # TYPE CODE OUT OF RANGE # KILL$UC(KILLCODE"INVRQT"); TEST I; END # TYPE CODE OUT OF RANGE # # * SET THE LONG TERM CONNECT TABLE ENTRY TO REFLECT THE CURRENT * REQUEST. # LTC$WORD3[LTCENTRY] = CPR3[0]; LTC$UCPA[LTCENTRY] = UCP$ADDR[0]; # * CALL THE APPROPRIATE REQUEST PROCESSOR. # GOTO TYPSW[CPR$RQT[0]]; TYPE1: LINK$RP; TEST I; TYPE2: TYP2$RP; TEST I; TYPE3: NONQ$RP; TEST I; TYPE4: QUE$RP; TEST I; TYPE5: ALT$RP; TEST I; END # PROCESS REQUEST FROM *UCP* # END # PROCESS *UCP* REQUEST # # * RETURN TO THE CALLER WHEN THERE IS NO REQUEST TO * PROCESS OR NO REQUEST CAN BE PROCESSED. # RETURN; END # UCP$RP # TERM PROC UCP$WRI((LLRQADDR2),(WORDCOUNT),(SCPADDR),RSTATUS); # TITLE UCP$WRI - PASS DATA TO *UCP*. # BEGIN # UCP$WRI # # ** UCP$WRI - PASS DATA TO *UCP*. * * *UCP$WRI* ISSUES AN *SF.WRIT* TO TRANSFER INFORMATION BACK * TO THE *UCP*. * * PROC UCP$WRI((LLRQADDR2),(WORDCOUNT),(SCPADDR),RSTATUS) * * ENTRY LLRQADDR2 = DESTINATION OF DATA IN *UCP*. * WORDCOUNT = NUMBER OF WORDS TO BE TRANSFERRED * TO *UCP*. * SCPADDR = SOURCE OF DATA IN THE *SCP*. * * EXIT RSTATUS = *SFCALL* ERROR RETURNED TO THE CALLER. * * NOTE *LTCENTRY* CONTAINS THE ORDINAL OF THE *UCP* LONG * TERM CONNECT TABLE ENTRY. * # ITEM LLRQADDR2 U; # DESTINATION OF DATA IN *UCP* # ITEM WORDCOUNT U; # NUMBER OF WORDS TO BE TRANSFERRED # ITEM SCPADDR U; # SOURCE OF DATA IN *SCP* # ITEM RSTATUS U; # *SFCALL* ERROR RETURNED TO CALLER # # **** PROC UCP$WRI - XREF LIST BEGIN. # XREF BEGIN PROC SFCALL; # INTERFACE TO *SFCALL* MACRO # END # **** PROC UCP$WRI - XREF LIST END. # DEF LISTCON #0#; # DO NOT LIST COMMON DECKS # *CALL COMBFAS *CALL COMBUCR *CALL COMXLTC *CALL COMXMSC # * SET UP AN *SFCALL* REQUEST FOR AN *SF.WRIT* AND ISSUE IT. # LTC$SFUCPA[LTCENTRY] = LLRQADDR2; LTC$SFSCPA[LTCENTRY] = SCPADDR; LTC$SFFP[LTCENTRY] = WORDCOUNT; LTC$SFFC[LTCENTRY] = SFWRIT; SFCALL(LOC(LTC$WORD0[LTCENTRY]),RCL); RSTATUS = LTC$SFRC[LTCENTRY]; RETURN; END # UCP$WRI # TERM