TITLE COMCON - COMMAND DECODER AND SAVEGET ROUTINES - V1754 SUBTTL /PFC/RCC/DAL/JBS 02-OCT-90 SEARCH F,S,DEVPRM $RELOC $HIGH SALL .DIRECT FLBLST ;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED ; OR COPIED ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE. ; ;COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION ; 1973,1974,1975,1976,1977,1978,1979,1980,1982,1984,1986,1988,1990. ;ALL RIGHTS RESERVED. .CPYRT<1973,1990> XP VCOMCN,1754 ;THIS MACRO PUTS VERSION NO. IN STORAGE MAP AND GLOB COMCON::ENTRY COMCON ;ALWAYS LOAD COMCON IF LIBRARY SEARCH ;CALLED FROM CLOCK ROUTINE WHEN 'COMCNT' IS GREATER THAN 0 ;AS SET BY TTY SERVICE ROUTINE ;ALL AC'S HAVE BEEN SAVED BY CLOCK CHANNEL ;THE COMMAND DECODER CALLS TTYCOM WHICH SCANS FOR TTY WHICH TYPED SUBTTL TABLE OF CONTENTS ; TABLE OF CONTENTS FOR COMCON ; ; ; SECTION PAGE ; 1. TABLE OF CONTENTS......................................... 1 ; 2. INTRODUCTION.............................................. 3 ; 3. COMMAND SETUP AND DISPATCH................................ 5 ; 4. COMMAND RETURN AND CLEANUP................................ 12 ; 5. COMMAND TABLE............................................. 14 ; 6. CORE 0 COMMAND............................................ 20 ; 7. PJOB & KJOB COMMANDS...................................... 21 ; 8. START GROUP (START,CSTART,REE,DDT)........................ 23 ; 9. DUMP & DCORE COMMANDS..................................... 25 ; 10. CONTROL-C PROCESSING...................................... 26 ; 11. SET COMMAND AND UUO ; 11.1 DISPATCH.......................................... 29 ; 11.2 JBSET............................................. 30 ; 11.3 PRIVILEGE TESTS................................... 31 ; 11.4 CORMAX AND CORMIN................................. 35 ; 11.5 DAYTIME AND SCHED................................. 40 ; 11.6 OPR, LOGMIN&MAX BATMIN&MAX........................ 41 ; 11.7 WATCH............................................. 42 ; 11.8 DATE.............................................. 44 ; 11.9 SPOOL............................................. 45 ; 11.10 DEFER/NODEFER..................................... 47 ; 11.11 CDR............................................... 48 ; 11.12 DISK STUFF........................................ 49 ; 11.13 ROUTINE TO READ DATE.............................. 51 ; 11.14 ROUTINES TO PRINT WATCH INFO...................... 53 ; 12. CONTINUE, CCONT AND JCONT................................. 57 ; 13. CORE COMMAND.............................................. 60 ; 14. CONTROL-T PRINTOUT........................................ 65 ; 15. SAVE, SSAVE AND GET - COMMAND SETUP....................... 70 ; 16. COMMANDS WHICH RUN PROGRAMS............................... 72 ; 17. ASSIGN, DEASSIGN AND REASSIGN COMMANDS.................... 75 ; 18. ATTACH AND DETACH COMMANDS................................ 92 ; 19. DATASET CONNECT & SYSTEM START............................ 99 ; 20. DAYTIME COMMAND........................................... 100 ; 21. RUNTIME ROUTINE (TIME COMMAND)............................ 101 ; 22. SEND COMMAND.............................................. 102 ; 23. VERSION COMMAND & PRVERS SUBROUTINE....................... 107 ; 24. EXAMINE AND DEPOSIT COMMAND............................... 109 ;CONTINUED ON NEXT PAGE ; 25. TTY COMMAND AND SET TTY COMMAND........................... 113 ; 26. FINISH AND CLOSE COMMANDS................................. 123 ; 27. SUBROUTINES ; 27.1 COMMAND SETUP..................................... 126 ; 27.2 GET A WORD........................................ 127 ; 27.3 GET CHARACTER..................................... 129 ; 27.4 TYPE OUT ROUTINES................................. 130 ; 28. SAVGET ; 28.1 PARAMETERS........................................ 143 ; 28.2 COMMAND SCAN...................................... 144 ; 28.3 RUN AND GETSEG UUO'S.............................. 147 ; 28.4 SAVE A JOB........................................ 148 ; 28.5 "EXE" SAVE FILES.................................. 151 ; 28.6 GET AND RUN COMMANDS.............................. 177 ; 28.7 RUN UUO........................................... 179 ; 28.8 GETSEG UUO........................................ 182 ; 28.9 COMMON CODE....................................... 183 ; 28.10 GET FILE FROM DEVICE (R,RUN,GET,GETSEG)........... 186 ; 28.11 IO ROUTINES....................................... 192 ; 28.12 EXPAND COMPRESSED FILES........................... 195 ; 28.13 SUBROUTINES....................................... 201 SUBTTL INTRODUCTION ;THE COMMAND AND THEN DISPATCHES(PUSHJ) TO APPROPRIATE ;COMMAND SETUP ROUTINE WITH AC'S SET AS: ;J = JOB NUMBER ;F = ADDRESS OF DEVICE DATA BLOCK TYPING COMMAND, IF ANY ;R = ADDRESS OF JOB'S CORE AREA, = 0 IF NO CORE ;S IS SET TO 0, USED FOR ADDRESS OF SUBSEQUENT CALLS ;U = ADDRESS OF LINE DATA BLOCK OF TTY TYPING COMMAND ;W = ADDRESS OF JOB'S PDB ;P4 = JOB STATUS WORD (C(JBTSTS(J))) ;P1 = 0 (USED FOR SAVGET FLAGS) ;P2 = COMMAND NAME (2ND NAME IF SET) ;THE PUSHDOWN LIST CONTAINS: ;LH(M) = 1B0=1B1= 1 (FLAG FOR COMMAND AT COMMAND LEVEL) ; = 1B8-17= COMMAND TABLE ENTRY ;-1 (P) = U = ADDRESS OF LDB ;THE FOLLOWING GLOBAL USAGE PREVAILS: ;T3 LAST INPUT CHARACTER ; ALSO TYPE OUT CHARACTER ;IN GENERAL, T1 - T4 AND P2 - 4 ARE SCRATCH ;AT COMMAND RETURN, IF J = 0 AND A ; JOB WAS REQUIRED, AN ERROR IS ASSUMED. ; ALL OTHER ACS CAN HAVE BEEN CHANGED ;UPON RETURN FROM COMMAND SETUP ROUTINE, A CR-LF IS ADDED TO ;MESSAGE AND TTY IS STARTED ON TTY SPECIFIED BY -1(P) ;SEVERAL COMMAND FLAGS ARE CHECKED BEFORE DISPATCHING TO ;COMMAND SETUP ROUTINES TO SEE IF COMMAND IS LEGAL AT THIS TIME ;SEVERAL MORE FLAGS ARE CHECKED UPON RETURN FROM COMMAND SETUP ;ROUTINES(UNLESS AN ERROR HAS OCCURRED) FOR STANDARD ;COMMAND RESPONSE ;IF AN ERROR OCCURS, THE JOB NO.(J) SHOULD BE 0 ON RETURN ;SO THAT JOB WILL NOT BE INITIALIZED IF FIRST COMMAND. ;ERRMES ROUTINE WILL SET J TO 0 ;SINCE THE COMMAND DECODER IS CALLED FROM THE CLOCK ROUTINE ;COMMAND SETUP ROUTINE MUST RUN TO COMPLETION QUICKLY ;IF A COMMAND FUNCTION CANNOT DO THIS, IT MUST JUST SET ;THE JOB TO RUNABLE STATUS AND RETURN IMMEDIATELY ;OR DELAY THE COMMAND FOR LATER EXECUTION ;THE FOLLOWING AC USAGE PREVAILS FOR TTY IN/OUT: ; ;INPUT: U=LDB, T3=CHARACTER CLOBBERS T1 ; ; CTEXT CLOBBERS W, RETURNS T2=NAME ; SKIPS RETURNS T2=0 ; DEC/OCT IN CLOBBERS P4, RETURNS T2=NUMBER ; PJPGNO CLOBBERS T2,P4, RETURNS P2=USER ; ; ;OUTPUT:U=LDB, T3=CHARACTER CLOBBERS T1,S ; ; CONMES POINTER IN T1 ; OCTPNT/PRTDI8/RADX10 NUMBER IN T1 ; (PRTDI8 CLOBBERS T2) ; PRNAME NAME IN T2 ;P1 ASSIGNMENTS: ; ;PHONLY==1B0 ;PHYSICAL ONLY ;INCREMENT==777777 ;STARTING ADDRESS OFFSET SUBTTL COMMAND SETUP AND DISPATCH COMMAN::SE1ENT ;ENTER SECTION 1 PUSHJ P,TTYCOM## ;SETUP F,U,J, AND W ; FOR ANY TTY WHICH HAS TYPED A COMMAND JRST [AOS CMNOTF## ;NONE FOUND, COUNT THE BUG SOS COMCNT## ;ADJUST COUNT POPJ P,] ;RETURN IFN FTMP, ;TO AVOID JOBSTS UUO RACE PUSHJ P,SVEUB## ;SAVE EBR AND UBR AND SETUP UBR FOR ; THE JOB THE COMMAND IS BEING EXECUTED FOR PUSH P,U ;SAVE TTY LINE DATA BLOCK ADDRESS LDB T1,LDPCMX## ;GET FORCED COMMAND INDEX, IF ANY MOVEM T1,.CPLFC## ;SAVE IT FOR COMPARISON MOVSI T2,LDBCMF## ;IS COMMAND FORCED? TDNN T2,LDBCOM##(U) ; .. JRST COM1 ;NO, TRY USER COMMANDS MOVE T2,TTFCOM##(T1) ;YES. GET SIXBIT NAME OF COMMAND JRST COM1S ;GO FIND IT COM1: PUSHJ P,CTEXT ;SCAN COMMAND NAME, RETURN IT IN T2 COM1Z: CAIE T3,"C"-100 ;BREAK ON CONTROL-C? JRST COM10 ;NO, TRY LOGICAL NAMES MOVE T2,HALTXT## ;YES--TURN COMMAND INTO HALT MOVEI T1,HALTXT##-COMTAB## ;CALCULATE OFFSET IMMEDIATELY MOVE P3,[XWD UNQTAB##,DISP##] ;SET P3=UNIQNESS BITS, DISPATCH TABLE MOVE P4,[XWD -DISPL##,COMTAB##] ;SET P4=-LENGTH,TABLE LOC JRST COM1E ;GO JOIN COMMON CODE COM10: CAMN P4,[XWD -DISPL2##,COMTB2##] ;IN THE MIDDLE OF A SET COMMAND? JRST COM1A ;YES, DON'T SEARCH LOGICAL NAMES JUMPE T2,COM1S ;BLANK COMMAND CANNOT BE REDEFINED JUMPE W,COM1S ;NO USER DEFINED COMMANDS IF NO PDB SKIPN .PDCMN##(W) ;ANY USER DEFINED COMMANDS TO SEARCH THROUGH? JRST COM1S ;THEN USE SYSTEM TABLES MOVE T3,JBTSTS##(J) ;NEED TO SEARCH PATHOLOGICAL NAMES TLNN T3,SWP!SHF ;IS JOB ON DISK OR ON ITS WAY? JRST COM11 ;NO, PROCEED HRRI M,DLYCM ;YES, SET TO SWAP JOB IN PUSH P,(P) ;KEEP THE STACK RIGHT JRST COMDIS ;WAIT FOR IT TO COME IN COM11: CAMN T2,[SIXBIT \R\] ;USER TYPED R COMMAND? JRST COM1S ;YES, THIS CAN'T BE REDEFINED MOVE P4,.PDCMN##(W) ;GET AOBJN POINTER TO COMMAND NAMES MOVE P3,.PDUNQ##(W) ;GET POINTER TO UNIQNESS BITS MOVSI T1,1 ;FLAG INDICATING THIS IS USER-COMMAND SEARCH PUSHJ P,FNDABV ;SEE IF WE CAN FIND A MATCH JRST COM1S ;NO, DEFAULT TO MONITOR'S COMMANDS ;HERE WE SEARCH MONITOR TABLE TO MAKE SURE NO UNIQUENESS CONFLICTS RESULT. TRNE T3,CEXACT!CUNIQ ;DID WE MATCH EXACTLY OR UNIQUELY? JRST COM11C ;YES, DON'T BOTHER WITH MONITOR COMMANDS PUSH P,T1 ;SAVE THE FLAGS,,DISPATCH PUSHJ P,FNDCOM ;GO FIND THE COMMAND IN TABLES JRST COM11A ;ERROR, TAKE USER'S COMMAND POP P,(P) ;ADJUST THE STACK JRST COM1B ;GO JOIN COMMON CODE ;HERE FOR USER COMMAND COM11A: POP P,T1 ;RESTORE THE DISPATCH AND FLAGS TRNE T3,CAMBIG ;WAS THE COMMAND AMBIGUOUS? JRST COM1A0 ;YES, IT STILL IS COM11C: HLRZ T3,T1 ;SAVE BITS ADD T1,.PDUNQ##(W) ;POINT TO DISPATCH FOR THIS COMMAND HRRZS T1 ;CLEAR SECTION CRUD HRL P3,(T1) ;AND SAVE THE DISPATCH IN LH P3 HRRI P3,DISP## ;FOR LATER USE MOVEI T1,PLNTXT##-COMTAB## ;SET UP FOR PATHOLOGICAL RUN COMMAND MOVE P4,[XWD -DISPL##,COMTAB##] ;POINT BACK TO MAIN TABLES MOVE P2,PLNTXT## ;GET SIXBIT COMMAND NAME JRST COM1E ;GO JOIN COMMON CODE ;HERE TO SEARCH MAIN COMMAND TABLES ; WITH T2/ COMMAND COM1S: PUSHJ P,FNDCOM ;FIND THE COMMAND IN THE TABLES JRST COM1A0 ;NOT FOUND, SEE IF ON FRCLIN JRST COM1B ;GO IF NO ERROR ;ENTRY POINT FOR "SET" COMMAND COM1A: SETZ T1, ;NO FLAGS FOR FULL WORD LDB POINTER PUSHJ P,FNDABV ;LOOK IT UP TRNA ;ERROR JRST COM1B ;GO IF NO ERROR COM1A0: MOVE P2,LINTAB##+FRCLIN## ;GET LDB ADDRESS OF FRCLIN CAME P2,U ;UNKNOWN COMMAND TYPED ON FRCLIN? JRST NOSUCH ;USER MISTYPED MOVEI T1,.RNTXT##-COMTAB## ;GET OFFSET OF .RUN COMMAND MOVE P2,T2 ;GET SIXBIT PROG NAME COM1E: HRL M,UNQTAB##(T1) ;GET PREDISPATCH BITS HRR M,DISP##(T1) ;AND GET THE DISPATCH ADDRESS MOVE T2,UNQTAB##(T1) ;GET THE UNIQUENESS BITS CAME P2,PLNTXT## ;USER-DEFINED COMMAND? JRST COM1C ;NO, JOIN COMMON CODE TRZE T3,CM.SAC## ;AUTO-PUSH FLAG LIT? TLO T2,SACFLG ;YES, PROPAGATE JRST COM1C ;AND RE-JOIN COMMON CODE COM1B: CAIL T1,COMPIL##-COMTAB## ;COMPIL-CLASS COMMAND CAILE T1,LASCCL##-COMTAB## TRNA ;NO MOVEI T1,COMPIL##-COMTAB## ;FUDGE DISPATCH OFFSET FOR COMPIL MOVE P2,T1 ;CALCULATE THE OFFSET ADDI P2,(P4) ; INTO THE COMMAND TABLE MOVE P2,(P2) ;AND GET THE SIXBIT PROG NAME OR COMMAND HRRZ M,P3 ;GET DISPATCH ADDI M,(T1) HRR M,(M) HLRZ T2,P3 ;NOW POINT TO UNIQUENESS TABLE ADDI T2,(T1) ;POINT TO THE COMMAND ENTRY HRL M,(T2) ;GET THE BITS MOVE T2,(T2) ;GET THE DISPATCH BITS COM1C: EXCH T2,(P) ;SAVE TABLE OFFSET ON THE STACK PUSH P,T2 ; BUT KEEP U ON TOP ADDI P3,(T1) ;POINT P3 TO DISPATCH ENTRY SKIPGE T1 ;SEE IF ERROR MOVEI P3,COMERD## ;YES--SET DISPATCH HRRZ P4,P3 ;CLEAR LEFT HALF JUNK HRR M,(P4) ;GET DISPATCH TABLE ENTRY MOVE P4,JBTSTS##(J) ;JOB STATUS WORD FOR THIS JOB ;THE FOLLOWING CODE IS THE LAST NOSTALGIC VESTIGE OF FT2741 TLNE P4,JLOG ; WHILE NOT LOGGED IN? JRST NT2741 ;NO--LEAVE ALONE JUMPGE T1,NT2741 ;JUMP IF NOT COMMAND ERROR CAMN T2,[SIXBIT .YQAOS.] ;DID HE TYPE LOGIN WITH WRONG BALL? HRRI M,SET987 ;YES--SET TTY ELEMENT 987 CAMN T2,[SIXBIT .VI.] ;MAYBE THE LEFT ONE? HRRI M,SET988 ;YES--SET TTY ELEMENT 988 SET987==CPOPJ1## SET988==CPOPJ1## NT2741: TRNE P4,JS.DEP ;IS JOB BEING STOPPED ON ERROR SO DAEMON CAN LOG? JRST CHKDLY ;YES, DELAY COMMAND UNTIL DAEMON IS FINISHED LOGGING TLNE P4,JLOG ;IS JOB LOGGED IN? JRST CHKNO ;YES, PROCEED TLNN M,NOLOGIN ;NO, CAN COMMAND PROCEED WITH NO LOGIN? JRST LOGPLE ;NO, TYPE "LOGIN PLEASE" SKIPE [M.RCMP##] ;MAYBE. ARE WE BEING PERMISSIVE? TLNE M,NORCMP ;OR IS THIS COMMAND ALLOWED ANYWAY? JRST CHKNO ;YES, PROCEED MOVEI T1,LDRRMT## ;REMOTE BIT TDNN T1,LDBDCH##(U) ;SEE IF DONE ON A LOCAL TERMINAL JRST CHKNO ;YES, IT'S LEGAL LOGPLE: JSP T1,COMER ;NO, TYPE "LOGIN PLEASE" LOGPLM::ASCIZ /LOGIN please / CHKNO: SETZB P1,R ;CLEAR PHYSICAL I/O FLAG, AND CORE LOCATION JUMPN J,CHKRUN ;JOB NUMBER ALREADY ASSIGNED? TLNE M,NOJOBN ;NO, DOES THIS COMMAND NEED A JOB NUMBER? JRST COMGO ;NO MOVEI J,1 ;YES, SCAN FOR ONE STARTING WITH 1 NUMLOP: HLLZ P4,JBTST2##(J) ;FOR JS.SIP HLR P4,JBTSTS##(J) ;FOR OTHER BITS TDNN P4,[JS.SIP+JNA+JRQ+CMWB] ;OR ONE OF THESE? IFN FTMP,< PUSHJ P,ANYRUN## ;RUNNABLE ANYWHERE? JRST NUMLO1 ;YES, JOB ISN'T REALLY AVAILABLE MOVE P4,JBTSTS(J) ;KEEP REST OF CODE HAPPY > IFE FTMP,< SKIPA P4,JBTSTS(J) ;KEEP OTHER CODE HAPPY JRST NUMLO1 ;JOB ISN'T AVAILABLE > JRST NEWJOB NUMLO1: CAIGE J,JOBMAX## ;YES, IS THE MAX. JOB NO.? AOJA J,NUMLOP ;NO, KEEP LOOKING SKIPG ARFLAG## ;SYSTEM STARTING UP? JRST CHKDLY ;YES--DELAY IT IFN FTNET,< MOVSI T1,LDBCMF## ;WAS THIS COMMAND FORCED? TDNN T1,LDBCOM##(U) JRST NEWJER ;NO, OKAY TO COMPLAIN SKIPGE LDBTTW##(U) ;IF ANF THEN PROBABLY .HELLO/.NETLD JRST CHKDLY ;SO DELAY IT > NEWJER: JSP T1,COMER ;YES, NONE LEFT, PRINT "JOB CAPACITY EXCEEDED" ASCIZ /Job capacity exceeded / NEWJED: JSP T1,COMER ;PRINT "NO FREE DDBs" ASCIZ /Job capacity exceeded (No free TTY DDBs) / NEWJEP: JSP T1,COMER ;Not enough core ASCIZ /Job capacity exceeded (No core for a PDB) / ;EVEN THOUGH THIS IS A NEW JOB NUMBER ;IT MAY HAVE CORE ASSIGNED NOW BECAUSE IT WAS DELAYED ;UNTIL IT COULD BE SWAPPED IN(LOGIN WITH CORE FULL) NEWJOB: SKIPE F,TTYTAB##(J) ;ANY TTY DDB? PUSHJ P,TTYKIL## ;YES--KILL IT OFF SETZB F,TTYTAB##(J) ;KEEP TTYATI HAPPY MOVE U,(P) ;RESTORE U PUSHJ P,TTYATI## ;TRY TO ATTACH TTY TO THIS JOB NUMBER JRST NEWJED ;IF CAN'T, NO DDB'S. SAY NO FREE DDBs PUSHJ P,CREPDB## ;CREATE A PDB FOR THIS JOB JRST [PUSHJ P,TTYKIL## ;KILL TTY DDB OBTAINED ABOVE JRST NEWJEP] ;CAN'T GET A PDB, SAY SO SETZM JBTPRG##(J) PUSHJ P,CLRJBT## ;GO CLEAR ALL THE JOB TABLES AND PDB PUSHJ P,ASICPT## ;ASSIGN INITIAL IN CORE PROTECT MOVE T2,DATE## MOVEM T2,JBTJLT##(J) IFN FTMDA,< MOVEM T2,.PDSTM##(W) ;INITIAL SETTING OF LAST RESET > ;IFN FTMDA SKIPE JBTADR##(J) ;CONTACT BOUNCE ON DLYCM? PUSHJ P,MKADD## ;YES, MAKE SURE JOB IS ADDRESSABLE IFN FTMP,< MOVEM J,COMJOB## ;FOR PTYSER > PUSHJ P,CTLJBU## ;GET PTY DDB IF THERE IS ONE JUMPL T1,NEWJB1 ;JUMP IF NOT PTY CONTROLLED MOVSI T1,DVDIBP ;GET BATCH PTY BIT MOVSI T2,(JB.LBT) ;GET A BATCH JOB BIT TDNE T1,DEVCHR(F) ;IS IT A BATCH PTY ? IORM T2,JBTLIM##(J) ;YES, THEN ITS A BATCH JOB NEWJB1: HRRZ F,LDBDDB##(U) ;RESTORE TTY DDB MOVEI T1,BPTBIT## ;GET INITIAL VALUE OF JS.BPT DPB T1,BPTPTR ;SET IT MOVE T1,TIME## ;INITIALIZE TO TIME OF DAY TLO T1,M.WCH## ;OR IN INITIAL SET WATCH BITS ; (IN CASE THIS JOB GETS AUTOMATIC LOGIN) MOVEM T1,JBTWCH##(J) ;STORE FOR THIS JOB CAMLE J,HIGHJB## ;HIGHEST JOB NUMBER ASSIGNED? MOVEM J,HIGHJB## ;YES,SAVE IT FOR SCHEDULER SCAN OF JOBS IFN FTNET,< PUSHJ P,FNDSTA## ;WHERE IS HE? DPB T1,PDVSTA## ;THAT IS WHERE HIS TTY IS NOW HRRZM T1,JBTLOC##(J) ;AND LOCATE HIM THERE > CHKRUN: IFN FTMP,< TLNE M,NORUN ;CAN COMMAND BE EXECUTED WHILE RUNNING? TLNE P4,RUN ;YES, IS IT JRST CHKRU1 ;YES PUSHJ P,ANYRUN## ;RUN BIT COULD BE OFF BUT THE JOB JRST CHKDLY ; COULD STILL BE THE CURRENT JOB ON ANOTHER CPU > CHKRU1: TLNE P4,RUN ;RUN BIT ON IN JOB STATUS? TLNN M,NORUN ;YES, DOES THIS COMMAND REQUIRE A JOB? JRST CHKBAT ;NO JSP T1,COMER ;YES. RUNERR::ASCIZ /Please type ^C first / CHKBAT: MOVE T1,JBTLIM##(J) ;GET BATCH BIT TLNE T1,(JB.LBT) ;SEE IF BATCH JOB TLNN M,NBATCH ;YES--SEE IF ILLEGAL COMMAND JRST CHKXO ;NO--OK TO PROCEED JSP T1,COMER ;YES--BOMB USER BATMSG: ASCIZ /Illegal in batch job / CHKXO: TRNE P4,JS.XO!JS.RUU ;SEE IF EXECUTE ONLY JOB TLNN M,NXONLY ;YES--SEE IF ILLEGAL COMMAND JRST CHKACT ;NO--OK TO PROCEED JSP T1,COMER ;YES--BOMB USER ILLXOM: ASCIZ /Illegal when execute only / CHKACT: MOVE R,JBTADR##(J) ;XWD PROTECTION,RELOCATION TLNE M,INCORE ;MUST JOB NOT BE SWAPPING OR ; IF JOB HAS CORE ASSIGNED, MUST IT BE ; IN PHYSICAL CORE (RATHER THAN DISK OR ON ITS WAY) TLNN P4,SWP!SHF ;YES, IS JOB ON DISK OR ON ITS WAY? JRST CHKCO2 ;NO HRRI M,DLYCM ;ASSUME JOB MUST BE IN PHY CORE ; SO SET TO SWAP JOB IN JRST COMDIS ;WAIT FOR JOB CHKDLY: HRRI M,DLYCM1 ;NO, JUST DELAY COMMAND UNTIL SWAP OUT OR IN IS FINISHED JRST COMDIS ;AND DISPATCH TO DELAY COMMAND CHKCO2: TLNE M,NOACT ;CAN COMMAND BE PERFORMED WITH ACTIVE DEVICES? PUSHJ P,RUNCHK ;NO, RETURN IF JOB STOPPED AND NO ACTIVE DEVICES TLNE M,NOCORE ;DOES THIS COMMAND NEED CORE? JRST COMGO ;NO. GO DISPATCH JUMPN R,CHKXPN ;YES, IS CORE IN MEMORY? JSP T1,COMER ;NO, PRINT "NO CORE ASSIGNED" ASCIZ /No core assigned / CHKXPN: TLNN M,INCORE ;DOES THIS COMMAND NEED CORE TO BE EXPANDED? JRST COMGO ;NO HLRE S,USRHCU## ;YES, IS CORE STILL COMPRESSED(SAVE DID NOT GO ; TO COMPLETION) JUMPGE S,COMGO ;LH=-2 DURING SAVE, WHEN CORE COMPRESSED ;LH=-1 DURING SAVE OF HIGH SEG, OR GET OF LOW ; OR HIGH SEG CAME P2,FCOTXT## ;IS THIS A FORCED CONTINUE? CAMN P2,CONTXT## ; OR CONTINUE COMMAND? JRST COMGO ;YES, DON'T EXPAND (LET SAVE FINISH) PUSHJ P,CLRASA ;CLEAR EXEC MODE UUO FLAG AOJGE S,COMGO ;JUMP IF DON'T NEED TO EXPAND S0PSHJ EXPAND ;NO, EXPAND CORE FIRST JFCL ;IGNORE ADDRESS CHECK ERROR, WE TRIED MOVSI T1,JERR ;SET JERR SO CONT WON'T WIN IORM T1,JBTSTS##(J) ; (WOULD GET ADR CHK IF ATTEMPTED) JRST CHKDLY ;DELAY COMMAND BECAUSE COMMAND DECODER ACS ARE ; ALL GONE, NEXT TIME JOBHCU WILL BE 0 NOSUCH: PUSH P,(P) ;SO COMDIS DOESN'T SCREW UP THE STACK SKIPA M,[NOCOM] ;GET THE ERROR ROUTINE COMER:: HRRI M,ERRMES ;CALL ERROR MESSAGE ROUTINE HRLI M,NOINCK!CMDERR ;SET APPROOPRIATE BITS COMGO: TLNN P4,CMWB ; WAS JOB IN COMM WAIT TLZ M,CMWRQ ;NO, CLEAR REQUEUE BIT IN DISP. FLAGS MOVSI S,CMWB ;CLEAR CMWB ANDCAM S,JBTSTS##(J) TLNE P4,CMWB ;IF NOT IN COMMAND WAIT, SKIPN .PDCMN##(W) ;OR NO USER-DEFINED COMMANDS, JRST COMDIS ;THEN DON'T NEED THIS MOVSI T2,LDBCMF## ;COMMAND FORCED BIT TDNN T2,LDBCOM##(U) ;SEE IF ON TLO M,CMWRQ ;NO, DEMAND A REQUEUE TO FIX UP AFTER DLYCOM COMDIS: POP P,T2 ;GET BACK THE OFFSET FROM THE STACK EXCH T2,(P) ;KEEPING U THERE TLNE M,CMDERR ;COMING IN FROM AN ERROR? JRST COMDS1 ;YES, JUST DISPATCH TLNN M,CMWRQ ;CMWRQ ON IN PREDISPATCH? (SEE COMGO) TLZA T2,CMWRQ ;NO, CLEAR IT IN POST DISPATCH FLAGS TLO T2,CMWRQ ;YES, SET IT IN POST DISPATCH FLAGS HLL M,T2 ;NO, GET THE REAL FLAGS COMDS1: MOVEI S,0 ;CLEAR S FOR SETTING DISPATCH ADDRESSES TLO M,FLMCOM!FLMCLV ;SET COMMAND AT COMMAND LEVEL FLAGS MOVEM P,.CPISF## ;SAVE PDL FOR DLYCOM & ABORTC S0PSHJ <(M)> ;DISPATCH TO COMMAND IN SECTION 0 JFCL ;IGNORE ERROR RETURN SUBTTL COMMAND RETURN AND CLEANUP ;RETURN FROM COMMAND SETUP ROUTINE COMRET: NTDBUG NO,EITHER ;STOP IF NETWORK INTERLOCK NOT RELEASED MOVE T1,.CPLFC## ;GET FORCED COMMAND INDEX BACK POP P,U ;RESTORE TTY LDB ADDRESS HRRZ F,LDBDDB##(U) ;RESTORE TTY DDB IF ANY PUSHJ P,TTYCMR## ;TELL SCNSER COMMAND IS COMPLETED SOS COMCNT## AOS COMTOT## ;KEEP COUNT OF TOTAL COMMANDS PROCESSED ; (DO NOT COUNT DELAYED COMMANDS UNTIL PROCESSED) MOVSI T1,1 ;ALSO KEEP COUNT OF COMMANDS PROCESSED ADDM T1,LDBBCT##(U) ;ON A PER-TERMINAL BASIS FOR ACCOUNT PURPOSES TLNN M,ERRFLG ;ERROR? JRST COMRT1 ;NO, PROCEED SETZM J ;YES, CLEAR J TLZ M,NOFLM!NOCRLF!NOPER!TTYRNU!TTYRNC!TTYRNW!NOMESS ;ERROR--CLEAR PROBLEM BITS TLO M,NOINCK+CMWRQ ;YES, JOB NUMBER REQUIRED, BUT NONE IN J. ; PRINT ERROR MESSAGE ONLY, AND ; REQUEUE JOB IF NECESSARY. COMRT1: MOVSI P4,JNA ;JOB STATUS WORD TLNN M,NOINCK ;SUPPRESS JOB INIT. CHECK? TDOE P4,JBTSTS##(J) ;NO, IS JOB INIT BIT ALREADY SET? JRST PCRLFA ;YES. MOVSI P4,JNA ;GET JNA BIT AGAIN IORB P4,JBTSTS##(J) ;NO, SO SET IT THIS COMMAND PUSHJ P,TTYATI## ;ATTACH TTY TO JOB JFCL ;IGNORE IF CAN NOT(SHOULD NEVER HAPPEN) PCRLFA: MOVEI T1,JDCON ;CLEAR JDCON SO THAT A RUNNING JOB TLNE M,TTYRNU!TTYRNC!TTYRNW ;WILL NOT BE THE "JCONT INVABLE" FROM ANDCAM T1,JBTSTS##(J) ;ANOTHER TTY TLNE M,NOMESS ;SEE IF MESSAGE SUPPRESSED JRST PCRLF0 ;YES--SKIP WATCH TLNE M,TTYRNU!TTYRNC!TTYRNW ;COMMAND START JOB UP (TTY IN EITHER MODE)? S0PSHJ WCHBEG ;YES, PRINT [HH:MM:SS] STARTED TO WAIT FOR RESPONSE PCRLF0: TLNN M,NOFLM!NOCRLF ;SUPRESS CRLF? PUSHJ P,CRLF ;NO TLNE M,NOPER ;SUPRESS PRINTING PERIOD? JRST PCRLF2 ;YES PUSHJ P,PRDOTM ;NO, GIVE A "." PUSHJ P,CLRPCT## ;RESET STOP COUNTER PUSHJ P,STRTDL## ;ALLOW A DEFERRED LINE TO ECHO IF NEEDED PCRLF2: JUMPE J,PCRLF1 ;JOB DOES NOT RUN IF ERROR OR NO JOB NO. ASSIGNED TLNE M,TTYRNU ;JOB TO RUN WHEN TTY FINISHED TYPING? ; COMMAND RESPONSE (TTY TO USER MODE)? PUSHJ P,TTYUSR## ;YES, CALL SCANNER AND SCHEDULER ROUTINES TLNE M,TTYRNW ;COMMAND RESTART TTY RESPECTING IO WAIT? PUSHJ P,TTYUSW## ;YES. CALL SCANNER ROUTINE AND SCHEDULER TLNE M,TTYRNC ;NO, JOB TO RUN AND REMAIN IN MONITOR MODE? PUSHJ P,SETRUN## ;YES, CALL SCHEDULER ROUTINE PCRLF1: TLNN M,NOMESS ;IS THERE A MESSAGE? PUSHJ P,TTYSTR## ;YES, START TTY TYPING IT OUT TLNE M,ERRFLG ;WAS AN ERROR? PUSHJ P,TSETBI## ;YES--CLEAR TYPE-AHEAD JUMPE F,PCRLF5 ;DON'T KILL NON-EXISTENT DDBS TLNN M,NOJOBN ;WAS NO JOB NUMBER NEEDED? TLNE M,ERRFLG ;OR DID AN ERROR OCCUR? CAIA JRST PCRLF5 MOVSI T1,JNA ;GET JNA LDB T2,PJOBN## ;AND JOB NUMBER SKIPE T2 ;HAVE A JOB? TDNE T1,JBTSTS##(T2) ;AND IS JOB NUMBER ASSIGNED? JRST PCRLF4 ;KILL OFF TTY IF IDLE MOVEI J,(T2) ;COPY JOB NUMBER SETZM TTYTAB##(J) ;ZAP TTY DDB POINTER PUSHJ P,TTYKIL## ;RETURN TTY DDB TO FREE POOL PUSHJ P,KILPDB## ;GIVE BACK PDB CORE TDZA J,J ;DON'T CONFUSE THINGS PCRLF4: PUSHJ P,TTYKLQ## ;KILL OFF TTY IF IDLE PCRLF5: PUSHJ P,DECHJB## ;DECREMENT HIGHJB IF APPROPRIATE IFN FTMP,< SETOM COMJOB## ;NO JOB IN COMCON NOW > JUMPE F,CPOPJ## ;IF NO JOB, QUIT MOVSI T1,LDBDET## ;SHOULD LINE BE DETACHED? TDNN T1,LDBCOM##(U) ;DELAYED BECAUSE OF CMW JRST PCRLF3 ANDCAM T1,LDBCOM##(U) PUSHJ P,PTYDET## ;YES, DO IT NOW PCRLF3: LDB J,PJOBN## ;GET ATTACHED JOB # FROM TTY DDB JUMPE J,CPOPJ## CAME J,.CPJOB## ;NEVER SET JRQ FOR CURRENT JOB! TLNN M,CMWRQ ;REQUEUE JOB AFTER COMMAND WAIT OR ERROR? POPJ P, JRST REQUE## ;YES SUBTTL CORE 0 COMMAND COR0: JUMPE R,CPOPJ## ;RETURN IF JOB DOES NOT HAVE CORE IFN FTFDAE,< PUSHJ P,CHKXTM ;SEE IF AN "EXIT" MESSAGE SHOULD ; BE SENT TO THE FILE DAEMON AND IF ; SO, SEND IT. > JSP T2,MONJOB## ;SET TO RUN MONITOR JOB(PC IN EXEC MODE) ; RETURN HERE AT UUO LEVEL(NO ACS SET UP) MOVEI T2,ESTOP## ;PUT ERROR STOP ON END OF PDL JSP T1,MONSTR## ;START MONITOR JOB BY SETTING UP ACS AND JOB1:: MOVSI T1,JERR ;TURN OFF JERR ANDCAM T1,JBTSTS##(J) ;.. PUSHJ P,RESET## ;RELEASE ALL IO DEVICES ASSIGNED TO THIS JOB IFN FTFDAE,< PUSHJ P,CALLF ;NEED TO CALL FILDAE FOR THIS JOB? PUSHJ P,SNDFXM ;YES, SEND FILDAE AN EXIT MESSAGE > JOB1A:: MOVSI T1,JERR ;TURN OFF JERR ANDCAM T1,JBTSTS##(J) ;.. PUSHJ P,TTYFNU## ;FIND TTY FOR THIS JOB(SETUP J WITH JOB NO.) IFN FTMP,< PUSHJ P,UPMM## ;MUST HAVE THE MM RESOURCE JRST ZAPPG1 ;ZAP THE PROGRAM (UUO LEVEL STYLE) > ZAPPGM:: IFN FTMP,< PUSHJ P,GETMM## ;GET MEMORY MANAGEMENT RESOURCE JRST .-1 ;MUST WAIT IF NOT AVAILABLE > ZAPPG1: PUSHJ P,KILHGA## ;HIGH SEG FOR THIS USER, RETURN CORE ; REMOVE HIGH SEG FROM THIS USER ; LOGICAL ADDRESSING SPACE ; IF NO OTHER USERS IN CORE ARE USING IT ; RETURN DISK SPACE IF NO LONGER SHARABLE HIGH SEG PUSHJ P,INTLVL## ;AT CLOCK LEVEL? PUSHJ P,DSKFLS## ;NO, UUO, CLOBBER ANY POSSIBLE DISK PAGES PUSHJ P,NOCORQ## ;PUT JOB IN NO CORE Q PUSHJ P,CLRTAB ;CLEAR BITS AND TABLE ENTRIES MOVSI T1,(PD.LGO) ;IF A LOGOUT UUO IS IN PROGRESS, TDNE T1,.PDDFL##(W) ; .. JRST JOB2 ; ALWAYS DELETE ALL CORE MOVSI T1,JLOG ;IF NOT LOGGED IN SKIPN .CPISF## ; OR COMING FROM ERRCON TDNN T1,JBTSTS##(J) JRST JOB2 ;ALWAYS DELETE FUNNY PAGES LDB T1,NFYPGS## ;ANY MONITOR FREE CORE PAGES? CAIN T1,UPMPSZ##+1 JRST JOB2 ;NO, RETURN CORE MOVE T1,[.JDAT,,.JDAT+1] ;ZERO JOB DATA AREA SETZM .JDAT ;JOBSA, JOBDDT, ETC. SETZM USRDDT## ;AND REMEMBERED COPY BLT T1,.JDAT+PG.BDY ; AND THE REST OF PAGE 0 IN CASE XO IFE FTMP,< POPJ P, ;YES, JUST RETURN > IFN FTMP,< PJRST GIVMM## > JOB2: SKIPE T1,JBTADR##(J) ;SKIP THIS IF NO CORE PUSHJ P,VMSIZE## ;VIRTUAL SIZE OF THE JOB LDB T2,NFYPGS## ;NUMBER OF FUNNY PAGES ADDI T1,-UPMPSZ##(T2) ;VMSIZE ADDED UPMP SIZE ADDM T1,VIRTAL## ;VIRTUAL CORE RETURNED PUSHJ P,ZERSWP## ;RETURNED SWAPPING SPACE PUSHJ P,FNDPDS## ;MAKE SURE W POINTS TO PDB SETZM .PDCMN##(W) ;CLEAR POINTER TO COMMAND NAMES SETZM .PDUNQ##(W) ;CLEAR POINTER TO UNIQNESS BITS PUSHJ P,UUOLVL## ;AT UUO LEVEL? JRST JOB3 ;NO MOVE T1,(P) ;YES, CAN'T USE STACK IN THE MOVE P,.CPNPD## ; UPMP AFTER GIVING THE PUSH P,T1 ; UPMP BACK TO FREE CORE JOB3: PUSHJ P,KCORE1## SETZM .CPADR## SETZM JBTIMI##(J) ;NO VIRTUAL CORE SETZM JBTIMO##(J) ;... SETZM JBTSWP##(J) IFN FTMP,< PJRST GIVMM## ;RETURN THE MM RESOURCE > IFE FTMP,< POPJ P, > SUBTTL PJOB & KJOB COMMANDS ; "PJOB" PRINT JOB NUMBER OF JOB TTY IS ATTACHED TO PJOB:: MOVE T1,J ;JOB NO. DECLF:: PUSHJ P,RADX10 ;PRINT T1 AS DEC. THEN CRLF JRST CRLF ;THIS PRINTS OUT: ; ; JOB N USER NAME [P,PN] TTY# ; PJOBX:: PUSHJ P,SAVJW## ;SAVE J(W GETS A RIDE) PUSHJ P,GETJOB ;GET JOB NUMBER TO DO PJOB ON SKIPA ;NO JOB NUMBER SO USE CURRENT JOB MOVE J,T2 ;PUT REQUESTED JOB NUMBER IN AC(J) JUMPE J,ATT4 ;ERROR IF NO JOB ASSIGNED PUSHJ P,INLMES ;GIVE FOLLOWING MESSAGE ASCIZ \Job \ ; MOVE T1,J ;PRINT THE PUSHJ P,RADX10 ; JOB NUMBER PUSHJ P,INLMES ;GIVE FOLLOWING MESSAGE ASCIZ \ User \ ; PUSHJ P,FNDPDB## ;SEE IF A PDB AND POINT AC(W) TO IT JRST PJOBX2 ;NO PDB, SO CAN'T PRINT USERS NAME MOVE T2,.PDNM1##(W) ;GET FIRST PART OF USERS NAME SKIPN .PDNM2##(W) ;PRINT IT JRST PJOBX1 ;GET USERS NAME PUSHJ P,PRSIXB ;IF LAST PART IS NULL WE'RE DONE ; WITH THE NAME PRINTOUT MOVE T2,.PDNM2##(W) ;DOES FIRST NAME END WITH A SPACE? PJOBX1: PUSHJ P,PRNAME PJOBX2: PUSHJ P,PR3SPC ;GIVE A SPACE MOVE T2,JBTPPN##(J) ;GET PPN PUSHJ P,PRTPPN ;PRINT PPN PUSHJ P,PR3SPC MOVE T2,@TTYTAB##(J) ;GET TTY NAME TLNN T2,-1 ;DETACHED? HRLI T2,'DET' ;YES PUSHJ P,PRNAME ;PRINT THE TTY NAME PJRST CRLF ;END WITH A CRLF ; "KJOB" KILL ATTACHED JOB KJOB:: SKIPE J ;WAS JOB INITIALIZED? TLNN P4,JNA ;JOB ASSIGNED? SKIPA ;NO JRST KJOB3 ;GO RUN LOGOUT SE1ENT ;ENTER SECTION ONE IFN FTNET,< SKIPGE LDBREM##(U) ;IF SET HOST IN PROGRESS, JRST KJOB2 ;JUST BE QUIET ABOUT IT > ;END IFN FTNET PUSHJ P,SKIPS1 ;EAT LEADING SPACES AND TABS JRST KJOB1 ;EOL CAIE T3,"/" ;WE EXPECT A SWITCH AT THIS POINT JRST COMERA ;CONFUSED USER PUSHJ P,CTEXT ;GET A KEYWORD JUMPE T2,COMERA ;CONFUSED USER MOVE T1,[-1,,[SIXBIT/DISCON/]] ;TABLE POINTER PUSHJ P,FNDNAM ;AND SEARCH IT JRST COMERA ;AMBIGUOUS OR UNKNOWN KJOB1: PUSHJ P,TOPDSF## ;HANG UP THE DATASET JFCL ;CAN'T IFN FTNET,< PUSHJ P,TOPDNT## ;DO A NETWORK DISCONNECT JFCL ;CAN'T SKIPGE LDBREM##(U) ;IF SET HOST, KJOB2: TLOA M,NOCRLP!NOFLM ;BE SILENT > ;END IFN FTNET TLO M,ERRFLG ;EXIT COMMAND PROCESSING CLEANLY MOVEI J,0 ;DITTO POPJ P, ;DONE KJOB3: TLNN P4,JLOG ;TEST JLOG ALSO IN CASE JOB NOT LOGGED IN JRST KJOB4 ;IF JOB NOT LOGGED IN PUSHJ P,TTYATI## ;ATTACH TTY JFCL TLO M,TTYRNU ;SET TTYRNU FOR COMRET MOVSI P1,PHONLY ;SET PHYSICAL I/O FORCE SYSTEM KJOB MOVSI T1,(JS.BPR) ;SET BYPASS PROGRAM TO RUN IORM T1,JBTST2##(J) ;TO INSURE KJOB REALLY RUNS IFN FTMP,< PUSHJ P,ALLJSP## ;SET CPU SPECIFICATION TO MAKE JOB RUNNABLE ; ON ALL CPU'S. THIS ALSO LEAVES A REASONABLE ; SPECIFICATION FOR THE NEXT USER WHO GETS ; THIS JOB NUMBER > ;END IFN FTMP HRRZ T1,.PDCVL##(W) ;GET PHYSICAL LIMIT TRZ T1,400000 ;IGNORE LIMIT/GUIDELINE SKIPN T1 ;IF NO LIMIT HERE, HRRZ T1,.PDMVL##(W) ;GET MPPL SKIPN T1 ;IF NOT LIMITED, MOVEI T1,LOGSIZ## ;FIX THE COMPARE BELOW MOVEI T2,LOGSIZ## ;GET SIZE TO RUN LOGIN CAIGE T1,(T2) ;IF NOT ENOUGH, HRRM T2,.PDCVL##(W) ;MAKE IT ENOUGH MOVE P2,LGINAM## ;GET 'LOGIN' JRST RUNAME ;GO RUN CUSP KJOB4: PUSHJ P,GETCIC ;GET MINIMAL JOB AREA ON DISK OR CORE IFN FTNET,< SE1ENT SKIPGE LDBREM##(U) ;IF SET HOST IN PROGRESS, TLO M,NOCRLP!NOFLM ;DON'T DO TYPEOUT > ;END IFN FTNET JSP T2,MONJOB## ;SCHEDULE MONITOR JOB (PC IN EXEC MODE) ; RETURN HERE AT UUO LEVEL WHEN SCHEDULED JOBKL:: IFN FTXMON, ;MUST RUN IN SECTION 0 MOVEI T2,ESTOP## ;PUT ESTOP ON END OF PDL JSP T1,MONSTR## ;GO SETUP ACS AND PD LIST AT UUO LEVEL ;RETURN HERE AT UUO LEVEL AFTER BEING SCHEDULED MOVSI T1,JERR ;TURN OFF JERR ANDCAM T1,JBTSTS##(J) ;.. SETZM .JDAT+.JBINT## ;NO OLD-STYLE TRAPPING EITHER PUSHJ P,RESET## ;ZAP PSI, IPCF STUFF, ETC. HANDLE ^C CORRECTLY IFN FTMP,< ;IF SMP PUSHJ P,ONCPU0## ;MAKE SURE WE CAN'T MESS UP COMMAND PROCESSING >; END IFN FTMP PUSHJ P,CTXLGO## ;DELETE ALL IDLE CONTEXTS IFN FTSCA,< PUSHJ P,SCSLGO## ;TELL SCSUUO JOB IS GONE >; END IFN FTSCA PUSHJ P,ENQLGO## ;TELL QUESER THAT ETERNAL LOCKS GO AWAY NOW IFN FTDECNET,< IFE FTXMON, ;TELL SCMUUO THAT JOB IS GOING AWAY IFN FTXMON, ;TELL SCMUUO THAT JOB IS GOING AWAY >; END IFN FTDECNET PUSHJ P,DSKKJB## ;CLEAR UP CORE BLOCKS ON A KJOB COMMAND ; MAY GO INTO WAIT, SO DO BEFORE GIVING UP USER CORE JUMPE W,JOBKL1 ;IF THIS JOB HAS A PDB, IFN FTKL10,< PUSHJ P,BRKDEC ;MAKE SURE ADDRESS BREAK COUNT IS DECREMENTED, ; IF NEED BE. > PUSHJ P,KILJSL## ;DESTROY THE JSL (GET MOUNT COUNTS RIGHT) JOBKL1: PUSHJ P,DEASTY ;DEASSIGN ALL BUT TTY PUSHJ P,IPCLGO## ;TELL [SYSTEM] INFO THAT JOB IS GONE PUSHJ P,JOB1 ;FLUSH CORE AFTER RELEASING DEVICES PUSHJ P,FNDPDS## ;TAPUUO COULD USE W PUSHJ P,TTYSRC## ;FIND THE TTY FOR THIS JOB SETZ F, ;NONE? SKIPE F ;IF THERE'S A TTY DDB, PUSHJ P,TTYKIL## ;RETURN TTY TO VIRGIN STATE JRST KSTOP## ;CLEAR JOB STATUS WORD AND STOP JOB SUBTTL START GROUP (START,CSTART,REE,DDT) ; "START L" OR "START" - START AT LOC. L OR STARTING ADDRESS START:: ;SAME AS CSTART, DIFF BY COMTAB BITS ; WHICH PUT TTY IN MONITOR OR USER MODE ; "CSTART L" OR "CSTART" - START AT LOC. L(TTY IN COMMAND MODE) STARTC::MOVE P3,P4 ;SAVE STATUS PUSHJ P,OCTPAR ;READ A NUMBER IF PRESENT JRST SNOARG ;NO ARG SPECIFIED RETURN TLNN P3,JLOG ;IS IT LOGGED IN? JRST STARTE ;NO--ERROR TRNE P3,JS.XO!JS.RUU ;SEE IF EXECUTE ONLY JRST ILLXO ;YES -- BOMB USER PUSHJ P,CHKMED## ;CHECK TO SEE IF HIGH SEG WHICH IS SHARABLE ; IF YES, TURN ON USER MODE WRITE PROTECT ; FOR THIS USER, AND SET MEDDLE BIT SO HE CANNOT ; TURN UWP OFF. JRST STARTN ;START IN USER MODE STARTE: MOVEI T1,LOGPLM ;SETUP ERROR MESSAGE PJRST ERRMES ;GO ISSUE IT ILLXO: MOVEI T1,ILLXOM ;GET ERROR MESSAGE PJRST ERRMES ;GO ISSUE IT ;"REENTER" - REENTER USER PROGRAM REENTE::SKIPN T2,JBTADR##(J) JRST CHKPCM ;NO ADDRESS IF NO CORE HRRZ T2,.JDAT+.JBREN## ;GET ADDRESS FROM JOBDAT SKIPN T1,.USUSA ;ANY SORT OF ENTRY VECTOR? JRST CHKPCM ;NO, GO CHECK FOR /USE SECTION JUMPE J,STARTE ;YES, BUT MUSTN'T ALLOW THIS IF NOT A JOB HLL T2,T1 ;HAVE ONE, MERGE IN ITS SECTION TLNN T2,370000 ;IS THIS JUST A START ADDRESS? JRST STARTN ;YES, ONLY WANT ITS SECTION NUMBER AOS T2,T1 ;NO, OFFSET TO REENTRY ADDRESS IN ENTRY VECTOR TLNN T2,360000 ;IS THE VECTOR LONG ENOUGH? TDZA T2,T2 ;NO, CLEAR THE ADDRESS TLZ T2,770000 ;YES, ISOLATE THE ADDRESS FROM ITS BITS JUMPE T2,CHKSTR ;BOMB USER IF NO ADDRESS PJRST SNOAR2 ;GET ADDRESS AT UUO LEVEL AND START THE USER ; "DDT" - START EXECUTION AT DDT IN USER AREA DDTGO:: JUMPE R,STARTE ;ERROR IF NO CORE (NOT A JOB) HRRZ T2,.JDAT+JOBDDT## ;DDT STARTING ADR. IN JOB DATA AREA IFN FTXMON,< HLLZ T1,.USUSA ;GET ENTRY VECTOR SECTION TLZ T1,770000 ;CLEAR OUT BITS SKIPE T2 ;PRESERVE ZERO ADD T2,T1 ;OFFSET DDT TO THAT SECTION > ;END IFN FTXMON SKIPN .USUSA ;IF THERE IS NO ENTRY VECTOR, JUMPN T2,CHKPCM ;OK IF WE HAVE DDT JUMPN T2,STARTN ;IGNORE /USE SECTION IF ENTRY VECTOR TLNN P4,JLOG ;MAKE SURE LOGGED IN JRST CHKPCM ;NOT BOMB HIM TRNN P4,JS.XO!JS.RUU ;SKIP IF EXECUTE ONLY PJRST GETDDT## ;MERGE IN DDT CHKPCM: JUMPE J,STARTE ;ERROR IF NOT A JOB (DDT,REENTER) JUMPE T2,CHKSTR ;IS A START ADR SPECIFIED? (ERROR IF 0) IFN FTXMON,< MOVE T1,.USUSN ;GET SECTION # LSH T1,P2WLSH ;POSITION ADD T2,T1 ;MAKE FULL WORD ADDRESS > ;END IFN FTXMON STARTN: MOVE T1,USRPC## ;YES, GET JOB'S PC HLR T1,JBTSTS##(J) ;AND JOB STATUS BITS TDNE T1,[XWD USRMOD,JERR] ;IS JOB IN USER MODE, OR STOPPED ON AN ERROR? JRST USTART## ;YES, START HIM UP NOW MOVE T1,T2 ;GET START ADDRESS PUSHJ P,SETUTP## ;SETUP UUO TRAP JRST USTART## ;START USER JRST RSTART## ;CLEAR STATUS FLAGS AND START JOB ; IN MIDDLE OF MONITOR WHERE IT STOPPED ;HERE TO START USER WHEN NO START ADR TYPED IN SNOARG: SKIPN T2,JBTADR##(J) JRST CHKSTR ;NO START ADDR IF NOT IN CORE SKIPE T2,.USUSA ;START ADDR SPECIFIED ON GET/RUN COMMAND? JRST SNOAR1 ;YES, SEE ABOUT USING IT HRRZ T2,.JDAT+JOBSA## ;START ADR. SPECIFIED BY LINKING LOADER ; FROM END STATEMENT JUMPE T2,CHKSTR ;IF ZERO, FORGET IT IFN FTXMON,< MOVE T1,.USUSN ;SECTION NUMBER USER SPECIFIED LSH T1,P2WLSH ;WHERE IT BELONGS ADD T2,T1 ;30 BIT START ADDRESS TLZ T2,770000 ;CLEAR POSSIBLE BITS > ;END IFN FTXMON HLLZM T2,.USUSA ;SAVE FOR NEXT TIME ;FALL INTO CHKSTR ;HERE TO CHECK TO SEE IF STARTING ADDRESS IS NON-ZERO, AND START USER IF OK CHKSTR: JUMPE J,STARTE ;ERROR IF NOT A JOB TLZ T2,770000 ;CLEAR SPECIFIED BY COMMAND BIT JUMPN T2,USTART## ;IS IT NON-ZERO?, IF YES ; STORE OLD PC IN JOBOPC IN JOB DATA AREA ; THEN START WITH PC IN USER MODE JSP T1,ERRMES ;NO, PRINT "NO START ADR" MESNSA: ASCIZ /No start address / SNOAR1: CAIN T2,1 ;IS THIS SPECIAL S0 JOBDAT HRRZ T2,.JDAT+.JBSA## ;YES, FIX IT TRNE T2,-1 ;IS THIS A FAKE JOBDAT ENTRY? TLNE T2,370000 ;OR A REAL ENTRY VECTOR? TRNA ;YES OR YES, NEED SAVCTX JRST CHKSTR ;NO, JUST A START ADDRESS, SO TRY IT SNOAR2: MOVE S,T2 ;YES, SAVE ACROSS SAVCTX JSP T2,SAVCTX## ;GET TO UUO LEVEL MOVE T2,S ;RESTORE ENTRY VECTOR ADDRESS PUSHJ P,GSADDR ;GET THE RIGHT START ADDRESS ;PJRST STARTV STARTV: SETZ F, ;FOR USRXIT (AVOID IME) TRNE T2,777700 ;REASONABLE ADDRESS? JRST STARTU ;YES, USE IT PUSHJ P,PPQCRL ;NO, START UP AN ERROR MESSAGE PJRST URUNSB ;COMPLAIN OF 'NO START ADDRESS' GSADDR::PUSH P,M ;SAVE FOR SAVCTX RETURN MOVE M,T2 ;PUT WHERE FETCH ROUTINES EXPECT IT TLZ M,770000 ;CLEAR OUT JUNK JUMPE M,GSADD0 ;DON'T FETCH IF JUNK CAIN T2,1 ;IF S0 JOBDAT, SETZ T2, ;FIX IT UP TDNN T2,[BYTE (6)37(12)(18)-1] ;IF NO LENGTH AND NO IN-SECTION ADDRESS, HRRI M,.JBSA## ;FIX UP THE REFERENCE ADDRESS PUSHJ P,PFHMWD## ;READ A WORD FROM THE USER'S ADDRESS SPACE SETZB T1,M ;INVALID ADDRESS TDNN T2,[BYTE (6)37(12)(18)-1] ;IF SPECIAL JOBDAT REFERENCE, HLL T1,M ;FIX UP SECTION NOW SKIPL T1 ;POSSIBLE IFIW? TLNE T1,^-<(SECMSK)> ;NO, IS IT A VALID ADDRESS? TLNN T1,377777 ;IFIW, IS IT PURE? SKIPA T2,T1 ;YES, USE INDIRECTED ADDRESS MOVE T2,M ;NO, USE ORIGINAL ADDRESS SKIPGE T2 ;IS IT AN IFIW? HLL T2,M ;YES, UPDATE THE SECTION NUMBER TRNN T2,^-17 ;TRYING TO START IN THE ACS? GSADD0: SETZ T2, ;YES, DON'T ALLOW THAT JRST MPOPJ## ;RETURN THE DESIRED ADDRESS TO THE CALLER SUBTTL .BPT (CONTROL-D) COMMAND ;HERE WHEN THE USER TYPES A ^D TO FORCE AN "UNSOLICITED" DDT BREAKPOINT. ; ;THE EFFECT IS TO "EXECUTE" A "JSR @.JBBPT" ON BEHALF OF THE CURRENTLY ;RUNNING USER PROGRAM; THE USER WILL THEN BE IN DDT, AND CAN "$P" TO ;RESUME THE USER PROGRAM WHERE IT WAS INTERRUPTED BY THE BREAKPOINT. CDBPT:: JUMPE J,ATT4 ;BOMB COMMAND IF NO JOB JUMPGE P4,BPTER2 ; OR IF THE JOB IS ^C'ED IFN FTMP,< ;IF MORE THAN ONE PROCESSOR, PUSHJ P,SPSTOP## ;MAKE SURE NOT RUNNING ANYWHERE ELSE JRST DLYCM ;OOPS, WE WERE, WAIT TILL OTHER CPU LETS GO IFN FTKL10,< ;IF NON-WRITE-THROUGH CACHES EXIST, PUSHJ P,SBCCSH## ;NOT RUNNING, BUT MIGHT BE IN OTHER CPU'S CACHE CAIA ;OK WRT CACHE JRST DLYCM ;STUCK IN OTHER CPU'S CACHE, WAIT > ;END IFN FTKL10 > ;END IFN FTMP PUSHJ P,SIMCHK## ;SEE IF JOB IN GOOD STATE TO BE STOPPED CAIA ;CAN STOP JOB NOW JRST DLYCM ;CAN'T STOP JOB (EXEC PC), WAIT SKIPG T2,.JDAT+JOBBPT## ;ADDRESS OF BREAKPOINT TRAP ENTRY JRST BPTER3 ;NO BREAKPOINT TRAP ADDRESS PUSHJ P,FLTTC## ;CHECK VALIDITY OF ADDRESS JRST BPTER5 ;ERROR: OUT OF BOUNDS JRST BPTER6 ;ERROR: PAGED OUT/INACCESSIBLE MOVE T1,.JDAT+JOBBPT## ;ADDRESS AGAIN PUSHJ P,IADCKL## ;I/O-LEGAL ADDRESS? JRST BPTER7 ;NO JRST BPTER6 ;PAGED OUT PUSHJ P,CDBRK## ;ALL SET, LET CLOCK1 PLAY WITH THE USER'S PC JFCL ;FAILED??? IFN FTMP,< ;IF WE CALLED SPSTOP ABOVE, PUSHJ P,CLRCCB## ;THEN UNDO THE CALL TO SPSTOP HERE > ;END IFN FTMP TLO M,NOPER ;NO DOT PLEASE POPJ P, ;.BPT COMMAND COMPLETED ;.BPT COMMAND ERRORS BPTER1: JSP T1,BPTERM ASCIZ \Breakpoint trapping is illegal when execute-only\ BPTER2: JSP T1,BPTERM ASCIZ \Program is not running\ BPTER3: SKIPE .JDAT+JOBDDT## JRST BPTER4 JSP T1,BPTERM ASCIZ \DDT is not loaded\ BPTER4: JSP T1,BPTERM ASCIZ \No breakpoint trap address\ BPTER5: JSP T1,BPTERM ASCIZ \Breakpoint trap address out of bounds\ BPTER6: JSP T1,BPTERM ASCIZ \Breakpoint trap address paged out\ BPTER7: JSP T1,BPTERM ASCIZ \Invalid breakpoint trap address\ ;COMMON BPT COMMAND ERROR MESSAGE PROCESSOR BPTERM: PUSH P,T1 ;SAVE ERROR MESSAGE ADDRESS PUSHJ P,CRLF ;TYPE A CRLF POP P,T1 ;GET ADDR BACK PUSHJ P,ERRMES ;PRINT THE ERROR MESSAGE TLZ M,ERRFLG ;DEFEAT ERRMES SE1XCT ;GET TTY CHARACTERISTICS WORD TLNE T1,LDLCOM## ;AT COMMAND LEVEL? TLOA M,ERRFLG ;YES TLO M,NOPER ;ELSE SUPPRESS THE DOT POPJ P, ;"ERROR" RETURN ; PROCESS A "SET EDDT BREAKPOINT" COMMAND ; SETEBP::SE1XCT ;GET LINE NUMBER IFE FTMP, IFN FTMP,< CAILE T1,FRCLIN## ;IS IT A CTY? CAILE T1,TCONLN## ;... > JRST COMERA1 ;NO PUSHJ P,SAVE1## ;SAVE P1 MOVEI P1,0 ;JOB 0 JRST SETBP1 ;ENTER COMMON CODE ; PROCESS A "SET DDT BREAKPOINT" COMMAND ; SETBPT::PUSHJ P,SAVE1## ;SAVE P1 MOVE P1,J ;GET OUR JOB NUMBER SETBP1: PUSHJ P,CTEXT ;GET A KEYWORD JUMPE T2,SETBP3 ;IF NO ARGUMENT, JUST TYPE CURRENT SETTING MOVE T1,[-3,,BPTTAB] ;POINT TO TABLE PUSHJ P,FNDNAM ;AND SEARCH IT JRST COMERA ;AMBIGUOUS OR UNKNOWN KEYWORD SKIPE T1 ;USER INCLUDE "BREAKPOINT" CHATTER? SOJA T1,SETBP2 ;NO--JUST STORE ON/OFF VALUE PUSHJ P,CTEXT ;GET "ON" OR "OFF" JUMPE T2,SETBP3 ;INFORM CONFUSED USER OF .BPT STATE MOVE T1,[-2,,BPTTB1] ;POINT TO ON/OFF TABLE PUSHJ P,FNDNAM ;SCAN IT JRST COMERA ;AMBIGUOUS OR UNKNOWN KEYWORD SETBP2: DPB T1,BPTPT1 ;TURN .BPT ON OR OFF SETBP3: MOVEI T1,[ASCIZ |[Control-D breakpoint facility is turned |] PUSHJ P,CONMES ;TYPE TEXT LDB T1,BPTPT1 ;GET THE BIT MOVEI T1,[ASCIZ |off| ASCIZ |on|](T1) PUSHJ P,CONMES ;TYPE ON OR OFF MOVEI T1,[ASCIZ | for exec mode debugging|] ;INCASE "SET EXEC CTRLD" SKIPN P1 ;JOB 0? PUSHJ P,CONMES ;YES MOVEI T3,"]" ;GET MESSAGE TERMINATOR PJRST COMTYO ;TYPE IT AND RETURN ; PROCESS SETUUO FUNCTIONS .STEBP AND .STBPT ; SETEBU: MOVEI J,0 ;SET EDDT SETUUO FUNCTION SETUBU: ANDI T2,1 ;SET DDT SETUUO FUNCTION (FOR USERS) DPB T2,BPTPTR ;TURN .BPT ON OR OFF MOVE J,.CPJOB## ;RELOAD OUR JOB NUMBER JRST CPOPJ1## ;AND RETURN BPTPTR: POINT 1,JBTSTS##(J),^L BPTPT1: POINT 1,JBTSTS##(P1),^L BPTTAB: SIXBIT /BREAKP/ BPTTB1: SIXBIT /OFF/ SIXBIT /ON/ SNDTXS: MOVE P3,[POINT 7,(T4)] ;TO COPY THE STRING MOVEI T3,7 ;GET A BELL IDPB T3,P3 ;STORE IN MESSAGE SUBI P1,1 ;ADJUST CHAR COUNT SNDTX1: PUSHJ P,COMTYI## ;NEXT CHARACTER IDPB T3,P3 ;STORE IT FOR THE ACTDAE CAIE T3,12 ;END OF LINE? CAIN T3,3 TDZA P1,P1 SOJG P1,SNDTX1 ;OR USED ALL THE SPACE? IDPB P1,P3 ;ASCIZIZE MOVE T1,P4 ;ACTDAE MOVE T4,P2 ;LENGTH,,ADDRESS PJRST SNDFFC## ;SEND IT SUBTTL CONTROL-C PROCESSING ; "HALT" OR "C" ;SCANNER ROUTINES DUMMY UP HALT WHEN CONTROL C TYPED IN ;STOP MUST BE DELAYED IF THIS JOB IS SYSTEM TAPE USER ;AND SYSTEM TAPE IS ACTIVE. OTHERWISE, THE JOB WILL NOT BE ;STOPPED WHEN DONE USING THE SYSTEM TAPE. ;IF JOB IS IN MONITOR MODE AND NOT IN TTY WAIT THIS JOB CANNOT BE STOPPED YET ;IN THIS CASE SET A BIT IN JOB STATUS WORD (CNTRLC) WHICH WILL BE CHECKED ;WHEN JOB RETURNS TO USER MODE STOP:: MOVE P2,HALTXT## STOPF:: IFN FTNET,< SE1XCT ;IF SET HOST IN PROGRESS, TLO M,NOCRLP!NOFLM ;DON'T TYPE OUT > ;END IFN FTNET JUMPE J,STOPB TLNE P4,JACCT ;JACCT AND WAITING TRNN P4,JDCON ;.. JRST STOPD ;NO--PROCEED JUMPL P4,STOPD ;JUMP IF RUN BIT IS SET TLO M,NOCRLP ;KILL THE DOT POPJ P,0 ;PUNT THE COMMAND STOPD: MOVEI T1,JDCON ;CLEAR JCONT.ABLE (DEV OK?) BIT ANDCAM T1,JBTSTS##(J) ; SO USER CAN STOP ONCE-A-MINUTE STUFF IFN FTMP,< PUSHJ P,SPSTOP## ;TEST IF JOB ON SLAVE, IF SO SIGNAL TO STOP IT, JRST DLYCM1 ; AND DELAY COMMAND > PUSHJ P,SIMCHK## ;OK TO "STOP IN MONITOR"? JRST STOPA ;YES, STOP JOB MOVSI T1,CNTRLC ;NO, FLAG THAT USER MUST BE STOPPED WHEN IORB T1,JBTSTS##(J) ; RETURNING TO USER MODE IN UUO HANDLER TLNE M,CMWRQ ;IS JOB IN COMMAND WAIT? PUSHJ P,REQUE## ;YES. PUT HIM BACK IN RUNNABLE QUEUE JRST DLYCM1 ;THEN DELAY COMMAND (IE ECHO CR-LF, DOT) ;UNTIL SWAPPED IN STOPA: MOVSI T1,SWP!SHF ;IS THE JOB SWAPPED? TDNE T1,JBTSTS##(J) ;IF SO, DELAY THE CONTROL C SINCE PJRST DLYCM ; THE JOB DATA AREA MUST BE IN CORE ; TO SEE IF THE JOB IS INTERCEPTING ; CONTROL C'S MOVSI T1,CNTRLC+CMWB ;DELAYED CONTROL C+ COMMAND WAIT ANDCAM T1,JBTSTS##(J) ;CLEAR THEM SKIPL JBTSTS##(J) ;IS RUN BIT ALREADY OFF? JRST STOPAA ;IF YES, DO NOT PRINT [XXXX] AGAIN PUSHJ P,STOPX ;STOP JOB TLNN M,NOPER ;IF NO PERIOD, SKIP [XXX] PUSHJ P,WCHEND ;PRINT [XXXX] CRLF IF USER IS WATCHING RESPONSES JRST STOPAB ;GO FINISH STOPAA: PUSHJ P,STOPX ;STOP JOB STOPAB: SKIPGE T1,JBTSTS##(J) ;GET JOB STATUS JRST STOPB ;IF NOT STOPPED, DON'T KJOB TLNN T1,JLOG ;IS JOB LOGGED IN? PUSHJ P,TTKJOB## STOPB: SKIPL JBTSTS##(J) ;RUNNING? PUSHJ P,FNDPDB## ;FIND PDB POPJ P, MOVEI T1,TTFCXI## ;FORCE .INITIA MOVEI T2,JS.RPC ;IF JS.RPC = 1 SKIPE .PDPGM##(W) ;AND PROGRAM TO RUN TDNN T2,JBTST2##(J) ; .. POPJ P,0 PUSHJ P,TTFORC## PJRST DLYCM STOPX: MOVSI T1,(JS.SAC) ;BIT TO TEST TDNE T1,JBTST2##(J) ;DOING AN AUTO-RESTORE ON PROGRAM EXIT? TLO M,NOCRLP ;YES, DON'T TYPE CRUFT PJUMPL P2,STOP1C## ;IF "HALT", STOP REGARDLESS PJRST STOP1## ;IF "^C^C", STOP IF POSSIBLE ;MONITOR COMMAND LEVEL RESPONSE ROUTINES ;FIVE MULTIPLE ENTRY SUBROUTINES TO PRINT SYSTEM RESPONSE DATA FOR A JOB ;CONTROL REACHES ONE OF THESE ROUTINES ON ANY OF THE FOLLOWING: ;1. USER TYPES CONTROL C ;2. PROGRAM HALTS ;3. PROGRAM CALLS EXIT, OR CALL N,EXIT ;4. DEVICE BECOMES UNREADY DEVICE XXX OK? ;5. ERROR IN JOB MESSAGE ;PRRSP1 - PRINT CRLF CRLF ;PRRSP3 - PRINT [XXXX] CRLF IF USER WATCHING SYSTEM DATA RESPONSE ;PRRSP4 - PRINT CRLF ;PRRSP5 - PRINT PERIOD PRRSP1::PUSHJ P,CRLF ;PRINT CR-LF PRRSP3::PUSHJ P,WCHEND ;PRINT SYSTEM RESPONSE DATA IF USER IS WATCHING PRRSP4::PUSHJ P,CRLF ;PRINT CR-LF PRRSP5::PUSHJ P,FNDPDB## ;ENSURE W IS SETUP PJRST PRDOTC ;? MOVEI T1,JS.RPC ;RUN PROGRAM BIT SKIPE .PDPGM##(W) ;ANY TO RUN? TDNN T1,JBTST2##(J) ;DOES HE WANT IT RUN PJRST PRDOTC ;NO, PRINT DOT POPJ P, ;YES, DONT PRINT DOT SUBTTL SET COMMAND AND UUO -- DISPATCH ;SET COMMAND/UUO SET:: MOVE P3,[XWD UNQTB2##,DISP2##] ;UNIQUENESS PLUS START OF SET-TABLE MOVE P4,[XWD -DISPL2##,COMTB2##] ;LENGTH, NAME MOVE P,.CPISF## ;RESTORE P TO VALUE AT COMGO XJRST [MCSEC1+COM1] ;GO INTERPRET 2ND PART OF THE COMMAND (IN SECTION 1) ;SUBROUTINE TO SEE IF A SYSTEM-WIDE SET COMMAND IS LEGAL ;SKIP RETURN IF LEGAL, ELSE NON-SKIP SETLGF==FUPOPJ## SETLGK==FUPOJ1## SETLGL::MOVE T3,LINTAB##+FRCLIN## CAMN T3,U JRST CPOPJ1## PUSHJ P,OPRLGL ;OPR? SKIPA T2,JBTPPN##(T1) ;NO, CHECK FURTHER JRST CPOPJ1## ;YES, OK CAMN T2,FFAPPN## ;1,2? AOS (P) ;YES, OK POPJ P, ;RETURN OPRLGL: PUSH P,U ;PRESERVE LINE PUSH P,F ;AND F MOVE T1,J MOVE T3,OPRLDB## ;SEE IF OPR CAMN T3,U ;ALSO OPR JRST SETLGK ;WE WIN MOVE T2,JBTSTS##(J) ;GET JOB STATUS TLNE T2,JLOG ;A JOB ON THE TTY? JRST SETLGF ;YES. COMMAND LOSES SE1XCT ;GET LINE NUMBER PUSHJ P,CTLJB## ;LOSE -- SEE IF PTY JUMPLE T1,SETLGF ;NO --- GIVE UP HRRZ U,TTYTAB##(T1) ;OK -- GET DDB MOVE U,DDBLDB##(U) ;THEN GET LDB JUMPE U,SETLGF ;IF CONTROL JOB DETACHED STOP SCAN AND FAIL MOVSI T2,DVDIBP ;GET BATCH JOB BITS TDNE T2,DEVCHR(F) JRST SETLGF ;YES. COMMAND LOSES CAMN T3,U ;OR HIS TTY? JRST SETLGK ;YES. COMMAND WINS JRST SETLGF ;LOSE SUBTTL SET COMMAND AND UUO -- JBSET. ;HERE FROM UUOCON ON JBSET. UUO ;CALL: MOVE AC,[+N,,BLK] ; CALLI AC,JBSET. ; ERROR RETURN AC=0 ; NORMAL RETURN ;BLK: JOB NUMBER ; XWD FUNCTION,VALUE UJBSET::PUSHJ P,PRVJ ;ARE WE A GOOD GUY JRST JBSET1 ;YES--GO DO THE SET JRST RTZER## ;NO--RETURN 0 JBSET1: PUSH P,M ;SAVE M HRRI M,(T1) ;GET ADDRESS OF BLK PUSHJ P,GETWDU## ;PICK UP JOB# MOVE J,T1 ;PUT JOB NUMBER IN J PUSHJ P,LGLPRC## ;SKIP IF LEGAL JOB NUMBER JRST JBSET2 ;NO, GIVE UP MOVSI T1,JNA ;SEE IF JOB EXISTS TDNN T1,JBTSTS##(J) ; AND EXISTENT JRST JBSET2 ; YES--GIVE UP MOVE T4,J ;SAVE NEW JOB PUSHJ P,GETWD1## ;GET NEXT WORD(XWD) PUT IT IN T1 MOVE J,T4 ;RESTORE NEW JOB NOSCHED PUSH P,JBTPPN##(J) ;SAVE PPN MOVE T2,FFAPPN## ;GET A GOOD PPN MOVEM T2,JBTPPN##(J) ;FAKE OUT PRIVJ AND PRVBIT PUSH P,J PUSH P,W ;PRESERVE W PUSHJ P,FNDPDS## ;GET THE PDB FOR THE TARGET JOB PUSHJ P,SETUUO ;DO IT TDZA T1,T1 ;NOTE BAD RETURN SETO T1, ;GOOD RETURN POP P,W ;RESTORE W POP P,J POP P,JBTPPN##(J) ;RESTORE PPN SCHEDULE POP P,M JUMPN T1,CPOPJ1## ;PASS THE GOOD WORD ON JRST STOTAC## ;ELSE RETURN ZERO JBSET2: POP P,M ;RESTORE AC JRST RTZER## ;GIVE ERROR SUBTTL SET COMMAND AND UUO -- PRIVILEGE TESTS ;DISPATCH HERE (FROM UUOCON) ON A SETUUO ;CALL: MOVE AC,[XWD FUNCTION,ARGUMENT] ; CALLI AC,SETUUO NEDPRV==1 ;BIT ON IN DISPATCH TABLE IF PRIVS NEEDED NLOGOK==2 ;BIT ON IS DISPATCH IF OK WHEN NOT LOGGED IN SETUUO::HRRZ T2,T1 ;ARGUMENT HLRES T1 ;FUNCTION CAML T1,[SETTBC-SETTBL] ;A LEGAL CUSTOMER FUNCTION? CAILE T1,SETLEN ;A LEGAL FUNCTION? POPJ P, ;NO, RETURN DOING NOTHING MOVE T1,SETTBL(T1) ;YES, GET TABLE WORD TLNE T1,NEDPRV ;NEED SPECIAL PRIVS TO DO IT? PUSHJ P,PRVJ ;YES, JOB HAVE PRIVS? PJRST (T1) ;YES, DISPATCH TLNE T1,NLOGOK ;NO PRIVS, IS IT OK IF NOT LOGGED IN? TLNE T3,JLOG ;YES, IS JOB LOGGED IN? JRST ECOD0## ;LOGGED IN OR NO PRIVS, ERROR RETURN PJRST (T1) ;DISPATCH FUNCTION ;SUBROUTINE TO SEE IF A JOB HAS PRIVILEGE: ;CALL: MOVE T1,BIT TO BE TESTED IN PRIVILEGE WORD ; MOVE J,JOB NUMBER ; PUSHJ P,PRVBIT ; RETURN IF PRIVILEGED BY BIT, [1,2], OR JACCT ; RETURN IF NOT PRIVILEGED ;RESPECTS T2 PRVBIT::TDNE T1,JBTPRV##(J) ;IS REQUESTED BIT ON IN TABLE? POPJ P, ;YES. OK RETURN ; PJRST PRVJ ;NO. CHECK FOR JACCT OR FSFPPN ;SUBROUTINE TO TEST FOR [1,2] OR JACCT PRIVILEGES. ;NEEDED IF A SETUUO FOR A SYSTEM-PARAMETER IS DONE. ;RETURNS CPOPJ IF HAVE PRIVS, CPOPJ1 IF DON'T. ;RESPECTS T2 PRVJ:: MOVE T3,JBTSTS##(J) ;JBTSTS WORD SKIPGE M ;COMMAND LEVEL? TLZA T3,JACCT ;YES--CLEAR JACCT PRVJC:: MOVE T3,JBTSTS##(J) ;IF AT UUO LEVEL AND THE SIGN BIT OF M COULD BE ON MOVE T4,JBTPPN##(J) ;JOB'S PRJ-PRG CAME T4,FFAPPN## ;=1,2? TLNE T3,JACCT ;NO, JACCT ON? POPJ P, ;YES, OK PJRST CPOPJ1## ;NO, ERROR RETURN ;TABLE FOR SETUUO. NEGATIVE FUNCTIONS ARE CUSTOMER DEFINED. ;POSITIVE FUNCTIONS ARE RESERVED FOR DEC. SETTBC: ;MINIMUM CUSTOMER DEFINED FUCTION IFN FTPATT,< EXP CPOPJ## ;ROOM FOR PATCHING >; END IFN FTPATT SETTBL: XWD NEDPRV,SETMX1 ;(0) - SET CORMAX XWD NEDPRV,SETMN1 ;(1) - SET CORMIN XWD NEDPRV,SETDA1 ;(2) - SET DAYTIME XWD NEDPRV,SETSC1 ;(3) - SET SCHED EXP SETSPI ;(4) - SET CDR EXP SETSPB ;(5) - SET SPOOL EXP SETWTU ;(6) - SET WATCH XWD NEDPRV,SETDT1 ;(7) - SET DATE XWD NEDPRV,SETOP1 ;(10) - SET OPR (INDIRECT) XWD NEDPRV,SETKSY ;(11) - SET KSYS XWD NEDPRV,CORELM## EXP SETIM1 ;(13) - SET TIME LIMIT EXP SETCPU## ;(14) - SET USER CPU SPECIFICATION XWD NEDPRV,SETCRN## ;(15) - SET CPU RUNABILITY XWD NEDPRV,SETLMX ;(16) - SET LOGMAX XWD NEDPRV,SETBMX ;(17) - SET BATMAX XWD NEDPRV,SETBMN ;(20) - SET BATMIN EXP DSKFUL ;(21) - SET DSKFUL- PAUSE OR ERROR XWD NEDPRV,SETVM1## ;(22) - SET VMMAX (SYSTEM-WIDE) XWD NEDPRV,CPOPJ1## ;(23) - HISTORICAL XWD NEDPRV+NLOGOK,SETUVL## ;(24) - SET VM MAXIMA (USER) EXP SETUV1## ;(25) - SET CURRENT VM MAXIMA (USER) EXP SETVTM## ;(26) - SET TIME FOR VIRTUAL TIME INTERRUPTS EXP SETABR ;(27)-SET ADDRESS BREAK EXP SETPGM ;(30)-SET PROGRAM TO RUN EXP SETDFU ;(31)-SET DEFERED SPOOLERS IFN FTNET,< XWD NEDPRV,HOST.U## ;(32)-SET HOST > IFE FTNET,< EXP CPOPJ## ;(32)-SET HOST - NOT DEFINED > EXP SETDLU ;(33)-SET DEFAULTS EXP SETPRV ;(34)-SET PRIVILEGES XWD NEDPRV,SETBSN ;(35) SET BATCH STREAM NUMBER XWD NEDPRV,SETWTO ;(36) SET WTO CAPABALITIES XWD NEDPRV,SETCDN## ;(37) SET CPU UP/DOWN STATUS IFN FTKL10,< IFN FTMP,< XWD NEDPRV,SETCSB## ;(40) SET/CLEAR CACHE BITS > IFE FTMP,< EXP CPOPJ## ;(40) SET/CLEAR CACHE BITS - NOT DEFINED > > ;END IFN FTKL10 IFN FTKS10,< EXP CPOPJ## ;(40) SET/CLEAR CACHE BITS - NOT DEFINED >; END IFN FTKS10 EXP SETFPS## ;(41) SET/CLEAR FLOATING POINT SIMULATION XWD NEDPRV+NLOGOK,SETOPP ;(42) SET OPERATOR PRIVS XWD NEDPRV,SETQST ;(43) SET QUEUE STRUCTURE XWD NEDPRV,CSHSIZ## ;(44) SET DISK BLOCK CACHE SIZE XWD NEDPRV,SETEBU ;(45) SET EDDT BREAKPOINT ON/OFF EXP SETUBU ;(46) SET DDT BREAKPOINT ON/OFF XWD NEDPRV,SETDA0 ;(47) SET TIME OF DAY IN SECONDS XWD NEDPRV,SETMXP ;(50) SET CORMAX IN PAGES XWD NEDPRV,SETMNP ;(51) SET CORMIN IN PAGES IFN FTMP,< EXP SETPCP## ;(52) SET POLICY CPU >; END IFN FTMP IFE FTMP,< EXP CPOPJ## ;(52) SET POLICY - UNDEFINED IF NOT FTMP >; END IFE FTMP XWD NEDPRV,SETDJB## ;(53) SET DAEMON JOB NUMBER EXP SETITP## ;(54) SET INTERVAL TIMER PATCH IFN FTPATT,< EXP CPOPJ## ;ROOM FOR PATCHING >; END IFN FTPATT SETLEN==.-SETTBL-1 IFE FTLOCK,< SETMN1==CPOPJ## SETMNP==CPOPJ## >; END IFE FTLOCK SUBTTL SET COMMAND AND UUO -- CORMAX AND CORMIN SETMXP: AOS T3,T2 ;COMPUTE HIGHEST ADDRESS ANDI T3,400000 ;PRESERVE SOFT CORMAX FLAG TRZ T2,400000 ;KEEP ONLY NUMBER OF PAGES LSH T2,P2WLSH ;CHANGE TO WORDS SOSA T2 ;CONTINUE SETMX1: SETZ T3, ;HARD CORMAX FOR OLD FUNCTION CODE IFN FTLOCK,< SKIPE LOCK## ;JOB BEING LOCKED? JRST ECOD0## ;YES - CAN'T CHANGE CORMAX > JRST SETMX2 ;ENTER COMMON CODE SETMAX::PUSHJ P,CORLGL ;GET DECIMAL ARG IF LEGAL IFN FTLOCK,< SKIPE LOCK## ;IF A JOB IS BEING LOCKED, JRST DLYCM1 ;WAIT TILL LATER > SETZ T3, ;FORCE HARD CORMAX FOR COMMAND SETMX2: PUSH P,T3 ;SAVE HARD/SOFT CORMAX FLAG MOVE T1,RMCMAX## ;REAL MAXIMUM CORMAX, INCLUDING FUNNY SPACE CAMG T2,T1 ;TRY TO SET IT TOO HIGH? JRST SETAOK ;NO JUMPGE M,SETMXE ;RETURN ERROR IF UUO PUSHJ P,INLMES ASCIZ / %Exceeds physical maximum-/ MOVE T1,RMCMAX## ;GET REAL MAXIMUM LSH T1,W2PLSH ;SET UP FOR P OR K PUSHJ P,PRCORE ;TELL WHAT IT IS MOVE T2,RMCMAX## ;REDUCE PHYSICAL LIMIT SETAOK: CAIL T2,MINMAX## ;TOO SMALL? JRST SETIOK ;NO JUMPGE M,SETMXE ;RETURN ERROR IF UUO PUSHJ P,INLMES ASCIZ / %Below minimum-/ MOVEI T1,MINMAX## ;GET MINIMUM LSH T1,W2PLSH PUSHJ P,PRCORE ;REPORT IT MOVEI T2,MINMAX## SETIOK: POP P,T3 ;GET FLAG BACK JUMPN T3,SETMXF ;CONTINUE IF SOFT CORMAX CAMGE T2,CORMAX## ;DECREASING? PUSHJ P,CHKMAX ;YES. CHECK JOB SIZES SETMXF: MOVEM T2,CORMAX## ;SAVE NEW VALUE LSH T2,W2PLSH ;REDUCE TO N HRRM T2,CORLIM## ;SAVE IN RH(CORLIM) JRST CPOPJ1## ;AND SKIP RETURN SETMXE: POP P,(P) ;PHASE STACK JRST ECOD0## ;RETURN ERROR CODE 0 (BAD ARGUMENT) CHKMAX: PUSHJ P,SAVE3## ;SEE IF NEW CORMAX SETZ P1,0 ;IS TOO SMALL FOR PUSH P,J ;JOBS NOW RUNNING MOVE P2,T2 ;SAVE DESIRED NEW VALUE MOVEI J,1 ;SCAN ALL JOBS CHKMX1: MOVE T2,JBTSTS##(J) ;DON'T COUNT LOCKED JOBS TLNE T2,NSHF!NSWP TDZA T2,T2 ;THIS JOB IS LOCKED PUSHJ P,SEGSIZ ;GET LOW SEG SIZE PUSH P,J ;SAVE JOB # HRRZ T3,JBTSGN##(J) ;SEE IF USER HAS ANY HIGH SEGS JUMPE T3,CHKMX2 ;NO CHKM1A: SKIPLE J,.HBSGN(T3) ;IS THIS HIGH SEG REAL? TLNE J,NSWP!NSHF ;AND NOT LOCKED? JRST CHKM1B ;LOCKED OR SPY MOVE P3,T2 ;SAVE CURRENT SUM PUSHJ P,SEGSIZ ;GET HISEG SIZE ADDI T2,(P3) ;TOTAL CHKM1B: HRRZ T3,.HBLNK(T3) ;POINT TO NEXT HIGH SEG JUMPN T3,CHKM1A CHKMX2: LSH T2,P2WLSH ;TOTAL WORDS CAMLE T2,P1 ;BIGGEST SO FAR? MOVE P1,T2 ;YES POP P,J ;GET BACK JOB # CAMGE J,HIGHJB## ;ALL JOBS SCANNED? AOJA J,CHKMX1 ;NO CAMG P1,P2 ;BIGGEST JOB FIT NEW CORMAX? JRST CHKMX3 ;YES. OK AS IS MOVE P2,P1 ;NO. ADJUST REQUEST JUMPGE M,CHKMX3 PUSHJ P,INLMES ASCIZ / %Too small for current job(s)-/ MOVE T1,P2 ;GET SIZE OF LARGEST JOB LSH T1,W2PLSH PUSHJ P,PRCORE ;REPORT IT CHKMX3: MOVE T2,P2 POP P,J ;BALANCE STACK JRST ECOD0## ;RETURN ERROR IFN FTLOCK,< SETMNP: LSH T2,P2WLSH ;CONVERT TO WORDS TROA T2,PG.BDY ;CONVERT TO HIGHEST LEGAL ADDRESS SETMIN::PUSHJ P,CORLGL ;GET DECIMAL ARG IF LEGAL SETMN1: CAMLE T2,CORMAX## ;CORMIN CAN'T MOVE T2,CORMAX## ;EXCEED CORMAX MOVEM T2,CORMIN## ;SET NEW VALUE IN CORMIN JRST CPOPJ1## ;AND SKIP RETURN > ;SUBROUTINE TO GET CORE ARGUMENT AND CHECK FOR LEGALITY ; DOES NOT RETURN IF NOT LEGAL CORLGL::PUSHJ P,SETLGL ;TEST FOR LEGALITY JRST COMERP ;NOT LEGAL PUSHJ P,CORARG ;GET THE CORE ARGUMENT JRST NOTENP ;NOT ENOUGH ARGUMENTS AOS T2,T1 ;CONVERT TO NUMBER OF WORDS POPJ P, ;RETURN ;SUBROUTINE TO TEST FOR LEGALITY, RETURN NEXT TYPED ARGUMENT IF LEGAL ;DOES NOT RETURN IF NOT LEGAL DECLGL::PUSHJ P,SETLGL ;TEST FOR LEGALITY JRST COMERP ;NOT LEGAL PUSHJ P,DECIN1 ;LEGAL - GET DECIMAL NUMBER PJRST NOTENP ;NOT ENOUGH ARGS PJRST COMERP ;NOT A NUMBER POPJ P, ;OK - RETURN ;HERE TO SET MEMORY ON OR OFF LINE SETMEM::PUSHJ P,SETLGL ;MUST BE PRIVILEGED JRST COMERA ;NOT PRIVLEGED, LOSE ; PUSHJ P,SAVE2## PUSHJ P,CTEXT ;GET MODIFIER JUMPE T2,NOTENF ;MUST BE ONE MOVE T1,[-2,,[SIXBIT /ON/ SIXBIT /OFF/]] PUSHJ P,FNDNAM ;LOOK FOR EITHER "ON" OR "OFF" JRST COMERA ;IF NEITHER, LOSE MOVE P1,T1 ;REMEMBER WHETHER HE SAID ON OR OFF PUSHJ P,SKIPS1 ;SKIP SPACES, TABS, ETC. JFCL ;IGNORE NON-SKIP RETURN CAIN T3,"-" ;ALLOW "-LINE" PUSHJ P,COMTYS ;IF A MINUS SIGN WAS TYPED, SKIP IT MOVE T1,[-2,,[SIXBIT /LINE/ SIXBIT /FROM/]] PUSHJ P,TXTARG ;ALLOW NOISE WORDS JRST SETME0 ;NONE WAS TYPED JUMPN T1,SETME0 ;SKIP ON IF "FROM" WAS TYPED HRROI T1,[SIXBIT/FROM/] PUSHJ P,TXTARG ;"LINE" WAS TYPED, EAT "FROM" IF ITS THERE JFCL ;DON'T CARE WHETHER IT WAS ON NOT SETME0: PUSHJ P,DECIN1 ;READ AN ARGUMENT (DEFAULT IS DECIMAL) JRST NOTENF ;THERE MUST BE ONE PUSHJ P,[CAIE T3,"K" ;NUMBER ENDED WITH A NON-DIGIT, CAIN T3,"P" ; WAS IT "P" OR "K"? CAIA ;YES JRST COMERP ;NO, COMPLAIN MOVEI T1,P2WLSH CAIE T3,"P" ;ARGUMENT SPECIFIED IN PAGES? MOVEI T1,K2WLSH LSH T2,(T1) ;CONVERT TO WORDS JRST COMTYS] ;AND EAT THE "P" OR "K" MOVE P2,T2 ;SAVE THE LOWER BOUND HRROI T1,[SIXBIT/TO/] PUSHJ P,TXTARG ;ALLOW THE NOISE WORD "TO" JFCL ;DON'T CARE IF IT ISN'T THERE PUSHJ P,DECIN1 ;READ THE SECOND ARGUMENT JRST NOTENF ;THERE MUST BE ONE PUSHJ P,[PUSHJ P,[CAIE T3,"K" CAIN T3,"P" ;ONCE AGAIN, ALLOW ARGUMENT TO BE CAIA ; QUALIFIED BY "P" OR "K" JRST COMERP ;HOWEVER, NOTHING ELSE WILL DO MOVEI T1,P2WLSH CAIE T3,"P" ;PAGES? MOVEI T1,K2WLSH LSH T2,(T1) ;CONVERT TO WORDS JRST COMTYS] ;AND THROW AWAY THE CHARACTER SOJA T2,CPOPJ##] CAMG P2,T2 ;FIRST ARGUMENT MUST BE .LT. THE SECOND CAIE T3,12 ;AND THE LINE MUST BE PROPERLY TERMINATED JRST COMERA ;GRUMBLE MOVE T1,P2 ;RESTORE FROM ARGUMENT TRZ T1,PG.BDY ;ROUND TO A PAGE BOUNDARY TRZ T2,PG.BDY ; .. ADDI T2,PAGSIZ ;ROUND UP LSHC T1,W2PLSH ;CONVERT FROM WORDS TO PAGES ;HERE T1 = LOWEST PAGE NUMBER (K NUMBER) OPR TYPED ; T2 = HIGHEST PAGE NUMBER (K NUMBER) + 1 OPR TYPED ;P1 = 0 IF SET MEMORY ON LINE ;P1 = 1 IF SET MEMORY OFF LINE ;DISPATCH TO ROUTINE TO SET MEMORY ON OR OFF LINE JUMPN P1,SETME1 ;HERE TO SET MEMORY ON LINE, T1 = FIRST PAGE TO SET ON LINE, T2 = LAST ; PAGE + 1 MEMONL::HRLZ S,T1 ;STARTING PAGE TO SET ON LINE HRR S,T2 ;HIGHEST PAGE TO SET ON LINE JSP T2,SAVCTX## ;SAVE THE JOB'S CONTEXT AND RETURN AT UUO LEVEL ; (THE JOB'S CONTEXT MUST BE SAVED BECAUSE ; IF SETTING THE MEMORY ON LINE CAUSES ; A NXM, THE JOB'S CONTEXT WILL BE DESTROYED) HLRZ T1,S ;RESTORE THE STARTING PAGE TO SET ON LINE HRRZ T2,S ;AND THE HIGHEST PAGE TO SET ON LINE ;JOIN HERE FOR RECON. UUO TO SET MEMORY ON LINE MEMONU::SE1ENT ;ENTER SECTION 1, TO LOOK AT PAGTAB. MOVE T3,[NXMTAB##,,OLDNXM##] ;SET UP BLT TO COPY NXMTAB BLT T3,NXMTAB##+NXMTBL##-1 ;MAKE "OLD" COPY OF ERROR LOGGING MOVE T3,MEMSIZ## ;CURRENT HIGHEST ADDRESS IN THE MACHINE MOVE T4,NWCORE## ;HIGHEST ADDRESS THAT CAN BE SET ON LINE ; (CANNOT MAKE PAGTAB AND MEMTAB BIGGER) LSHC T3,W2PLSH ;CONVERT TO PAGES CAMG T3,T4 ;PICK THE BIGGER OF THE TWO AS THE MOVE T3,T4 ; HIGHEST ADDRESS THAT CAN BE SET ON LINE TRZE T3,PG.BDY ;ROUND UP TO A 256K BOUNDARY (IF NOT ADDI T3,PAGSIZ ; ALREADY ON A 256K BOUNDARY CAMG T3,T2 ;IF ASKING FOR MEMORY ON LINE ABOVE THE ; HIGHEST WHICH CAN BE DONE, MOVE T2,T3 ; SET ON UP TO THE HIGHEST THAT CAN BE DONE CAML T1,T2 ;LOWEST PAGE ABOVE THE HIGHEST PAGE? POPJ P, ;YES, NOTHING TO SET ON LINE MOVE P1,T1 ;LOWEST PAGE TO SET ON LINE IDIVI P1,^D36 ;COMPUTE BIT POSITION AND WORD NUMBER WITHIN NXMTAB MOVNI P2,-^D35(P2) ;BIT POSITION BYTE POINTER STYLE HRLI P1,(POINT 1,0,0);FORM A 1 BIT BYTE POINTER TO NXMTAB DPB P2,[POINT 6,P1,5] ADDI P1,NXMTAB## ;BYTE POINTER TO BIT CORRESPONDING TO FIRST PAGE TO SET ON SETZB T4,P2 ;INITIALIZE FIRST AND HIGHEST NON-EXISTANT PAGES SEEN MOVEI P3,PAGSIZ ;TO UPDATE MAXMAX ON EACH PAGE SET ON LINE IFN FTMP,< PUSHJ P,UPMM## ;GET THE MM RESOURCE > MEMON6: MOVE T3,@[IW MS.MEM,PAGTAB(T1)] ;PAGE DESCRIPTOR BITS TLNE T3,NXMBIT ;IS THIS PAGE NON-EXISTANT? TLNE T3,MONTRB ;IF AN UNMAPPED MONITOR PAGE SKIP IT TOO JRST MEMON8 ;NO, ITS ALREADY ON LINE DPB P3,P1 ;INDICATE THIS PAGE EXISTS IN NXMTAB PUSHJ P,MEMOZR ;ZERO OUT THE PAGE AND CHECK FOR NXM JRST MEMON8 ;GOT AN NXM ADDM P3,MAXMAX## ;INCREASE THE MAXIMUM VALUE FOR CORMAX ADDM P3,RMCMAX## ;INCREASE REAL MAX VALUE FOR CORMAX SKIPN P2 ;SKIP IF NOT THE FIRST PAGE SET ON LINE MOVE P2,T1 ;REMEMBER THE FIRST PAGE SET ON LINE JUMPE T4,MEMON7 ;JUMP IF FIRST PAGE HRRZM T1,@[IW MS.MEM,PAGTAB(T4)] ;LINK PAGES BEING SET ON LINE TOGETHER MEMON7: MOVE T4,T1 ;REMEMBER LAST PAGE MEMON8: IBP P1 ;BUMP BYTE POINTER TO NEXT PAGE IN NXMTAB CAIE T1,-1(T2) ;LOOKED AT THE ENTIRE RANGE OF PAGES TO SET ON LINE? AOJA T1,MEMON6 ;NO, LOOK AT THE NEXT PAGE IFE FTMP,< JUMPE P2,CPOPJ## ;RETURN DOING NOTHING IF ALL PAGES WERE ALREADY > ; ON LINE IFN FTMP,< PJUMPE P2,DWNMM## ;GIVE UP THE MM > SETZM @[IW MS.MEM,PAGTAB(T4)] ;INDICATE END OF THE LIST OF PAGES SET ON LINE ;HERE WHEN MEMORY HAS BEEN MARKED ON LINE AND CHECKED FOR NXM. ;ADD ALL PAGES WHICH WERE OFF LINE TO THE FREE CORE LIST. MOVE T1,P2 ;FIRST PAGE IN THE LIST OF PAGES SET ON LINE MOVE P1,T4 ;LAST PAGE FREED LSH T4,P2WLSH ;HIGHEST ADDRESS SET ON LINE ADDI T4,PAGSIZ ;ADDRESS OF PAGE FOLLOWING HIGHEST SET ON LINE CAMLE T4,MEMSIZ## ;IS THAT GREATER THAN CURRENT MEMORY SIZE? MOVEM T4,MEMSIZ## ;YES, SAVE NEW HIGHEST ADDRESS IN MEMORY + 1 MOVE T4,MEMSIZ## ;HIGHEST ADDRESS IN MEMORY + 1 LSH T4,W2PLSH ;CONVERT TO HIGHEST PAGE MOVE T2,T4 ;NEW HIGHEST PAGE TRZE T2,PG.BDY ;ROUND UP ADDI T2,PP256K## ;TO A 256K BOUNDARY IDIVI T2,^D36 ;BITS/WORD MOVNI T2,1(T2) ;NEGATIVE LENGTH OF NXMTAB HRLM T2,NXMPTR## ;UPDATE NXMPTR TO REFLECT ADDITIONAL MEMORY MOVEI T4,PAGTAB-1(T4) ;BYTE POINTER TO HIGHEST PAGE IN MEMORY SSX T4,MS.MEM ;GIVE IT A SECTION NUMBER MOVEM T4,CORLST## ;STORE THAT FOR CHKTAL SSX T1,MS.MEM ;CLEAR BACK POINTER SO HLLZS PT2TAB(T1) ;GVPAGS DOESN'T GET CONFUSED PUSHJ P,GVPAGS## ;ADD THE PAGES SET ON LINE TO THE FREE CORE LIST ;FINISH UP PUSHJ P,CPINXF## ;FIX CORE ALLOCATION VARIABLES JFCL ;CORMAX MAY HAVE CHANGED, BUT ALL JOBS WILL STILL FIT IFN FTMP,< PUSHJ P,DWNMM## ;GIVE UP THE MM >; END IFN FTMP MOVEI T1,.CSCMO ;CONFIG STATUS CODE PJRST MEMELG## ;MAKE AN ERROR LOG ENTRY ;ROUTINE TO ZERO THE PAGE BEING SET ON-LINE AND CHECK FOR NXM. ;CALL WITH T1=PAGE NUMBER, P1=BYTE POINTER TO NXMTAB ;RETURNS CPOPJ IF NXM, CPOPJ1 IF PAGE OK. ;MUST BE CALLED WITH MM, RETURNS WITH MM. ;PRESERVES T1-T4. MEMOZR: PUSHJ P,SAVT## ;SAVE T1-T4 HRRZ T3,T1 ;GET PAGE NUMBER MOVE T4,.CPMAP## ;GET ADDRESS OF EXEC MAP HRLI T3,(B2+PM.WRT) ;ACCESSIBLE AND WRITABLE MOVEM T3,.EUPMP/PAGSIZ(T4) ;SET NEW MAPPING FOR PAGE CLRPT .EUPMP ;FLUSH PAGE TABLE SO NEW MAPPING IS IN EFFECT IFN FTMP,< PUSHJ P,DWNMM## ;GIVE UP THE MM IN CASE NXM HAPPENS >; END IFN FTMP MOVEI T4,1000 ;TIME TO WAIT FOR NXM TO CAUSE AN INTERRUPT MOVEM J,MOFLPG## ;FLAG WE ARE SETTING MEMORY OFF-LINE SETZM .EUPMP ;ZERO FIRST WORD OF PAGE SOJG T4,. ;WAIT LONG ENOUGH FOR NXM INTERRUPT TO HAPPEN LDB T3,P1 ;GET BIT FROM NXMTAB JUMPN T3,MEMOZ1 ;JUMP IF NXM HAPPENED MOVE T3,[XWD .EUPMP,.EUPMP+1] ;SET TO CLEAR REMAINDER OF PAGE MOVEI T4,1000 ;TIME TO WAIT FOR NXM TO CAUSE AN INTERRUPT BLT T3,.EUPMP+PG.BDY ;ZERO THE REMAINDER OF THE PAGE SOJG T4,. ;WAIT LONG ENOUGH FOR NXM INTERRUPT TO HAPPEN LDB T3,P1 ;GET BIT FROM NXMTAB SKIPN T3 ;DID NXM HAPPEN? AOS (P) ;NO, SET UP SKIP RETURN MEMOZ1: SETZM MOFLPG## ;NO LONGER CHECKING FOR OFFLINE PAGE IFN FTMP,< PUSHJ P,UPMM## ;GET BACK THE MM >; END IFN FTMP POPJ P, ;RETURN SETME1: SKIPN [M.LOK##] ;MUST HAVE THE LOCK UUO TO SET MEMORY OFF JRST COMERA ;ERROR IF LOKCON NOT LOADED PUSHJ P,CKMOL## ;CHECK THAT RANGE DOESN'T OVERLAP THE MONITOR JRST SETME6 ;IT DOES SO WE CAN'T DO IT LDB T3,[POINT 14,NWCORE##,26] ;GET TOTAL SIZE (ON OR OFF) CAIL T1,(T3) ;LOWER BOUND BEYOND END? POPJ P, ;YES, IT'S ALREADY OFF CAIL T2,(T3) ;UPPER BOUND BEYOND END? MOVE T2,T3 ;YES,CHANGE UPPER BOUND PUSH P,T1 ;SAVE LOWER BOUND PUSH P,T2 ;AND UPPER BOUND MOVEI P1,[ASCIZ /?Job(s) too big to continue to run/] PUSHJ P,NEWCMX## ;SEE IF ALL JOBS CAN CONTINUE TO RUN JUMPLE T1,[POP P,(P) ;IF .LE. 0, TRYING TO SET MONITOR MEMORY OFF LINE POP P,(P) JRST SETME6];GO EXPLAIN THE PROBLEM PUSH P,J ;SAVE J FOR COMRET MOVEI J,0 ;STARTING WITH JOB 0, SETME3: PUSHJ P,JBSTBG## ;MAKE SURE ALL JOBS CAN STILL RUN (I.E., NONE IS TOO BIG) JRST SETME4 ;NONE ARE PUSHJ P,MOLMS ;TELL THE OPR ABOUT THIS JOB JRST SETME3 ;AND LOOK FOR MORE THAT ARE TOO BIG SETME4: JUMPE P1,SETME7 ;EXIT IF SOME JOBS WERE TO BIG MOVEI P1,[ASCIZ /?Attempt to set memory containing locked jobs off-line/] MOVEI J,0 ;STARTING WITH JOB 0, MOVE T1,-2(P) ;LOWER BOUND, SETME5: MOVE T2,-1(P) ;UPPER BOUND, PUSHJ P,CKLJB## ;SEE IF RANGE OVERLAPS SOME LOCKED JOB JRST SETME7 ;IT DOESN'T SO ALL IS WELL PUSHJ P,MOLMS ;TELL THE OPR ABOUT THIS JOB JRST SETME5 ;AND LOOP TO SEE IF THERE ARE ANY MORE IN THE WAY SETME6: JSP T1,ERRMES ;PRINT THE ERROR MESSAGE ASCIZ /Attempt to set monitor memory off-line/ SETME7: POP P,J ;RESTORE J FOR COMRET POP P,T2 ;RESTORE UPPER BOUND POP P,T1 ;AND LOWER BOUND JUMPE P1,PCRLF ;EXIT IF THERE WAS AN ERROR PJRST MEMOFL## ;GO SET THE MEMORY OFF-LINE MOLMS: PUSH P,T1 ;SAVE T1 SKIPE T1,P1 ;SKIP IF ERROR MESSAGE WAS ALREADY TYPED PUSHJ P,CONMES ;TYPE THE ERROR MESSAGE MOVEI T1,[ASCIZ/ ?Problem with job(s)/] SKIPE P1 ;SAY PROBLEM WITH JOBS ONCE PUSHJ P,CONMES ;TYPE THAT MOVEI P1,0 ;FLAG AN ERROR AND DON'T PRINT ERROR HEADING TWICE TLO M,ERRFLG ;TELL COMRET THAT THERE WAS AN ERROR PUSHJ P,PRJBNM## ;DISPLAY INFO. ABOUT THE PROBLEM JOB JRST TPOPJ## ;RESTORE T1, AND RETURN SUBTTL SET COMMAND AND UUO -- DAYTIME AND SCHED SETDAY::PUSHJ P,SETLGL JRST COMERA PUSHJ P,RDTIM ;GET TIME OF DAY PJRST ERRCRL ;ISSUE CRLF/ERROR MESSAGE AND RETURN JRST SETDA3 ;SKIP AROUND SETUUO CHECK SETDA0: IFN FTMP,< ;IF SMP PUSHJ P,ONCPU0## ;RUN ON POLICY CPU >; END IFN FTMP CAIL T2,<^D24*^D60*^D60> ;RANGE CHECK IT JRST ECOD3## ;ILLEGAL TIME (GREATER THAN 23:59:59) MOVE T1,T2 ;SHUFFLE TIME TO SAME AC RDTIM USES SETDA3::MOVE T4,T1 ;SAVE RESULT IDIVI T1,^D60*^D60 ;T1:= HOURS IDIVI T2,^D60 ;T2:= MINUTES, T3:= SECONDS MOVEM T1,LOCHOR## ;SAVE HOURS MOVEM T2,LOCMIN## ;SAVE MINUTES MOVEM T3,LOCSEC## ;SAVE SECONDS IMUL T4,TICSEC## ;CONVERT TO JIFFIES MOVEM T4,TIME## ;SAVE IT MOVEM T4,.CPTML## ;SAVE TIME AT THE LAST CLOCK TIC MOVEI T1,.C0CDB## ;POINT AT FIRST CDB MOVN T2,T3 ;GET -SECONDS ADDI T2,^D60 ;GET SECONDS 'TIL NEXT MINUTE MOVE T3,TICSEC## ;TIME TO NEXT SECOND JRST SETDA2 ;ENTER COMMON CODE SETDA1: IFN FTMP,< ;IF SMP PUSHJ P,ONCPU0## ;RUN ON POLICY CPU >;END IFN FTMP IDIVI T2,^D100 ;HOURS INTO T2 MOVEM T3,LOCMIN## MOVEM T2,LOCHOR## SETZM LOCSEC## ;ZERO SECOND COUNTER IMULI T2,^D60 ;CONVERT HOURS TO MINS ADD T2,T3 ;+ORIGINAL MINS IMUL T2,TICMIN## ;CONVERT TO JIFFIES MOVEM T2,TIME## ;SAVE AS NEW TIME MOVEM T2,.CPTML## MOVEI T1,.C0CDB## ;POINT AT FIRST CDB MOVEI T2,^D60 ;TIME TO NEXT MINUTE MOVE T3,TICSEC## ;TIME TO NEXT SECOND SETDA2: MOVEM T2,.CPSEC##-.CPCDB##(T1) ;STORE IN THIS CDB MOVEM T3,.CPHTM##-.CPCDB##(T1) ;TIME TO NEXT SECOND HLRZ T1,.CPCDB##-.CPCDB##(T1) ;STEP TO NEXT JUMPN T1,SETDA2 ;LOOP FOR ALL PUSHJ P,OMSTIM## ;RECOMPUTE OPR MESSAGE TIME PJRST SETDT2 ;FIXUP 'DATE' & SKIP RETURN SETSCD::PUSHJ P,SETLGL ;CHECK FOR LEGALITY JRST COMERA ;NOT LEGAL PUSHJ P,OCTIN1 ;OK - GET OCTAL NUMBER PJRST NOTENF ;NOT ENOUGH ARGS PJRST COMERA ;ILLEGAL NUMBER SETSC1: HRRZ T1,STATES## ;GET OLD SCHEDULE HRRM T2,STATES## ;SET NEW SCHEDULE CAIE T1,(T2) ;OLD AND NEW THE SAME? PUSHJ P,SNDSCM## ;NO, TELL QUASAR IT CHANGED JFCL JRST CPOPJ1## ;AND SKIP RETURN SETIM1: IMUL T2,TICSEC## ;CONVERT TO JIFFIES MOVSI T3,(JB.LBT) ;GET BATCH BIT TDNN T3,JBTLIM##(J) ;BATCH JOB? JRST SETIM2 ;NO, GO STORE LDB T3,JBYLTM## ;YES, LAST CHANCE JUMPE T3,SETIM2 ;CAN ALWAYS ADD RESTRICTIONS PUSHJ P,PRVJC ;IS HE [1,2] OR JACCT? JRST SETIM2 ;LET HIM THROUGH PJRST RTZER## ;NO, BOMB HIM SETRTM::PUSHJ P,DECIN1 ;GET DECIMAL NO OF SECS PJRST NOTENF ;NOT ENOUGH ARGS PJRST COMERA ;NOTA NUMBER IMUL T2,TICSEC## ;CONVERT TO JIFFIES TLNE T2,(-JB.LTM-1) ;SEE IF TOO BIG PJRST COMERA ;YES. ERROR MOVEI T1,BATMSG LDB T3,JBYLTM## JUMPE T3,SETIM2 MOVE T3,JBTLIM##(J) TLNE T3,(JB.LBT) JRST ERRMES SETIM2: DPB T2,JBYLTM## JRST CPOPJ1## ;AND RETURN SUBTTL SET COMMAND AND UUO -- OPR, LOGMIN&MAX BATMIN##&MAX SETOPR::PUSHJ P,SETLGL ;SEE IF SET OPR LEGAL JRST COMERA ;NOT LEGAL PUSHJ P,CTEXT1 ;GET NAME OF DEVICE MOVE T1,T2 ;MOVE FOR STDOPR PUSHJ P,STDOPR## ;SET IT PJRST COMERA ;NO GOOD POPJ P,0 ;GOOD SETOP1: HRR M,T2 ;UUO, GET ADDRESS PUSHJ P,GETWDU## ;GET CONTENTS IF LEGAL PUSHJ P,STDOPR## ;CHANGE DEVICE JRST ECOD0## ;ERROR RETURN JRST CPOPJ1## ;GOOD RETURN ;LOGIN CONTROL PARAMETERS SETLMX: CAIL T2,1 ;LOGMAX MUST BE .GE. 1 CAILE T2,M.JOB## ; AND .LE. M.JOB JRST ECOD0## MOVEM T2,LOGMAX## JRST CPOPJ1## SETBMX: CAIL T2,0 ;BATMAX MUST BE .GE. 0 CAILE T2,M.JOB## ; AND .LE. M.JOB JRST ECOD0## MOVEM T2,BATMAX## JRST CPOPJ1## SETBMN: CAIL T2,0 ;BATMIN MUST BE .GE. 0 CAMLE T2,BATMAX## ; AND .LE. BATMAX JRST ECOD0## MOVEM T2,BATMIN## JRST CPOPJ1## ;SET QUEUE STRUCTURE SETQST: HRR M,T2 ;GET ADDR OF USER'S ARG PUSHJ P,GETWDU## ;GET THE ARGUMENT SKIPE T1 ;WEED OUT JUNK PUSHJ P,SRSTR## ;MAKE SURE ITS A KNOWN STR PJRST ECOD2## ;LOSE - ILLEGAL STRUCTURE MOVEM T1,QUESTR## ;SAVE FOR % LDQUS GETTAB JRST CPOPJ1## ;RETURN SUBTTL SET COMMAND AND UUO -- WATCH SETWAT::PUSHJ P,SAVE1## ;SAVE P1 MOVE P1,[IORM T2,JBTWCH##(J)] ;WE'RE CHANGING JBTWCH(J) PUSHJ P,CTEXT ;GET 1ST ARG JUMPE T2,WATLP1 ;ERROR IF MISSING SKIPA T1,[-WATLEN-NOTLEN,,WATTAB] ;SCAN BOTH TABLES 1ST TIME WATLOP: MOVE T1,[-WATLEN,,WATTAB] ;POINT TO TABLE PUSHJ P,FNDNAM ;LOOK FOR ABBREV. JRST WATLP1 ;ERROR CAIL T1,NOTTAB-WATTAB ;SEE IF IN NOTTAB JRST WATCH2 ;YES, MUST BE NO, ALL, NONE MOVNI T1,(T1) ;-NO. OF ENTRY IN TABLE MOVSI T2,JW.WCX ;FIRST BIT ROT T2,(T1) ;ROTATE RIGHT TO PROPER POSITION WATCH1: XCT P1 ;ANDCAM OR IORM T2,JBTWCH(J) PUSHJ P,CTEXT ;GET NEXT ARG JUMPE T2,CPOPJ## ;0 IF FINISHED OR NONE JRST WATLOP ;AND SET A BIT FOR IT WATCH2: SUBI T1,WATLEN ;RELATIVE TO NOTTAB TRNN T1,1 ;NO OR NONE? HRLI P1,(ANDCAM T2,(J)) ;YES MOVSI T2,WCHALL ;READY FOR ALL,NONE JUMPN T1,WATCH1 ;YES IT IS PUSHJ P,CTEXT ;GET ARG OF NO JUMPN T2,WATLOP ;SEE IF VALID WATLP1: JSP T1,ERRMES ;NO, TELL USER THE LEGAL ONES ASCIZ /Args are: contexts,day,run,wait,read,write,version,mta,files,all,none/ $LOW WATTAB:: ;ADD NEW ITEMS HERE AND IN ERROR COMMENT AND IN S.MAC WATLEN==.-WATTAB WTCMXL==:B26 ;THIS TABLE MUST BE IN ORDER NO, ALL, NONE ;AND MUST FOLLOW WATTAB NOTTAB: NOTLEN==.-NOTTAB $HIGH SUBTTL SET COMMAND AND UUO -- DATE SETDAT::PUSHJ P,SETLGL ;TEST FOR LEGALITY JRST COMERA ;NOT PRIVILEGED PUSHJ P,SAVE3## ;FRE UP SOME ACS MOVE P1,LOCYER## ;SAVE THE OLD DATE MOVE P2,LOCMON## MOVE P3,LOCDAY## MOVEI T1,LOCYER## PUSHJ P,GTDATE ;ACCEPT E.G. 3-JAN-72 JRST [MOVEM P1,LOCYER## ;RESTORE OLD DATE MOVEM P2,LOCMON## MOVEM P3,LOCDAY## JRST COMERR] ;BAD DATA SETDT2: AOS (P) ;SKIP RETURN PUSH P,DATE## ;SAVE OLDDAE PUSHJ P,SUDATE## ;RECOMPUTE UNIV. DATE POP P,T1 ;GET OLD DATE BACK SUB T1,DATE## ;SUBTRACT NEW FROM OLD MOVNS T1 ;MAKE IT ADDITIVE MOVEM T1,DTCVAL ;SAVE DATE/TIME CHANGE VALUE MOVE T2,HIGHJB## ;GET HIGHEST JOB ASSIGNED SETDT3: SKIPE JBTJLT##(T2) ;ANYTHING THERE? ADDM T1,JBTJLT##(T2) ;YES, ADJUST IT HRRZ T3,JBTPDB##(T2) ;GET PDB ADDR CAIE T3,0 ;SEE IF THERE ADDM T1,.PDSTM##(T3) ;YES ADJUST IT SOJG T2,SETDT3 ; AND LOOP SKIPE RSDTTM## ;LAST CPU ROLE SWITCH? ADDM T1,RSDTTM## ;YES--UPDATE IT IFN FTNSCHED,< SKIPE SCDSTS## ;LAST SETTING OF SCHEDULER PARAMETERS? ADDM T1,SCDSTS## ;YES--UPDATE IT >;END IFN FTNSCHED SKIPE SCDSET## ;.. ADDM T1,SCDSET## ;YES PUSHJ P,FILSDT## ;TELL FILSER TO FIX THINGS UP PUSHJ P,ENQSDT## ;AND QUESER PUSHJ P,PSISDT## ;SIGNAL USERS TOO SETZ T1, ;CAUSE SEB ALLOCATION TO HAPPEN XMOVEI T2,DTCTBL ;POINT TO TRANSFER TABLE PUSHJ P,XFRSEB## ;FILL AND QUEUE UP RECORD JFCL ;NO CORE IFN FTKL10,< PUSHJ P,THSDA## ;RECOMPUTE 12 BIT DATE PJRST COMSDT## ;TELL ANY FRONT ENDS ABOUT D/T CHANGE >;END IFN FTKL10 IFN FTKS10, ;RECOMPUTE 12 BIT DATE AND RETURN ;DATE/TIME CHANGE TRANSFER TABLE FOR ERROR.SYS LOGGING DTCTBL: SEBTBL (.ERCSC,DTCEND,) MOVE DTCVAL ;(R00) OFFSET TO NEW DATE/TIME MOVE DATE## ;(R01) CURRENT DATE/TIME MOVSI .CSCTC ;(R02) REASON CODE DTCEND:! ;END OF TABLE $LOW DTCVAL: EXP 0 ;DATE/TIME CHANGE VALUE $HIGH SETDT1: IFN FTMP,< ;IF SMP PUSHJ P,ONCPU0## ;RUN ON POLICY CPU >;END IFN FTMP IDIVI T2,^D31 ;DECOMPOSE 12 BIT DATE INTO LOCYER... AOS T3 MOVEM T3,LOCDAY## IDIVI T2,^D12 AOS T3 MOVEM T3,LOCMON## ADDI T2,^D1964 MOVEM T2,LOCYER## JRST SETDT2 ;GO MAKE & STORE THSDAT & DATE SETKSY:: IFN FTMP,< ;IF SMP PUSHJ P,ONCPU0## ;RUN ON POLICY CPU >; END IFN FTMP CAIN T2,-1 ;KSYS NOW? SETOM T2 ;YES MOVEM T2,SYSKTM## ;STORE VALUE FOR CLOCK1 PUSHJ P,PSIKSY## ;TELL EVERYONE OF CHANGE JRST CPOPJ1## ;RETURN SUBTTL SET COMMAND AND UUO -- SPOOL SETSPL::PUSHJ P,SAVE2## ;SAVE P1 MOVE P1,[IORM T2,JBTSPL##(J)] ;WE'RE CHANGING JBTSPL PUSHJ P,CTXDEV ;GET 1ST ARG JUMPE T2,NOTENF ;NOT ENOUGH ARGS MOVE T1,[-NOTLEN,,NOTTAB] PUSHJ P,FNDNAM ;SEE IF NO. ALL, NONE JRST SETSP0 ;NO, SEE IF DEVICE TRNN T1,1 ;IS IF NO OR NONE HRLI P1,(ANDCAM T2,(J)) ;YES, TURN OFF BIT JUMPN T1,SETSP3 ;ALL OR NONE? PUSHJ P,CTXDEV ;NO, GET ARG FOR NO JUMPE T2,NOTENF ;NOT ENOUGH ARGS SETSP0: MOVEI F,SPLTAB## ;POINT TO SPOOL TABLE TRNN T2,-1 ;DID HE SPEC A PHYS DEV? JRST SETSP1 ;NO ALL IS OK JSP T1,ERRMES ;YES, GIVE A MESSAGE ASCIZ /Cannot spool a physical device / SETSP1: CAMN T2,SPLNAM##(F) ;HATCH? JRST SETSP2 ;YES! ADDI F,SPLLEN## ;BUMP TO NEXT CARRY CAIGE F,SPLTOP## ;DONE? JRST SETSP1 ;NO, LOOP JSP T1,ERRMES ;YES, NOT FOUND ASCIZ /Not a spoolable device / SETSP2: HRRZ T2,SPLBIT##(F) ;GET THE SPOOL BIT SKIPA ;SKIP ALTERNATE ENTRY SETSP3: MOVEI T2,.SPALL ;ALL OR NONE TLNE P1,20000 ;P1 AN ANDCAM? JRST SETSP4 ;NO - ALWAYS ALLOWED TO SET SPOOLING MOVSI T1,PVNSPL ;PRIV? TSNN T1,STATES## ;OR SCHED BIT? PUSHJ P,PRVBIT ;90 SEC. ;NOTE THIS CODE DEPENDS ON PVNSPL=ST.NSP IFN PVNSPL-ST.NSP, JRST SETSP4 ;YES - OK JSP T1,ERRMES ;NO - TYPE THE MESSAGE: ASCIZ /No privs to unspool / SETSP4: XCT P1 ;TURN ON/OFF SPOOL BIT(S) MOVE F,LDBDDB##(U) ; AND F PUSHJ P,CTXDEV ;GET NEXT DEV JUMPE T2,CPOPJ## ;RETURN IF NOTHING JRST SETSP0 ;AND SET ITS BIT SUBTTL SET COMMAND AND UUO -- DEFER/NODEFER - BATCH STREAM - WTO - OPER PRIV ;ENTER HERE ON SETUUO FOR DEFER/NODEFER SETDFU: JUMPE T2,SETNDC ;ZERO MEANS NO-DEFERED ; ELSE FALL INTO DEFER ;ENTER HERE ON SET DEFER COMMAND SETDFC::MOVEI T2,JB.DFR ;GET DEFER BIT IORM T2,JBTSPL##(J) ;SET IT JRST CPOPJ1## ;RETURN ;ENTER HERE ON SET NODEFER COMMAND SETNDC::MOVEI T2,JB.DFR ;GET DEFER BIT ANDCAM T2,JBTSPL##(J) ;CLEAR IT JRST CPOPJ1## ;RETURN ;ENTER HERE ON SETUUO FOR BATCH-STREAM-NUMBER SETBSN: MOVSI T1,(JB.BSS) ;LOAD "ALREADY SET" BIT TDNE T1,.PDOBI##(W) ;TEST IT JRST ECOD0## ;SET ALREADY! DPB T2,PDYBSN## ;STORE VALUE IORM T1,.PDOBI##(W) ;SET BIT JRST CPOPJ1## ;RETURN ;ENTER HERE ON SETUUO FOR WTO CAPABILITIES SETWTO: DPB T2,PDYWTO## ;STORE VALUE JRST CPOPJ1## ;AND RETURN ;ENTER HERE ON SET OPER PRIVILEGE SETOPP: DPB T2,PDYOPP## JRST CPOPJ1## SUBTTL SET COMMAND AND UUO -- DEFAULTS SETDFL::PUSHJ P,CTEXT ;GET DEFAULT ARGUMENT MODIFIER JUMPE T2,NOTENF ;MUST BE ONE MOVE T1,[-DFLTTL,,DFLTTB] ;ARGUMENT FOR FNDNAM PUSHJ P,FNDNAM ;SEE IF A LEGAL MODIFIER WAS SPECIFIED JRST COMERA ;BAD ARGUMENT TLNN P4,JLOG SKIPGE DFLCTB(T1) JRST @DFLCTB(T1) ;DISPATCH TO SET THE DEFAULT JRST STARTE ;HERE ON SET DEFAULT UUO SETDLU: HRR M,T2 ;ADDRESS OF FUNCTION CODE PUSHJ P,GETWDU## ;GET THE FUNCTION CODE HLRZ T2,T1 ;NUMBER OF ARGUMENTS HRRZS T1 ;FUNCTION CODE CAILE T1,DFLUTL ;IS IT A DEFINED FUNCTION CODE? JRST ECOD0## ;NO, ERROR RETURN JRST @DFLUTB(T1) ;DISPATCH TO SET THE DEFAULT DEFINE NAMES< C PROTECTION,DFLPRT,0 C BUFFERS,DFLBFN,0 C ACCOUNT,DFLACS,400000 C BIGBUF,DFLBBC,0 > DEFINE C(A,B,D,E)< IFNB, > XALL DFLTTB::NAMES DFLTTL==.-DFLTTB DFLMXL==:B26 DEFINE C(A,B,D,E)< XWD D,B > DFLCTB: NAMES DFLUTB: EXP DFLPRU EXP DFLBFU EXP DFLDAU EXP DFLBBU DFLUTL==.-DFLUTB-1 SALL ;HERE ON SET DEFAULT PROTECTION COMMAND DFLPRT: MOVE T1,[-2,,[SIXBIT /ON/ SIXBIT /OFF/]] PUSHJ P,TXTARG ;WAS "ON OR OFF" TYPED? JRST DFLPR0 ;NO JUMPE T1,DFLPR1 ;JUMP IF ON WAS TYPED MOVSI T1,(PD.DPS) ;YES, CLEAR THE BIT WHICH SAYS ANDCAM T1,.PDDFL##(W) ; DEFAULT PROTECTION WAS SET POPJ P, ;AND RETURN DFLPR0: PUSHJ P,SKIPS1 ;SKIP BLANKS, TABS, ETC. JFCL ;IGNORE CAIN T3,074 ;WAS A BRACKET TYPED ? PUSHJ P,COMTYS ;YES, FLUSH IT. PUSHJ P,OCTIN1 ;READ THE PROTECTION VALUE JRST NOTENF ;IT MUST BE THERE JRST COMERA ;ILLEGAL CHARACTER TDNE T2,[-1,,777000] ;LEGAL PROTECTION VALUE ? JRST COMERA ;NO, COMPLAIN DPB T2,PDYDPT## ;STORE DEFAULT PROTECTION JRST DFLPR1 ;AND INDICATE A DEFAULT WAS SPECIFIED ;HERE ON SET DEFAULT PROTECTION UUO DFLPRU: PUSHJ P,GETWD1## ;GET THE PROTECTION VALUE TDNE T1,[-1,,777000] ;LEGAL ? JRST ECOD0## ;NO, ERROR RETURN DPB T1,PDYDPT## ;STORE DEFAULT PROTECTION DFLPR1: MOVSI T1,(PD.DPS) ;DEFAULT PROTECTION SPECIFIED BIT IORM T1,.PDDFL##(W) ;LITE THAT JRST CPOPJ1## ;AND GIVE GOOD RETURN ;HERE ON SET DEFAULT NUMBER OF BUFFERS COMMAND DFLBFN: PUSHJ P,DECIN ;READ NUMBER JRST NOTENF ;NOT THERE JRST COMERA ;NOT A NUMBER TDNE T2,[-1,,777000] ;IN RANGE? JRST COMERA ;NO, ERROR SKIPA T1,T2 ;YES, STORE DEFAULT NUMBER ;HERE ON SET DEFAULT BUFFERS UUO DFLBFU: PUSHJ P,GETWD1## ;GET ARGUMENT TDNE T1,[-1,777000] ;IN RANGE? JRST ECOD0## ;NO, ERROR DPB T1,PDYBFN## ;STORE DEFAULT NUMBER OF DISK BUFFERS JRST CPOPJ1## ;AND GIVE GOOD RETURN ;HERE ON SET DEFAULT DON'T ASK ABOUT DETACHED JOBS UUO DFLDAU: PUSHJ P,GETWD1## ;GET ARGUMENT MOVE T2,.PDDFL##(W) ;DEFAULT WORD SKIPN T1 ;SET? TLZA T2,(PD.DAD) ;NO, CLEAR TLO T2,(PD.DAD) ;YES MOVEM T2,.PDDFL##(W) ;STORE ANSWER JRST CPOPJ1## ;AND GIVE GOOD RETURN ;HERE TO SET DEFAULT ACCOUNT STRING (USED FOR JOBS LOGGED IN ON FRCLIN) DFLACS: PUSHJ P,SETLGL ;MUST BE OPR JRST COMERA ;NOT, COMPLAIN PUSHJ P,SAVE2## ;WORKING ACS HRRZ P1,JBTPDB##+0 ;NULL JOB'S PDB ADD P1,[POINT 7,.PDACS##] ;WHERE TO STORE DEFAULT HRREI P2,5*ACTSTL##-1 ;LENGTH OF ACCOUNT STRING JUMPLE P2,COMERA ;FORGET IT IF ZERO LENGTH DFLAC1: PUSHJ P,COMTYI## ;NEXT CHARACTER CAIE T3,12 ;LINEFEED? CAIN T3,3 ;OR CONTROL C JRST DFLAC2 ;YES, THAT'S ALL FOLKS IDPB T3,P1 ;NO, STORE THE CHARACTER SOJG P2,DFLAC1 ;LOOP FOR MORE DFLAC2: MOVEI T1,0 ;ASCIZIZE IDPB T1,P1 POPJ P, ;RETURN ;HERE ON SET DEFAULT BIGBUF COMMAND DFLBBC: PUSHJ P,DECIN ;GET THE NUMBER OF BLOCKS PER BUFFER JRST NOTENF ;NOT THERE JRST COMERA ;NOT A NUMBER MOVE T1,T2 CAILE T1,LIMBBF ;IN RANGE? JRST COMERA ;NO, ERROR TLO M,400000 ;SET THAT IT GETS SET PERMANENTLY JRST DFLBB2 ;HERE ON SET DEFAULT BIGBUF UUO DFLBBU: PUSHJ P,GETWD1## TLNN T1,-1 ;SET JOB-WIDE DEFAULT? JRST DFLBB1 ;NO, CONTINUE HLRZS T1 ;YES, MAKE IT AN RH QUANTITY TLO M,400000 ;PRETEND WE HAVE A COMMAND DFLBB1: CAILE T1,LIMBBF## ;IN RANGE? JRST ECOD0## ;NO, ERROR DFLBB2: LSH T1,BLKLSH## ;YES, CONVERT TO NUMBER OF WORDS SKIPE T1 ;CLEAR IT IF ARGUMENT IS 0 ADDI T1,1 SKIPL M ;UUO? HRLM T1,.PDLBS##(W) ; SAVE IN PDB SKIPGE M ;COMMAND? HRRM T1,.PDLBS##(W) ; SAVE IN PBD JRST CPOPJ1## ;AND TAKE GOOD RETURN SUBTTL SET COMMAND AND UUO -- BREAK IFN FTKS10,< ;NO ADDRESS BREAK XP SETBRK,COMERA XP SETABR,CPOPJ## XP CLRBRK,CPOPJ## > IFN FTKL10,< ;HERE IF THE USER TYPED SET BREAK SETBRK::PUSHJ P,SAVE2## ;SAVE P1,P2 PUSHJ P,FNDPDS## ;FIND THE PDB FOR THIS USER MOVSI P1,400000 ;NO NUMBER SEEN YET PUSHJ P,OCTPRG ;SEE IF FIRST ARGUMENT IS A NUMBER JRST SETBR2 ;NOT A NUMBER, LOOK FOR LEGAL TEXT SETBR1: MOVE P1,T2 ;NUMBER TO P1 CAIG P1,17 ;WEED OUT REFERENCES CAIGE P1,1 ; TO THE ACS CAMLE P1,[MXSECN,,-1] ;REPORT THIS AS AN ERROR RATHER THAN CONFUSING USER JRST COMERA ;COMPLAIN DPB P1,[POINT 23,.PDABS##(W),35] ;STORE BREAK ADDRESS PUSHJ P,SGSEND ;SEE IF EOL JRST SETBR2 ;NO, READ NEXT ARGUMENT SKIPN P2,P1 ;BREAK ADDRESS ZERO? JRST SETB10 ;YES, TREAT SET BREAK 0 WITH NO CONDITION LIKE NONE HLLZ P2,.PDABS##(W) ;GET PREVIOUS CONDITIONS IF ANY TLZ P2,(OC.BSU) ;CLEAR SET BY UUO SETB1A: TLNN P2,(OC.BCI+OC.BCD+OC.BCW+OC.BCM) ;WERE THERE ANY PREVIOUSLY? TLO P2,(OC.BCI+OC.BCD+OC.BCW) ;NO, ASSUME ALL JRST SETBR8 ;ENABLE BREAK, STORE CONDITIONS, AND GO AWAY SETBR2: MOVE T1,[-4,,BRKLS1] ;TABLE LENGTH,,ADDRESS OF THE TABLE PUSHJ P,TXTARG ;RECOGNIZABLE TEXT ARGUMENT? JRST SETBR5 ;NO, POSSIBLY IN ANOTHER CONTEXT MOVE P2,T1 ;INDEX INTO BRKTBL JUMPN T1,SETBR3 ;JUMP IF THE USER DIDN'T TYPE 'NONE' ;HERE WHEN THE USER TYPED 'NONE' JUMPGE P1,COMERA ;IF A NUMBER WAS TYPED WE SHOULDN'T BE HERE JRST SETB10 ;GO CLEAR BREAK CONDITIONS SETBR3: PUSHJ P,SGSEND ;AT END OF LINE? CAIA ;NO JRST NOTENF ;IF WE'RE HERE THERE HAS TO BE ONE JRST .(P2) ;DISPATCH TO THE APPROPRIATE PROCESSOR JRST SETBR4 ;USER TYPED 'AT' JRST SETBR5 ;USER TYPED 'ON' JRST SETBR6 ;USER TYPED 'NO' ;HERE WHEN THE USER TYPED 'AT' SETBR4: JUMPGE P1,COMERA ;NO PREVIOUS NUMBERS ALLOWED IF WE GET HERE PUSHJ P,OCTPRG ;READ A NUMBER JRST COMERA ;IT MUST BE A NUMBER BUT ISN'T SO COMPLAIN JRST SETBR1 ;LOOK FOR THE NEXT TEXT ARGUMENT ;HERE WHEN THE USER TYPED 'ON' SETBR5: SKIPA P1,[TDO P2,BRKTBL-1(T1)] ;HERE WHEN THE USER TYPED 'NO' SETBR6: MOVE P1,[TDZ P2,BRKTBL-1(T1)] HLLZ P2,.PDABS##(W) ;GET CURRENT BREAK CONDITIONS TLZ P2,(OC.BSU) ;CLEAR SET BY UUO SETBR7: MOVE T1,[-7,,BRKLS2] ;TABLE LENGTH,,TABLE ADDRESS PUSHJ P,TXTARG ;GET A BREAK CONDITION JRST COMERA ;IT CAN'T BE ANYTHING ELSE JUMPE T1,SETB11 ;JUMP IF 'USERS' CAIN T1,AFTERX JRST SETB12 XCT P1 ;SET OR CLEAR THE CONDITION PUSHJ P,SGSEND ;LAST ARGUMENT? JRST SETBR7 ;NO, CHECK NEXT ARGUMENT TLZ P2,(OC.ABE+OC.FUP) ;ASSUME NO CONDITIONS TLNN P2,(OC.BCI+OC.BCD+OC.BCW+OC.BCM) ;ANY CONDITIONS DESIRED? JRST SETB10 ;NO, DECREMENT NUMBER OF USERS USING ADDRESS BREAK SETBR8: PUSHJ P,BRKAV ;SEE IF ADDRESS BREAK IS AVAILABLE AND INCREMENT ; THE COUNT OF USERS USING IT IF SO JRST NOBRAK ;NOT AVAILABLE, COMPLAIN SETBR9: TLOA P2,(OC.ABE+OC.FUP) ;ENABLE THE USER FOR ADDRESS BREAK SETB10: PUSHJ P,BRKDEC ;DECREMENT THE COUNT OF USERS USING ADDRESS BREAK LSH P2,-^D23 ;POSITION BITS DPB P2,[POINT 13,.PDABS##(W),12] ;STORE NEW CONDITIONS POPJ P, ;AND RETURN TO COMCON ;HERE WHEN THE USER TYPED 'USERS', MUST BE PRIVILEGED SETB11: PUSHJ P,SETLGL ;USER SUFFICIENTLY PRIVILEGED TO MONOPOLIZE ; ADDRESS BREAK? JRST COMERA ;NO, COMPLAIN PUSHJ P,FDNJP ;FIND THE NULL JOB'S PDB MOVSI T2,400000 ;SET TO TURN ON OR OFF ADDRESS BREAK CAME P1,[TDZ P2,BRKTBL-1(T1)] ;WAS 'USERS' WITHOUT A 'NO' TYPED? JRST [ANDCAM T2,.PDABS##(T1) ;YES, ALLOW USERS TO USE ADDRESS BREAK POPJ P,] ;RETURN ;HERE WHEN THE USER TYPED 'NO USERS' SKIPLE .PDABS##(T1) ;IS ADDRESS BREAK CURRENTLY BEING USED? JRST NOBRAK ;DON'T ALLOW HIM TO YANK IT OUT FROM UNDER THEM IORM T2,.PDABS##(T1) ;DON'T ALLOW USERS TO USE ADDRESS BRAEK POPJ P, ;RETURN TO COMCON ;HERE WHEN THE USER TYPED 'AFTER' SETB12: PUSHJ P,DECIN ;GET THE NEXT ARGUMENT PJRST NOTENF ;THERE MUST BE ONE JRST COMERA ;NOTHING BUT A NUMBER IS LEGAL CAILE T2,^D510 ;IS IT TOO BIG? JRST COMERA ;YES ADDI T2,1 DPB T2,[POINT 9,.PDTMI##(W),17] ;SAVE THE REPEAT COUNT JRST SETB1A ;STORE IT AND GO AWAY ;HERE ON A SET ADDRESS BREAK UUO SETABR::PUSHJ P,SAVE2## ;SAVE P1,P2 HRR M,T2 ;ADDRESS OF USER'S ARGUMENT PUSHJ P,GETWDU## ;GET THE ARGUMENT LDB P1,[POINT 9,T1,17] ;GET PROCEED COUNT DPB P1,[POINT 9,.PDTMI##(W),17] ;STORE IT LDB P1,[POINT 5,T1,8];GET SECTION NUMBER DPB P1,[POINT 14,T1,17] ;STORE THAT DPB T1,[POINT 23,.PDABS##(W),35] ;STORE BREAK ADDRESS MOVE P2,T1 ;P2 = BREAK CONDITIONS TLO P2,(OC.BSU) ;INDICATE SET BY UUO AOS (P) ;PREPARE TO GIVE GOOD RETURN TLNN P2,(OC.BCI+OC.BCD+OC.BCW+OC.BCM) JRST [PUSHJ P,SETB10 ;TURNING OFF BREAK PJRST SETRL1##] PUSHJ P,BRKAV ;IS ADDRESS BREAK AVAILABLE? SOSA (P) ;NO, ERROR RETURN JRST [PUSHJ P,SETBR9 ;YES, SETUP BREAK CONDITIONS PJRST SETRL1##] JRST ECOD0## ;GIVE ERROR RETURN ;HERE ON RESET TO CLEAR BREAK ADDRESS AND CONDITIONS ; IF SET BY UUO CLRBRK::SKIPE T1,.PDABS##(W) ;BREAK IN USE AT ALL? TLNN T1,(OC.BSU) ;AND SET BY UUO? POPJ P, ;NO PUSHJ P,BRKDEC ;YES, DECREMENT COUNT OF USERS SETZM .PDABS##(W) ;CLEAR ADDRESS AND CONDITIONS POPJ P, ;AND RETURN ;THE ORDER OF AND THE NUMBER OF ENTRIES ; IN THE FOLLOWING TABLES CANNOT BE CHANGED ; WITHOUT CHANGING THE CODE IN SETBRK BRKLS1: SIXBIT /NONE/ SIXBIT /AT/ SIXBIT /ON/ SIXBIT /NO/ BRKLS2: SIXBIT /USERS/ SIXBIT /EXECUT/ SIXBIT /READ/ SIXBIT /WRITE/ SIXBIT /MUUO/ SIXBIT /ALL/ BRKLS3: SIXBIT /AFTER/ AFTERX==BRKLS3-BRKLS2 ;THE ENTRIES IN THIS TABLE CORRESPOND IN ORDER ; TO THE ENTRIES IN THE ABOVE TABLE BRKTBL: EXP OC.BCI EXP OC.BCD EXP OC.BCW EXP OC.BCM EXP OC.BCI+OC.BCD+OC.BCW ;SUBROUTINE TO DETERMINE WHETHER ADDRESS BREAK IS AVAILABLE TO USERS ;CALLING SEQUENCE: ; PUSHJ P,BRKAV ;NON-SKIP RETURN IF NOT AVAILABLE BECAUSE MEMORY ; INDICATORS ARE DISABLED OR ADDRESS BREAK IS BEING ; USED BY SYSTEM PROGRAMMERS FOR MONITOR DEBUGGING ;SKIP RETURN IF ADDRESS BREAK IS AVAILABLE TO USERS, COUNT OF THE NUMBER ;OF USERS USING ADDRESS BREAK HAS BEEN UPDATED ;PRESERVES T2 BRKAV: PUSHJ P,FDNJP ;FIND THE NULL JOB'S PDB IFN FTMP,< PUSHJ P,CP0RC## ;SEE IF THE JOB IS RUNNABLE ON CPU0 TLNN P2,(OC.BCM) ;ITS NOT, BUT IF HE IS ENABLED FOR UUOS, SOME > ; MUST HAPPEN ON CPU0 SKIPGE .PDABS##(T1) ;HAS ADDRESS BREAK BEEN DISABLED BY THE OPR? POPJ P, ;YES, LOSE MOVE T3,.PDABS##(W) ;GET HIS CURRENT ADDRESS BREAK SETTINGS TLNN T3,(OC.ABE) ;IS HE ALREADY BREAKING? AOS .PDABS##(T1) ;NO, COUNT UP THE NUMBER OF USERS USING ADDRESS BREAK JRST CPOPJ1## ;AND GIVE THE HAPPY RETURN ;SUBROUTINE TO DECREMENT THE COUNT OF THE NUMBER ; OF USERS USING ADDRESS BREAK BRKDEC: MOVE T1,.PDABS##(W) ;GET HIS CURRENT BREAK SETTINGS TLNN T1,(OC.ABE) ;IS HE ENABLED FOR ADDRESS BREAK? POPJ P, ;NO, NOTHING TO DO PUSHJ P,FDNJP ;FIND THE PDB FOR THE NULL JOB SOS .PDABS##(T1) ;DECREMENT THE COUNT OF USERS USING ADDRESS BREAK POPJ P, ;AND RETURN NOBRAK: PJSP T1,CONMES ;SORRY FOLKS! ASCIZ /?Not available / ;SUBROUTINE TO RETURN THE ADDRESS OF THE NULL JOB'S PDB IN T1 ;PRESERVES T2-T4 FDNJP:: MOVEI T1,0 ;NULL JOB'S JOB NUMBER PUSHJ P,FPDBT1## ;FIND THE NULL JOB'S PDB, RETURN ITS ADDRESS IN T1 JFCL ;IT MUST HAVE ONE POPJ P, ;RETURN TO THE CALLER >;END IFN FTKI10!FTKL10 SUBTTL SET COMMAND AND UUO -- PRIVILEGE WORDS ;HERE FOR UUO TO CHANGE PRIVILEGES SETPRV: HRRI M,(T2) ;POINT TO FIRST ARGUMENT PUSH P,J ;SAVE JOB NUMBER PUSHJ P,GETWDU## ;PICK UP FUNCTION CODE SKIPL T2,T1 ;SEE IF NEGATIVE CAILE T2,SPRVMX ;OR TOO LARGE JRST [POP P,J ;BALANCE THE STACK JRST ECOD0##] ;YES, ERROR RETURN ADDI M,1 PUSHJ P,GTWST2## ;GET ARGUMENT INTO T1 POP P,J ;RESTORE JOB NUMBER JRST @SPRVTB(T2) ;DISPATCH SPRVTB: EXP SPRVWD ;(0) SET PRIVILEGE WORD EXP SPRVON ;(1) SET BITS IN PRIV WORD EXP SPRVOF ;(2) CLEAR BITS IN PRIV WORD EXP SCAPWD ;(3) SET CAPABILITY WORD EXP SCAPON ;(4) SET BITS IN CAPABILITY WORD EXP SCAPOF ;(5) CLEAR BITS IN CAPABILITY WORD SPRVMX==.-SPRVTB-1 ;HIGHEST FUNCTION SPRVOF: ANDCAB T1,JBTPRV##(J) ;CLEAR REQUESTED BITS JRST STOTC1## ;AND STORE RESULT SPRVON: IOR T1,JBTPRV##(J) ;INCLUDE BITS HE ALREADY HAS SPRVWD: MOVE T2,.PDCAP##(W) ;GET CAPABILITIES ANDCB T2,JBTPRV##(J) ;GET BITS HE CAN'T GET TDNE T1,T2 ;TRYING TO SET BITS HE CAN'T HAVE? PUSHJ P,PRVJ ;YES, BUT SEE IF PRIVILEGED SKIPA ;OK TO SET BITS JRST ECOD0## ;LOSE, ERROR RETURN MOVEM T1,JBTPRV##(J) ;SET NEW PRIVILEGE WORD JRST STOTC1## ;AND STORE FOR USER TO SEE SCAPOF: ANDCAB T1,.PDCAP##(W) ;CLEAR REQUESTED BITS JRST STOTC1## ;AND RETURN RESULT SCAPON: IOR T1,.PDCAP##(W) ;INCLUDE BITS ALREADY OWNED SCAPWD: SETCM T2,.PDCAP##(W) ;GET BITS HE CAN'T SET TDNE T1,T2 ;NOT SETTING ANY NEW BITS? PUSHJ P,PRVJ ;OR IS PRIVILEGED USER? SKIPA ;YES, OK JRST ECOD0## ;NO, LOSES MOVEM T1,.PDCAP##(W) ;SET NEW CAPABILITY WORD JRST STOTC1## ;AND GIVE TO USER ;HERE FOR COMMANDS TO ENABLE OR DISABLE PRIVILEGES. ;ONLY THE WHOLE WORD CAN BE MODIFIED NOW. DISABL::SETZM JBTPRV##(J) ;CLEAR WORD POPJ P, ;AND RETURN. ENABLE::MOVE T1,.PDCAP##(W) ;GET CAPABILITIES IORM T1,JBTPRV##(J) ;ADD TO PRIVILEGE WORD POPJ P, ;DONE SUBTTL SET COMMAND AND UUO -- CDR ;ENTER HERE ON SET CDR UUO SETSPI: HRLOS T2 ;GET NAME, -1 AOS (P) ;AND SKIP COMMAND ENTRY AND FORCE SUCCESS RETURN JRST SETCD2 ;SET CDR COMMAND SETCDR::PUSHJ P,CTEXT1 ;GET FILE NAME JUMPE T2,NOTENF ;NONE SPECIFIED TRNE T2,-1 ;MORE THAN 3 CHARACTERS? JRST COMERA ;YES. NO GOOD. SETCD2: HLLM T2,JBTSPL##(J) ;SAVE NAME POPJ P, ;AND RETURN ;HERE TO SET SPOOL BITS BY UUO SETSPB: SETCM T3,T2 ;-BITS HE WANTS ON ANDI T3,.SPALL TDNN T3,JBTSPL##(J) ;CLEARING SOME BITS FROM JBTSPL? JRST SETSPC ;NO - OK MOVSI T1,PVNSPL ;PRIV? TSNN T1,STATES## ;OR SCHED BIT? PUSHJ P,PRVBIT ;GO SEE ;NOTE THIS CODE DEPENDS ON PVNSPL=ST.NSP IFN PVNSPL-ST.NSP, JRST SETSPC ;YES. GO DO IT. JRST ECOD0## ;NO. FAILURE RETURN SETSPC: DPB T2,[POINT 5,JBTSPL##(J),35] ;YES, DO IT JRST CPOPJ1## ;SUCCESS RETURN DSKSIL::PUSHJ P,SETLGL ;LEGAL? JRST COMERA ;NO PUSHJ P,CTEXT1 ;YES, GET DRIVE NAME MOVE T1,T2 ;INTO T1 CAMN T2,[SIXBIT 'PDP11'] ;DOES HE WANT TO STOP PDP-11 MESSAGE? PJRST D76SIL## ;YES--GO SHUT HIM UP IFN FTKS10,< CAMN T2,[SIXBIT 'MEMORY'] ;DOES HE WANT TO STOP MEMORY ERROR MESSAGES? PJRST MEMSIL## ;YES--GO SHUT HIM UP >; END IFN FTKS10 PUSHJ P,TPMSIL## ;SEE IF A TAPE KONTROLLER PJRST CPOPJ1## ;YES - EXIT PUSHJ P,DSKQUI## ;STOP MESSAGES FOR THIS DRIVE JRST COMERA ; NO SUCH UNIT, OR WRONG STATUS PJRST CPOPJ1## ;OK SUBTTL SET COMMAND AND UUO -- DISK STUFF ;SET DSKPRI N DSKPRI::TLZA P4,-1 ;CLEAR LH(P4) DSKPR2: TLO P4,-1 ;MINUS, SET LH(P4)=-1 PUSHJ P,SKIPS ;GET FIRST CHAR JRST NOTENF CAIN T3,"-" ;-? JUMPE T2,DSKPR2 ;YES, SET LH(P4), TRY AGAIN PUSHJ P,DECIN1 ;NO, GET THE NUMBER JRST NOTENF JRST COMERA SKIPGE P4 ;- SEEN? MOVNS T2 ;YES PUSHJ P,PRICOM## ;CALL FILSER TO CHECK PRIUS SKIPA POPJ P, PRIERR::JSP T1,ERRMES ASCIZ /No privileges to set priority that high / ;SET DSKFUL PAUSE (ERROR) FULSTP::PUSHJ P,CTEXT MOVE T1,[-2,,STPNST] ;LOOK AT ARGUMENT PUSHJ P,FNDNAM PJRST COMERA STPSET: MOVEI T2,JS.SFL XCT STPXCT(T1) ;TURN THE PAUSE-BIT ON OR OFF PJRST CPOPJ1## STPNST: SIXBIT /PAUSE/ SIXBIT /ERROR/ STPXCT: IORM T2,JBTSTS##(J) ANDCAM T2,JBTSTS##(J) ;SET DSKFUL UUO (0=PAUSE, 1=ERROR, OTHER=READ) DSKFUL: CAILE T2,1 ;SETTING? JRST DSKFU1 ;NO MOVE T1,T2 ;YES, T1=FUNCTION JRST STPSET ;GO SET OR CLEAR THE BIT DSKFU1: MOVEI T2,JS.SFL ;READING THE BIT TDNE T2,JBTSTS##(J) ;IS HE SET TO PAUSE? TDZA T1,T1 ;NO - 0 MOVEI T1,1 ;YES - 1 PJRST STOTC1## ;STOTAC, THEN CPOPJ1 ;UUO TO SET PROGRAM TO RUN SETPGM: PUSHJ P,PRVJ ;PRIV'D JOB? JRST SETPG1 ;YES, ALLOW IT MOVE T3,JBTLIM##(J) TLNN T3,(JB.LBT) ; IN A BATCH JOB? TLNN T3,(JB.LSY) ;FROM SYS: ? JRST ECOD0## ;NO, ERROR SETPG1: HRR M,T2 ;COPY ADDRESS PUSH P,J PUSHJ P,GETWDU## ;GET THE WORD MOVE J,(P) MOVEI T2,JS.RPC ;CLEAR BIT ANDCAM T2,JBTST2##(J) ; .. SKIPGE T1 ;WANT IT SET? IORM T2,JBTST2##(J) ;YES PUSHJ P,GETWD1## ;GET NAME POP P,J PUSHJ P,FNDPDS## MOVEM T1,.PDPGM##(W) JRST CPOPJ1## SUBTTL SET COMMAND AND UUO -- ROUTINE TO READ DATE ;GTDATE-ACCEPTS DATE IN FORM 21-JAN-72 OR ; JAN-21-72 OR 5-JAN OR JAN-5 GIVING ; CREATION YEAR AS DEFAULT ; STORES YEAR (E.G. 1972), MONTH (1-12), DAY (1-31) IN 3 WORD ; VALVE BLOCK POINTED TO BY T1. ; ;CALL T1:=ADDRESS ; PUSHJ P,GTDATE ; ERROR, RETURN ; SUCCESS RETURN GTDATE::PUSHJ P,SAVE2## ;SAVE POINTER MOVEI P1,2 ;SET LOOP COUNT MOVE P2,T1 SETZM 1(P2) ;NO MONTH TYPED YET DATE01: PUSHJ P,CTEXT ;READ NEXT ARGUMENT MOVE T1,[-MLEN,,MONTHS] PUSHJ P,FNDNAM ;SCAN FOR A MONTH JRST GTDAY ADDI T1,1 ;FORM MONTH INDEX MOVEM T1,1(P2) ;STORE MONTH SOJG P1,DATE01 ;LOOP IF DAY NEXT JRST GTYEAR GTDAY: JUMPN T1,CPOPJ## ;ERROR, AMBIGOUS MONTH SETZM T3 ;CLEAR FOR SUM DATE02: SETZ T1, LSHC T1,6 ;GET NEXT DIGIT JUMPE T1,DATE03 ;DONE, IT 0 TRC T1,20 ;FORM OCTAL REPRESENTATION CAILE T1,^D9 POPJ P, ;NOT A DIGIT IMULI T3,^D10 ADDI T3,(T1) ;FORM SUM JRST DATE02 DATE03: SKIPN 1(P2) ;IF NO MONTH WAS TYPED, MOVEM T3,1(P2) ; STORE IT AS MONTH ALSO SO OLD FORMAT WILL WIN MOVEM T3,2(P2) ;STORE DAY SOJG P1,DATE01 ;LOOP IF MONTH NEEDED GTYEAR: PUSHJ P,DECIN ;GET YEAR (IF TYPED) SKIPA T2,MONYER ;CREATION YEAR IF MONITOR POPJ P, ;BAD TERMINATOR CAIGE T2,^D100 ;IF JUST 2 CHAR'S TYPED ADDI T2,^D1900 ; ADD 1900 MOVEM T2,(P2) ;STORE YEAR JRST CPOPJ1## ;SUCCESS DEFINE .MONTH (A), > MONTHS: .MONTH MLEN==.-MONTHS MONYER: M.YEAR## ;YEAR OF MONITOR CREATION SUBTTL SET COMMAND AND UUO -- ROUTINES TO PRINT WATCH INFO ;SUBROUTINE TO PRINT TIME OF DAY USER STARTS TO WAIT FOR RESPONSE ; IF HE HAS ENABLED IT WITH "WATCH DAY" ;CALL: MOVE J,JOB NO. ; PUSHJ P,WCHBEG ; ALWAYS RETURN HERE ;THIS SUBROUTINE IS ALWAYS CALLED FROM THE COMMAND DECODER ;WHEN USER IS ABOUT TO WAIT FOR A RESPONSE WCHBEG: MOVE T2,JBTWCH##(J) MOVE T1,TIME## ;TIME OF DAY IN JIFFIES TLNE T2,JW.WWT DPB T1,JBYWCH## ;STORE FOR JOB TLNN T2,JW.WDY ;DOES USER WANT TO SEE THIS? POPJ P, ;NO. PUSHJ P,PRLBK ;YES, PRINT LEFT BRACKET MOVE T1,TIME## ;TIME OF DAY IN JIFFIES PUSHJ P,PRTIM ;PRINT HH:MM:SS(NO CRLF) ;FALL INTO PRRBKC ;SUBROUTINE TO PRINT RIGHT BRACKET,CRLF PRRBKC::PJSP T1,CONMES ASCIZ /] / ;SUBROUTINE TO PRINT LEFT BRACKET PRLBK:: PJSP T1,CONMES ASCIZ /[/ ;SUBROUTINE TO PRINT RIGHT BRACKET PRRBK:: PJSP T1,CONMES ;PRINT AND RETURN ASCIZ /]/ ;SUBROUTINE TO PRINT SYSTEM RESPONSE STATISTICS EACH TIME ;USER FINISHES WAITING FOR SYSTEM ;PRINT INCREMENTAL RUN TIME, WAIT TIME, # DISK BLKS READ, #DISK BLKS WRITTEN ;CALL: MOVE J,JOB NUMBER ; PUSHJ P,WCHEND ; ALWAYS RETURN HERE WCHEND::MOVSI T1,JW.WRN!JW.WWT!JW.WDR!JW.WDW ;USER WANT ANY RESPONSE DATA? TDNN T1,JBTWCH##(J) ; .. POPJ P, ;NO. PUSHJ P,SAVE1## ;SAVE P1 PUSHJ P,PRLBK ;YES, PRINT LEFT BRACKET PUSHJ P,FNDPDS## ;FIND PDB ADDRESS. HALT IF NONE MOVSI P1,-WCHLEN ;LOOP THRU ALL RESPONSE DATA ITEMS WCHLOP: HLLZ T1,WCHTAB(P1) ;GET BIT ASSOCIATED WITH THIS FIELD HRRZ T2,WCHTAB(P1) ;GET DISPATCH ADDRESS TDZE T1,JBTWCH##(J) ;DOES USER WANT TO WATCH IT? PUSHJ P,(T2) ;YES, PRINT IT OUT AOBJP P1,WCH1 ;FINISHED ALL FIELDS? PUSHJ P,PRSPC ;NO, PRINT A SPACE WCH1: JUMPL P1,WCHLOP ;LOOP IF MORE BITS TO CONSIDER PJRST PRRBKC ;APPEND RIGHT BRACKET, CRLF, AND RETURN ;TABLE OF ROUTINES TO PRINT RESPONSE DATA WCHTAB: XWD JW.WRN,PRTWRN ;PRINT RUN TIME XWD JW.WWT,PRTWWT ;PRINT WAIT TIME XWD JW.WDR,PRTWDR## ;PRINT # DISK BLOCKS READ XWD JW.WDW,PRTWDW## ;PRINT # DISK BLOCKS WRITTEN ;ADD NEW DATA HERE WCHLEN==.-WCHTAB ;ROUTINE TO PRINT INCREMENTAL RUNTIME(NO CRLF) ;CALL: MOVEI T1,0 ; PUSHJ P,PRTWRN PRTWRN: EXCH T1,.PDRTM##(W) ;CLEAR INCREMENTAL RUN TIME PJRST PRTIM ;PRINT AS HH:MM:SS, MM::SS OR SS.HH (NO CRLF) ;ROUTINE TO PRINT WAIT TIME (NO CRLF) ;CALL: PUSHJ P,PRTWWT PRTWWT: LDB T1,JBYWCH## ;TIME OF DAY USER STARTED TO WAIT SUB T1,TIME## ;-CURRENT TIME OF DAY = -WAIT TIME SKIPLE T1 ;IS IT REALLY MINUS? SUB T1,MIDNIT## ;NO. MUST HAVE BEEN WAITING ACROSS MIDNIGHT ; SO SUBTRACT A DAY TO GET IT NEGATIVE MOVNS T1 ;NOW MAKE IT PLUS WAIT TIME PJRST PRTIM ;TYPE OUT TIME (NO CRLF) SETWTU: HLRZ T1,JBTWCH##(J) ;GET CLOCK OVERFLOW ANDI T1,77 ;(ENOUGH FOR 24.*60.*60.*60.) TRZ T2,77 ;CLEAR REQUEST JUNK IOR T2,T1 ;INCLUDE OVERFLOW HRLM T2,JBTWCH##(J) ;SAVE WATCH BITS JRST CPOPJ1## ;AND RETURN SUBTTL CONTINUE, CCONT AND JCONT ; "CONTC" - CONTINUE EXECUTION(TTY REMAINS IN COMMAND MODE) CONTC:: ;SAME AS CONT ; "CONT" - CONTINUE EXECUTION FROM WHERE LEFT OFF CONT:: JUMPE J,STARTE ;COMPLAIN IF NO JOB LDB T1,JBYDEB## ;DEFERRED ECHO BITS SE1XCT ;RESTORE FOR CONTINUE TLNN P4,JERR ;IS JOB ERROR BIT SET? JRST CONT1 ;COMMAND DECODER WILL DO THE REST JSP T1,ERRMES ;YES, PRINT CANT CONTINUE ASCIZ /Can't continue / CONT1: IFN FTMP,< MOVE T1,USRPC## ;PC TLNE T1,(XC.USR) ;USER MODE? PJRST DPXST## ;YES, MAKE RUNNABLE ON ALL CPUS > POPJ P, ;*** NO ;JOB CONTINUE COMMAND ;FORCES A CONTINUE COMMAND FOR JOB Y JCONT:: PUSHJ P,GETJOB ;GET JOB TO CONTINUE JRST NOTENF ;MUST HAVE ARGUMENT TRNN T3,JDCON ;JOB WAITING FOR CONT? JRST JCERR2 ;NO CAMN T2,J ;SEE IF FOR US PJRST FCONT ;YES, GO DO IT MOVE T1,T2 ;GET JOB # IN CORRECT AC FOR FCONRQ PUSHJ P,FCONRQ ;GO REQUEST CONT BE FORCED FOR JOB POPJ P, ;RETURN - SUCCESSFUL PJRST SNDBSI ;NOT ENTERED - GO TYPE "BUSY" ;CALLED TO SET UP FORCED COMMAND FOR JOB CONTINUE ;JOB NUMBER IN T1 ;SKIP RETURN IF COMMAND WAS NOT ENTERED BECAUSE ALREADY A ;FORCED COMMAND PENDING FCONRQ::MOVEI T2,TTFCXJ## ;INDEX FOR FORCED CONTINUE ;SUBROUTINE TO FORCE COMMAND ;ARGS T1=JOB NUMBER ; T2=INDEX OF FORCED COMMAND COMFRC::SE1ENT ;ENTER SECTION 1 PUSH P,U ;SAVE THIS AC PUSH P,J ;SAVE THIS JOB NUMBER MOVE J,T1 ;GET HIS JOB NUMBER PUSHJ P,TTYSRC## ;SET UP LINE (LDB) JRST JCONDM ;SEE IF ATTACHED JRST COMFR2 COMFRL::SE1ENT ;ENTER SECTION 1 PUSH P,U ;SAVE ACS PUSH P,J COMFR2: JUMPE U,JCONDM ;CAN'T FORCE TO DETACHED LINE. MOVSI T1,LDBCMF## ;ANY FORCED COMMAND SCNOFF TDNE T1,LDBCOM##(U) ;FOR THIS JOB ALREADY JRST JCONDL ;YES DPB T2,LDPCMX## ;STORE COMMAND INDEX MOVSI T1,LDBCMR##+LDBCMF## ;BITS FOR FORCE PUSHJ P,COMSTF## ;WAKE COMCON (RETURNS WITH SCAN ON) POP P,J ;RESTORE JOB PJRST LPOPJ## ;RETURN ;HERE IF JOB ALREADY HAS FORCED COMMAND PENDING, DELAY THIS COMMAND JCONDL: SCNON JCONDM: POP P,J ;RESTORE JOB NUMER JRST LPOPJ1## ;CAN'T ENTER - SKIP RETURN ;HERE IF JOB NOT WAITING FOR CONTINUE JCERR2: JSP T1,ERRMES ASCIZ /Job not waiting/ ;FORCED CONTINUE COMMAND ;NO TTY OUTPUT UNLESS COMMAND IS REALLY EXECUTED - IT WILL NOT BE ; IF USER HAS TYPED A COMMAND IN THE MEAN TIME. FCONT:: MOVE P4,JBTSTS##(J) ;GET JOB STATUS TLNN P4,JERR ;CAN WE CONTINUE TRNN P4,JDCON ;IS JOB WAITING POPJ P, TLO M,TTYRNW ;SET FOR RESCHEDULE TLZ M,NOCRLF!NOMESS ;RESET NOMESS PUSHJ P,INLMES ;TELL USER HE'S CONT ASCIZ /Continued by OPR/ POPJ P, SUBTTL CORE COMMAND ; "CORE #" - ASSIGNS #*1024 WORDS OF CORE TO JOB ; "CORE" WITH NO ARG. WILL PRINT NO OF FREE BLOCKS LEFT ; WITHOUT AFFECTING CURRENT ASSIGNMENT OF CORE ; JOB NOT IN MIDDLE OF SWAPPING ; EITHER ON DISK OR CORE OR NEITHER PLACE CORE:: PUSHJ P,CORARG ;GET HIGHEST RELATIVE ADDRESS USER SPECIFIED JRST COR5 ;NO ARG. SPECIFIED, JUST TYPE FREE BLOCK LEFT TLNE T1,-1 ;NO ARG GREATER THAN A SECTION ALLOWED JRST COR4 JUMPL P4,[MOVEI T1,RUNERR ;RUNNING? JRST ERRMES] ;YES, LOSE JUMPE T1,COR1 ;RELEASE DEVICES IF USER ASKING FOR 0 CORE TRNE P4,JS.XO!JS.RUU ;SEE IF EXECUTE ONLY PJRST ILLXO ;YES -- GO GIVE ERROR HRRZ T2,JBTSGN##(J) ;CLEAR JUNK IN LH JUMPE T2,COR1 ;THERE REALLY ISN'T A HIGH SEG COR3: SKIPG T3,.HBSGN(T2) ;IS THIS A REAL SEGMENT? TLOA T3,-1 ;NO, FLAG SUCH HLLZ T3,JBTADR##(T3) ;GET SIZE OF SEGMENT HLRES T3 ;IN THE CORRECT HALF SUBI T1,1(T3) ;ROUND UP AND SUBTRACT OUT JUMPL T1,COR3D ;IF WENT NEGATIVE, ARG IS TOO SMALL HRRZ T2,.HBLNK(T2) ;NEXT SEGMENT JUMPN T2,COR3 ;CHECK IT OUT COR1: SKIPE T1 SKIPN JBTADR##(J) PUSHJ P,COR15 ;CALL UNLOCK, GETMIN, ET ALL JUMPE T1,COR0 SKIPE JBTADR##(J) ;IF DIDN'T GET CORE IN CORE. JRST COR2 LDB T2,IMGOUT## ;DID WE GET CORE ON DSK? JUMPE T2,COR4 ;ERROR IF NONE JRST DLYCM COR2: IFN FTMP,< PUSHJ P,GETMM## ;GET THE MM JRST DLYCM ;NOT AVAILABLE, DELAY > SKIPE PAGIPC## ;PAGING IN PROGRESS? IFN FTMP,< JRST [PUSHJ P,GIVMM## JRST DLYCM ] ;YES, DELAY > IFE FTMP,< JRST DLYCM > PUSHJ P,CORE0## ;GET CORE IFN FTMP,< JRST [PUSHJ P,GIVMM## ;NONE AVAILABLE JRST COR4] PUSHJ P,GIVMM## ;GIVE UP THE MM. > IFE FTMP,< JRST COR4 ;CORE NOT AVAILABLE, GO PRINT MESSAGE > LDB T1,PJBSTS## CAIE T1,NULQ## ;IN THE NO CORE Q? POPJ P, ;NO MOVEI T1,STOPQ## ;YES, OK RETURN, CORE ASSIGNED ON DISK OR MEMORY DPB T1,PJBSTS## ;PUT JOB IN THE STOP Q SINCE IT NOW HAS CORE PJRST REQUE## COR3D: PUSHJ P,INLMES ;TOO SMALL AN ARG. ASCIZ /?Try larger arg. / COR4: PUSHJ P,TTYFND## ;RE-FIND TTY LINE JUMPE U,CPOPJ## ;GIVE UP IF GOT DETACHED PUSHJ P,PRQM ;TYPE ? FOR BATCH PUSHJ P,COR11 ;PRINT USAGE/LIMIT SUMMARY TLO M,ERRFLG ;SET ERROR FLAG POPJ P, ;HERE TO GIVE CURRENT CORE SIZE FOR VM USER COR5: PUSHJ P,FNDPDS## ;FIND PDB FOR JOB SKIPN JBTADR##(J) ;DON'T BOTHER IF NO CORE JRST COR11 ;JUST SHOW LIMITS JSP T2,SAVCTX## ;WE COULD HAVE A LOT OF OUTPUT PUSHJ P,SAVE4## ;SAVE WORKING ACS PUSHJ P,INLMES ;PRINT HEADER ASCIZ /Page number Page status Origin / MOVEI P1,1 ;START WITH PAGE 1, PAGE 0 ALWAYS EXISTS PUSH P,U ;GTPACC CLOBBERS U MOVEI T1,0 ;PAGE 0 PUSHJ P,GTPACC## ;GET PAGE 0 ACCESSABILITY POP P,U ;RESTORE LDB TDZ T1,[<(PA.CPO+PA.OUT+PA.AA+PA.VSP)>,,-1] ;CLEAR DON'T CARE MOVE P2,T1 ;FOR THE LOOP MOVEI P3,0 ;END OF REGION MOVEI P4,1 ;COUNT OF PAGES COR6: MOVE T1,P1 ;CURRENT PAGE NUMBER LSH T1,P2SLSH ;JUST SECTION NUMBER SKIPN T2,.UPMP+SECTAB(T1) ;SECTION EXIST? JRST COR9 ;NEXT SECTION LDB T1,[POINT 3,T2,2] ;GET POINTER TYPE CAIE T1,PM.ICD ;INDIRECT? JRST COR8 ;NO MOVEI T1,[ASCIZ /Section /] PUSHJ P,CONMES ;PRINT THAT MOVE T1,P1 ;PAGE NUMBER LSH T1,P2SLSH ;SECTION NUMBER PUSH P,T2 ;PRTDI8 CLOBBERS T2 PUSHJ P,PRTDI8 ;PRINT SECTION NUMBER MOVEI T1,[ASCIZ / @section /] PUSHJ P,CONMES ;INDIRECT POP P,T2 ;RESTORE POINTER HLRZ T1,T2 ;RIGHT HALF ANDI T1,MXSECN ;ISOLATE SECTION NUMBER PUSHJ P,PRTDI8 ;PRINT INDIRECT SECTION NUMBER PUSHJ P,CRLF ;CRLF COR7: TRO P1,PG.BDY ;NEXT SECTION JRST COR10 ;CONTINUE COR8: MOVE T1,P1 ;PAGE NUMBER PUSH P,U ;GETPAC CLOBBERS U PUSHJ P,GTPACC## ;GET PAGE ACCESSIBILITY POP P,U ;RESTORE LDB TDZ T1,[<(PA.OUT+PA.CPO+PA.AA+PA.VSP)>,,-1] ;DON'T CARE ABOUT IN, OUT, OR TARGET TLNN T1,(PA.GSP) ;A SPY PAGE? SKIPGE T1 ;DOES PAGE EXIST? CAIA ;DON'T COUNT NON-EXISTANT OR SPY PAGES IN TOTAL AOS P4 ;UPDATE TOTAL PAGE COUNT CAMN T1,P2 ;SAME AS PREVIOUS PAGE? JRST COR10 ;YES, LOOK AT NEXT PAGE COR9: PUSH P,T1 ;SAVE NEW ACCESSIBILITY BITS SKIPL P2 ;PREVIOUS PAGES NON-EXISTANT? PUSHJ P,PRTACC ;NO, REPORT THEM POP P,P2 ;NEW ACCESSIBILITY BITS MOVE P3,P1 ;START OF RANGE MOVE T1,P1 ;PAGE NUMBER LSH T1,P2SLSH ;CURRENT SECTION NUMBER SKIPE .UPMP+SECTAB(T1);DOES IT EXIST? JRST COR10 ;YES, LOOK AT IT TLO P2,400000 ;NO, PREVIOUS PAGE NON-EXISTANT JRST COR7 ;NEXT SECTION COR10: CAIGE P1,HLGPGS ;LOOKED AT ALL SECTIONS? AOJA P1,COR6 ;NO, LOOP ON SKIPL P2 ;PREVIOUS PAGES NON-EXISTANT? PUSHJ P,[AOJA P1,PRTACC] ;NO, REPORT THEM MOVEI T1,[ASCIZ / Total of /] PUSHJ P,CONMES ;SUMMARY MOVE T1,P4 ;TOTAL NUMBER OF "REAL" PAGES SEEN PUSHJ P,RADX10 ;OUTPUT THAT MOVEI T1,[ASCIZ / page/] PUSHJ P,CONMES ;FINISH UP CAIN P4,1 ;SINGULAR? SKIPA T1,[[ASCIZ / /]] MOVEI T1,[ASCIZ /s /] ;NOTE THAT THIS IS SO FITS IN 1 WORD PUSHJ P,CONMES ;OUTPUT ;CONTINUED ON NEXT PAGE COR11: HLRZ T1,.PDMVL##(W) ;GET MVPL JUMPE T1,COR13 ;SKIP FIRST LINE IF ZERO MOVEI T1,[ASCIZ "Virt. mem. assigned "] PUSHJ P,CONMES ;PRINT TITLE PUSHJ P,VMSIZE## ;GET SIZE OF JOB JUMPE T2,[PUSHJ P,PRCORE ;IF JUST A LOWSEG JRST COR12]; PRINT ONLY 1 NUMBER PUSH P,T2 ;SAVE SIZE OF HISEG PUSHJ P,RADX10 ;PRINT SIZE OF LOWSEG PUSHJ P,PRTPLS POP P,T1 ;SIZE OF HISEG PUSHJ P,PRCORE ;PRINT THAT COR12: HLRZ T4,.PDCVL##(W) ;GET CVPL PUSHJ P,PRCXPL ;PRINT THAT HLRZ T4,.PDMVL##(W) ;GET MVPL SKIPN T4 MOVEI T4,1000 PUSHJ P,PRMXPL ;PRINT THAT PUSHJ P,INLMES ;ADD ) CRLF ASCIZ /) / COR13: PUSHJ P,INLMES ASCIZ /Phys. mem. assigned / PUSHJ P,PRTSEG ;PRINT LOWSEG SIZE MOVEI T1,JBTSGN##-.HBLNK(J) ;START OF CHAIN COR13A: SKIPN T1,.HBLNK(T1) ;NEXT SEGMENT DATA BLOCK JRST COR13B ;NO MORE SKIPG T2,.HBSGN(T1) ;SPY SEG? JRST COR13A PUSHJ P,PRTHGH## ;PRINT SIZE OF HISEG COR13B: PUSHJ P,PRPORK ;PRINT P OR K HRRZ T4,.PDCVL##(W) ;GET CPPL TRZN T4,400000 JRST [PUSHJ P,PRCPGL JRST .+2] PUSHJ P,PRCXPL ;PRINT IT MOVEI T4,0 MOVSI P1,PHONLY PUSH P,.PDCVL##(W) MOVEI T1,400000 ANDCAM T1,.PDCVL##(W) PUSHJ P,PRMXPL ;PRINT IT POP P,.PDCVL##(W) ;CONTINUED ON NEXT PAGE PUSHJ P,INLMES ;ADD NOISE WORDS ASCIZ /) Swap space left: / MOVE T1,VIRTAL## ;GET THAT NUMBER PUSHJ P,PRCORE ;PRINT IN RADIX 10 PJRST CRLF ;ADD IN A CRLF AND RETURN COR15: PUSH P,T1 ;SAVE T1 PUSHJ P,UNLOCK## ;SO CALLING GETMIN DOES SOMETHING JFCL ;OOPS PUSHJ P,CLRLPG## ;CLEAR LOCKED PAGES PUSHJ P,GETMIN PJRST TPOPJ## ;AND RETURN ;ROUTINE TO PRINT CURRENT AND MAX LIMITS PRCPGL: MOVEI T1,[ASCIZ " (Guideline: "] JRST PRXXPL PRCXPL: SKIPA T1,[[ASCIZ " (Current limit: "]] PRMXPL: MOVEI T1,[ASCIZ " Max limit: "] PRXXPL: PUSH P,T4 PUSHJ P,CONMES ;PRINT THE TITLE PUSHJ P,CORBND## ;GET MAX CORE LSH T1,W2PLSH ;IN PAGES SKIPN (P) ;ANYTHING GIVEN? MOVEM T1,(P) ;CHOOSE GOOD MAX POP P,T1 ;RESTORE NUMBER PRCORE: PUSHJ P,RADX10 ;PRINT IN DECIMAL PJRST PRPORK ;GIVE UNITS ;ROUTINE TO PRINT PAGE ACCESSIBILITY. CALL WITH P1=HIGHEST PAGE NUMBER IN REGION, ; P2=BITS RETURNED FROM GETPAC (ALTERED!), P3=FIRST PAGE NUMBER IN REGION PRTACC: MOVE T1,P3 ;FIRST PAGE IN REGION PUSHJ P,PRTDI8 ;PRINT THAT CAIN P1,1(P3) ;EXACTLY 1 PAGE? JRST PRTAC1 ;YES, SKIP NEXT PUSHJ P,INLMES ;PRINT A MINUS SIGN ASCIZ /-/ MOVEI T1,-1(P1) ;HIGHEST PAGE IN REGION PUSHJ P,PRTDI8 ;PRINT THAT PRTAC1: MOVEI T1,[ASCIZ / /] PUSHJ P,CONMES ;LINE THINGS UP MOVEI T2,-1(P1) ;FIX OFF BY ONE ABOVE CAIE T2,(P3) ;ALWAYS TAB IF NO RANGE TRNN T2,777000 ;SEVEN OR MORE CHARACTERS ALREADY BEEN OUTPUT? PUSHJ P,CONMES ;NO, NEED ANOTHER TAB MOVEI T2,0 ;COUNT CHARACTERS MOVEI T1,[ASCIZ /EX /];IF ITS NOT A SPY PAGE, ITS EXECUTABLE TLNN P2,(PA.GSP) ;A SPY PAGE? PUSHJ P,[AOJA T2,CONMES] ;NO, OUTPUT MOVEI T1,[ASCIZ /RD /];ASSUME IT CAN BE READ TLNE P2,(PA.RED) ;CAN IT BE PUSHJ P,[AOJA T2,CONMES] ;YES, OUTPUT THAT MOVEI T1,[ASCIZ /WR /];ASSUME IT CAN BE WRITTEN TLNE P2,(PA.WRT) ;CAN IT BE PUSHJ P,[AOJA T2,CONMES] ;YES, OUTPUT THAT MOVEI T1,[ASCIZ /AZ /];ASSUME ABZ TLNE P2,(PA.ZER) ;IS IT? PUSHJ P,[AOJA T2,CONMES] ;YES, OUTPUT THAT MOVEI T1,[ASCIZ /SH /];ASSUME ITS SHARABLE TLNN P2,(PA.GSP) ;WOULD YOU BELIEVE THAT SPY PAGES ARE SHARABLE? TLNN P2,(PA.GSH) ;IS IT? CAIA ;NO PUSHJ P,[AOJA T2,CONMES] ;YES, OUTPUT THAT MOVEI T1,[ASCIZ /LK /] ;ASSUME LOCKED TLNE P2,(PA.LCK) ;IS IT? PUSHJ P,[AOJA T2,CONMES] ;YES, OUTPUT THAT MOVEI T1,[ASCIZ / /] TLNN P2,(PA.GSH) ;NEED A TAB IF SHARABLE CAIG T2,2 ;ALSO IF LESS THAT 2 ATTRIBUTES PUSHJ P,CONMES ;LINE THINGS UP TLNN P2,(PA.GSP) ;SPY PAGES? PRTA1A: SKIPA T1,[[ASCIZ / Private/]] ;NO, ASSUME IT'S PRIVATE MOVEI T1,[ASCIZ / Spy/] ;SPY TLZE P2,(PA.GSH) ;PRIVATE TLNE P2,(PA.GSP) ;OR SPY? JRST PRTAC4 ;YES, WE HAVE AN ATTRIBUTE PUSHJ P,SAVE1## ;SAVE P1 PUSHJ P,SAVJW## ;AND J (W ALONG FOR THE RIDE) MOVE P1,P3 ;GET PAGE # OF FIRST PAGE LSH P1,P2SLSH ;GET SECTION SETZ T1, ;FIRST SEG THAT SECTION PRTA1B: PUSHJ P,NXSSP1## ;GET NEXT SEGMENT IN THAT SECTION JRST PRTA1A ;HUH (BITS ZEROED ABOVE) SKIPG J,.HBSGN(T1) ;GET SEGMENT NUMBER JRST PRTA1B ;SPY HRRZS J ;CLEAR JUNK LDB T2,JBYHSO## ;GET ORIGIN OF THAT HIGH SEG XOR T2,P3 ;SEE IF IT'S THIS PAGE TRNE T2,HLGPNO ;? JRST PRTA1B ;NO, CHECK NEXT SEGMENT MOVE T2,JBTDEV##(J) ;DEVICE NAME PUSHJ P,PRNAME ;PRINT THAT MOVEI T1,[ASCIZ /:/] ;DEVICE DELIMITER PUSHJ P,CONMES ;PRINT THAT MOVE T2,JBTNAM##(J) ;GET HIGH SEGMENT NAME PUSHJ P,PRNAME ;PRINT THAT MOVE J,JBTPPN##(J) ;GET PPN TLNE J,-1 ;PATH OR PPN? SKIPA T2,J ;PPN MOVE T2,(J) ;PATH, PPN IS STORE HERE PUSHJ P,PRTPP1 ;PRINT THE LEFT BRACKET, P,PN TLNE J,-1 ;IF ONLY A PPN, DONE JRST PRTAC3 ;GO PRINT THE RIGHT BRACKET PRTAC2: SKIPN T2,1(J) ;NEXT SFD JRST PRTAC3 ;NO MORE, DONE PUSHJ P,PRCOM ;PRINT A COMMA PUSHJ P,PRNAME ;PRINT THE SFD NAME AOJA J,PRTAC2 ;NEXT SFD PRTAC3: PUSHJ P,PRTRBK ;PRINT RIGHT BRACKET PJRST CRLF ;PRINT A CRLF AND RETURN PRTAC4: PUSHJ P,CONMES ;OUTPUT WHAT WE HAVE CAIN P1,1(P3) ;EXACTLY ONE PAGE? SKIPA T1,[[ASCIZ / page /]] MOVEI T1,[ASCIZ / pages /] PJRST CONMES ;ROUTINE TO PRINT ACCOUNT STRING CACCT:: MOVEI T1,.PDACS##(W) ;ADDRESS OF USER'S ACCOUNT STRING PUSHJ P,CONMES ;TYPE IT PJRST PCRLF ; SUBTTL CONTROL-T PRINTOUT ;SUBROUTINE TO PRINT A 1 TO 3 LINE USE STATUS REPORT ;CALLED FROM USESTAT COMMAND IT PRINTS A 1 LINE ; STATUS REPORT OF THE FORM: ; INCREMENTAL DAY TIME ; INCREMENTAL RUN TIME ; INCREMENTAL DISK READS ; INCREMENTAL DISK WRITES ; PROGRAM NAME ; CORE SIZE ; JOB STATE ; PC ; USECOM::TLNN P4,JNA ;IS THIS A JOB? PJRST ATT4 ;NO--SAY "NOT A JOB" MOVEI T1,[ASCIZ 'Day: '] PUSHJ P,CONMES PUSHJ P,PRTWWT ;INCREMENTAL DAYTIME MOVE T1,TIME## ;RESET THE TIMER FOR DPB T1,JBYWCH## ; THE NEXT TIME PUSHJ P,UDCPUT## ;UPDATE RUN TIME IF NECESSARY MOVEI T1,[ASCIZ ' Run: '] PUSHJ P,CONMES MOVEI T1,0 ;CLEAR INCREMENTAL RUNTIME EXCH T1,.PDRTM##(W) ; AND PICK UP OLD RUN TIME PUSHJ P,PRTIM ;PRINT THAT MOVEI T1,[ASCIZ ' Rd:'] PUSHJ P,CONMES PUSHJ P,PRTWDR## ;DISK READS MOVEI T1,[ASCIZ ' Wr:'] PUSHJ P,CONMES PUSHJ P,PRTWDW## ;DISK WRITES PUSHJ P,PRSPC ;ANOTHER SPACE MOVE T2,JBTPRG##(J) ;PROGRAM NAME PUSHJ P,PRNAME ;PRINT THE NAME PUSHJ P,USEHSG ;PRINT JOB'S HIGH SEGMENTS PUSHJ P,PRSPC ;ANOTHER SPACE PUSHJ P,PRTSEG ;LOW SEG SIZE PUSHJ P,PRTHGH## ;HIGH SEG SIZE PUSHJ P,PRPORK ;PRINT P OR K PUSHJ P,CTXPRT## ;PRINT CURRENT CONTEXT NUMBER PUSHJ P,PRSPC ;ANOTHER SPACE MOVSI T2,'^C' ;ASSUME CONTROL-C STATE JUMPG P4,USECM1 ;JUMP IF TRUE LDB T1,PJBSTS## ;PICK UP JOB STATE IDIVI T1,3 ;DIVIDE BY 3 TO GET WORD NUMBER IMULI T2,^D12 ;MULTIPLY REMAINDER BY 12 TO GET POSITION MOVE T3,STSTBL##(T1) ;PICK UP ENTRY ROT T3,(T2) ;GET CORRECT THIRD MOVSI T2,777700 ;ONLY LOOK AT TOP 12 BITS AND T2,T3 ;COPY STATE USECM1: PUSHJ P,PRNAME ;PRINT THAT IFN FTLOCK,< MOVEI T3,"&" ;ASSUME LOCKED TLNE P4,NSWP ;SEE IF LOCKED PUSHJ P,PRCHR ;YES, LOCKED >;END IFN FTLOCK MOVEI T3,"*" ;ASSUME CURRENT JOB PUSHJ P,ANYCPU## ;ARE WE THE CURRENT JOB? PUSHJ P,PRCHR ;YES--PRINT * PUSHJ P,PRSPC ;ANOTHER SPACE MOVSI T2,'SW ' ;ASSUME SWAPPED TLNE P4,SWP!SHF ;IS JOB IN CORE? PUSHJ P,[SKIPE JBTADR##(J) ;ANY PHYS MEM? MOVSI T2,'SW*' ;YES--ADD * TO MEAN SWAPPING PJRST PRNAME] ;PRINT SW OR SW* MOVEI T1,[ASCIZ ' PC:'] PUSHJ P,CONMES MOVE T2,JBTPC##(J) ;GET CURRENT PC PUSHJ P,UDPCP## ;PRINT PC IN OCTAL USECPU: IFN FTMP,< SKIPE T2,[M.CPU##-1] ;SKIP IF FTMP ON BUT SINGLE CPU MONITOR HRRZ T2,JBTST3##(J) ;GET CDB OF LAST CPU WE RAN ON JUMPE T2,USECP1 ;SKIP THIS IF A SINGLE CPU OR NO CORE FOR JOB PUSHJ P,PRSPC ;SPACE OVER MOVE T2,.CPLOG##-.CPCDB##(T2) ;GET CPU NAME PUSHJ P,PRNAME ;PRINT IT USECP1: > ;END IFN FTMP SKIPN JBTADR##(J) JRST USECM3 MOVSI T1,SWP!SHF ;BIT INDICATING SWAPPED OR BEING SWAPPED SKIPE .USVRT ;VIRTUAL? TDNE T1,JBTSTS##(J) ;AND IN CORE? JRST USECM3 ;NO, SKIP THIS MOVEI T1,[ASCIZ / Faults - IW: /] PUSHJ P,CONMES ;PRINT THE TEXT MOVE T1,.USVCT ;REPORT INCREMEMTAL IN WORKING SET FAULTS SUB T1,.USICT HRRZS T1 PUSHJ P,RADX10 MOVEI T1,[ASCIZ / NIW: /] PUSHJ P,CONMES ;PRINT TEXT MOVE T1,.USVCT ;REPORT INCREMENTAL NOT IN WORKING SET FAULTS SUB T1,.USICT HLRZS T1 PUSHJ P,RADX10 MOVE T1,.USVCT ;UPDATE INCREMENTAL STATISTICS MOVEM T1,.USICT MOVEI T1,[ASCIZ / Virt core: /] PUSHJ P,CONMES ;PRINT TEXT LDB T1,LOVSIZ## ;LOW SEGMENT VIRTUAL CORE PUSHJ P,RADX10 ;REPORT LOW SEGMENT VIRTUAL CORE PUSHJ P,PRTPLS ;PRINT A PLUS SIGN LDB T1,HIVSIZ## ;HIGH SEG PUSHJ P,PRCORE ;REPORT HIGH SEGMENT VIRTUAL CORE MOVEI T1,[ASCIZ / Page rate: /] PUSHJ P,CONMES ;PRINT TEXT MOVE T1,J PUSHJ P,FPDBT1## TDZA T3,T3 HLRZ T3,.PDVRT##(T1) ;GET PAGING RATE SETZB T1,T2 ;ASSUME A RATE OF ZERO JUMPE T3,USECM2 ;JUMP IF THE RATE IS ZERO MOVEI T1,RTUPS## ;COMPUTE THE JOBS PAGING RATE IDIVI T1,(T3) IMULI T2,^D100 IDIVI T2,(T3) USECM2: PUSH P,T2 ;SAVE THE REMAINDER PUSHJ P,RADX10 ;PRINT THE RATE PUSHJ P,PRPER ;AND A DOT POP P,T1 ;RESTORE THE REMAINDER MOVEI T3,"0" ;ASSUME THE REMAINDER IS IN HUNDREDTHS CAIG T1,^D9 ;IS IT? PUSHJ P,PRCHR ;YES, PRINT A LEADING ZERO PUSHJ P,RADX10 ;AND PRINT DIGITS FOLLOWING THE DECIMAL PLACE USECM3: HRRZ F,JBTDDB##(J) ;GET DDB ADDRESS JUMPE F,USECM5 ;ALL DONE IF NO DDB IFN FTMP,< DDBSRL ;LOCK DDB SEARCH MAP T1,(F) ;MAP DDB ADDRESS PUSHJ P,FLTCHK## ;STILL AROUND? JRST USECM4 ;NO > MOVE T1,JBTSTS##(J) ;GET STATUS CAMLE F,SYSSIZ## ;DDB IN THE MONITOR? TLNN T1,SWP!SHF ;NO, IS THE JOB IN CORE? TRNA ;YES, PROCEED JRST USECM4 ;NO, DON'T TRY TO REPORT DEVICE INFO MOVE T3,DEVMOD(F) ;GET DEVICE TYPE FOR TEST TRNE T1,JS.XO ;EXECUTE ONLY? TLNN T3,DVDSK!DVDTA ;AND DISK OR DECTAPE? SKIPA T2,DEVIOS(F) ;NO, TYPE DDB INFO JRST USECM4 ;YES TO BOTH, SKIP DDB PRINTOUT MOVEI T1,[ASCIZ " Input"] TLNE T3,DVTTY ;IS IT A TTY? TLNE T3,DVDSK ;AND NOT NUL:? JRST USECMA ;NO, GO DO NORMAL DEVICE TLNE T2,TTYOUW## ;OUTPUT DIRECTION? MOVEI T1,[ASCIZ " Output"] JRST USECMB ;TYPE THE MESSAGE USECMA: TLNE T2,IO ;OUTPUT DIRECTION? MOVEI T1,[ASCIZ " Output"] USECMB: PUSHJ P,CONMES ;PRINT THE TEXT MOVEI T1,[ASCIZ " wait for "] PUSHJ P,CONMES PUSHJ P,PRTDDB ;PRINT FILE SPEC MOVE T1,DEVMOD(F) ;GET DEVICE BITS TLNE T1,DVDSK ;IS THIS A DISK? PUSHJ P,DSKCTT## ;YES -- PRINT GOOD STUFF MOVE T1,DEVMOD(F) ;IS THIS A TLNE T1,DVMTA ; TAPE? PUSHJ P,TPMCTT## ;YES--PRINT FILE & RECORD USECM4: IFN FTMP,< DDBSRU ;UNLOCK DDB > USECM5: SE1ENT ;LDB'S ARE IN SECTION MUMBLE. HRRZ F,LDBDDB##(U) ;GET DDB ADDRESS MOVE T1,LDBDCH##(U) ;GET DEVICE BITS FOR TTY TLNE T1,LDLCOM## ;COMMAND LEVEL? TLZ M,NOPER ;YES--PRINT A PERIOD MOVSI T2,LDBCMF## ;ALWAYS CALL TTYSTR IF TDNE T2,LDBCOM##(U) ;USESTAT COMMAND (NOT ^T) TRNN T1,LDROSU## ;CONTROL-O IN EFFECT TLZ M,NOMESS ;NO--CLEAR NOMESS POPJ P,0 ;RETURN ;SUBROUTINE TO PRINT JOB'S HIGH SEGMENT(S) FOR CONTROL-T COMMAND ;CALL WITH: ; J/ JOB NUMBER USEHSG: ;WRAPS THE LINE AND TOO LATE FOR DOCUMENTATION POPJ P, ;PATCH TO JFCL TO ENABLE THIS NIFTY FEATURE PUSHJ P,SAVE2## ;FREE UP A FEW ACS SETZ P1, ;START WITH FIRST HIGH SEGMENT USEHS1: MOVE T1,P1 ;COPY HSB ADDRESS PUSHJ P,GNXHSB## ;GET NEXT HSB POPJ P, ;NONE, RETURN MOVE P1,T1 ;REMEMBER FOR POSTERITY SKIPG P2,.HBSGN(P1) ;IS THERE A REAL SEGMENT THERE? JRST USEHS1 ;NO, SKIP THIS HSB PUSHJ P,PRTPLS ;PRINT A "+" MOVE T2,JBTPRG##(P2) ;GET NAME OF HIGH SEGMENT CAME T2,JBTPRG##(J) ;UNLESS LOW AND HIGH SEG ARE SAME NAME, PUSHJ P,PRNAME ; PRINT NAME OF HIGH SEGMENT JRST USEHS1 ;KEEP LOOPING ;SUBROUTINE TO PRINT A FILESPEC FOR A DDB ;CALL WITH: ; F = DDB ADDRESS ; U = LDB ADDRESS (OR FIX COMTOA) ; PUSHJ P,PRTDDB ; RETURN HERE ; PGMMRG: SKIPA T1,[[ASCIZ/Merged /]] PGMFIL: MOVEI T1,[ASCIZ/ from /] SKIPE F,USRJDA##+0 ;SEE IF DDB AND GET ADDRESS TLNN F,INPB ;WAS AN INPUT DONE? POPJ P, ;NO PUSHJ P,CONMES PRTDDB::PUSHJ P,SAVE1## ;SAVE P1 MOVE P1,DEVMOD(F) ;GET DEVICE TYPE BITS MOVSI T2,'NUL' ;ASSUME NUL PUSHJ P,NULTST## ;IS IT THE NUL DEVICE? JRST PRTDD1 ;YES MOVE T2,DEVNAM(F) ;GET DEVICE NAME HRRZ T3,DEVUNI##(F) ;UDB POINTER JUMPE T3,PRTDD1 ;NO UNIT IF A KNOWN SEGMENT TLNN P1,DVDSK ;IS THIS A DISK? JRST PRTDD1 ;NO SKIPN T2,UNILOG(T3) ;YES, PART OF STR? MOVE T2,UDBNAM(T3) ;NO PRTDD1: PUSHJ P,PRNAME ;PRINT IT MOVEI T3,":" ;ADD A COLON PUSHJ P,PRCHR ; .. TLNN P1,DVDSK!DVDTA ;FILE AND EXT? JRST PRTDD2 ;NO MOVE T2,DEVFIL(F) ;GET FILE NAME JUMPE T2,CPOPJ## ;PUNT IF NO NAME HLRZ T3,DEVEXT(F) ;IS THIS A UFD TLNE P1,DVDSK ;ON DISK CAIE T3,'UFD' JRST PRTDD3 ;NO PUSHJ P,PRTPPN ;YES -- PRINT FILE NAME AS [M,N] JRST PRTDD4 ;AND NOT SIXBIT PRTDD2: IFE FTTLAB, ;RETURN IFN FTTLAB,< TLNE P1,DVMTA ;IS THIS A MAGTAPE? SKIPN %SITLP## ;AND IS TAPE LABELER RUNNING? POPJ P, ;NO TO EITHER--RETURN PUSH P,U ;SAVE U MOVE U,TDVUDB##(F) ;UDB ADDRESS LDB T1,TUYLTP## ;GET LABEL TYPE POP P,U ;RESTORE U JUMPE T1,CPOPJ## ;RETURN IF NOT A LABELED TAPE SKIPN T2,DEVFIL(F) ;ELSE GET FILE NAME POPJ P, ;UNLESS THERE ISN'T ONE > ;END IFN FTTLAB PRTDD3: PUSHJ P,PRNAME ;PRINT IT PRTDD4: PUSHJ P,PRPER ;ADD IN A DOT HLLZ T2,DEVEXT(F) ;GET EXTENSION PUSHJ P,PRNAME ;PRINT IT TLNE P1,DVDSK ;IS THIS THE DISK? SKIPN T2,DEVPPN(F) ;FALL INTO PRTPPN IF PPN POPJ P, ;ELSE RETURN ; PJRST PRTPTH ;PRINT PATH (NEXT PAGE) ;ROUTINE TO TYPE A PATH WITH SFD'S IF NEEDED PRTPTH: PUSHJ P,PRTPP1 ;PROJ, PROG PART OF PATH HRRZ P1,DEVSFD##(F) ;PATH POINTER JUMPE P1,PRTRBK ;IF NO SFD'S PUSH P,[0] ;MARK END OF PATH PRTPT1: PUSH P,NMBNAM##(P1) ;SAVE THE SFD NAME PRTPT2: HLRZ P1,NMBPPB##(P1) ;BACK ONE LEVEL TRZN P1,NMPUPT## ;NAME SHOULD BE OUTPUT? JUMPN P1,PRTPT2 ;NO, GET NEXT LEVEL IF NOT AT END JUMPN P1,PRTPT1 ;YES, SAVE NAME AND GET NEXT LEVEL PRTPT3: POP P,T2 ;RESTORE SFD NAME JUMPE T2,PRTRBK ;IF END, TYPE RIGHT BRACKET AND RETURN PUSHJ P,PRCOM ;PRINT COMMA PUSHJ P,PRNAME ;PRINT THIS SFD NAME JRST PRTPT3 ;LOOP OVER WHOLE PATH PRTPPN::PUSHJ P,PRTPP1 PJRST PRTRBK PRTPP1: PUSH P,T2 ;SAVE PPN MOVEI T3,"[" ;PRINT [ PUSHJ P,PRCHR HLRE T1,(P) JUMPGE T1,PRTPP2 ;WILDCARD? MOVEI T3,"*" ;YES PUSHJ P,COMTYO SKIPA PRTPP2: PUSHJ P,PRTDI8 ;PROJECT PUSHJ P,PRCOM ;COMMA HRRE T1,(P) AOJN T1,PRTPP3 ;WILDCARD? MOVEI T3,"*" ;YES PUSHJ P,COMTYO JRST T2POPJ## PRTPP3: HRRZ T1,(P) ;GET PROGRAMMER HALFWORD AGAIN PUSHJ P,PRTDI8 ;PRINT IT JRST T2POPJ## PRTRBK: MOVEI T3,"]" PJRST P,PRCHR SUBTTL NETWORK COMMANDS -- LOCATE CLOCAT::JSP T2,SAVCTX ;MUST SCHEDULE THIS COMMAND SE1ENT ;ENTER SECTION ONE PUSHJ P,CTEXT1 ;GET THE ARGUMENT IN SIXBIT NETDBJ ;INTERLOCK THIS CODE WITH NETSER SKIPN T1,T2 ;COPY TO T1 SKIPA T2,JBTLOC## ;USE LOCAL STATION PUSHJ P,CVTOCT## ;TRY TO CONVERT TO OCTAL MOVE T1,T2 ;CAN'T-GET THE NAME BACK PUSH P,T1 ;SAVE THE ARG IFN FTNET,< SKIPE [M.ANF##] ;ANF-10 SOFTWARE? PUSHJ P,SRCNDB## ;SEARCH FOR THE NODE BLOCK JRST LOCERR ;DOES NOT EXIST HLRZ T2,NDBNNM##(W) ;YES, GET THE NODE NUMBER MOVEI T1,[ASCIZ/Node number out of range/] CAILE T2,77 ;KEEP IT REASONABLE FOR BATCH JRST [POP P,(P) ;CLEAN STACK JRST ERRMES] ;GIVE ERROR MOVEM T2,JBTLOC##(J) ;LOCATE HIM WHERE HE WANTS POP P,(P) ;RESTORE THE STACK PUSHJ P,TYPNDB## ;TYPE THE NODE NAME JSP T1,CONMES ;AND FINISH UP ASCIZ / located / > ;END IFN FTNET LOCERR: POP P,T2 ;GET NUMBER BACK CAIG T2,77 ;IS IT A NUMBER JUMPG T2,LOCER1 ;YES, WILL ALLOW THE LOCATE TO HAPPEN IFN FTNET, ;UNDEFINED NETWORK NODE IFE FTNET,< MOVEI T1,[ASCIZ \Invalid station address\] ;NO. PJRST ERRMES ;TYPE IT > ;END IFE FTNET LOCER1: MOVEM T2,JBTLOC##(J) ;STORE THE LOCATION IFN FTNET,< MOVEI T1,[ASCIZ /%Node (/] SKIPN [M.ANF##] ;ANF-10 SOFTWARE? > ;END IFN FTNET MOVEI T1,[ASCIZ /Station /] PUSHJ P,CONMES ;PRINT TEXT HRRZ T1,JBTLOC##(J) ;GET THE NUMBER PUSHJ P,PRTDI8 ;PRINT THE NUMBER IFN FTNET,< MOVEI T1,[ASCIZ /) located but offline/] SKIPN [M.ANF##] ;ANF-10 SOFTWARE? > ;END IFN FTNET MOVEI T1,[ASCIZ / located/] PUSHJ P,CONMES ;PRINT TEXT PJRST PCRLF ;END LINE WITH A CRLF SUBTTL NETWORK COMMANDS -- WHERE CWHERE::SE1ENT ;ENTER SECTION ONE IFE FTNET!FTKL10!FTDECNET!FTENET,< MOVSI T1,JLOG ;IF NOT TDNN T1,JBTSTS##(J) ;LOGGED IN DPB T1,PJOBN## ;DON'T LEAVE GHOST JOB JSP T1,ERRMES ;CAN'T DO THESE IF NO NETWORK ASCIZ /No network, DAS78, or DN60 software / > ;END IFN FTNET!FTKL10!FTDECNET!FTENET IFN FTNET!FTKL10!FTDECNET!FTENET,< JSP T2,SAVCTX## ;SAVE THE CONTEXT OF THE JOB PUSHJ P,CTEXT1 ;GET FIRST ARG = SIXBIT DEV NAME IFN FTNET,< NETDBJ ;INTERLOCK WITH NETSER PUSHJ P,NETASG## ;TRY TO ASSIGN "NODE_DEVICE" POPJ P, ;ERROR IN ARGUMENTS (MESSAGE PRINTED) >;END IFN FTNET PUSH P,T2 ;SAVE 6 BIT PUSHJ P,FNDSTA## ;GET OUR STATION POP P,T2 ;GET 6 BIT NAME MOVE T1,T2 ;INTO T1 PUSH P,U ;SAVE U PUSHJ P,DVCNSG## ;SEARCH FOR PHYSICAL DEV NAME PJRST NOTDV1 ;PRINT "NO SUCH DEVICE" PUSHJ P,FNDDEV## ;FIND LOCATION LDB T2,PDVTYP## ;GET DEVICE TYPE IFN FTKL10,< CAIN T2,.TYD78 ;IS IT A DAS78? PJRST CWHD78## ;LET D78INT HANDLE IT > ;END IFN FTKL10 IFN FTNET,< CAIE T2,.TYTTY ;IS IT A TTY? PJRST CWHANF## ;LET NETSER HANDLE NON-TTY DEVICES > ;END IFN FTNET MOVE U,DDBLDB##(F) ;GET TARGET TTY'S LDB MOVE T4,LDBTTW##(U) ;GET THE TTY USE FLAGS TLNN T4,LTLUSE## ;IS TTY IN USE? JRST CWHNCN ;NO, JUST SAY "NOT CONNECTED" IFN FTNET,< TLNE T4,LTLANF## ;IF ANF-10, PJRST CWHANF## ;LET NETSER TYPE IT OUT > ;END IFN FTNET IFN FTDECNET,< ;IF DECNET, TLNE T4,LTLNRT## ;IF NRT/CTERM JRST CWHNRT## ;LET NRTSER TYPE IT OUT > ;END IFN FTDECNET IFN FTENET,< ;IF ETHERNET/LAT TLNE T4,LTLLAT## ;IF LAT TERMINAL PJRST CWHLAT## ;LET LATSER TYPE IT OUT > ;END IFN FTENET TLNE T4,LTLREM## ;REMOTE? PJRST CWHNCN ;YES, BUT DON'T KNOW WHAT FLAVOR IFE FTNET, ;GIVE UP IFN FTNET, ;SAY LOCAL STATION CWHNCN::PUSHJ P,INLMES ;DEVICE IS NOT CONNECTED . . . ASCIZ \Device \ MOVE T2,DEVNAM(F) ;GRAB THE DEVICE NAME PUSHJ P,PRNAME ;AND TYPE IT OUT PUSHJ P,INLMES ;NOT CONNECTED ASCIZ / not connected / PUSHJ P,TTYKLQ## ;ZAP THE USELESS DDB POP P,U POPJ P, ;RETURN > ;END IFN FTNET!FTKL10!FTDECNET!FTENET SUBTTL NETWORK COMMANDS -- NODE CNODE:: SE1ENT ;ENTER SECTION ONE JSP T2,SAVCTX## ;SAVE CONTEXT, RUN AT UUO LEVEL IFE FTNET!FTDECNET,< MOVEI T1,[ASCIZ /No network support/] PJRST ERRMES ;REPORT ERROR AND RETURN > ;END IFE FTNET!FTDECNET IFN FTNET!FTDECNET,< SKIPN [M.NET##] ;NETWORK SUPPORT IN MONITOR? JRST [MOVEI T1,[ASCIZ /No network support/] ;NO PJRST ERRMES] ;REPORT ERROR AND RETURN PUSHJ P,CTEXT1 ;GET THE ARGUMENT IFN FTNET,< PUSHJ P,NODE.A## ;ANF-10 NODE? SKIPA ;NO POPJ P, ;DONE > ;END IFN FTNET IFN FTDECNET,< PUSHJ P,NODE.D## ;DECNET NODE? SKIPA ;NO POPJ P, ;DONE >; END IFN FTDECNET UNDERR::MOVEI T1,[ASCIZ /Undefined network node/] PJRST ERRMES ;PRINT ERROR MESSAGE AND RETURN > ;END IFN FTNET!FTDECNET SUBTTL SAVE, SSAVE AND GET - COMMAND SETUP ; "SSAVE DEVICE:FILNAM.EXT [PROJ,R] CORE" ;WORKS LIKE SAVE, EXCEPT THAT HIGH SEG IS SAVED AS SHARABLE(EXT=SHR) ;INSTEAD OF NON-SHARABLE(EXT=HGH) ; "SAVE DEVICE:FILE-NAME[PROJ.,PROG.] CORE" - SAVES JOB AREA ON RETRIEVABLE DEVICE ;ONLY A SAVE OR A GET IN PROGRESS FOR EACH JOB ;NO ATTEMPT IS MADE TO SAVE DEVICE ASSIGNMENTS, AC'S, OR PC NSAVE:: TLO S,NSRBIT ;SET FLAG FOR SAVE NSSAVE::MOVSI T1,(JS.EXE) ;GET EXE BIT IORM T1,JBTST2##(J) ;SET IT IN JOB STATUS WORD JRST SSAVE2 ; AND CONTINUE AS BEFORE SAVEO:: TLO S,NSRBIT ;OLD SAVE JRST SSAVE1 CSAVE:: TLO S,NSRBIT ;SET FLAG FOR NON-SHARABLE EXT(HGH) SSAVE:: MOVE T1,CNFST2## ;CHECK CONFIG BIT FOR EXE FILE SAVES TRNE T1,ST%EXE ;IF ON,... JRST NSSAVE ;... PROCEED AS IN "NSAVE" SSAVE1::MOVSI T1,(JS.EXE) ;GET EXE BIT ANDCAM T1,JBTST2##(J) ;CLEAR IT JUST FOR SAFETY SSAVE2: TLO P1,GTSAV ;FLAG THAT DOING A SAVE HRRI S,SAVJOB ;SETUP TO RUN SAVJOB (S CLEARED BEFORE CALL) JRST SGSETD ; SAVE UUO - CALLED LIKE RUN AND GETSEG UUOS USAVE:: MOVE T2,JBTSTS##(J) ;GET JOB STATUS TLNE T2,JLOG ;LOGGED IN? JRST USAVE1 ;YES, OK MOVEI T1,NLIERR ;NOT LOGGED IN ERROR PUSHJ P,SGRELE ;TRY TO TELL USER MOVEI T1,LOGPLM ;ADDRESS OF ERROR TEXT JRST PHOLD## ;START TTY AND STOP JOB USAVE1: MOVSI T2,(JS.EXE) ;EXE-STYLE SAVE BIT IORM T2,JBTST2##(J) ;SET FOR THIS USER TLO P1,GTSAV ;DON'T KILL HISEG IF GETARG ABORTS MOVEM P1,.JDAT+SGAEND ;A SAFER PLACE TO BE PUSHJ P,GETARG ;GET USER'S ARGUMENTS SKIPGE .JDAT+SGANEW ;EXTENDED CORE ARG GIVEN? JRST IUUAGL## ;YES, MUSN'T DO THAT FOR SAVE (YET) MOVE T1,DEVMOD(F) ;GET DEVICE TYPE TLNN T1,DVDSK ;IS IT A DISK? JRST [MOVEI T1,ILUERR ;GET ERROR CODE PUSHJ P,SGRELE ;TRY TO TELL USER PJSP T1,PHOLD## ;GIVE UP ASCIZ\SAVE. UUO only valid for disks\] TLNE T1,DVTTY ;IS IT NUL? JRST [POP P,(P) ;POP OFF JUNK JRST CPOPJ1] ;AND GIVE GOOD RETURN MOVE T1,.JDAT+JOBPD1##+1 ;GET UUO RETURN ADDR TRNN T1,^-17 ;FROM THE ACS? HRRZS .JDAT+JOBPD1## ;YES, SAY NOT FROM USER IFN FTMP,< PUSHJ P,CLRJSP## ;ENSURE MONITOR RUNS ON MASTER CPU > OPEN 0,SGAMOD ;OPEN THE SPECIFIED DEVICE JRST SGERRU ;DEVICE WENT AWAY SKIPL .JDAT+JOBPD3##+1 ;DID USER SPECIFY SHARABLE? TLO S,NSRBIT ;NO, MAKE IT NONSHARABLE MOVEI T2, 'EXE' ;GET THE LEGAL EXTENSION HRLM T2,.JDAT+SGAEXT ;STORE IN ENTER BLOCK PUSHJ P,SETEXT## ;AND SET UP SGALOW AND SGAHGH MOVE T1,.JDAT+JOBPD1## ;OUR NOMINAL RETURNING FLAGS TLNN T1,USRMOD ;WILL WE EVER RETURN? JRST USAVE2 ;NO, SO SKIP THIS PUSH P,.PDTMI##(W) ;SAVE SOME VM LOCS PUSH P,.PDTMC##(W) USAVE2: HLRZ T1,JBTADR##(J) ;GET HIGHEST ADDRESS IN LOW SEG HRRZS T2,.JDAT+SGANEW ;CLEAR JUNK FROM LH (FOR COMPATABILITY) CAMGE T1,T2 ;COMPARE WITH USER STORED CORE ARG MOVE T1,T2 ;USER'S WAS LARGER, USE IT HRRM T1,.JDAT+JOBCOR## ;AND SET UP JOBCOR. PUSHJ P,RMVPFH## ;GET RID OF PFH PUSHJ P,ADJCOR## ;SET UP GOOD CORE ARG PJRST SAVEXE ;GO SAVE A FILE SUBTTL SEGOP. UUO ; ;CALL: XMOVEI AC,ARGLIS ; SEGOP. AC, ; ERROR CODE IN AC ; SUCCESS, AC UNCHANGED ; ; SEGOP:: PUSHJ P,SXPCS## ;VALIDATE THE ARG BLOCK POINTER JRST SOPADC ;ADDRESS ERROR MOVE M,T1 ;COPY FOR FETCHING PUSHJ P,GETEWD## ;GET LENGTH,,FCN JRST SOPADC ;ADDRESS ERROR MOVE T4,T1 ;SAVE IT HLRZ T2,T1 ;GET LENGTH OF ARG BLOCK HRRES T1 ;ISOLATE FUNCTION CODE CAML T1,[SEGCMX] ;LEGAL CUSTOMER FUNCTION? CAILE T1,SEGFMX ;LEGAL FUNCTION CODE? JRST SOPILF ;NOPE CAMGE T2,SEGMLN(T1) ;ARGUMENT LIST LONG ENOUGH? JRST SOPATS ;NO, ARGUMENT LIST TOO SHORT MOVE T1,M ;GET ADDRESS OF ARG LIST PUSHJ P,ARNGE## ;ADDRESS CHECK THE ARG BLOCK ITSELF JRST SOPADC ;NOT ALL ADDRESSABLE JRST SOPADC ;CAN'T STORE RESULTS HRRE T1,T4 ;GET FCN CODE AGAIN PJRST @SEGJMP(T1) ;AND GO FOR IT DEFINE SOPFNS,< SOPFUN (4,SOPINF) ;(0) GET SEGMENT INFO SOPFUN (7,SOPGET) ;(1) GET A SEGMENT SOPFUN (3,SOPREL) ;(2) RELEASE SEGMENT(S) SOPFUN (6,SOPRMP) ;(3) REMAP SOPFUN (3,SOPSWP) ;(4) SETUWP SOPFUN (6,SOPCOR) ;(5) CORE SOPFUN (3,SOPDMP) ;(6) RETURN A LIST OF SEGMENTS IN SOME ADR SPACE > DEFINE SOPFUN(LENGTH,DISPATCH), ;DISPATCH TABLE OF SEGOP. ;CUSTOMER FUNCTIONS GO HERE CSEGJM: SEGJMP: SOPFNS SEGFMX==.-SEGJMP-1 SEGCMX==SEGJMP-CSEGJM DEFINE SOPFUN(LENGTH,DISPATCH), ;TABLE OF MINIMUM LEGAL LENGTHS OF ARGUMENT LIST FOR VARIOUS FUNCTIONS SEGMLN: SOPFNS ;TABLE OF MINIMUM LENGTHS ;ERROR RETURNS SOPNSS: MOVEI T1,FNFERR ;NO SUCH SEGMENT JRST STOTAC## ;STORE ERROR CODE SOPNCA: MOVEI T1,NECERR ;NOT ENOUGH CORE AVAILABLE JRST STOTAC## ;STORE ERROR CODE SOPILF: MOVEI T1,ILUERR ;ILLEGAL FUNCTION JRST STOTAC## ;STORE ERROR CODE SOPCCW: MOVEI T1,WLKERR ;CAN'T WRITE ENABLE SEGMENT JRST STOTAC## ;STORE ERROR CODE SOPADC: MOVEI T1,ACRERR ;ADDRESS CHECK READING ARGUMENTS JRST STOTAC## ;STORE ERROR CODE SOPACS: MOVEI T1,ACSERR ;ADDRESS CHECK STORING ARGUMENTS JRST STOTAC## ;STORE ERROR CODE SOPATS: MOVEI T1,ATSERR ;ARGUMENT LIST TOO SHORT JRST STOTAC## ;STORE ERROR CODE SOPIAL: MOVEI T1,NZAERR ;ILLEGAL ARGUMENT LIST JRST STOTAC ;STORE ERROR CODE SOPNSA: MOVEI T1,NFSERR ;NO FREE SECTION JRST STOTAC## ;STORE ERROR CODE SOPSII: MOVEI T1,SIIERR ;SEG INFO INCONSISTANT (NAME AND NUMBER DON'T AGREE) JRST STOTAC## ;STORE ERROR CODE ;FUNCTION 0 - GET SEGMENT INFORMATION SOPINF: PUSHJ P,SAVE4## ;SAVE SOME WORKING ACS PUSHJ P,GETEW1## ;GET FLAGS AND CONTEXT NUMBER JRST SOPADC ;ADDRESS CHECK TRNN T1,-1 ;ALLOW 0 TO MEAN CURR