FTHALT==-1 TITLE SEGCON - HIGH SEGMENT CONTROL FOR REENTRANT USER PROGRAMMING V435 SUBTTL T. HASTINGS/TW/TNM/TH/AF/CHW/TW/RCC TS 22 DEC 69 XP VSEGCN,434 ;PUT VERSION NUMBER IN GLOB LISTING AND LOADER MAP ;ALL OF THE CODE DEALING WITH THE SECOND RELOCATION REGISTER HAS BEEN ISOLATED ;IN THIS ONE ROUTINE NAMED SEGCON ;SIX OF THE MONITOR MODULES CALL SUBROUTINES IN SEGCON WITH PUSHJ'S. ;THIS HAS BEEN DONE FOR TWO REASONS: ; 1.TO MAKE IT EASY TO BUILD SYSTEMS WITH OR WITHOUT 2 REG. CAPABILITY ; SEGCON CAN BE REPLACED BY A SHORT DUMMY ROUTINE(NULSEG), SO THERE ; IS NO CONDITIONAL ASSEMBLY REQUIRED TO ELIMINATE MOST OF THE CODE. ; THOSE CUSTOMERS WHO WOULD LIKE TO ELIMINATE ALL OF THE CODE MAY DO SO BY ; REASSEMBLING THE MONITOR WITH FEATURE SWITCH FT2REL=0. ; THIS WILL ELIMINATE ALL PUSHJ CALLS TO SEGCON ; 2. TO MAKE IT CLEAR EXACTLY WHERE TWO SEGMENTS ARE DEALT WITH ;ALL OF THE CALLS TO SEGCON ARE OF THE FORM: ;IFN FT2REL,< ; EXTERN XXXXXX ; PUSHJ PDP,XXXXXX ; ERROR RETURN OR NOTHING TO DO ; OK RETURN ;> ;OR: ;IFN FT2REL,< ; EXTERN XXXXXX ; PUSHJ PDP,XXXXXX ; OK RETURN ;> ;SEGCON IS GOOD FOR SWAPPING AND NON-SWAPPING SYSTEMS ;AND FOR SYSTEMS WITH AND WITHOUT DISK INTERN FTSWAP,FTDISK ;TO MAKE IT CLEAR WHERE EACH SUBROUTINE IS CALLED FROM ;AND WHAT FUNCTION IT IS PERFORMING, THE MODULES OF THE MONITOR HAVE BEEN REPLICATED ;IN SEGCON USING SUBTTL. THE MODULES ARE: ; 1. CLOCK ; 2. COMCSS ; 3. CORE1 ; 4. SAVGET ; 5. SWAP ; 6. UUOCON ;ADDITIONAL MONITOR DATA TO HANDLE TWO SEGMENT USER PROGRAMS: ;A NUMBER OF THE ALREADY EXISTING JOB TABLES HAVE BEEN LENGTHENED ;BY AN AMOUNT SEGN(THE NUMBER OF POSSIBLE HIGH SEGMENTS). THE LOWER ;PART OT THESE TABLES HAVE REMAINED AS THEY WERE(O THRU JOBMAX=JOBN-1) ;WITH ONE WORD PER JOB( OR LOW SEGMENT). THE NEW HALF(GREATER THAN JOBMAX) ;HAVE ONE WORD FOR EACH HIGH SEGMENT. A HIGH SEGMENT NUMBER IS REALLY ;A LARGE JOB NUMBER AND IS AN INDEX INTO THE JOB TABLES. ;THE HIGHEST INDEX IN THESE LENGTHENED JOB TABLES IS JBTMAX. ;THERE IS AT LEAST ENOUGH TABLE SPACE SO THAT EACH JOB CAN HAVE A ;DIFFERENT HIGH SEGMENT. THE FOLLOWING TABLES HAVE BEEN LEGNTHENED: ;JBTSTS- JOB(SEG) STATUS ; LH=STATUS BITS: ; SWP=1 IF HIGH SEG SWAPPED OUT(WHETHER SPACE ON DISK OR NONE) ; OR ON WAY IN OR OUT. IE SWP=1 MEANS NOT RUNABLE COR IN CORE. ; SWP=0 WHEN HIGH SEG HAS RUNABLE COR IN CORE ; EVEN THOUGH ALSO HAS SPACE ONDISK. ; SNA=1 IF HIGH SEG NO. APPEARS IN AT LEAST ONE USER'S LOGICAL ADR. SPACE ; SNA IS SIGN BIT OF JBTSTS. ; SNA=0 IF HIGH SEG IS COMPLETELY FREE OR IS DORMANT, ; WHERE DORMANT MEANS THAT THE SEGMENT DOES NOT APPEAR IN ANY USER'S ; LOGINCAL ADDRESSING SPACE, BUT IS STILL AROUND PHYSICALLY ON DISK ; OR IN CORE ; SHRSEG=1 IF SEG IS SHARABLE(WHETHER IT STILL HAS A NAME OR ; HAS BEEN SUPERCEDED). ; BITS 9-17 ARE ACCESS PRIBILEGES - SAME FORMAT AS DISK FILES ; HSAPOS=RIGHT MOST BIT POSITION ; HSAMSK=MASK FOR BITS(ALL ONES) ; HSASIZ=SIZE OF FIELD ; RH=IN-CORE COUNT(RATHER THAN RUN TIME LEFT) IE NUMBER OF JOBS ; IN CORE USING HIGH SEG IN CORE ;JBTADR- HIGH JOB(SEG) CORE ASSIGNMENT ; LH=LENGTH-1 OF HIGH SEG(NOT PROTECTION LIKE LOW SEG) ; FOR LOW SEGS PROTECTION(HIGHEST LEGAL USER ADDRESS) AND LENGTH-1 ; ARE THE SAME. HOWEVER THEY ARE DIFFERENT FOR HIGH SEGS, SO LENGTH-1 ; WAS CHOSEN INSTEAD OF THE PROTECTION AS THE QUANTITY FOR THE LH. ; RH=ABSOLUTE ADR. OF BEG OF HIGH SEG(NOT RELOCATION LIKE LOW SEG) ; FOR LOW SEGS THE RELOACTION AND THE ABSOLUTE ORIGIN ARE THE SAME. ; HOWEVER THEY ARE DIFFERENT FOR HIGH SEGS, SO THE ABSOLUTE ORIGIN WAS ; CHOSEN INSTEAD OF THE RELOCATION AS THE QUANTITY FOR THE RH. ; 0 MEANS NO CORE IN MEMORY AT ALL ; CORE IS ASSIGNED DURING SWAP IN AND OUT TOO ;JBTSWP- JOB SWAP INFO ; LH=DISK ADR. ALWAYS(NEVER CORE PROTECT TIME LIKE LOW SEG WHEN IN CORE) ; RH=IMGIN,IMGOUT - NO. OF 1K BLOCKS WHEN BROUGHT IN, NO. OF 1K BLOCKS ON DISK ; IMGOUT=0 WHEN NO COPY ON DISK(ALWAYS TRUE IF UWP IS OFF ; FOR HIGH SEG SO USER CAN MODIFY HIGH SEG) ;JBTCHK- CHECKSUM FOR HIGH SEG WHEN SWAPPED OUT ;THE FOLLOWING JOB TABLES HAVE BEEN ADDED: ;JBTSGN(0...JOBMAX) - HIGH SEG NUMBER WHICH JOB IS USING IN CORE OR ON DISK ; 0 MEANS JOB DOES NOT HAVE A HIGH SEGMENT. ; LH BITS: ; SPYSEG=1(SIGN BIT) HIGH SEG IS PART OF PHYSICAL CORE(SPY UUO), ; RH IS HIGHEST PHYSICAL ADR FOR THIS USER TO LOOK AT ; SERSEG=1 MEANS THAT THE HIGH SEG WHICH THIS USER IS USING IS SHARABLE ; THIS BIT ALSO APPEARS IN THE JBTSTS WORD IN THE SAME POSITION ; IN THE WORD, SINCE SHARABLE IS A PROPERTY OF A SEGMENT, NOT OF ; THE JOB USING THE SEGMENT. IT IS DUPLICATED HERE ONLY AS ; A CONVENIENCE SO IT WILL APPEAR IN THE LH OF AC ITEM. ; UWPOFF=1 USER WRITE PROTECT IS OFF FOR THIS USER(NORMALLY ; UWP OS ON, SO UWPOFF=0) ; MEDDLE=1 IF USER HAS MEDDLED WITH PROGRAM SO HE SHOULD NOT BE ALLOWED ; TO TURN OFF UWP OR CHANGE CORE ASSIGNMENT ; MEDDLE IS SET ONLY IF HIGH SEG IS SHARABLE OR A SPY SEG ; MEDDLING IS DEFINED AS ANYTHING WHICH CAUSES THE PROGRAM NOT ; NOT TO BE IN CONTROL OF ITSELF: ; 1. START COMMAND WITH ARG ; 2. DEPOSIT COMMAND(D) IN LOW SEG(HIGH SEG ALWAYS ILLEGAL) ; 3. RUN UUO WITH BIGGER START ADR. INCREMENT THAN 0 OR 1 ; 4. GETSEG UUO ; 5. HIGH SEG IS PHYSICAL CORE(SPY UUO) ;CORCNT=1 IF HIGH SEG IN CORE COUNT HAS BEEN INCREMENTED FOR THIS JOB ; (JOB LOW SEG MAY OR MAY NOT BE IN CORE) ; SET BY INCCNT ROUTINE, CLEARED BY DECCNT ROUTINE ;JBTDIR(JOBN...JBTMAX) - HIGH SEG DEVICE NAME OF FILE STRUCTURE NAME ; (EG DSKA,DSKB,DTAN,MTAN) ;PRJPRG(JOBN...JBTMAX) - HIGH SEG DIRECTORY NAME(EXTENSION OF PRJPRG TABLE) ; IS PROJECT-PROGRAMMER IF DISK, 0 IF DTA OR MTA ;JBTNAM(JOBN...JBTMAX) - HIGH SEG NAME(EXTENSION ASSUMED TO BE SHR) ; (EXTENSION OF JBTPRG TABLE) ; THE NAME(AND DISK COPY) IS RETAINED EVEN AFTER NO JOBAS ARE USING ; HIGH SEG IN CORE OR ON DISK, THUS SAVING TIME FOR GET'S. ; HOWEVER, IF SWAPPING SPACE BECOMES FULL, THESE UNUSED HIGH SEGS ; ARE DELETED ONE AT A TIME, UNTIL THERE IS ROOM. IF STILL NO ROOM, ; COPIES OF HIGH SEGS WHICH ARE ALSO IN CORE ARE DELETED. ; ANY HIGH SEG WHICH HAS A NAME IS SHARABLE AND HAS SHRSEG SET IN JBTSTS. ; A HIGH SEG WITH SEGSHR SET AND JBTNAM=0 IS A HIGH SEG WHICH HAS BEEN ; SUPERCEDED BY A LATER VERSION OF A HIGH FILE. ;THE FOLLOWING LOCATION HAS BEEN ADDED TO THE JOB DATA AREA: ;JOBHRL - RH IS ANALOGOUS TO JOBREL, HIGHEST RELATIVE(USER) ADR. IN HIGH SEG ; IE HIGHEST LEGAL USER ADDRESS IN HIGH SEG ; 0 MEANS JOB DOES NOT HAVE A HIGH SEG ; SET BY MONITOR EVERY TIME JOB RUNS ; LH IS ANALOGOUS TO LH OF JOBSA, FIRST FREE(RELATIVE) LOCATION IN HIGH SEG ; SET BY LINKING LOADER, USED ON SAVE FOR AMOUNT TO WRITE ; THE FIRST FREE LOCATION CONTAINS THE STARTING ADDRESS OF JOB ; WHICH IS SET BY SAVE FROM JOBSA WHICH WAS SET BY LINKING LOADER ; BOTH HALVES ARE 0 IF NO HIGH SEG ;JOBCOR - LH IS HIGHEST LOC LOADED WITH DATA IN LOW SEG ; SET BY LINKING LOADER ; USED BY SAVE FOR 2 SEG PROGRAM ONLY, WRITE LOW SEG IF LH JOBCOR IS ; GREATER THAN 137(HIGHEST LOC IN JOB DATA AREA ;THE HIGH SEGMENT HAS A VERY SMALL JOB DATA AREA(10 LOCATIONS) ;WHICH IS USED FOR INITIALIZING THE REGULAR JOB DATA AREA ON A GET ;IN CASE THE JOB DOES NOT HAVE A LOW SEGMENT FILE(HIGHLY DESIRABLE) ;SEE JOBDAT FOR DEFINITIONS. ;THE CONTENTS OF AC ITEM MAY BE A JOB NUMBER OR A HIGH SEGMENT NUMBER ;AC ITEM IS LOADED FROM JBTSGN INDEXED BY JOB NUMBER ;SO THAT AC ITEM CONTAINS LH BITS FOR EASY TESTING WHEN THE RH ;HAS A HIGH EGMENT NUMBER IN IT. WHEN AC ITEM HAS A JOB NUMBER ;IN IT, THE LH IS ALWAYS 0 ;IN SWAP, AC ITEM IS DEFINED TO BE AC ITEM ;HOWEVER, A COMPARE WITH JOBMAX WILL STILL GIVE HIGH SEG OR LOW SEG ;NOTE, THAT SPYSEG IS SIGN BIT SO 'SKIPG' TEST FOR REAL HIGH SEG ;TERMINOLOGY IN THE COMMENTS OF SEGCON: ;'SEG' IS AN ABREVIATION FOR 'SEGMENT' ;'JOB' OR 'JOB NUMBER' ALWAYS REFERS TO NUBERS LESS-THAN OR EQUAL-TO JOBMAX ;THE COMMENTS IN THE REST OF THE MONITOR HAVE NOT BEEN CHANGED, SO THAT THERE ARE ;MANY ROUTINES WHICH ARE NOW DEALING WITH BOTH JOB NUMBERS AND HIG SEG NUMBERS ;(MAINLY IN CORE AND SWAP ROUTINES) WITHOUT KNOWING IT. ;'SEGMENT' REFERS TO BOTH LOW AND HIGH SGMENTS, RATHER THAN JUST HIGH SEGMENTS ;AND WILL ALWAYS BE PRECEDED BY 'LOW' OR 'HIGH' IF BOTH IS NOT INTENDED. ;'JOB NUMBER' IS USED INTERCHANGEABLE WITH 'LOW SEG NUMBER'. ;'ADDRESS','ADR','LOCATION','LOC', AND 'ORIGIN' ALL ;REFER TO USER(IE BEFORE HARDWARE OR SOFTWARE RELOCATION) QUANTITIES. ;MOST OF THE TIME THESE WORDS ARE MODIFIED WITH 'USER' OR 'RELATIVE'. ;HOWEVER, THIS IS NOT COMPLETELY CONSISTENT. ;OCCASIONALLY ABSOLUTE ADDRESSES ARE COMPUTED BY THE MONITOR. IN ALL THESE ;CASES, 'ABSOLUTE' OR 'ABS' PRECEEDS THESE WORDS. ;THE REENTRANT CAPABILITY IMPROVES SYSTEM THRUPUT BY REDUCING THE DEMANDS ON: ; 1. CORE MEMORY - SHARING ; 2. SWAPPING STORAGE - SHARING ; 3. SWAPPING CHANNEL READS ; 4. SWAPPING CHANNEL WRITES ; 5. STORAGE CHANNEL READS - GET ;HOWEVER, 2 COMPETES WITH 4 AND 5, IN THAT TO REDUCE THE DEMANDS 4 AND 5, ;COPIES OF UNUSED (DORMANT) HIGH SEGMENTS ARE KEPT ON THE SWAPPING DEVICE, THEREBY ;INCREASING THE DEMAND FOR SWAPPING STORAGE(2). THE QUESTION NATURALLY ARISES, ;HOW DOES THE SYSTEM DETERMINE THIS SPACE-TIME TRADEOFF? ;THE MONITOR ACHIEVES THE BALANCE DYNAMICALLY, AFTER THE OPERATOR ;ESTABLISHED THE SIZE OF THE SWAPPING SPACE WHEN THE SYSTEM IS STARTED ;(ONCE ONLY DIALOG). THE MONITOR ASSUMES THAT THERE IS NO SHORTAGE ;OF SWAPPING SPACE, AND SO KEEPS A SINGLE COPY OF AS MANY HIGH SHARABLE ;SEGMENTS IN THE SWAPPING SPACE AS THERE ARE HIGH SEG NUMBERS. ;(THE MAX NUMBER OF HIGH SEG NUMBERS IS ESTABLISHED AT BUILD TIME ;AND IS EQUAL TO OR GREATER THAN THE NUMBER OF JOBS(COUNTING THE NULL JOB). ;THUS DEMANDS 4 AND 5 ARE MINIMIZED. ;HOWEVER IF SWAPING SPACE IS EXHAUSTED, THE MONITOR WILL TRY DELETING ;A HIGH SHARABLE SEG THAT IS NOT IN USE BY ANY JOB.(A SO-CALLED DORMANT SEG) ;WHEN DELETED SEG IS NEXT NEEDED(A GET OCCURRED), IT WILL ;BE GOTTEN FROM STORAGE DEVICE, INCREASING DEMAND 5. IF NO UNUSED HIGH SEGS EXIST ;THE MONITOR WILL TRY DELETING A HIGH(SHARABLE OR NON-SHARABLE) SEG THAT ;IS IN USE AND HAS A COPY, BOTH ON THE DISK AND IN CORE. THUS WHEN THIS HIGH SEG IS ;SWAPPED OUT, IT WILL REQUIRE A WRITE, INCREASING DEMAND 4. ;TO RESTATE: THE MONITOR USES ALL THE SWAPPING SPACE AVAILABLE. IF IT RUNS OUT, ;IT INCREASES STORAGE CHANNEL READS(GET), THEN SWAPPING CHANNEL WRITES IN ORDER ;TO OVERCOME THE SPACE SHORTAGE. ;THE SAME LOOK-A-SIDE TECHNIQUE IS USED FOR CORE IN BOTH SWAPPING AND NON-SWAPPING ; SYSTEMS IN THAT THE MONITOR KEEPS DORMANT SEGMENTS IN CORE ;UNTIL THEY ARE NEEDED OR CORE DEMAND REQUIRES THAT THEY BE RETURNED ;THERE IS A THIRD CLASS OF SEGMENTS, CALLED 'IDLE'. ;AN IDLE SEGMENT IS A SHARABLE SEG WHICH IS IN CORE, BUT NO JOB IN CORE ;IS USING IT, BUT SOMEONE ON DISK IS. IT WILL BE DELETED IF CORE IS NEEDED ;THE 3 CLASSES OF SEGMENTS ARE ACTIVE,IDLE,DORMANT. ;LOCATION CORTAL CONTAINS THE SUM OF FREE BLOCKS+DORMANT BLOCKS ;HOWEVER CORTAB CONTAINS 0 BITS ONLY FOR FREE BLOCKS ;TO FREE STORAGE ;THE CORE COMMAND WITH NO ARG STILL PRINTS CORE AS IF NO DORMANT SEGS IN CORE ;VIRTAL CONTAINS THH AMOUNT OF FREE VIRTUAL CORE LEFT IN SYSTEM ;INCLUDING HIGH SEGMENTS. SINCE THIS QUANTITY IS USED TO PREVENT ;THE CORE ROUTINES FROM OVER COMMITTING SWAP SPACE. SHARED SEG ARE ONLY ;COUNTED ONCE, AND DORMANT SEGMENTS ARE NOT INCLUDED. THUS VIRTAL IS ;DECREMENTED WHEN THE FIRST USER SHARES A SEGMENT CHANGING IT FROM DORMANT ;TO ACTIVE ENTRY SEGCON SEGCON: ;ENTRY POINT SYMBOL TO CAUSE LOADING OF SEGCON ;(AS OPPOSED TO NULSEG OR NEITHER) SUBTTL ONCE - ONCE ONLY STARTUP CODE ;LOCATION 'TWOREG' IS A FLAG WHICH IS TESTED AT POINTS WHERE A HIGH ;SEGMENT CAN BE CREATED, TO SEE IF BOTH HARDWARE AND SOFTWARE HAVE TWO ;REGISTER CAPABILITY ;INITIALIZE LOC TWOREG TO 0 IF SOFTWARE OR HARDWARE DOES NOT HAVE 2 SEGMENT ;CAPABILTIY. SET TWOREG TO -1 IF BOTH DO HAVE 2 SEGMENT CAPABILITY. ;SYMBOL AND2RG IS ANDDED TO 'TWOREG' FROM ONCE ONLY CODE AFTER THE HARDWARE IS ;EXAMINED AND TWOREG HAS BEEN SET TO 0 OR -1 ACCORDINGLY. INTERN AND2RG AND2RG=-1 ;AND WITH -1, IE LEAVE 'TWOREG' SET TO 0 OR -1 ACCORDING TO THE ;CAPABILITIES OF THE HARDWARE. SUBTTL CLOCK - CLOCK ROUTINE ;ROUTINE TO ADJUST AC R SO THAT IT HAS PROPER RELOCATION AND PROTECTION ;INFORMATION FOR CURRENT JOB, SO THAT A DATAO APR, R CAN BE DONE. ;CALLED FROM SETREL ONLY. SETREL IS CALLED FROM CLOCK,CORE UUO, ;REMAP UUO, AND RESET UUO. ;CALL: MOVE ITEM,JOB NUMBER ; MOVE R,JBTADR(ITEM) ;XWD PROTECT,RELOC FOR LOW SEGMENT ; PUSHJ P,SETHGH ; RETURN WITH R SET FOR DATAO APR,R FOR BOTH LOW AND HIGH SEGMENTS ; J STILL JOB NUMBER INTERN SETHGH EXTERN JBTSGN,JBTADR,JOBHRL,JOBHCU SETHGH: MOVEI TAC1,377777 ;ASSUME HIGH SEGMENT STARTS AT USER LOC 400000 SKIPGE PROG ;IS LOW SEGMENT LONG(GREATER THAN 377777) HLRZ TAC1,PROG ;YES, PROTECTION FOR LOW SEG IS STARTING ADR-1 SKIPG AC1,JBTSGN(ITEM) ;DOES USER HAVE A REAL HIGH SEG? SKIPA TAC,AC1 ;NO, MUST BE NONE OR SPYING ON EXEC ; IF SPYING, RH HAS HIGHEST PHY. ADR FOR THIS USER HLRZ TAC,JBTADR(AC1) ;NO. OF WORDS-1 IN HIGH SEG JUMPE TAC,NOHGH ;DOES USER HAVE A HIGH SEG IN CORE? ADDI TAC,1(TAC1) ;YES, HIGHEST USER ADR.=1+NO. WORDS-1+HIGH ORIGIN-1 NOHGH: SKIPL JOBHCU(PROG) ;DO NOT STORE IN JOBHRL IF SAVE OR GET IN PROGRESS ; BECAUSE IT USES THESE LOCATIONS FOR ZERO COMPRESSION HRRM TAC,JOBHRL(PROG) ;STORE IN USER AREA SO HE CAN LOOK AT IT. ;LH UNALTERED(HIGHESTREL LOC LOADED+1 BY LOADER) ;0 MEANS NO HIGH SEG LSH TAC,-12 ;RIGHT JUSTIFY 8 BIT PROTECTION FOR HIG SEG DPB TAC,[POINT 8,PROG,16] ;STORE IN POSITION FOR DOING DATAO APR,PROG ;IF NO HIGH SEG, 0 WILL CAUSE FAILURE IF REF SKIPGE AC1 ;IS THIS ASPY SEG? TDZA TAC,TAC ;YES, ABS. ADR OF BEGINNING IS 0 ; (AC1 HAS HIGHEST PAT ADR USER WANTS HRRZ TAC,JBTADR(AC1) ;ABSOLUTE ADR. OF BEG. OF HIGH SEG SUBI TAC,1(TAC1) ;SUBTRACT 400000 OR LENGTH OF LOW SEG(IF GREATER) LSH TAC,-11 ;SHIFT RELOC. FOR HIGH SEG TO POSITION FOR DATAO ANDI TAC,776 ;MASK OUT ALL BUT 8 BITS IOR PROG,TAC ;INSERT RELOC AND PROT FOR HIGH SEG IN PROG TLO PROG,UWP ;ASSUME USER-MODE WRITE PROTECT IS ON TLNE AC1,UWPOFF ;HAS USER DONE A SETUWP UUO AND TURNED OFF UWP? ; (AND HAS NOT MEDDLED WITH PROGRAM) TLZ PROG,UWP ;YES, SET UWP OFF FOR DATAO POPJ PDP, ;ROUTINE TO CHARGE CURRENT USER FOR HIS USE OF HIGH SEGMENT ;CALL: MOVE ITEM,CURRENT JOB NUMBER ; PUSHJ PDP,CHGHGH ; RETURN ;CALLED EVERY JIFFY FROM CLOCK ROUTINE IFN FTKCT,< INTERN CHGHGH EXTERN JBTSGN,JBTADR,JBTSTS,JBTKCT CHGHGH: SKIPG TAC,JBTSGN(ITEM) ;CURRENT JOB HAVE A REAL HIGH SEG? POPJ PDP, ;NO, DO NOT CHARGE HIM(EVEN IF PY SEG) HLRZ TAC,JBTADR(TAC) ;YES, SIZE OF HIGH SEG-1 LSH TAC,-12 ;CONVERT TO SIZE IN K-1 ADDI TAC,1 ;NUMBER OF K ADDM TAC,JBTKCT(ITEM) ;CUMMULATE K-CORE TICKS FOR CURENT JOB POPJ PDP, > SUBTTL COMCSS - COMMAND DECODER SUBROUTINES ;ROUTINE TO STOP NEW USERS FROM SHARAING EXISTING SEGMENTS ON DECTAPE ;AND MAGTAPE WHICH HAVE BEEN JUST ASSIGNED, SINCE THE NEW TAPE MAY HAVE ;A LATER VERSION OF THE FILE WITH THE SAME NAME AS THE SEGMENT. ;REMSEG - DELETE ALL SEGS OF DISK FILE STRUCTURE BEING REMOVED ;CALLED FROM ASSIGN,DEASG(DEASSIGN,FINISH,KJOB) CONSOLE COMMAND. REMSTRR UUO ;CALL: MOVE F,DEVICE DATA BLOCK ADDRESS OR STR DATA BLOCK ADR. ; MOVE TAC1,DEVMOD(F) ;DEVICE CHARACTERISTICS ; PUSHJ PDP,ASGHGH ; ALWAYS RETURN, C(TAC1) DESTROYED INTERN ASGHGH EXTERN SEGPTR,JBTDIR,IPOPJ ASGHGH: TLNN TAC1,DVDTA!DVMTA ;IS THIS DEVICE JUST ASSIGNED A DTA OR MTA? POPJ PDP, ;NO, NO CONFLICT POSSIBLE PUSH PDP,ITEM ;YES, SAVE JOB NUMBER MOVE ITEM,SEGPTR ;SCAN ALL HIGH SEGMENTS ASG1: MOVE TAC,DEVNAM(DEVDAT) ;GET DEVICE NAME(PHYSICAL) CAME TAC,JBTDIR(ITEM) ;DOES IT MATCH DEVICE NAME ; ( DEVICE NAME) OF SEGMENT? ASG3: AOBJN ITEM,ASG1 ;NO, KEEP LOOKING, FINISHED? JUMPG ITEM,IPOPJ ;RETURN IF FINISHED AND RESTORE JOB NUMBER TLZ ITEM,-1 ;CLEAR OUT LH BITS OF HIGH SEG NO. PUSHJ PDP,CLRNAM ;NOT FINISHED, CLEAR SEG NAME ;AND RETURN DISK SPACE IF NOT IN USE JRST ASG3 ;CONTINUE SCAN, RESTORE TAC TO DEVICE NAME ;ROUTINE TO PRINT SIZE OF HIGH SEG LOGICAL CORE ;CALL: MOVE ITEM,JOB NO. ; PUSHJ PDP,PRTHGH ; ALWAYS RETURN WITH ITEM RESTORED ;PRINTS +N(UNLESS NOT TWO REG HARDWARE, SO USERS CAN TELL IF 2 REG. HARD.) INTERN PRTHGH EXTERN TWOREG,INLMES,JBTSGN,PRTSEG,IPOPJ PRTHGH: SKIPN TWOREG ;2 REG. MACHINE? POPJ PDP, ;NO, DO NOT PRINT EVEN +0 PUSHJ PDP,INLMES ;YES, PRINT + ASCIZ /+/ PUSH PDP,ITEM ;SAVE JOB NUMBER SKIPG ITEM,JBTSGN(ITEM) ;DOES JOB HAVE A REAL HIGH SEG? MOVEI ITEM,0 ;NO, MAKE SURE NO HIGH SEG(IN CASE SPY SEG) PUSHJ PDP,PRTSEG ;PRINT SIZE OF LOGICAL ADR. HIGH SEG JRST IPOPJ ;RESTORE JOB NUMBER AND RETURN ;ROUTINE TO CHECK TO SEE IF USER IS MEDDLING WITH A SHARABE PROGRAM ; IF YES, TURN UWPOFF OFF SO UWP(USER MODE WRITE PROTECT) WILL BE ON ; AND SET MEDDLE, SO HE CANNOT TURN UWP BACK OFF AND CANNOT CHANGE CORE ; ASSIGNMENT OF HIGH SEG(EXCEPT TO REMOVE IT COMPLETELY) ;CALL: MOVE ITEM,JOB NO. ; PUSHJ PDP,CHKMED ; ALWAYS RETURN, ITEM RESTORED AND TAC1 PRESERVED(TAC USED) ;CALLED FROM DEPOSIT, START N, RUN UUO, GETSEG UUO ;TAC1 PRESERVED INTERN CHKMED EXTERN JBTSGN CHKMED: SKIPLE TAC,JBTSGN(ITEM) ;DOES JOB HAVE A REAL HIGH SEG? TLNN TAC,SHRSEG ;YES, IS IT SHARABLE? POPJ PDP, ;NO(NONE OR SPY SEG(MEDDLE ALREADY ON)) TLO TAC,MEDDLE ;YES, FLAG TIS USER AS MEDDLING TLZ TAC,UWPOFF ;AND FORCE UWP ON IN HARDWARE SO WRITES TRAP MOVEM TAC,JBTSGN(ITEM) ;NEXT TIME USER RUNS POPJ PDP, SUBTTL CORE1 - LOGICAL AND PHYSICAL CORE ALLOCATION ;ROUTINE TO CHECK FOR SAVE IN PROGRESS FROM A HIGH SEG ;ABOUT TO BE SHUFFLED OR SWAPPED, OR CORE REASSIGNED ;CALL: MOVE ITEM,LOW OR HIGH SEG TO BE SHUFFLED OR SWAPPED ; PUSHJ PDP,ANYSAV ; RET1 - THIS IS A HIGH SEG WHICH SOME JOB IS DOING A SAVE OF ; RET2 - THIS IS A HIGH SEG WHICH CAN BE SHUFFLED OR SWAPPED ;CALLED FROM ANYACT IN CORE MODULE,TAC1 PRESERVED FOR SWAPPER INTERN ANYSAV EXTERN JOBMAX,JBTADR,TPOPJ1,HIGHJB,JOBHCU,JBTSGN,ANYDEV ANYSAV: CAILE ITEM,JOBMAX ;IS THIS A LOW SEG? SKIPN JBTADR(ITEM) ;NO, IS THIS HIGH SEG IN CORE? JRST CPOPJ1 ;YES, GIVE SINGLE SKIP RETURN PUSH PDP,ITEM ;SAVE HIGH SEG NUMBER MOVE ITEM,HIGHJB ;HIGHEST JOB NUMBER ASSIGNED ANYSV0: SKIPE PROG,JBTADR(ITEM) ;IS JOB IN CORE (R=R)? SKIPL JOBHCU(PROG) ;YES, IS A SSVE OR GET FOR EITHER SEG IN PROGRESS? ANYSV1: SOJG ITEM,ANYSV0 ;NO, KEEP LOOKING, FINISHED? JUMPLE ITEM,ANYSV2 ;YES, FIND A SAVE OR GET IN PROGRESS HRRZ TAC,JBTSGN(ITEM) ;NO, GET ITS HIGH NUMBER, IF ANY CAIE TAC,@(PDP) ;IS IT SAME AS HIGH SEG IN QUESTION? ; (INDIRECT AND INDEX BITS ALWAYS 0) JRST ANYSV1 ;NO, KEEP LOOKING PUSHJ PDP,ANYDEV ;YES, DOES THIS JOB HAVE ; ANY ACTIVE DEVICES(THE SAVE GET DEVICE) OR ; HAS DEVICE STOPPED DURING SAVE FOR SOME REASON? SOSA (PDP) ;YES, GIVE SAVE ACTIVE RETURN JRST ANYSV1 ;NO, KEEP LOOKING FOR OTHER JOBS ANYSV2: POP PDP,ITEM ;RESTORE HIGH SEG NUMBER MOVE PROG,JBTADR(ITEM) ;RESTORE ITS RELOC. JRST CPOPJ1 ;GIVE ERROR OR OK RETURN ;ROUTINE TO DEPOSIT USER COMMAND ARG IN HIGH SEG IF USER HAS PRIVILEGES ; TO WRITE OR SEG IS NON-SHARABLE ;CALL: MOVE ITEM,JOB NO. ; MOVE PROG,JOB RELOC. ; MOVE TAC1,REL. USER ADR. NOT IN LOW SEG ; MOVE IOS,WORD TO DEPOSIT ; PUSHJ PDP,HGHDEP ; ERROR RETURN ; OK RETURN - JOBEXM SET TO USER ADR IN HIGH SEG, S STORED IN HIGH SEG INTERN HGHDEP EXTERN TPOPJ,JOBEXM,IPOPJ1,IPOPJ IFN FTSWAP, HGHDEP: HRR UUO,TAC1 ;MOVE REL. ADR. TO UUO FOR HGHWRD ROUT. PUSHJ PDP,HGHWRD ;SET TAC OT HIGH WORD, TAC1 TO ABS ADR. POPJ PDP, ;NOT IN BOUNDS, ERROR RETURN OR NO HIGH SEG MOVE AC2,ITEM ;SETUP JOB NUMBER FOR CHKHSW ROUT. PUSH PDP,ITEM ;SAVE JOB NUMBER PUSH PDP,TAC1 ;SAVE ABS. ADR. OF LOC. IN HIGH SEG SKIPLE ITEM,JBTSGN(ITEM) ;GET HIGH SEG NUMBER PUSHJ PDP,CHKHSW ;CAN JOB(P2) WRITE IN HIGH SEG(ITEM)? SOSA -2(PDP) ;NO, SET FOR ERROR RETURN MOVEM IOS,@(PDP) ;YES,STORE USER ARG HRRZM UUO,JOBEXM(PROG) ;STORE LOC OF DEPOSIT FOR D,E WITH NO ARG ; LH=O MEANING D WAS LAST DONE RATHER THAN E POP PDP,TAC1 ;RESTORE PD LIST JRST IPOPJ1 ;RESTORE JOB NUMBER AND SKIP OR ERROR RETURN ;ROUTINE TO REMOVE HIGH SEGMENT FROM USER'S LOGICAL ADDRESSING SPACE ;THIS IS CONTRANSTED WITH REMOVING A HIGH SEGMENT FROM PHYSICAL CORE ;WHICH THE SWAPPER DOES EVERY TIME A JOB WITH A HIGH SEG IS SWAPPED OUT (KCORE1) ;THE SEGMENT NUMBER ASSOCIATED WITH THE JOB IS ERASED (JBTSGN) ;IF NO OTHER JOB IS USING HIGH SEG IN CORE(IN CORE COUNT GOES TO 0) ; HIGH SEG IS NOT DELETED FROM CORE(UNLESS NOT SHARABLE) BUT RATHER BECOMES 'IDLE'. ; WHERE IDLE HAS SNA SET. ;IF NO OTHER JOB IS USING HIGH SEG IN LOGICAL ADR. SPACE, HIGH SEG IS ; NOT DELETED FROM CORE OR DISK(UNLESS NOT SHARABLE) BUT RATHER BECOMES 'DORMANT'. ; WHERE DORMANT HAS SNA TURNED OFF, BUT HAS CORE AND/OR DISK SPACE. ;RATHER IT BECOMES DORMANT(UNLESS IT NO LONGER HAS A NAME OR WAS NEVER SHARABLE) ;A DORMANT SEGMENT IS LEFT IN SYSTEM ACCORDING TO: ; A. SWAP SYS - LEFT ON BOTH SWAPPING DEVICE AND CORE ; B. NON-SWAP SYS - LEFT IN CORE ;DORMANT SEGMENTS HAVE JNA BIT OFF, HOWEVER THEY HAVE DISK SPACE AND/OR CORE ;DORMANT SEGMENTS ARE FLUSHED ONLY WHEN DISK OR CORE IS NEEDED ; OR HIGH SEGMENT NUMBERS ARE NEEDED ;KILHGH IS CALLED AT CLOCK AND UUO LEVELS BY: ;GET,R,RUN,LOGIN COMMANDS ;CORE 0 COMMAND ;CORE UUO(0 LESS-THAN LH LESS-THAN 400000) ;KJOB COMMAND AT UUO LEVEL ;REMAP UUO ;CALLER MUST INSURE THAT NEITHER LOW OR HIGH SEG ARE BEING SWAPPED ;CALL: MOVE ITEM,JOB NUMBER ; MOVE PROG,LOW SEG RELOC. AND PROT. ; PUSHJ PDP,KILHGH ; OK RETURN - ITEM,PROG RESTORED TO JOB (LOW SEG) RELOCATION INTERN KILHGH EXTERN JBTSGN,JBTADR,JBTNAM,JBTSTS,CORTAL,IPOPJ,SEGSIZ KILHGC: SKIPA ITEM,JOB ;KILL HIGH SEG FOR CURRENT JOB(GETSEG,REMAP,CORE UUO) KILHG1: AOS (PDP) ;ALWAYS SKIP RETURN(CALLED FROM UCORHI) KILHGH: PUSH PDP,ITEM ;SAVE JOB NUMBER SKIPG ITEM,JBTSGN(ITEM) ;DOES JOB HAVE A REAL HIGH SEG? JRST KILFIN ;NO, ZERO HIGH SEG NUMBER FOR THIS JOB IN CASE SPY SEG IFN FTSWAP,< PUSHJ PDP,SEGSIZ ;TAC1=SIZE OF HIGH SEG PUSH PDP,TAC1 ;SAVE SIZE IN CASE NEED TO INCREASE AMOUNT ;OF FREE VERTICAL CORE LEFT. > SKIPN PROG,JBTADR(ITEM) ;YES, IS HIGH SEG ALSO IN CORE? JRST SCNLOG ;NO, SCAN TO SEE IF OTHER USERS USING THIS HIGH SEG ; IN THEIR LOGICAL ADDRESSING SPACE IFE FTSWAP,< MOVE TAC,(PDP) ;JOB NUMBER > IFN FTSWAP,< MOVE TAC,-1(PDP) ;JOB NUMBER > PUSHJ PDP,DECCNT ;YES, DECREMENT HIGH SEG IN CORE COUNT FOR THIS JOB ; HIGH SEG IN-CORE COUNT TRANSITION TO 0? JRST KILFN1 ;NO, JUST REMOVE HIGH SEG FROM THIS ; USER'S LOG. ADR SPACE SKIPN JBTNAM(ITEM) ;YES, COULD NEW USER'S SHARE ON GET ; (STILL HAVE A NAME)? IE HIGH SEG GONE TO 0? PUSHJ PDP,KCOREH ;NO, EITHER NEVER WAS SHARABLE OR SUPERCEDED, ; SO RETURN CORE AND CLEAR R JUMPE PROG,SCNLOG ; AND GO SCAN FOR OTHER USER'S WHO MIGHT BE ; SHARING IT IN THEIR LOGICAL ADR SPACE LDB TAC,PCORSZ ;YES, LEAVE HIGH SEG IN CORE WITH IN CORE COUNT 0 ; IE IDLE AS OPPOSED TO DORMANT SINCE SNA STILL SET ADDI TAC,1 ;BUT INCREASE COUNT OF FREE+DORMANT+IDLE CORE ADDM TAC,CORTAL ;IN J WORDS IFN FTHALT,< PUSHJ PDP,CHKTAL ;CHECK CORTAL AGAINST CORTAB, HALT IF BAD > SCNLOG: IFN FTSWAP, MOVSI TAC,SNA ;FLAG HIGH SEG AS UNASSIGNED(OR DORMANT ; IF STILL IN ; CORE OR DISK). TURN OFF NO SWAP AND NO SHUFFLE ; IN CASE ON BY ACCIDENT(SAVE NOT GO TO COMPLETION) ANDCAM TAC,JBTSTS(ITEM) IFN FTSWAP,< EXTERN VIRTAL MOVE TAC,(PDP) ;SIZE IN J OF HIGH SEG WHICH IS BECOMING DORMANT ADDM TAC,VIRTAL ; OR UNASSIGNED, INCREASE AMOUNT OF VIRTUAL CORE LEFT ; IN SYSTEM,(EVEN THOUGH CORE AND DISK SPACE ; MAYBE STILL USED) > KILFN1: IFN FTHALT,< PUSHJ PDP,CHKTAL ;CHECK CORTAL AGAINST CORTAB, HALT IF BAD > IFN FTSWAP,< POP PDP,TAC ;REMOVE SIZE OF SEG IN J > KILFIN: POP PDP,ITEM ;RESTORE JOB NUMBER SETZM JBTSGN(ITEM) ;REMOVE HIGH SEG FROM THIS USER'S LOGICAL ADR. SPACE RPOG: MOVE PROG,JBTADR(ITEM) ;RESTORE LOW SEG RELOC AND PRTECTION POPJ PDP, ;RETURN ;ROUTINE TO CLEAR A HIGH SEGMENT NAME SO NO NEW USERS CAN SHARE ;AND RETURN BOTH DISK AND CORE SPACE (IF ANY) IF HIGH SEG WAS DORMANT(SNA=0) ;IE NO LONGER IN ANY USER'S VIRTUAL ADR. SPACE ;CALL: MOVE ITEM, HIGH SEG NUMBER ; PUSHJ PDP, CLRNAM ; RETURN ITEM AND PROG PRESERVED ;CALLED FROM FRESWP,FRECOR,FNDSGN (UREMAP,UCORHI), ASGHGH,RELSEG EXTERN JBTNAM,JBTSTS,JBTDIR IFN FTDISK, CLRNAM: SETZM JBTDIR(ITEM) ;CLEAR DIRECTOIRY NAME (OR DEVICE NAME) CLRNM1: SETZM JBTNAM(ITEM) ;AND SEG NAME SO NEW USER'S CAN USE ; CLRNM2 CALLED PQOM ASGHGH AND RELSEG ; WHEN FILE SUPERCEDED, BUT LEAVE DIR ; NAME FOR SYSTAT TO PRINT (OBS) SKIPGE JBTSTS(ITEM) ;IS SEG DORMANT(IE NOT IN ANY USER'S VIRTUAL ; ADR. SPACE)? POPJ PDP, ;NO,(SNA=1) ALLOW USER'S TO CONTINUE TO SHARE ; UNTIL FINISHED, HOWEVER NO NEW USERS CAN ; SHARE SINCE NO LONGER A NAME IFN FTSWAP,< EXTERN ZERSWP PUSHJ PDP,ZERSWP ;YES, RETURN DISK SPACE, IF ANY > ;FALL INTO ROUTINE TO KILL DORMANT CORE ;ROUTINE TO RETURN DORMANT OR IDLE CORE (IF ANY) ;CALL: MOVE ITEM, HIGH SEG NUMBER ; PUSHJ P,KDORCR ; RETURN ITEM,PROG PRESERVED ;CALLED FROM CLRNAM AND FRECOR INTERN FTHALT EXTERN CORTAL,JBTADR KDORCR: PUSH PDP,PROG ;SAVE R(EITHER HIGH OR LOW RELOC) PUSH PDP,CORTAL ;SAVE FREE CORE COUNT SKIPE PROG,JBTADR(ITEM) ;DOES DORMANT SEG HAVE CORE? PUSHJ PDP,KCOREH ;YES, RETURN PHYSICAL COREAND FLAG HIGH SEG ; AS ON DISK IF IT HAS DISK SPACE(SET SWP=1) POP PDP,CORTAL ;RESTORE FREE CORE COUNT, SINCE DORMANT ; SEGS ALREADY INCLUDED IN CORTAL IFN FTHALT,< PUSHJ PDP,CHKTAL ;CHECK CORTAL WITH CORTAB, HALT IF BAD > POP PDP,PROG ;RESTORE PROG POPJ PDP, ;RETURN ;ROUTINE TO RETURN HIGH SEGMENT CORE(MUST BE SOME) AND FLAG SEG AS ON DISK ; IF HIGH SEG HAS DISK SPACE(IE SET SWP=1 IF IMGOUT NON-ZERO) ;CALL: MOVE ITEM,HIGH SEG NUMBER ; MOVE PROG,HIGH SEG RELOC AND PROTECTION ; PUSHJ P,KCOREH ;CALLED FROM KDORCR(FRECOR,CLRNAM,KILHGH) AND FORHGH IFN FTSWAP,< EXTERN IMGOUT,KCORE1,JBTSTS KCOREH: LDB TAC,IMGOUT ;DOES HIGH SEG HAVE DISK SPACE? JUMPE TAC,KCORE1 ;NO, RETURN CORE MOVSI TAC,SWP ;YES, FLAG HIGH SEG AS SWAPPED OUT IORM TAC,JBTSTS(ITEM) ;SET SWP=1 JRST KCORE1 ;THEN RETURN CORE > IFE FTSWAP,< EXTERN KCORE1 KCOREH=KCORE1 > ;CORE UUO ROUTINE TO ASSIGN OR REASSIGN CORE FOR HIGH SEG ;CALLED AFTER LOW SEG SEG IS REASSIGNED IF USER HAS NON-ZERO RH IN AC ;CALL: HRRZ TAC,DESCRED HIGHEST USER ADR. IN HIGH SEG ; MOVE ITEM, JOB NUMBER ; PUSHJ PDP,UCORHI ; ERROR RETURN - SUM OF SEGMENTS EXCEED MAX. PHYSICAL CORE OR ; EXCEED TOTAL SYSTEM VIRTUAL CORE CAPACITY ; SHARABLE PROGRAM MEDDLED WITH(AND NO WRITE PRIV.) ; OR HIGH SEG IS SPY SEG ; OK RETURN - CORE ASSIGNED(MAYBE NOT IN MEMORY) OR USER ASKED NO CHANGE(LH=0) ; J AND R RESTORED TO LOW SEG NO AND RELOC ;IF LH IS NON-ZERO BUT LESS THAN 400000 OR END OF LOW SEG(IF GREATER THAN 400000) ;THE HIGH SEGMENT WILL BE REMOVED FROM USERS LOGICAL ADDRESSING SPACE INTERN UCORHI EXTERN CPOPJ1,JBTADR,JBTSGN,TWOREG,JBTSTS,SEGPTR EXTERN JBTSTS,JOB,CORE0,JOBADR UCORHI: JUMPE TAC,CPOPJ1 ;ASKING FOR ANY CHANGE? SUBI TAC,400000 ;YES, GET LENGTH-1 ASSUMING HIGH SEG START AT 400000 HLRZ TAC1,JBTADR(ITEM) ;LENGTH-1 OF LOW SEGMENT TRNE TAC1,400000 ;IS LOW SEG SO LONG AS TO CAUSE HIGH SEG TO START ; HIGHER UP IN USER ADDRESSING SPACE THAN 400000? SUBI TAC,-400000+1(TAC1);YES, ADD BACK 400000 AND SUBTRACT LENGTH OF LOW SEG JUMPL TAC,KILHG1 ;KILL HIGH SEG IF ITS HIGHEST USER ADR WOULD ; BE LESS THAN USER ORIGIN OF HIGH SEG ; ALWAYS SKIP RETURN IORI TAC,1777 ;USER WANTS MORE OR LESS HIGH SEG CORE, ; MAKE IT EVEN 1K-1 PUSH PDP,TAC ;SAVE CORE ARG(NEW SIZE-1) SKIPL ITEM,JBTSGN(ITEM) ;GET HIGH SEG NUMBER(IF ANY),SPY SEG? SKIPN TWOREG ;NO, DOES MACHINE HAVE JUST 1 RELOC REG? JRST UCORHE ;YES, GIVE ERROR RETURN TO USER TLNN ITEM,MEDDLE ;HAS USER MEDDLED WITH THIS PROGRAM(AND WAS ; SHARABLE) OR THIS A SPY SEG? JRST UCORH1 ;NO, OK TO CHANGE CORE ASSIGNMENT MOVE AC2,JOB ;YES, CURRENT JOB NUMBER PUSHJ PDP,CHKHSW ;CHECK TO SEE IF USER HAS PRIVILEGES TO ; WRITE HIGH SEG JRST UCORHE ;NO, ERROR RETURN TO USER UCORH1: SKIPN ITEM ;YES, DOES JOB HAVE A HIGH SEG YET? ; OR IS THIS FIRST ASSIGNMENT OF CORE TO HIGH SEG PUSHJ PDP,FNDSGN ;NO, FIND FREE SEG NUMBER BEFORE ASSIGNING CORE ; (TAC PRESERVED) IFN FTSWAP,< EXTERN ZERSWP PUSHJ PDP,ZERSWP ;RETURN SWAPPING SPACE, IF ANY (NULL JOB NEVER HAS ; SINCE NEW SIZE MAY BE DIFFERENT FROM OLD SIZE ; SO IT SHOULD BE WRITTEN NEXT SWAPOUT ; EVEN IF WRITE PROTECTED. > POP PDP,TAC ;RESTORE AMOUNT OF CORE REQUEST MOVE PROG,JBTADR(ITEM) ;R TO PREVIOUS HIGH SEG CORE ASSIGNMENT(IF ANY) PUSHJ PDP,CORE0 ;TRY TO ASSIGN CORE TO HIGH SEG(ON DISK OR MEMORY) JRST SETREL ;ERROR, CORE REQUEST TOO BIG, IF NO ONE IS USING ; (INCLUDING THIS USER) LEAVE SEG NON-EXISTENT, ; OTHERWISE DORMANT OR STILL IN USE BY THIS AND/OR ; OTHER USERS MOVE PROG,JOBADR ;RESTORE LOW SEGMENT ADDRESS, FOR USE BY WSCHED JRST SHARE2 ;OK RETURN, MARK USER AS HAVING THIS HIGH SEG IN LOG. ; ADR. SPACE(IN CASE IT WAS NOT BEFORE) ; SET RELOC AND SKIP RETURN ; AND INCREMENT HIGH SEG IN CORE CONT FOR THIS JOB ; IF NOT ALREADY DONE SO. UCORHE: POP PDP,TAC ;RESTORE PD LIST JRST SETREL ;AND SETUP HARDWARE, SET R TO LOW SEG ; RELOC, J TO CURRENT JOB, AND ERROR RETURN ;UUO TO REMAP TOP PART OF LOW SEGMENT INTO HIGH SEGMENT ;PREVIOUS HIGH SEGMENT(IF IT EXISTED) IS REMOVED FROM LOGICAL ADDRESSING SPACE ;CALL: MOVE TAC,HIGHEST DESIRED REL. ADR. IN NEW LOW SEG. ; (EXEC ORES IN 1777 TO MAKE EVEN 1K-1) ; MOVE PROG,XWD PROTECTION,RELOCATION FOR LOW SEGMENT ; PUSHJ PDP,UREMAP ; ERROR RETURN - DESIRED HIGHEST REL. ADR PAST END OF LOW SEG ; ;OR 1 REGISTER MACHINE ; OK RETURN - HARDWARE AND SOFTWARE RELOCATION INFO RESET ; ITEM RESET TO CURRENT JOB NUMBER, AND PROG TO RELOC ;MUST BE CALLED AT UUO LEVEL ONLY INTERN UREMAP EXTERN USRREL,TWOREG,IOWAIT,CPOPJ1,SETREL,JOB UREMAP: IORI TAC,1777 ;MAKE AN EVEN MULTIPLE OF 1K-1 SKIPE TWOREG ;DOES MACHINE HAVE TWO RELOCATION REG? CAMLE TAC,USRREL ;YES, IS NEW TOP OF LOW SEG LESS THAN OR EQUAL TO OLD? POPJ PDP, ;NO, ERROR RETURN - 1 REG MACHINE OR ARG TOO BIG PUSH PDP,TAC ;YES, SAVE DESIRED HIGHEST ADR OF NEW LOW SEG PUSHJ PDP,IOWAIT ;WAIT FOR IO TO STOP IN LOW SEG PUSHJ PDP,KILHGC ;KILL PREVIOUS HIGH SEG IF IT EXISTED FOR CUR. JOB POP PDP,TAC1 ;RESTORE DESIRED HIGHEST ADR IN NEW LOW SEG HLRZ TAC,JBTADR(ITEM) ;GET PREVIOUS HIGHEST ADR OF LOW SEG HRLM TAC1,JBTADR(ITEM) ;STORE NEW(LESS THAN OR EQUAL) HIGHEST ADR OF LOW SEG SUBI TAC,1(TAC1) ;COMPUTE LENGTH-1 OF NEW HIGH SEG JUMPL TAC,SETRL1 ;-1 MEANS NEW LOW SEG=OLD LOW SEG ; RESET HARDWARE BECAUSE NO HIGH SEG ANY MORE ; FOR SURE, SET RELOC. HARD. AND SKIP RETURN ADD TAC1,JBTADR(ITEM) ;ADD ABS. ADR. OF LOW SEG TO LENGTH-1 OF LOW SEG ;TO FORM LENGTH-1 OF NEW HIGH SEG HRLI TAC,1(TAC1) ;MOVE ABS ADR. OF NEW HIGH SEG TO LH PUSHJ PDP,FNDSGN ;FIND FREE SEG NUMBER(TAC PRESERVED) ; AND SET IN CORE COUNT TO 0 MOVSM TAC,JBTADR(ITEM) ;STORE LENGTH-1 AND ABS. ADR. OF NEW HIGH SEG JRST SHARE1 ;SET IN CORE COUNT TO 1, FLAG THIS SEG IN CURRENT ; JOB'S LOG. ADR. SPACE, AND FLAG HIGH SEG NO. ; AS ASSIGNED(SNA=1) ; RESET HARD. AND SOFT. RELOC, AND SKIP RETURN ;ROUTINE TO FIND A FREE SEG NUMBER FOR A NEW HIGH SEGMENT FOR CURRENT JOB ;CALLED BY CORE UUO AND REMAP UUO(MUST BE CALLED AT UUO LEVEL ONLY) ;TRIES TO FIND A FREE SEGMENT WITHOUT DORMANT COPY ON DISK OR CORE ;IF NONE, IT FINDS A SEG WHICH IS DORMANT ON DISK AND/OR CORE ; DELETES UNUSED DISK AND CORE AND REUSES THAT HIGH SEG NUMBER ;(A SEGMENT CANNOT BE DORMANT ON DISK AND USED IN CORE OR VICE VERSA) ;NEW HIGH SEG IS FLAGGED AS NON-SHARABLE(SHRSEG=0 IN JBTSTS FOR HIGH SEG) ;IN CORE COUNT IS SET TO 0 ;CALL: PUSHJ PDP,FNDSGN ; RETURN WITH ITEM SET TO FREE SEG NUMBER ;HOWEVER CURENT JOB IS NOT MARKED AS HAVING THIS SEG IN LOGICAL ADR SPACE ; SINCE THER MAY NOT BE ENOUGH CORE FOR SEGMENT. THE CALLER MUST FLAG USER ; AS HAVEING THIS SEG IN ADDRESSING SPACE IF EVERYTHING OK ;THE LH OF ITEM IS SET TO 0(SHRSEG=MEDDLE=UWPOFF=SPYSEG=0) ;THE CALLER MUST ALSO FLAG HIGH SEG AS ASSIGNED(SNA=1) IF EVERYTHING OK ;TAC IS PRESERVED, TAC1 IS USED EXTERN SEGPTR,JBTSTS,JOB,JBTSGN,TPOPJ,UERROR,JBTNAM IFN FTDISK, FNDSGN: PUSH PDP,TAC ;SAVE TAC(HIGHEST REL. ADR. DESIRED ;IN CALLS TO CORE AND REMAP) MOVE ITEM,SEGPTR ;SCAN JUST HIGH SEGMENTS(NOT JOBS) IFN FTSWAP,< EXTERN JBTSWP,OUTMSK MOVEI TAC1,OUTMSK ;MASK FOR DISK IMAGE BYTE POINTER > FND1: SKIPL JBTSTS(ITEM) ;SEG NUMBER ASSIGNED(SNA=1)? SKIPE JBTADR(ITEM) ;NO, DOES HIGH SEG STILL HAVE CORE ANYWAY? IFN FTSWAP,< JRST .+2 ;YES, KEEP LOOKING TDNE TAC1,JBTSWP(ITEM) ;NO, DOES IT HAVE DISK SPACE? > AOBJN ITEM,FND1 ;YES, KEEP LOOKING, MORE TO GO? JUMPL ITEM,FNDOK ;NO, WAS A FREE SEG NUMBER FOUND WITH NO CORE ASSIGNED? MOVE ITEM,SEGPTR ;NO, FIND FREE SEG EVEN IF DORMANT ON DISK OR CORE FND2: SKIPGE JBTSTS(ITEM) ;IS THIS HIGH SEG NO. ASSIGNED(SNA=1)? AOBJN ITEM,FND2 ;YES, KEEP LOOKING, MORE TO GO? JUMPL ITEM,FNDOK ;NO, WAS A FREE ONE FOUND? JSP JBUF,UERROR ;NO MORE FREE SEG NUMBERS - ; SHOULD NEVER HAPPEN SINCE THERE ARE THE SAME ; NUMBER OF SEG NUMBERS AS JOB NUMBERS ; (COUNTING NULL JOB) ; BLAME CURRENT USER FNDOK: TLZ ITEM,777777 ;TURN OFF MEDDLE,SHRSEG,UWPOFF,SPYSEG,CORCNT) PUSHJ PDP,CLRNAM ;CLEAR HIGH SEG NAME SO NO LONGER ; SHARABLE TO NEW USERS, DELETE DISK AND CORE(IF ANY) SETZM JBTSTS(ITEM) ;CLEAR ALL BITS AND IN CORE COUNTS JUST FOR GOOD ; MEASURE(SHRSEG!JERR COULD BE STILL ON FOR HIGH SEG) JRST TPOPJ ;RESTORE TAC AND RETURN ;ROUTINE TO INCREMENT HIGH SEG IN CORE COUNT (OCNCE) ; FOR A JOB WHICH HAS A REAL HIGH SEG WHICH MUST BE IN CORE ;CALL: MOVE ITEM,XWD JOB HIGH SEG BITS, HIGH SEG NUMBER ; MOVE TAC,JOB NUMBER ; PUSHJ PDP,INCCNT ; ALWAYS RETURN WITH C(ITEM)=JBTSGN(TAC) ;CORCNT IS SET TO 1 TO FLAG THIS JOB AS HAVING INCREMENTED IN CORE COUNT ;CALLED FROM SHARES(GET,REMAP,CORE) AND FININ EXTERN JBTSGN,JBTSTS INCCNT: TLON ITEM,CORCNT ;HAS HIGH SEG IN CORE COUNT ALREADY BEEN AOS JBTSTS(ITEM) ; INCREMENTED FOR THIS JOB? ;NO, INCREMENT HIGH SEG IN CORE COUNT IFN FTHALT,< PUSHJ PDP,COMIT ;COMPARE J WITH JBTSGN(TAC) > MOVEM ITEM,JBTSGN(TAC) ;STORE CORCNT FLAG FOR THIS JOB? POPJ PDP, ;ROUTINE TO DECREMENT HIGH SEG IN CORE COUNT (ONCE) ; FOR A JOB WHICH HAS A REAL HIGH SEG WHICH MUST BE IN CORE ;CALL: MOVE ITEM XWD JOB HIGH SEG BITS, HIGH SEG NUMBER ; MOVE TAC, JOB NUMBER ; PUSHJ P,DECCNT ; RET1 IN CORE COUNT NOT YET 0 OR IN-CORE COUNT NOT UP FOR THIS JOB ; RET2 IN CORE COUNT WENT TO 0 ;CALLED FROM KILHGH,FORHGH,FINOT EXTERN JBTSGN,JBTSTS DECCNT: IFN FTHALT,< PUSHJ PDP,COMIT ;COMPARE J WITH JBTSGN(TAC) > TLZN ITEM,CORCNT ;HAS HIGH SEG IN CORE COUNT ALREADY BEEN ;DECREMENTED FOR THIS JOB? POPJ PDP, ;YES, RETURN SOS JBTSTS(ITEM) ;NO, DECREMENT HIGH SEG IN CORE COUNT MOVEM ITEM,JBTSGN(TAC) ;CLEAR CORCNT FLAG IN MEMORY FOR THIS JOB DECERR: HRRE TAC,JBTSTS(ITEM) ;GET HIGH SEG IN CORE COUNT JUMPG TAC,CPOPJ ;STILL GREATER THAN 0? JUMPE TAC,CPOPJ1 ;EQUAL TO 0 AOS JBTSTS(ITEM) ;NO, ERROR ADD BACK TO 0 HALT DECERR ;AND HALT, CONTINUE WILL ;ROUTINE TO COMPARE RH OF ITEM WITH JBTSGN(TAC) ;BEFORE STORES INTO JBTSGN(TAC) ;WHERE TAC CONTAINS JOB NUMBER AND ITEM IS HIGH SEG NUMBER ;USED FOR DEBUGGING. MONITOR CANNOT RUN VERY LONG IF THIS ERROR GOES UNDETECTED IFN FTHALT,< COMIT: PUSH PDP,TAC ;SAVE JOB NUMBER SKIPE TAC ;JOB NUMBER CANNOT BE 0 CAILE TAC,JOBMAX ;MAKE SURE TAC IS A JOB NUMBER HALT . ;HALT, DO NOT ALLOW CONTINUE HRRZ TAC,JBTSGN(TAC) ;GET JOBS HIGH SEG NUMBER JUMPE TAC,TPOPJ ;IF NONE, OK TO RESTORE J CAIE TAC,(ITEM) ;MAKE SURE RH OF J SAME AS RH OF JBTSGN(TAC) HALT . ;HALT IF NOT JRST TPOPJ ;RESTORE TAC AND RETURN > ;ROUTINE TO CHANGE RELOC INFO IF SEG JUST ASSIGNED IS A HIGH SEG ;WHICH THE CURRENT USER MAY BE USING ;CALL: MOVE ITEM,LOW OR HIGH SEG FOR WHICH CORE WAS JUST ASSIGNED(OR RETURNED) ; PUSHJ PDP,CURHGH ; ALSWAYS RETURN WITH ITEM PRESERVED ; PROG RESET TO RELOC FOR HIGH SEG IF ITEM IS HIGH SEG, OTHERWISE PROG AND ; ITEM UNCHANGED INTERN CURHGH EXTERN JBTSGN,SETREL,IPOPJ CURHGH: MOVE TAC,JOB ;CURRENT JOB NUMBER HRRZ TAC,JBTSGN(TAC) ;GET HIGH SEG NUMBER OF CURRENT JOB OR 0 CAIE TAC,(ITEM) ;IS HIGH SEG JUST ASSIGNED SAME AS CURRENT JOB'S POPJ PDP, ;NO PUSH PDP,ITEM ;YES, SAVE HIGH SEG NUMBER PUSHJ PDP,SETREL ;SET HARD. AND SOFT. RELOC INFO FOR CURRENT JOB ; (EVEN THOUGH THIS CALL TO CURHGH MAY BE FOR SOME ; OTHER JOB) SONCE HIGH SEG MAY BE IN NEW PLACE IN CORE POP PDP,ITEM ;RESTORE HIGH SEG NUMBER AND RELOC FOR HIGH SEG IN CORE POPJ PDP, ;RETURN ;ROUTINE TO SEE IF SUM OF BOTH SEGMENTS WILL FIT INTO MAXIMUM SIZE ;OF PHYSICAL CORE TOGETHER ;CALL: MOVE TAC,REQUESTED LENGTH-1 OF SEG BEING ASSIGNED(LOW OR HIGH) ; TAC IS ASSUMED TO HAVE 1777 ORED IN BEFORE CALL ; MOVE ITEM,JOB OR HIGH SEG NUMBER ; PUSHJ P,SUMSEG ; ERROR RETURN, CAN NEVER FIT ; OK RETURN ;PREVIOUS CONTENTS OF TAC AND ITEM PRESERVED ON BOTH RETURNS ;IF HIGH SEG, MUST BY CALLED AT UUO LEVEL, IF TAC NON-ZERO ;OK TO CALL FOR HIGH SEG AT CLOCK LEVEL, PROVIDED ASKING FOR 0 ONLY. ;SHUFFLER MODIFIED SO IT NEVER CALLS SUMSEG(SINCE IT MIGHT SHUFFLE ;HIGH SEGMENT AT CLOCK LEVEL WHICH IS NOT THE CURRENT USERS) ;THIS WILL BE TRUE AS LONG AS A CORE COMMAND IS NOT IMPLEMENTED WHICH ;ALLOWS USER TO ADJUST HIGH SEG TO ANYTHING BUT 0. ;CALLED FROM CORE UUO(CORE0 AND CORE1 ROUTINES) INTERN SUMSEG EXTERN CPOPJ1,JOBMAX,JOB,JBTSGN,CORMAX,IPOPJ,SEGSIZ SUMSEG: JUMPE TAC,CPOPJ1 ;ASKING FOR 0 CORE(IF YES, COULD BE ;HIGH SEG AT CLOCK LEVEL)? HAVE NO IDEA WHAT LOW ; SEG NO. IS HOWEVER, 0 ALWAYS WILL FIT PUSH PDP,ITEM ;NO, SAVE JOB OR HIGH SEG NUMBER CAILE ITEM,JOBMAX ;IS THIS A LOW SEG? SKIPA ITEM,JOB ;NO,(ASSUME AT UUO LEVEL), GET CURRENT JOB NUMBER MOVE ITEM,JBTSGN(ITEM) ;YES, GET HIGH SEG NUMBER, IF ANY MOVEI TAC1,0 ;ASSUME NO HIGH SEG NUMBER JUMPLE ITEM,SUM1 ;IS THERE NO HIGH SEG OR IS THIS A SPY SEG? PUSHJ PDP,SEGSIZ ;TAC1=SIZE(IN J) OF HIGH OR LOW SEG ASH TAC1,12 ;CONVERT TO NUMBER OF WORDS(SEG NOT BEING ALLOCATED) SUM1: ADD TAC1,TAC ;ADD REQUEST(ORED 1777) TO LENGTH-1(OR 0) OF SEG NOT ; BEING CHANGED CAMGE TAC1,CORMAX ;WILL TOTAL SIZE-1 BE LESS THAN MAX SIZE AOS -1(PDP) ;YES, OK RETURN JRST IPOPJ ;NO, ERROR RETURN, RESTORE J ;ROUTINE TO FREE UP CORE FOR NON-SWAPPING SYSTEMS ;BY DELETING 1 DORMANT SEGMENT ;CALL: MOVE TAC,LENGTH-1 DESIRED(HIGH OR LOW SEG) ; MOVE ITEM,JOB OR SEG NUMBER ; PUSHJ PDP,FRECOR ; RETURN1 - NOT ENOUGH CORE, EVEN IF ALL DORMANT SEG DELETED ; RETURN2 - 1 DORMANT SEG DELETED, TRY TO ASSIGN CORE AGAIN ; TAC, AND ITEM PRESERVED ;CALLED FROM CORE ROUTINE (NON-SWAPPING SYSTEMS ONLY) WHEN CORE NEEDED IFE FTSWAP,< INTERN FRECOR FRECOR: MOVE TAC1,CORTAL ;NO. OF FREE & DORMANT 1K BLOCKS OF CORE LSH TAC1,12 ;CONVERY TO NUMBER OF WORDS CAML TAC,TAC1 ;WILL REQUEST FIT, EVEN IF ALL DORMANT SEGS DELETED? POPJ PDP, ;NO, ERROR (DON'T DELETE DORMANT SEGS FOR NOTHING) ; YES, FALL INTO FRECR1 > ;ROUTINE TO FREE UP CORE FOR SWAPPING SYSTEMS ;BY DELETING ONE DORMANT OR IDLE SEGMENT IN CORE (DISK COPY LEFT IF ANY) ;CALL: PUSHJ PDP,FRECR1 ; SKIP RETURN - ITEM PRESERVED ;CALLED FROM SWAP ONLY WHEN SHUFFLING COMPLETE AND STILL NOT ROOM ;SWAPPER COMPARES AMOUNT NEEDED WITH CORTAL BEFORE CALLING ;CORTAL=SUB OF FREE BLOCKS+DORMANT+IDLE BLOCKS OF CORE INTERN FRECR1 EXTERN CORTAL,SEGPTR,JBTSTS,JBTADR,OERROR,JBTNAM,TPOPJ1 IFN FTDISK, FRECR1: PUSH PDP,TAC ;SAVE CORE ARG(ON CALLS TO FRECOR) PUSH PDP,ITEM ; SAVE JOB OR SEG NUMBER MOVE ITEM,SEGPTR ;SCAN JUST HIGH SEGMENTS MOVEI TAC,777777 ;FIELD FOR HIGH SEG IN CORE COUNT FREC1: SKIPE JBTADR(ITEM) ;DOES THIS HIGH SEG HAVE CORE? TDNE TAC,JBTSTS(ITEM) ;YES, IS IN-CORE COUNT EQUAL TO 0? AOBJN ITEM,FREC1 ;NO, KEEP LOOKING, FINISHED? JUMPL ITEM,FREC2 ;YES, DID WE FIND A DORMANT OR IDLE SEG WITH CORE? IFE FTSWAP,< POP PDP,ITEM ;RESTORE JOB OR SEG. # JRST TPOPJ ;RESTORE CORE REQUEST AND RETURN > IFN FTSWAP,< JSP DAT,OERROR ;NO, ERROR-CORTAB AND CORTAL DO NOT AGREE ; PRINT ON OPERATOR'S CONSOLE, DO NOT BLAME ; ANY PARTICULAR JOB > FREC2: TLZ ITEM,-1 ;CLEAR OUT LH OF SEG NUMBER IFN FTSWAP,< EXTERN IMGOUT LDB TAC,IMGOUT ;DOES HIGH SEG ALSO HAVE COPY ON DISK? JUMPN TAC,FREC4 ;IF NON-ZERO, DO NOT CLEAR NAME SINCE NEW USERS ; CAN USE DISK COPY SKIPGE JBTSTS(ITEM) ;IS SEG IDLE(SNA=1) AS OPPOSSED TO DORMANT(SNA=0)? > PUSHJ PDP,CLRNAM ;NO, CLEAR SEG NAME SO THIS SEG WILL BE ; NON-EXISTENT, RETURN DORMANT CORE IFN FTSWAP,< FREC4: PUSHJ PDP,KDORCR ;YES, JUST RETURN DORMANT OR IDLE CORE(IF NOT ALREADY ; RETURNED BY CLRNAM), BUT LEAVE DORMANT DISK COPY ; STILL DORMANT ON DISK FOR NEW USERS > POP PDP,ITEM ;RESTORE JOB OR SEG NUMBER JRST TPOPJ1 ;RESTORE CORE REQUEST AND SKIP RETURN ;ROUTINE TO COMPARE CORTAL(FREE+DORMANT+IDLE CORE) WITH CORTAB(USE BIT TABLE) ;AND HALT IF INCONSISTENT. ;CALL: PUSHJ PDP,CHKTAL -AFTER CORTAL ADJUSTED ; RETURN ONLY IF OK-ALL ACS SAVED INTERN FTHALT IFN FTHALT,< INTERN CHKTAL ;PUT IN STORAGE MAP(ONLY CALLED FROM SEGCON EXTERN CORLST,CORTAL,SEGPTR,JBTSTS,JBTADR,PCORSZ,CORE2P CHKTAL: PUSH PDP,TAC ;SAVE ALL ACS USED PUSH PDP,ITEM PUSH PDP,DAT MOVEI DAT,0 ;SET FREE+DORMANT+IDLE COUNT TO 0 MOVE ITEM,CORE2P ;POINTER TO CORTAB, 1 BIT BYTES CHKT1: ILDB TAC,ITEM ;GET NEXT 1K BIT SKIPN TAC ;IS THAT ITEM IN USE? ADDI DAT,1 ;NO, ADD 1 TO FREE COUNT CAME ITEM,CORLST ;FINISHED CORTAB? JRST CHKT1 ;NO, MOVE ITEM,SEGPTR ;YES, SCAN ALL HIGH SEGMENTS CHKT2: HRRZ TAC,JBTSTS(ITEM) ;HIGH SEG IN CORE COUNT SKIPN JBTADR(ITEM) ;IS HIGH SEG EVEN IN CORE? JRST CHKT3 ;NO JUMPN TAC,CHKT3 ;YES, IS IN CORE COUNT 0 LDB TAC,PCORSZ ;YES, THEREFORE DORMANT OR IDLE ADDI DAT,1(TAC) ;ADD SIZE IN ITEM TO FREE CHKT3: AOBJN ITEM,CHKT2 ;SCANNED ALL HIGH SEGS? CAME DAT,CORTAL ;YES, IS FREE+DORMANT+IDLE = BIT TABLE HALT . ;NO. HALT, DO NOT ALLOW CONTINUE POP PDP,DAT ;YES, RETORE ACS AND RETURN POP PDP,ITEM JRST TPOPJ ;RETORE TAC AND RETURN > SUBTTL ERRCON - MONITOR DETECTED ERROR ROUTINES ;ILLEGAL MEMORY(ILM) DETERMINE IF WILD TRANSFER OR NOT ;CALL: HRRZ TAC,USER PC ; PUSHJ PDP,SEGILM ; LEGAL PC RETURN(MUST BE ILLEGAL REF) ; ILLEGAL PC RETURN(MUST BE WILD TRANSFER) INTERN SEGILM EXTERN KT10A SEGILM: LDB TAC1,[POINT 8,KT10A,16] ;8 BIT PROTECTION FOR CURRENT HIGH SEG LSH TAC1,12 ;LEFT JUSTIFY IN RH CAIL TAC,400000 ;IS PC 400000 OR BIGGER? CAILE TAC,1777(TAC1) ;YES, IS PC BELOW TOP OF HIGH SEG? AOS (PDP) ;NO, ILLEGAL PC RETURN POPJ PDP, ;YES, PC IN HIGH SEG(MUST BE ILLEGAL REF) SUBTTL SAVGET - SAVE, GET, R, AND RUN COMMANDS ;THE LOWER CORE LOCATION 0-17 IN USER AREA ARE USED FOR TEMP STORAGE FOR SAVE-GET ;THEY ARE DEFINED IN BEGINNING OF SAVGET ROUTINE EXTERN SGAMOD,SGAEXT,SGAHGH,SGALEN,SGALOW,SGANAM,SGAPPN,SGAREN ;ROUTINE TO SET EXTENSION OF HIGH SEG ;SAME CALL AS SETEXT EXCEPT S NOT SETUP ;CALLED FROM GETARG(RUN, GET SEG UUO) INTERN SETEX1 EXTERN USRREL,JOBPD1 SETEX1: TLZ IOS,NSRBIT ;TRY SHARABLE SEG FIRST(.SHR) THEN .HGH ;FALL INTO SETEXT ;ROUTINE TO SET EXTENSION OF HIGH SEGMENT TO SHR(SSAVE,GET,R) OR HGH(SAVE) ;CALL: HRLI S,0(GET,SSAVE,RUN) OR NSRBIT(SAVE) ; MOVE PROG,XWD PROTECT,RELOC FOR LOW SEG ; MOVEI TAC1, LOW FILE EXTENSION OR 0 IF NONE TYPED IN ; PUSHJ PDP,SETEXT ; RETURN TAC PRESERVED(TTY INPUT BYTE POINTER) ; CALLED FROM COMMAND DECODER ROUTINE SGSET, TAC PRESERVED (INPUT BYTE POINTER) INTERN SETEXT SETEXT: HRLZM TAC1,SGALOW(PROG) ;SAVE EXTENSION USER TYPED FOR LOW SEG MOVE TAC1,[SIXBIT /SHRHGH/] ;ASSUME SSAVE COMMAND(OR GET) TLNE IOS,NSRBIT ;WAS IT? MOVSS TAC1 ;NO, EXCHANGE ROLES OF EXTENSIONS, MUST ; BY SAVE MOVEM TAC1,SGAHGH(PROG) ;SAVE FOR ENTER AND RENAME OF HIGH SEGMENT POPJ PDP, ;ROUTINE TO SAVE HIGH SEG IF IT EXISTS (AS.SHR(SSAVE) OR .HGH(SAVE)) ;AND DETERMINE IF LOW SEG HAS DATA TO BE SAVED, OR NOT(IF YES IT WILL BE WRITTEN ;AS LOW UNLESS USER SPECIFIED DIFFERENTLY RATHER THAN.SAV) ;ALWAYS SAVE LOW SEG IF MAGTAPE OR IF NO HIGH SEG ;CALL: MOVE ITEM, JOB NUMBER (R,R,F SET UP) ; PUSHJ PDP,SAVHGH ; RETURN1 NO DATA IN LOW SEGMENT ; RETURN2 SAVE LOW SEGMENT ; ITEM DESTROYED,SGAEXT RESTORED TO SAV OR USERS TYPED EXTENSION ; SGALLEN RESTORED TO IOWD FOR LOW SEG IF DTA,PROJ R IF DSK ; DEVICE INITED ON EITHER RETURN INTERN SAVHGH EXTERN JBTSGN,JBTSTS,JBTADR,JOBSA,JOB41,JOBCOR,JOBVER,SG4 EXTERN JOBHRL,JOBREN,USRREL,SGIOCK,SAVERR,USRDDT,JOB,JOBHCU,USRHCU SAVHGH: PUSHJ PDP,SGOPEN ;TRY TO ASSIGN DEVICE(INIT IN SAVMOD) SKIPG ITEM,JBTSGN(ITEM) ;DOES CURRENT JOB HAVE A REAL HIGH SEGMENT? JRST SAVLOW ;NO, RESTORE SGAEXT,SGALEN AND SKIP ;RETURN SO LOW SEG WILL BE SAVED ; USER HAS NO CHOICE(MAY BE HAD SPY SEG PUSHJ PDP,SGH ;SET EXTENSION IN E+1 OF ENTER BLOCK ; SET E+3 TO -1 IF DTA,PROJ PROG NO. IF DSK HLRZ TAC1,JBTADR(ITEM) ;LENGTH-1 OF HIGH SEG ADDI TAC1,1 ;LENGTH HLLZ TAC,JOBHRL(JDAT) ;RELATIVE FIRST FREE LOC IN HIGH SEG(SET BY LOADER) TLNE TAC,777777 ;HAS LOADER SET IT (OR IS THIS SEG CREATED ; BY CORE OR REMAP BY USER R)? SKIPE USRDDT ;YES, IS USER USING DDT? HRLM TAC1,JOBHRL(JDAT) ;YES, SET FIRST FREE TO BE FIRST WORD BEYOND END(REL) HLRZ TAC,JOBHRL(JDAT) ;GET CORRECT FIRST REL FREE LOC IN HIGH SEG MOVNM TAC,SGALEN(PROG) ;SET LH=-NO. OF WORDS TO WRITE. RH=0 HLLOS SGALEN(PROG) ;SET RH=-1 IN CASE DECTAPE(USES RH TO COMPUT ; LENGTH=FIRST REL LOC-1 ENTER 0,SGANAM ;ENTER NAME IN DIRECTORY(SHR OR HGH) JRST SAVERR ;CAN'T, PRINT ENTER FAILURE MOVE ITEM,JOB ;RESTORE JOB NUMBER MOVE ITEM,JBTSGN(ITEM) ;GET SEGMENT NUMBER FROM JOB NUMBER TLNE ITEM,SHRSEG ;IS HIGH SEG SHARABLE? JRST SAVSHR ;YES, DO NOT INITIALIZE VESTIGIAL JOB DATA AREA ; SINCE IT MUST HAVE BEEN DONE WHEN HIGH FILE CREATED ; AND USER CANNOT MODIFY NOW MOVE TAC,JBTADR(ITEM) ;NO, INITIALIZE VESTIGIAL JOB DATA AREA IN HIGH SEG SUBI TAC,1 ;FROM LOW SEG JOB DATA AREA PUSH TAC,JOBSA(JDAT) ;SAVE JOB STARTING ADDRESS (RH) ; AND INITIAL FIRST FREE LOC (LH) PUSH TAC,JOB41(JDAT) ;SAVE USER LOC 41(USER UUO HANDLER JSR) PUSH TAC,JOBCOR(JDAT) ;SAVE USER TYPED THIRD (CORE) ARG (RH) AND ; HIGHEST DATA LOC LOADED IN LOW SEG (LH) HRR TAC1,JOBREN(JDAT) ;SAVE REENTER COMMAND STARTING ADDRESS HLL TAC1,JOBHRL(JDAT) ;AND FIRST (REL) FREE LOCATION SET BY LOADER PUSH TAC,TAC1 PUSH TAC,JOBVER(JDAT) ;SAVE BOTH HALVES OF PROGRAM VERSION NUMBER ; LH IS USED FOR PROGRAMMER NUMBER LAST MODIFYING PUSH TAC,[EXP 0] ;CLEAR REST OF 10 (OCTAL) LOCATIONS FOR FUTURE PUSH TAC,[EXP 0] ;SO OLD SAVE FILES WILL ALWAYS WORK PUSH TAC,[EXP 0] SAVSHR: HLLZ TAC,JOBHRL(JDAT) ;GET CORRECT FIRST REL FREE LOC IN HIGH SEG MOVNM TAC,SGALEN(PROG) ;SET LH=-NO. WORDS TO WRITE, RH=0 ; SET AGAIN SINCE ENTER CHANGED E+3 HRROS USRHCU ;SET LH OF HIGEST CHANNEL USED AS A FLAG THAT ; A SAVE IS IN PROGRESS FOR HIGH SEG HRROS JOBHCU(PROG) ;ALSO SET IN JOB DATA AREA FOR ANYSAV ROUTINE ; TO SEE(CALLED FROM ANYACT) HRRZ TAC,JBTADR(ITEM) ;ABSOLUTE ADDRESS OF HIGH SEG SUBI TAC,1(PROG) ;-ABSOLUTE ADDRESS OF LOW SEG-1 HRRM TAC,SGALEN(PROG) ;=REL ADR. OF HIGH SEG-1 AS SEEN FROM EXPANDED LOW SEG HLRZ TAC1,JBTADR(ITEM) ;LENGTH-1 OF HIGH SEG ADDI TAC,1(TAC1) ;+LENGTH OF HIGH SEG=REL ADR OF LAST LOC IN HIGH SEG ; AS SEEN FROM LOW SEGMENT HRL PROG,TAC ;INCREASE PROTECTION TO INCLUDE ALL OF HIGH SEGMENT ; THIS MAY REACH OVER MONITOR AND OTHER USERS ; IF HIGH SEG IS BELOW LOW SEG HLRZM PROG,USRREL ;ALSO CHANGE PROTECTION USED FOR ADDRESS CHECKING OUTPUT 0,SGALEN ;WRITE ALL OF ORIGINAL HIGH SEG FROM EXTENDED LOW SEG ; JBTADR FOR LOW SEG REMAINS SAME AS DOES ; JOBADR,JOBDAT. THE UUO HANDLER ASSUMES THAT ; PROG AND PDP ARE ALREADY SETUP PROPERLY FOR UUOS ; FROM MONITOR, AND SO DOES NOT SETUP PROG AND PDP ; FROM JOBADR, CLOCK ROUTINE SAVES ACS IN JOB DAT ; AREA USING JOBDAT, SUFFLING AND SWAPPING CODE ; EVEN TAKE PLACE BECAUSE ; PROG AND PDP WOULD BE DIDLES PROPERLY ; FOR NEW POSITION, IO SERVICE ROUTINES ; WHICH CAN DO SAVES(DISK,MTA,DTA) MUST BE SAVE PROG ; AT UUO LEVEL IN DEVICE DATA BLOCK, FOR ; USE AT INTERRUPT LEVEL, INSTEAD OF SETTING ; PROG UP FROM JBTADR WHEN INTERRUPT OCCURS. ; IN CASE DUMP IO CANNOT GO TO COMPLETION ; IN ONE OPERATION(IE JOB MUST BE RESCHEDULED) ; SERVICE ROUTINE MUST CALL SAVDDL EACH TIME ; TO DIDDLE RELOCATION IN CASE JOB SHUFFLED ; OR SWAPPED AFTER PARTIAL IO COMPLETED MOVE ITEM,JOB ;RESTORE JOB NUMBER OF CURRENT JOB MOVE PROG,JBTADR(ITEM) ;RESTORE XWD,PROT,RELOC FOR LOW SEG HRRZS USRHCU ;NOW CLEAR SAVE IN PROGRESS FLAG IN ; PROTECTED PART OF MONITOR. JOBHCU WILL ; BE CLEARED ON NEXT RESCHEDULE PUSHJ PDP,SGIOCK ;CHECK FOR TRANSMISSION ERRORS(RETURN IF OK) CLOSE 0, ;CLOSE OUTPUT(BEFORE LOOKUP FOR DELETE) ; SO SHARABLE SEG WILL BE SUPERCEDE BY NEW FILE ; IF SAME NAME HRLZ TAC,SGAHGH(PROG) ;DELETE HGH IF SHR WRITTEN OR VICE VERSA PUSHJ PDP,DELET ;DEPENDING IF THIS WAS A SSAVE OR SAVE COM. PUSHJ PDP,LOWCHK ;CHANGE EXTENSION FOR LOW FILE TO .LOW ; UNLESS USER SUPPLIED HIS OWN ARG SKIPA TAC,SGALOW(PROG) ;DO NOT NEED LOW FILE WRITTEN ; SO DELETE POSSIBLE PREVIOUS VERSION ; SO USER WILL NOT BE CONFUSED JRST CPOPJ1 ;LOW FILE NEEDED, DO NOT BOTHER TO DELETE ; GIVE SKIP RETURN TO CALLER MTAPE 3 ;WRITE A NULL LOW SEG IF MTA JRST DELET ;DELETE FILE AND GIVE NO SKIP RETURN TO CALLER ;ROUTINE TO DIDDLE RELOCATION DURING DUMP MODE SAVE OPERATION OF HIGH SEGMENT ; WHEN IO OPERATION IS DONE IN MORE THAN ONE STEP ; IE WHEN DEVICE GOES INACTIVE IN MIDDLE(SAY BECAUSE CONTIGUOUS DISK SPACE ; EXHAUSTED) AND HIGH AND/OR LOW SEG MAY HAVE BEEN SHUFFLED OR SWAPPED ;CALLED ONLY AT UUO LEVEL ;CALL: MOVE TAC,[IOWD N,ADR (BEFORE RELOCATION)] ; MOVE PROG,LOW SEG RELOC ; PUSHJ PDP,SAVDDL ; ALWAYS RETRUN - RH OF AC TAC ADJUSTED FOR NEW POSITION OF HIGH SEG ; WITH RESPECT TO LOW SEG. NO OTHER ACS CHANGED, LH AC TAC SAME ;CALLED FOR DISK SERVICE INTERN SAVDDL EXTERN JOB,USRHCU,JBTSGN,IPOPJ,JBTADR,SGALEN,USRREL SAVDDL: PUSH PDP,ITEM ;SAVE CONTENTS OF ITEM MOVE ITEM,JOB ;SETUP CURRENT JOB NUMBER SKIPGE USRHCU ;IS A SAVE OR GET IN PROGRESS FOR CURRENT USER? SKIPG ITEM,JBTSGN(ITEM) ;YES, DOES CURRENT JOB HAVE A HIGH SEG? JRST IPOPJ ;NO, NO DIDDLING REQUIRED PUSH PDP,TAC ;SAVE TAC HRRZ TAC,SGALEN(PROG) ;ORIGIN-1 OF HIGH SEG WITH RESPECT TO LOW SEG ; (STORED BY SAVGET AS COMMAND LIST) CAMGE TAC,USRREL ;IS COMMAND LIST ABOVE LOW SEG? JRST SAVDLW ;NO, MUST BE LOW SEG SAVE IN PROGRESS HRRZ TAC,JBTADR(ITEM) ;YES, ABSOLUTE ADDRESS OF HIGH SEG SUBI TAC,1(PROG) ; MINUS ABSOLUTE ADDRESS OF LOW SEG MINUS 1 ; EQUALS NEW HIGH SEG ORIGIN-1 W.R.T. LOW SEG SUB TAC,SGALEN(PROG) ;MINUS OLD HIGH SEG ORIGIN-1 WITH RESPECT ; TO OLD LOW SEG YIELDS CORRECTION FACTOR ADD TAC,(PDP) ;ADD CORRECTION FACTOR TO SAVDDL ARG HRRM TAC,(PDP) ;STORE ONLY RH (AVOID RH TO LH CARRY) SAVDLW: POP PDP,TAC ;RESTORE MODIFIED SAVDDL ARGUMENT TO TAC JRST IPOPJ ;THEN RESTORE J AND RETURN ;UUO TO GET JUST HIGH SEGMENT, USER CHANNELS 1 THRU 17 UNTOUCHED ;CALL: MOVEI AC,D ;WHERE D IS LOCATION OF 5 ARG(SEE RUN UUO) ; ;THE 6TH(CORE ARG IS IGNORED) BUT MUST BE IN LEGAL MEMORY ; CALL AC,[SIXBIT /GETSEG/] OR CALLI AC,40 ; ERROR RETURN UNLESS LH=HALT ; OK RETURN INTERN UGETHI EXTERN GETARG,UGTERR,TWOREG,NOFILE,SGREL,TPOPJ1 UGETHI: SKIPN TWOREG ;IS HARDWARE 2 RELOC REG JRST UGTERR ;NO, ERROR RETURN TO USER UNLESS HALT IN LH PUSHJ PDP,GETARG ;YES,GET 6 ARGS FROM USER PUSHJ PDP,GETSEG ;TRY TO SHARE HIGH SEG OR READ IN HIGH FILE JRST NOFILE ;NO FILE FOUND, PRINT MESSAGE OR ERROR RETURN PUSHJ PDP,CHKMED ;CHECK TO SEE IF THIS IS SHARABLE SEG(EXT=SHR) ; IF YES, SET MEDDLE BIT FOR THIS USER ; SO HE CANNOT TURN OFF UWP OR CHANGE CORE ASSIGNMENT PUSHJ PDP,SGREL ;RELEASE JUST CHANNEL 0 IF WAS INIT JRST TPOPJ1 ;OK(SKIP RETURN TO USER AFTER REMOVING USER ARG+AC ;FROM PD LIST WHICH GETARG PUT ON ;ROUTINE TO ADD CURRENT USER TO A SHARED SEGMENT IF IT EXISTS OR ;TRY TO INITIALIZE A HIGH SEGMENT FROM A FILE AND MAKE IT SHARABLE(-SHR) OR NOT(.HGH) ;DEPENDING ON THE EXTENSION OF THE FILE ;CALL: MOVE ITEM, CURRENT JOB NUMBER ; ACS DEVDAT,PROG,PROG,PDP,SETUP ;IFN FTDISK, ; PUSHJ PDP,GETHGH ; RETURN1-HIGH SEG NOW IN ADDRESSING SPACE AND NO LOW FILE NEED BE GOTTEN ; RETURN2 - HIGH SEG NOW IN ADDRESSING SPACE, AND LOW FILE NEEDED ; OR NO HIGH FILES FOUND, TRY LOW FILE ; ITEM RESTORED TO CURRENT JOB NUMBER ; USER MODE FLAG CLEARED IN UUO PD LIST IR RUN UUO FROM HIGH SEG ; WHICH IS NO LONGER SAME(SO NO ATTEMPT TO ERROR RETURN IF ERROR) INTERN GETHGH EXTERN TWOREG,JBTSGN,UERROR,JBTADR,JBTSTS,WSCHED,JBTNAM EXTERN JOB,JOBPOP,JOBREN,JOBHRL,JOBVER,JOBCOR,JOB41,JOBSA,JOBDA,SGERRA EXTERN SG3,CPOPJ2,JOBSV,JOBDA,JOBDDT,USRDDT GETHGH: SKIPE TWOREG ;IS THIS A 2 RELOC REG. MACHINE? PUSHJ PDP,GETSEG ;YES, TRY TO ATTACH TO HIGH SEG OR READ ; IN HIGH FILE IF IT EXISTS, HIGH SEG OK? JRST NOHIGH ;NO, TRY TO READ IN LOW FILE OLD HIGH ; SEG STILL IN ADR SPACE(AF ANY) MOVSI TAC,JOBSV(JDAT) ;CLEAR JOB DATA AREA HRRI TAC,JOBSV+1(JDAT) ;WHERE IO WOULD BE DONE INTO SETZM JOBSV(JDAT) ;IF A LOW FILE EXISTS BLT TAC,JOBDA-1(JDAT) ;DO THIS IN CASE THERE IS NO LOW FILE SETZM JOBDDT(JDAT) ;ALSO CLEAR DDT STARTING ADDRESS SETZM USRDDT ;IN MONITOR PROTECTED AREA AS WELL AS JOBDAT ; IN CASE RETURN TO USER WITHOUT RESCHEDULING PUSHJ PDP,ADJCOR ;COMPUTE AMOUNT OF CORE FOR BOTH LO & HI SEGS ; FROM USER'S CORE ARG.(IF ANY) ; RETURNS WITH HI SEG # IN TAC HRRO TAC,JBTADR(TAC) ;ABSOLUTE ADDRESS OF HIGH SEG(LH=-1 FOR ; POPS SO NO PDL UNDERFLOW) ADDI TAC,JOBPOP ;ADD POP OFFSET POP TAC,JOBVER(JDAT) ;RESTORE BOTH HALVES OF PROG. VERSION NO. POP TAC,TAC1 ;RESTORE HLLM TAC1,JOBHRL(JDAT) ;RELATIVE FIRST FREE LOC IN HIGH SEG HRRZM TAC1,JOBREN(JDAT) ;PROGRAM REENTER ADR, LH=0 ; SAVED FOR FUTURE USE POP TAC,JOBCOR(JDAT) ;HIGHEST DATA LOC IN LOW SEG(LH) ; AMOUNT OF CORE IN RH TO BE ASSIGNED(#J-1) POP TAC,JOB41(JDAT) ;USER UUO HANDLER JSR POP TAC,JOBSA(JDAT) ;FIRST FREE LOC IN LOW SEG(LH), START COMMAND ; STARTING ADDRESS(RH) ;HERE FROM SAVE TOO LOWCHK: HRRZ TAC,JOBPD1(JDAT) ;IS CALL FROM HIGH SEGMENT? CAMLE TAC,USRREL ;COMPARE PC WITH LOW SEG PROTECTION HRRZS JOBPD1(JDAT) ;YES,(OR EXEC) SO CLEAR USRMOD PC FLAG IN LH ; SO ERROR MESSAGES WILL NOT ATTEMPT TO ERROR ; RETURN TO HIGH SEG WHICH IS NO LONGER ; THE ORIGINAL ONE SKIPE TAC1,SGALOW(JDAT) ;DID USER SPECIFY AN EXTENSION? JRST SETLOW ;YES, ALWAYS LOAD LOW FILE (HE MAY WANT ONE SEG ; VERSION WITH EXTENSION .SAV FOR EXAMPLE) HLRZ TAC,JOBCOR(JDAT) ;DOES THIS JOB NEED A LOW SEG INPUT OR OUTPUT CAIGE TAC,JOBDA ;I.E. IT THERE ANY DATA LOADED ABOVE JOB DATA AREA JRST SG3 ;NO, RETURN AND DO NOT READ IN LOW FILE MOVSI TAC1,(SIXBIT /LOW/) ;YES, READ OR WRITE LOW FILE WITH EXTENSION .LOW JRST SETLOW NOHIGH: HRRZ TAC,JOBPD1(JDAT) ;(HERE ON GET COM. OR RUN UUO - NO NEW HIGH SEG ; BUT NOT ON GETSEG UUO) CAMLE TAC,USRREL ;COMPARE PC WITH LOW SEG PROT. HRRZS JOBPD1(JDAT) ;YES - CLEAR USRMOD BIT SO ERRORS WON'T ;RETURN TO HI SEG WHICH IS NO LONGER ;THE ORIGINAL ONE PUSHJ PDP,KILHGC ;REMOVE PREVIOUS HI SEG (IF ANY) TRYLOW: MOVE TAC1,SGALOW(PROG) ;(HERE ON SAVE) ; LOW FILE EXTENSION USER TYPED OR 0 IF HE DIDN'T SETLOW: MOVEM TAC1,SGAEXT(PROG) ;SET IN E+1 FOR LOOKUP AOS (PDP) ;SET FOR NEED LOW READ OR WRITE RETURN ; (HERE FROM SAVE IF NO HIGH SEG) JUMPL DEVDAT,SG3 ;HAS DEVICE ALREADY BEEN INITED? ; INITB=1(BIT 0) IF YES SGOPEN: OPEN 0,SGAMOD ;NO, INIT DEVICE IN SAVMOD JRST SGERRA ;ERROR, NOT AVAILABLE JRST SG3 ;OK RESTORE SGALEN TO IOWD IF DTA,PP IF DSK AND RET SAVLOW: MTAPE 3 ;WRITE A NULL HIGH SEGMENT IF MTA JRST TRYLOW ;RESTORE SGAEXT ETC. ;ROUTINE TO CREATE A NEW HIGH SEG AND READ IN HIGH FILE OR ;PLACE THE DESIRED SHARABLE HIGH SEGMENT IN CURRENT USER'S LOGICAL ADDRESSING SPACE ;CALL: MOVE PROG,LOW SEG RELOC ;IFN FTDISK, ; MOVE DEVDAT,ADR. OF DEVICE DATA BLOCK ; MOVE ITEM,JOB NUMBER ; PUSHJ PDP,GETSEG ; RETURN 1 - HIGH SEG OR FILE NOT FOUND ; RETURN 2 - HIGH SEG FOUND AND IN LOG ADR. SPACE(IN FACT ALSO IN CORE) EXTERN NROOM1,DEVPHY,PJOBN,JOB,SGADAT,JOBPD1 GETSEG: IFN FTDISK,< EXTERN CUSPPP,PRJPRG SKIPN TAC,SGAPPN(PROG) ;USER SUPPLY PROJ PROG NO? MOVE TAC,PRJPRG(ITEM) ;NO, USE HIS PROJ. PROG. TLNE DEVDAT,SYSDEV ;YES, IT THIS THE SYSTEM DEVICE(DTA OR DSK)? MOVE TAC,CUSPPPP ;YES, ASSUME DSK AND SETUP CUSP PROJ,PROG NO. TLNN TAC1,DVDSK ;NO, IT THIS DEVICE A DISK? > MOVE TAC,DEVNAM(DEVDAT) ;NO, GET PHYSICAL DEVICE NAME(DTAN,MTAN) MOVE TAC1,SGANAM(PROG) ;AND GET FILE NAME SUPPLIED BY USER PUSHJ PDP,SRCSEG ;DOES SEGMENT ALREADY EXIST? JRST GETH1 ;NO, TRY TO READ IN HIGH FILE MOVSI AC1,(200B) ;CHECK READ ACCESS PRIV. MOVE AC2,JOB ;FOR CURRENT JOB PUSHJ PDP,CHKHSA ;WITH FILE WHICH INITIALIZED HIGH SEG JRST GETH1 ;CAN'T READ-DTA,MTA NOT AVAIL ; OR DSK ACCESS RIGHTS NOT PROPER JRST SHARE ;CAN READ. GO SHARE HIGH SEGMENT GETH1: OPEN 0,SGAMOD ;TRY TO ASSIGN DEVICE (MUST BE IN LINE, ; ELSE PD OVF IF PUSHJ PDP,SGOPEN) JRST SGERRA ;CAN'T, GO PRINT ERROR OR RETURN TO USER. PUSHJ PDP,SGH ;AND SET SGALEN TO 0 IF DTA. PP IF DISK MOVE TAC,DEVMOD(DEVDAT) ;IS THIS MAG TAPE? (MAG TAPE CAN NEVER BE SHARABLE) TLNN TAC,DVMTA ;(MAG TAPE LOOKUPS ALWAYS SUCCEED) LOOKUP 0,SGANAM ;NO, LOOKUP ON HIGH FILE WITH EXT .SHR JRST TRYHGH ;NOT FOUND, TRY EXTENSION OF .HGH PUSHJ PDP,INPSEG ;FOUND, GO READ IN HIGH FILE PUSHJ PDP,FNDSEG ;SEE IF FILE NAME SNUCK INTO SEGMENT TABLE ; FOR OTHER USER WHILE IO GOING ON(UNLIKEY) JRST STONAM ;USUALLY NOT FOUND SHARE: PUSH PDP,ITEM ;FOUND, SAVE SHAREABLE+NAMED HIGH SEG NO. TO BE ; SHARED BY THIS USER PUSHJ PDP,KILHGC ;REMOVE PRESENT HIGH SEG FROM LOGICAL ADR. ; PSAVE(DELETE CORE SPACE IF JUST ASSIGNED BY ; INPSEG SINCE NOT NAMED YET) POP PDP,ITEM ;CONNECT THIS USER TO THIS SHAREABLE AND NAMED HIGH SEG IFN FTSWAP,< EXTERN SEGSIZ,VIRTAL ;TAC1=SIZE OF HIGH SEG (WHTHER IN CORE OR DSK) SKIPGE JBTSTS(ITEM) ;IS THIS HIGH SEG DORMANT(SNA=0) ? JRST SHARE0 ;NO, BY-PASS ADJUSTING VIRTUAL CORE TALLY PUSHJ PDP,SEGSIZ ;YES, TAC1=SIZE IN K OF HIGH SEGMENT CAMLE TAC1,VIRTAL ;WILL ALLOWING THIS SEGMENT TO BECOME ACTIVE ; EXCEED VIRTUAL CORE ? JRST SHRNRM ;YES, DO NOT LET HIM SHARE DORMANT COPY, EVEN ; THOUGH IT MAY BE ON DISK, BECAUSE THIS ; WOULD OVER COMMIT THE SYSTEM AND MEAN ; THAT NOT ABLE TO SWAP OUT BIGGEST JOB MOVN TAC1 ;NO.NO. OF K IN DORMAT SEG ADDM TAC1,VIRTAL ;DECREASE COUNT OF VIRTUAL CORE AVAILABLE > SHARE0: PUSHJ PDP,CHKIDL ;CHECK TO SEE IF SEG IS IDLE IN CORE ; IE IN-CORE COUNT 0 BUT IN SOME USER'S ; ADR. SPACE WHO IS SWAPPED OUT OR DORMANT IN CORE ; (I.E., IN NO ONE'S LOGICAL ADR. SPACE) SHARE1: ;HERE FROM REMAP UUO SHARE2: MOVE TAC,JOB ;(HERE FROM CORE UUO)CURRENT JOB NUMBER IFN FTHALT,< PUSHJ PDP,COMIT ;COMPARE J TO JBTSGN(TAC), HALT IF DIFF. SEGS > MOVEM ITEM,JBTSGN(TAC) ;MAKE SURE THIS HIGH SEG IF MARKED AS BEING ; IN CURRENT USER'S LOGICAL ADR. SPACE MOVSI TAC1,SNA ;MAKE SURE THIS HIGH SEG IS FLAGGED AS IN USE ; IE SEG IN SOME USER'S LOG. ADR. SPACE IORB TAC1,JBTSTS(ITEM) ;MAY HAVE BEEN JUST ASSIGNED OR DORMANT IFN FTSWAP,< MOVE DAT,JBTSTS(TAC) ;JOB STATUS WORD TLNN DAT,JXPN ;JOB WAITING TO EXPAND LOW OR HIGH SEG? TLNE TAC1,JXPN ;NO, IS HIGH SEG BEING EXPANDED? ; OR WAITING TO EXPAND? JRST SETRL0 ;YES, WAIT TILL HIGH SEG IN CORE TOO > SHARE3: PUSHJ PDP,INCCNT ;NO, INCREMENT HIGH SEG IN-CORE COUNT FOR THIS ; JOB(TAC) IF NOT ALREADY INCREMENTED, RETURN ; WITH J = HIGH SEG NO. IFN FTHALT,< PUSHJ PDP,CHKTAL ;CHECK CORTAL WIT CORTAB, HALT IF DIFF. > JRST SETRL1 ;SET HARD. AND SOFT. RELOC. AND SKIP RETURN SHRNRM: HRRZ TAC1,JOBPD1(JDAT) ;GET RETURN PC IN CASE THIS IS RUN UUO CAMLE TAC1,USRREL ;IS IT IN THE HIGH SEG WHICH IS NOW GONE ? HRRZS JOBPD1(JDAT) ;YES, TURN OFF USER MODE FLAG, SO ERROR ; WILL NOT LOOK FOR HALT AFTER UUO MOVE TAC,TAC1 ;SETUP NO. OF K NEEDED FOR MESSAGE JRST NROOM1 ;GO PRINT MONITOR MESSAGE AND STOP JOB ; OR ERROR RETURN TO LOW SEGMENT ; (UNLESS UUO HAS A HALT FOLLOWING IT) STONAM: MOVE DAT,JOB ;CURRENT JOB NUMBER MOVSI ITEM,SHRSEG ;FLAG THIS USER AS USING A SHARABLE HIGH SEG IORB ITEM,JBTSGN(DSER) ;AND SETUP HIGH SEG NUMBER MOVEM TAC,JBTDIR(ITEM) ;STORE DIRECTORY(OR PHY DEV NAM)> MOVEM TAC1,JBTNAM(ITEM) ;STORE HIGH SEG FILENAME MOVSI TAC,SHRSEG ;ALSO FLAG HIGH SEG ASSIGNED IORM TAC,JBTSTS(ITEM) ;BY INPSEG AS SHARABLE FOR OTHER USERS IFN FTDISK,< LDB TAC,[POINT 9,SGADAT(PROG),8] ;GET ACCESS RIGHTS FROM LOOKUP E+2 DPB TAC,[POINT 9,JBTSTS(ITEM),HSAPOS] ;AND STORE IN MONITOR WITH HIGH ; SEG STATUS > IFN FTSWAP,< EXTERN XPANDH,WSCHED SETRL0: PUSHJ PDP,XPANDH ;FLAG THIS USER AS TRYING TO EXPAND(SWP=1) ; SO THAT THIS NEW HIGH SEG WILL BE SWAPPED IN SETRL2: PUSHJ PDP,WSCHED ;WAIT TILL IT IS SWAPPED IN(CALL SCHEDULER) > SETRL1: AOS (PDP) ;SKIP RETURN(GETSEG,UCORHI,UREMAP) JRST SETREL ;SET HARDWARE AND SOFTWARE RELOC INFO ; FOR CURENT JOB AND RESTORE R AND J ;ROUTINE TO ADJUST USER'S CORE ARG. IN GET,R,RUN OR SAVE COMMANDS SO THAT ; THE ARG. SUPPLIED IS THE TOTAL OF BOTH THE LO & HI SEGS. IF THERE IS NO ; HI SEG THEN ARG. IS THE LO SEG SIZE AS IN NON-REENTRANT SYSTEMS. ; IF THERE ARE BOTH LO & HI SEGS AND THE ARG. IS LESS THAN THE HI SEG + 1K ; MANDATORY LO SEG SIZE THEN THE CORE ALLOCATION IS UNCHANGED. ;CALL MOVE PROG,ADR. OF JOB DATA AREA ; MOVE ITEM,JOB NO. ; PUSHJ PDP,ADJCOR ; ALWAYS RETURN WITH TAC=HI SEG #,TAC1 & U DESTROYED INTERN ADJCOR EXTERN SGANEW ADJCOR: SKIPN TAC,JBTSGN(ITEM) ;IS THERE A HI SEG ? POPJ PDP, ;EVIDENTLY NOT HLRZ TAC1,JBTADR(TAC) ;GET ITS SIZE SKIPE DAT,SGANEW(JDAT) ;WAS AN ARG. TYPED OF 0 OR NOT AT ALL ? SUBI DAT,1(TAC1) ;NO - COMPUTE LO SEG SIZE SKIPLE DAT ;MUST BE 1K OR GREATER! MOVEM DAT,SGANEW(PROG) ;STORE IT POPJ PDP, ;RETURN ; TO LOW SEG RELOC AND JOB NUMBER ;TRY TO READ IN NON-SHARABLE FILE WITH EXTENSION .HGH TRYHGH: MOVSI TAC,(SIXBIT /HGH/) ;TRY LOOKUP WITH EXTENSION .HGH PUSHJ PDP,SGH1 ;SET EXT AND E+3 OF LOOKUP BLOCK ; FOR DTA OR DSK LOOKUP 0,SGANAM ;LOOKUP WITH EXT .HGH POPJ PDP, ;NOT FOUND, NO HGIH SEG RETURN FROM GETSET AOS (PDP) ;FOUND, SET FOR SKIP RETURN FROM GETSEG ; FALL INTO INPSEG ;ROUTINE TO READ IN A HIGH FILE INTO TOP OF LOW SEG AND REMAP ;LOOKUP MUST HAVE BEEN ALREADY BEEN DONE ;CALL: MOVE PROG,XWD PROTECTION, RELOCATION FOR LOW SET ; PUSHJ PDP,INPSEG ; RETURN1 - NO HIGH FILE, ; RETURN2 - HIGH FILE READ IN ; C(ITEM)=JOB NUMBER ;CALLED FROM TRYHGH AND GETH1 EXTERN USRREL,GETERR,GETCOR,SGIOCK,JOBPD1,UERROR INPSEG: MOVE TAC,USRREL ;HIGHEST REL(USER) ADR IN LOW SEG FOR CURRENT USER TRO TAC,1777 ;MAKE EVEN 1K-1(SHOULD BE 140) SO CAN USE REMAP UUO ; OR USER'S LOW SEG IF RUN OR GETSEG UUO HRRM TAC,SGALEN(PROG) ;STORE ADR-1 OF IOWD FOR READING IN ; HIGH FILE JUST ABOVE END OF CURRENT LOW SEG MOVE TEM,DEVMOD(DEVDAT) ;DEVICE CHARACTERISTICS TLNE TEM,DVMTA ;MTA? JRST INPMAG ;YES, GO DO SOME SPECIAL STUFF HLRE TAC1,SGALEN(PROG) ;-FILE LENGTH FROM DIRECTORY LOOKUP JUMPGE TAC1,GETERR ;MUST BE NEGATIVE(128K MAX SIZE FOR HIGH FILE) INPSE2: SUB TAC,TAC1 ;FIRST ADR-1 PLUS(-MINUS) LENGTH YIELDS: ; LAST USER LOC TO BE READ INTO PUSHJ PDP,GETCOR ;ASSIGN ENOUGH CORE FOR LAST WORD OF HIGH FILE ; RETURN ONLY IF OK INPUT 0,SGALEN ;READIN HIGH FILE PUSHJ PDP,SGIOCK ;ANY ERRORS? TLNE TEM,DVMTA ;MTA? JRST INPMG2 ;YES, DO STUFF WHICH IS DONE ON LOOKUP FOR ;DIRECTORY DEVICES INPSE3: HRRZ TAC,SGALEN(PROG) ;GET HIGHEST USER ADR IN ORIGINAL LOW SEG PUSHJ PDP,UREMAP ;DO REMAP UUO JSP DAT,UERROR ;ARGS NOT RIGHT, SHOULD NEVER HAPPEN POPJ PDP, ;RETURN, CALLI UUO SETS JOB NO IN ITEM EXTERN MTSIZ,JOBHRN INPMAG: MOVNI TAC1,MTSIZ ;LENGTH OF A MAGTAPE RECORD HRLM TAC1,SGALEN(PROG) ;SET TO READ 1ST RECORD OF FILE JRST INPSE2 ;GO READ IT INPMG2: TRNE IOS,IODEND ;EOF? JRST CPOPJ1 ;YES, THER IS NO HIGH SEGMENT MOVE TAC,SGALEN(PROG) ;NO, THERE IS A HIGH SEGMENT PUSH PDP,TAC ;SAVE ORIGINAL IOWD ADDI TAC,1(PROG) ;LOC OF 1ST DATA WORD OF THE RECORD HLRZ TAC,JOBHRN(TAC) ;LENGTH OF HIGH SEG CAIG TAC,MTSIZ JRST INPMG3 ;WHOLE FILE WAS 1 RECORD MOVNM TAC,TAC1 ;-WORD COUNT HRL TAC1,(PDP) ;ADDRESS OF START OF 1ST RECORD ADD TAC1,[XWD MTSIZ,MTSIZ] ;INCREMENT OVER 1ST RECORD MOVSM TAC1,SGALEN(PROG) ;NEW IOWD HLRZS TAC1 ADD TAC,TAC1 ;HIGHEST ADDRESS NEEDED PUSHJ PDP,GETCOR ;GET THE CORE INPUT SGALEN ;READ THE REST OF THE FILE PUSHJ PDP,SGIOCK ;ANY ERRORS? INPMG3: STATO IOTEND+IODEND ;MAGTAPE AT END OF TAPE OR END OF FILE? MTAPE 16 ;NO, SKIP OVER THE EOF SETSTS DR ;RESET THE EOF BIT POP PDP,SGALEN(PROG) ;RESTORE THE ORIGINAL IOWD JRST INPSE3 ;AND CONTINUE ;ROUTINE TO CHECK IF HIGH SEG ABOUT TO BE SHARED WAS IDLE OR DORMANT ;IF YES, THE COUNT OF FREE+DORMANT+IDLE CORE IS DECREASED ;CALL: MOVE ITEM,HIGH SEG NUMBER ; PUSHJ PDP,CHKIDL ;CALLED FROM GETSEG AND FININ EXTERN PCORSZ,JBTSTS,CPOPJ,JBTADR,CORTAL CHKIDL: HRRZ TAC,JBTSTS(ITEM) ;HAS HIGH SEG IN-CORE COUNT GONE TO 0? JUMPN TAC,CPOPJ ;NOT IDLE NON-ZERO LDB TAC,PCORSZ ;SIZE IN CORE(ITEM-1) MOVNI TAC,1(TAC) ;- NO. OF ITEM IN CORE SKIPE JBTADR(ITEM) ;IS HIGH SEG IN CORE AT ALL? ADDM TAC,CORTAL ;YES, THEN DECREASE COUNT OF FREE+DORMANT+IDLE ; CORE SINCE THIS HIGH SEG WILL NOT BE IDLE POPJ PDP, ; ANY MORE ;ROUTINE TO SETUP LOWER CORE FOR LOOKUP OR ENTER FOR HIGH FILE ;CALL: LH OF SGAHGH(R) SET TO FILE EXT FOR HIGH SEG ; PUSHJ PDP,SGH ; SETUP SGALEN TO -1 IF DTA OR MTA, PROJ R IF DSK EXTERN SG4 SGH: MOVE TAC,SGAHGH(PROG) ;SETUP EXTENSION(FOR HIGH FILE SHR OR HGH) SGH1: HLLZM TAC,SGAEXT(PROG) ;STORE EXTENSION FOR LOOKUP ORENTER MOVEI TAC,-1 ;SET SGALEN TO -1 IF DEVICE NOT DISK ; (FIRST REL LOC-1 DUMPED FROR HIGH SEG) JRST SG4 ;OTHERWISE SET TO PROJ,R NO. ;ROUTINE TO DELETE A FILE, SO SUBSEQUENT GET WILL NOT BE CONFUSED ;USED BY SAVE AND SSAVE (NOT BY GET) ;CALL: HRLI TAC, EXTENSION (.LOW,.SHR,.HGH, OR USER TYPED ARG) ; PUSHJ PDP,DELET ; ALWAYS RETURN DELET: PUSHJ PDP,SGH1 ;SETUP EXTENSION, AND E+3 IN DIRECTORY BLOCK LOOKUP 0,SGANAM ;LOOKUP FILE POPJ PDP, ;NOT FOUND CLOSE 0, ;CLOSE SO RENAME WILL WORK RENAME 0,SGAREN ;DELETE FILE JFCL ;IGNORE IF CAN'T, WE TRIED POPJ PDP, ;RETURN SUBTTL SWAP - USER PROGRAM SWAPPING ROUTINES ;ROUTINE CALLED AFTER A HIGH OR LOW SEG JUST SWAPPED IN ;IT SEES IF A HIGH SEG IS STILL TO BE SWAPPED IN ;DOES POST PROCESSING AFTER HIGH SEG SWAPPEN IN ;CALL: MOVE J,JOB NUMBER ; PUSHJ PDP,FININ ; RETURN1 IF HIGH SEG TO BE SWAPPEN IN(HIGH SEG NO. IN AC J) ; RETURN2 IF NO HIGH SEG, OR HIGH SEG ALREADY IN, OR THIS WAS HIGH SEG ; AC ITEM RETURNED WITH JOB NUMBER(IE LOW SEG NO.) J=ITEM ;CONTAINS JOB OR HIGH SEG NUMBER(SAME AC AS SWAP USES) IFN FTSWAP,< INTERN FININ EXTERN JOBMAX,JBTSGN,SWPIN,JBTSTS,CPOPJ1,ZERSWP EXTERN IMGOUT,JBTSWP,FXSAT FININ: CAILE J,JOBMAX ;WAS A LOW SEG JUST SWAPPED IN? JRST FINHGH ;NO, HIGH SEG JUST SWAPPED IN, GO FINISH MOVEM J,SWPIN ;YES, SAVE JOB NUMBER(FOR FINHGH AND RETURN) SKIPG J,JBTSGN(J) ;DOES JOB HAVE A REAL HIGH SEG? JRST BOTHIN ;NO, GIVE NOTHING TO DO RETURN(MAYBE SPYSEG) SKIPN JBTADR(J) ;YES, IS HIGH SEG ALREADY IN CORE? ;(NOT POSSIBLE TO BE IN MIDDLE OF SWAPPING) POPJ PDP, ;NO, GIVE "SWAP-IN-HIGH-SEG" RETURN, ; AC J SET TO HIGH SEG NO. PUSHJ PDP,CHKIDL ;YES, CHECK IF THIS HIGH SEG IS IDLE(IF YES, ; DECREASE CORTAL=FREE+DORMANT+IDLE CORE ; BY SIZE IN J OF HIGH SEG SINCE IT WILL ; NO LONGER BE IDLE(IN CORE COUNT NON-ZERO) MOVE TAC,SWPIN ;RESTORE JOB NUMBER PUSHJ PDP,INCCNT ;INCREMENT HIGH SEG IN CORE COUNT ; FOR THIS JOB IFN FTHALT,< PUSHJ PDP,CHKTAL ;CHECK CORTAL WITH CORTAB, HALT IF DIFFER > FINHGH: MOVSI TAC,SWP ;CLEAR SWAPPED OUT OR ON WAY FLAG FOR HIGH SEG ANDCAM TAC,JBTSTS(J) ;AND CLEAR SUPPRESS IN-CORE COUNT INCREMENT FLAG TLNE J,UWPOFF ;IS USER MODE WRITE PROTECT(UWP) OFF ; FOR THIS USER? PUSHJ PDP,ZERSWP ;YES, CHANGE SWAPPING SPACE TO 0 FOR HIGH SEG ;0 TO IMGOUT,IMGIN, AND SWP IN JBTSTS(HIGH SEG) ;NO, KEEP COPY OF SEG ON DISK(USUAL CASE) ; WHETHER SHARABLE OR NOT BOTHIN: MOVE J,SWPIN ;RESTORE JOB NUMBER(LOW SEG NUMBER) JRST CPOPJ1 ;SKIP RETURN > ;ROUTINE CALLED JUST BEFORE HIGH OR LOW SEG TO BE SWAPPED IN ; AND AFTER CORE HAS BEEN ASSIGNED ;FITHGH SEES IF HIGH SEG AND INCREASES IN-CORE COUNT(USUALLY TO 1) ; FOR JOB BEING SWAPPED IN(SWPIN ALREADY SET TO JOB # BY PREVIOUS CALL ; TO FININ FOR LOW SEGMENT OF THIS JOB IFN FTSWAP,< INTERN FITHGH EXTERN SWPIN,JOBMAX FITHGH: CAIG J,JOBMAX ;IS THIS A HIGH SEGMENT POPJ PDP, ;NO, MOVE TAC,SWPIN ;YES, GET JOB NUMBER(SET BY FININ) THAT ; GOES WITH THIS HIGH SEG JRST INCCNT ;AND INCREMENT INCORE COUNT > ;ROUTINE TO CHECK IF THIS WAS A HIGH SEG JUST SWAPPED OUT ;IF YES, RETURN JOB NUMBER SO LOW SEG CAN BE SWAPPED OUT(IF NOT ACTIVE IO) ;CALL: MOVE ITEM,HIGH OR LOW SEG NUMBER JUST FINISHED SWAPPING OUT ; PUSHJ PDP,FINOT ; RETURN1 - LOW SEG TO BE WRITTEN, C(ITEM) SET TO JOB(LOW SEG) NUMBER ; RETURN2 - NOTHIGN MORE TO SWAP OUT FOR THIS JOB IFN FTSWAP,< INTERN FINOT EXTERN JOBMAX,CPOPJ1 FINOT: CAIG J,JOBMAX ;IS SEG JUST WRITTEN A HIGH SEG? JRST CPOPJ1 ;NO, IT WAS A LOW SEG-NOTHING MORE TO DO MOVE TAC,SWPOUT ;DECREMENT HIGH SEG IN CORE COUNT HLL J,JBTSGN(TAC) ;WITH CORRECT CORCNT BIT FROM TABLE PUSHJ PDP,DECCNT ;FOR JOB FOR WHICH IT WAS JUST SWAPPED OUT JFCL ;ALREADY DECREMENTED. IGNORE. JRST RETJOB ;YES, RETURN JOB NUMBER(LOW SEG NUMBER) ; TO TRY TO BE SWAPPED OUT > ;ROUTINE TO COMPUTE AMOUNT OF CORE NEEDED TO GET THIS USER INTO CORE ;CALL: MOVE ITEM,JOB NUMBER OR HIGH SEG NUMBER IF LOW SEG ALREADY IN ; LDB AC1,IMGIN ;SIZE OF THIS SEG WHEN SWAPPED IN(OR O IF ALREADY IN) ; PUSHJ PDP,FITSIZ ; RET1 - CANNOT FIT THIS USER IN(AC1=SUM OF SEGS NEEDED) ; RET2 - BOTH WILL FIT(AC1 RESTORED TO SIZE OF THIS SEG) ; ITEM RESTORED ON BOTH RETURNS IFN FTSWAP,< INTERN FITSIZ EXTERN JOBMAX,JBTSGN,IMGIN,JBTADR,CORTAL,CPOPJ1 FITSIZ: PUSH PDP,J ;SAVE LOW OR HIGH SEG NUMBER CAIG J,JOBMAX ;IS THIS A LOW SEG(IF NO, LOW SEG ALREADY IN)? SKIPG J,JBTSGN(J) ;YES, DOES THIS JOB HAVE A REAL HIGH SEG? JRST FITCHK ;NO, GO SEE IF JUST THIS HIGH OR LOW SEG WILL FIT LDB AC2,IMGIN ;YES, INCLUDE SIZE OF HIGH SEG WHEN SWAPPED IN SKIPN JBTADR(J) ;IS IT IN CORE SO NO SWAP IN NEEDED? ADD AC1,AC2 ;NO, ADD LENGTH OF HIGH SEG IF NEEDED FITCHK: POP PDP,J ;RESTORE LOW OR HIGH SEG NUMBER CAMLE AC1,CORTAL ;IS AMOUNT OF CORE REQUIRED, AVAILABLE? ; EVEN IF ALL CORE DORMANT SEGS ARE DELETED POPJ PDP, ;NO, RETURN AND SCAN FOR JOB TO OUTOUT LDB AC1,IMGIN ;YES, RETURN SIZE OF THIS SEGMENT JRST CPOPJ1 ;RETURN AND TRY SHUFFLING TO GET A HOLE BIG ENOUGH ; IF THAT NOT GOOD ENOUGH, DELETE SOME DORMANT ; SEGS FROM CORE > ;ROUTINE TO COMPUTE SIZE OF CORE FREED UP IF A JOB WERE TO BE FORCED OUT ;CALL: MOVE J,JOBNUMBER ; MOVE DEVDAT,LOW SEG SIZE IN 1K BLOCKS ; PUSHJ PDP,FORSIZ ; RETURN - AC DEVDAT INCREMENTED APPROPRIATELY(C(J)=JOB NUMBER) ; ACS TAC AND TAC1 ARE PRESERVED BECAUSE THEY ARE IN USE BY ; QUEUE SCANNING ROUTINES IFN FTSWAP,< INTERN FORSIZ EXTERN JBTSGN,JBTSTS,CPOPJ,JBTADR FORSIZ: MOVSI AC3,SWP ;SWP BIT SET WHEN HIGH SEG SWAPPED TDNN AC3,JBTSTS(J) ;HAS HIGH SEG ALREADY BEEN SWAPPED OUT FOR ;THIS JOB(OR IN-CORE COUNT DECREMENTED)? SKIPG AC3,JBTSGN(J) ;NO, DOES JOB HAVE A REAL HIGH SEG? POPJ PDP, ;NO, RETURN J STILL SETUP TO JOB NUMBER ; (MAYBE SPYSEG) HLRZ AC2,JBTADR(AC3) ;YES - GET HISEG SIZE JUMPE AC2,CPOPJ ;NOT IN CORE - TETURN LSH AC2,-12 ;COMPUTE SIZE IN 1K BLOCKS ADDI AC2,1 HRRZ AC3,JBTSTS(AC3) ;GET NO. OF IN CORE USERS IDIV AC2,AC3 ;COMPUTE HISEG SIZE/NO. OR USERS ADDI DEVDAT,1(AC2) ;ADD THIS TO TOTAL JOB SIZE AND ADD 1 FOR LUCK? POPJ PDP, ;RETURN > ;ROUTINE TO CHECK IF JOB HAS A HIGH SEG WHICH NEEDS TO BE SWAPPED OUT ;IF YES, IT IS WRITTEN FIRST BEFORE LOW SEG ;IN THIS WAY THE IO BUFFERS MAY STAY ACTIVE LONGER ;IN FACT, THE HIGH SEG CAN BE BROUGHT BACK IN WITHOUT LOW SEG ;EVER LEAVING CORE. ;SHF BIT IS SET IN JOB STATUS WORD IF JOB ONLY HAS A LOW SEG, SO IO WILL STOP ;ON NEXT BUFFERFUL. THUS ONLY 2 SEG JOBS HAVE ACTIVE IO LONGER. ;BUFFER ADVANCE ROUTINES LOOK AT SHF BUT NOT SWP FOR JOB ;CALL: MOVEM FIT SWAP IN JOB NO.,FIT ; MOVE J,LOW OR HIGH SEG NUMBER ; PUSHJ PDP,FORHGH ; ALWAYS RETURN WITH HIGH OR LOW SEG TO BE WRITTEN IN J ; IFN FTSWAP,< INTERN FORHGH EXTERN JOBMAX,JBTSTS,SWPOUT,JBTSGN,JBTADR,IMGOUT,CPOPJ,FIT FORHGH: MOVSI TAC,SWP ;SET WHEN HIGH SEG SWAPPED OUT OR IN-CORE ; COUNT REDUCED CAIG J,JOBMAX ;IS THIS A HIGH SEG(ONLY IF WAITING FOR HIGH SEG IO) TDNE TAC,JBTSTS(J) ;NO, HAS HIGH SEG ALREADY BEEN SWAPPED FOR THIS USER? POPJ PDP, ;YES, TRY HIGH SEG AGAIN OR WRITE LOW SEG IORM TAC,JBTSTS(J) ;NO,SET SWAP BIT IN JOB STATUS WORD TO INDICATE ; 1. HIGH SEG SWAPPED IF ANY OR LOW SEG SWAPPED IF NONE SKIPLE JBTSGN(J) ;DOES JOB HAVE A REAL HIGH SEG IN CORE OR DISK? JRST FORH1 ;YES MOVSI TAC,SHF ;NO, SET WAITING TO SHUFFLE BIT IN JOB STATUS WORD ; SO IO WILL STOP AFTER NEXT BUFFERFUL(MAYBE SPYSEG) IORM TAC,JBTSTS(J) ;CHECK EVEY BUFFERFUL IN ADVBFF, ADVBFE ROUTINES POPJ PDP, ;RETURN AND TRY TO SWAP OUT LOW SEG FORH1: MOVEM J,SWPOUT ;REMEMBER THIS JOB NUMBER DURING HIGH SEG SWAPOUT MOVE TAC,J ;SET UP JOB NUMBER FOR DECCNT ROUTINE MOVE J,JBTSGN(J) ;GET HIGH SEG NUMBER FOR THIS JOB SKIPE PROG,JBTADR(J) ;IS HIGH SEG STILL IN CORE? ; MAY NOT BE IF JOB JUST CONNECTED TO HIGH SEG ; BY GET(XPANDH) OR HIGH SEG SWAPPED OUT PREVIOUSLY ;SETUP R IN CASE KCOREH CALLED PUSHJ PDP,DECCNT ;YES, DECREMENT IN CORE USE COUNT JRST RETJOB ;STILL GREATER THAN 0(OR NOT IN CORE), SWAP OUT LOW SEG MOVE TAC,FIT ;IS JOB BEING FITTED IN(0 IF NOT FITTING IN) HRRZ TAC1,JBTSGN(TAC) ;ABOUT TO USE THIS SAME HIGH SEG? CAIG TAC,JOBMAX ;IS SEGMENT BEING FITTED A LOW SEG(JOB #) ; (USUALLY SINCE SWAPPER DOES NOT SWAP IN UNTIL ; ROOM FOR BOTH HIGH AND LOW SEGS CAIE TAC1,(J) ;YES, FIT JOB HIGH SEG SAME? JRST FORH2 ;NO, EITHER FIT HIGH SEG(RARE) OR NOT SAME PUSHJ PDP,INCCNT ;YES,INCREMENT HIGH SET IN CORE COUNT FOR JOB ; ABOUT TO BE FITTED IN CORE EVEN THOUGH ITS LOW ; SEG HAS YET TO BE SWAPPED IN. (COUNT WILL ONLY ; BE INCREMENTED ONCE SINCE CORCNT BIT WILL BE SET) ; HIGH SEG WILL NOT APPEAR IDLE IN CORE ; DURING OTHER SWAPOUTS AND FIT SWAP IN ; LEAST FRECOR GRAB IT IFN FTHALT,< PUSHJ PDP,CHKTAL ;CHECK CORTAL WITH CORTAB, HALT IF DIFFER > JRST RETJOB ;RETURN AND SWAP JUST LOW SEG OUT (LEAVING ; HIGH SEG IN CORE FOR FIT USER) FORH2: MOVE TAC,SWPOUT ;JOB NUMBER OF JOB WHICH HAS HIGH SEG ; WHICH MAY BE WRITTEN LDB TAC1,IMGOUT ;IS A COPY OF SEG ALREADY ON DISK? JUMPE TAC1,INCCNT ;IF NOT(0), RETURN AND WRITE HIGH SEG ; AFTER INCREMENTING IN-CORE COUNT TO 1 ; SO IT WILL NOT APPEAR IDLE DURING SWAP OUT PUSHJ PDP,KCOREH ;ALREADY ON DISK, JUST RETURN CORE ; AND FLAG HIGH SEG AS ON DISK(SET SWP=1) IFN FTHALT,< PUSHJ PDP,CHKTAL ;CHECK CORTAL WITH CORTAB, HALT IF DIFFER > RETJOB: IFN FTHALT,< PUSHJ PDP,CHKTAL ;CHECK CORTAL WITH CORTAB, HALT IF DIFFER > MOVE J,SWPOUT ;RETURN JOB NUMBER(LOW SEG NUMBER) POPJ PDP, ;AND TRY TO SWAP IT OUT > ;ROUTINE TO TRY TO FREE UP DISK SPACE WHEN IT IS FULL ;BY DELETING A HIGH SEG FROM SWAPPING AREA ;IT TRIES TO FIND SEG ON DISK (I.E. SNA=0 AND IMGOUT NON-ZERO MEANING ON DISK BUT ; IN NO ONE'S LOGICAL ADDRESSING SPACE) ;CALLER MUST ALREADY GUARRANTEE 0 HAS BEEN STORED IN IMGOUT(DISK SPACE) ;FOR THIS HIGH OR LOW SEG, ELSE FRESWP WILL TRY TO RETURN IT(BUT NOT REALLY THERE) ;IF NONE FOUND. SWAPPING SPACE IS FULL ;CALL: MOVE ITEM,LOW OR HIGH SEG TRYING TO BE SWAPPED OUT ; PUSHJ PDP,FRESWP ; RETURN1 - HIGH SEG DELETED FROM DISK. C(ITEM) PRESERVED ; RETURN2- NONE FOUND. C(ITEM) PRESERVED IFN FTSWAP,< INTERN FRESWP EXTERN OUTMSK,SEGPTR,JBTSTS,JBTSWP EXTERN IPOPJ,IPOPJ1 FRESWP: PUSH PDP,ITEM ;SAVE SEG NO. TRYING TO SWAP OUT MOVEI TAC1,OUTMSK ;MASK FOR BYTE POINTER ON DISK SPACE MOVE ITEM,SEGPTR ;SCAN JUST HIGH SEGS SKIPL JBTSTS(ITEM) ;IS SET UNUSED(SNA=0)? TDNN TAC1,JBTSWP(ITEM) ;YES, DOES IT HAVE SPACE ON DISK(IMGOUT=0)? AOBJN ITEM,.-2 ;NO, KEEP LOOKING, FINISHED? JUMPGE ITEM,IPOPJ1 ;YES, WAS DORMANT SEG FOUND WITH DISK SPACE? ; IF NO. GIVE SKIP(NON FOUND) RET AND RESTORE ITEM TLZ ITEM,-1 ;CLEAR LH BITS OF HIGH SEG NUMBER PUSHJ PDP,CLRNAM ;CLEAR NAME AND DELETE(WAS DORMANT) ;BOTH DISK AND CORE SPACE AND SET NAME TO 0 JRST IPOPJ ;RESTORE JOB NUMBER (ITEM) AND RETURN > SUBTTL SYSINI - SYSTEM INITIALIZATION ;INITIALIZE HIGH SEG IN 140 RESTART INTERN SEGINI EXTERN SEGPTR,JBTSTS SEGINI: MOVE ITEM,SEGPTR ;POINTER TO JUST HIGH SEG NUMBER MOVSI TAC,NSHF!NSWP ;CLEAR NO SHUFFLE AND NO SWAP BITS ANDCAM TAC,JBTSTS(ITEM) ;LEAVE SNA, SEGSHR,SWP,SUPINC, AOBJN ITEM,.-1 ;AND ACCESS PRIVILEGES AND IN CORE COUNT POPJ PDP, ;ALONE SUBTTL UUOCON - HANDLING ROUTINES ;ROUTINE TO CHECK TO SEE IF A KNOWN SEGMENT IS BEING SUPERCEDED BY A FILE ;OF THE SAME NAME WITH EXTENSION OF .SHR IN THE SAME DIRECTORY. ;IF YES, THE SHARABLE SEGMENT IF FLAGGED AS NO LONGER SHARABLE FOR ;ADDITIONAL USERS(ITS NAME IS SET TO 0 IN JBTNAM). THE USERS ;WHO ARE USING IT WILL CONTINUE TO SHARE IT UNTIL ALL OF THEM ARE THROUGH. ;IF NO USERS ARE USING SEGMENT ON DISK OR CORE, ITS DISK SPACE WILL BE RETURNED. ;CALLED FROM CLOSE INPUT AND OUTPUT DUMP AND BUFFERED(RELSEG) AND SUCCESSFUL RENAME(RELSG1) ;CALL: MOVE DEVDAT,ADR. OF DEVICE DATA BLOCK ; PUSHJ PDP,RELSEG ; ALWAYS RETURN (RELSEG) ; ALWAYS SKIP RETURN (RELSG1) INTERN RELSEG,RELSG1 EXTERN JOB,JBTNAM RELSG1: AOSA (PDP) ;RELSG1 _ ALWAYS SKIP RETURN (HEREON RENAME) RELSEG: TLNE DEVDAT,ENTRB ;HAS AN ENTER BEEN DONE(HERE ON CLOSE)? ; IS THIS OUTPUT CLOSE? ; I.E. WAS A FILE CREATED OR RECREATED? PUSHJ PDP,FNDSEG ;YES, DOES A KNOWN SEG ALREADY HAVE THIS NAME? ; SEARCH USING OLD (RATHER THAN NEW) IF RENAME POPJ PDP, ;NO, NO CONFLICT JRST CLRNM1 ;YES, CLEAR NAME AND DELETE CORE AND DISK IF ; BUT LEAVE DIRECTORY NAME FOR YSTAT ; SO IT CAN PRINT (OBS) PDP,PDP ; HIGH SEGMENT IS ALREADY DORMANT ;ROUTINE TO RESET HIGH SEG ;CALLED ON RESET UUO ;SETS USER:MODE WRITE PROTECT BIT ON IN HARDWARE AND SOFTWARE FOR THIS ;JOB ONLY(CURRENT JOB). OTHER JOBS MAY HAVE UWP ON OR OFF FOR ;SAME HIGH SEGMENT(EXCEPT THAT INITIALLY SETUWP UUO DOES NOT ALLOW ;TURNING UWP OFF IF HIGH SEG SHARABLE) ;CALL: MOVE ITEM,CURRENT JOB NUMBER ; PUSHJ PDP,HRESET ; RETURN WITH APR RESET AND SOFTWARE RESET INTERN HRESET EXTERN JBTSGN,SETREL HRESET: MOVSI TAC,UWPOFF ;FLAG THIS USER AS HAVING UWP ON FOR HIGH SEG ANDCAM TAC,JBTSGN(ITEM) ;SO HE WILL NOT BE ABLE TO WRITE HIGH SEG JRST SETREL ;GO DO DATAO APR AND SET UWP ON ;UUO ROUTINE TO SET OR CLEAR USER-MODE WRITE PROTECT(UWP) ;ON HIGH SEGMENT FOR CURRENT JOB ;CALL: MOVEI AC,0 OR 1(CLEAR OR SET UWP) ; MOVE ITEM,CURRENT JOB NUMBER ; PUSHJ PDP,USTUWP ; ERROR RETURN - MACHINE OR MONITOR NOT HAVE 2 REG. CAPABILITY OR ; TRYING TO TURN OFF UWP AFTER R HAS BEEN MEDDLED WITH ; AND USER DOES NOT HAVE WRITE PRIV. TO FILE WHICH INIT HIGH SEG ; OR HIGH SEG IS A SPYSEG(IE PHYSICAL CORE) ; OK RETURN - WHETHER JOB HAS HIGH SEG OR NOT ; PREVIOUS SETTING OF UWP RETURNED IN AC(BOTH RETURNS) INTERN USTUWP EXTERN TWOREG,RTZER,JBTSGN,JBTSTS,SETREL,STOTAC USTUWP: SKIPN TWOREG ;IS THIS A TWO REG MACHINE? JRST RTZER ;NO, ERROR RETURN TO USER, WITH 0 IN HIS AC AOS (PDP) ;ASSUME OK RETURN SKIPN ITEM,JBTSGN(ITEM) ;DOES JOB HAVE A REAL OR SPY HIGH SEG? JRST USTU0 ;NO, GIVE OK RETURN, BUT RETURN 0 AS PREVIOUS ; UWP SETTING JUMPN TAC,UWPON ;YES, IS USER TRYING TO TURN UWP ON? TLNN ITEM,MEDDLE ;NO, HAS HE BEEN MEDDLING WITH PROGRAM ; (START N,DEPOSIT,GETSEG,RUN +2)? JRST USTU1 ;NO, ALWAYS ALLOW UWP TO BE TRUNED OFF SINCE ; R IS IN COMPLETE CONTROL OF ITS SELF MOVE AC2,JOB ;YES, CURRENT JOB NO. FOR CHKHSW ROUT. PUSHJ PDP,CHKHSW ;DOES THIS JOB HAVE WRITE PRIVILEGES TO FILE ; EVEN THOUGH MEDDLING WITH PROGRAM? ; MAYBE SHARED DATA SEGMENT WITH GETSEG UUO USTUE: SOSA (PDP) ;NO, THEN DO NOT ALLOW PROGRAM TO TURN OFF UWP USTU1: TLOA ITEM,UWPOFF ;YES, SO OK TO TURN OFF UWP, EVEN IF THIS ; IS SHARABLE HIGH SEG UWPON: TLZ ITEM,UWPOFF ;TURN OFF UWPOFF SO UWP WILL BE ON IFN FTSWAP,< EXTERN ZERSWP TLNE ITEM,UWPOFF ;WILL HIGH SEG BE WRITEABLE? PUSHJ PDP,ZERSWP ;YES, RETURN SWAPPING SPACE SO HIGH SEG ; WILL HAVE TO BE WRITTEN WHEN JOB ; IS SWAPPED OUT > MOVE TAC,JOB ;CURRENT JOB NUMBER IFN FTHALT,< PUSHJ PDP,COMIT ;COMPARE J WITH JBTSGN(TAC), HALT IF DIFF. > EXCH ITEM,JBTSGN(TAC) ;MARK NEW UWP SETTING FOR TIS USER AND GET OLD ONE MOVEI TAC,1 ;ASSUME UWP WAS ON FOR THIS USER TLNE ITEM,UWPOFF ;WAS UWP OFF? USTU0: MOVEI TAC,0 ;YES, RETURN 0 PUSHJ PDP,STOTAC ;TO USER'S AC ARG JRST SETREL ;GO RESET HARDWARE AND SOFTWARE RELOC. ; AND RETURN TO USER ;ROUTINE TO CHECK ACCESS PRIVILEGES FOR SHARED SEGMENTS ;CALL: MOVE ITEM,HIGH SEG NUMBER ; MOVSI AC1,(200B) OR (100B) TO READ OR WRITE ; MOVE AC2,JOB NUMBER ; PUSHJ PDP,CHKHSA ; CAN'T READ OR WRITE ; USER HAS PRIV IF SHARABLE, OR HIGH SEG NOT SHARABLE ;DTA READ OK IF DEVICE UNASSIGNED,SYSTEM, OR ASSIGNED TO THIS JOB ;DTA WRITE OK IF DEVICE UNASSIGNED OR ASSIGNED TO THAT JOB, EXCEPT CAN'T ;DEPOSIT SYSTEM TAPE ;CALLED FROM SAVGET TO SEE IF USER HAS READ PRIVILEGES TO SHARE ;CALLED FROM DEPOSIT COMMAND IF IN HIGH SEG TO SEE FI WRITE PROV ;CALLED FROM SETUWP IF TRY TO SET UWP TO 0 AND MEDDLE BIT IS ON TO ; SEE IF WRITE PRIV. OK EXTERN JBTDIR,DEVPHY,PJOBN,CPOPJ1,SYSTAP CHKHSW: MOVSI AC1,(100B) ;CHECK FOR HIGH SEG UPDATE CHKHSA: TLNN ITEM,SHRSEG ;IS THIS HIGH SEG SHARABLE? JRST CPOPJ1 ;NO, ALWAYS OK TO READ OR WRITE IFN FTDISK,< EXTERN PRJPRG SKIPG AC3,JBTDIR(ITEM) ;YES, IS HIGH SEG FROM DATA OR MTA ; (SIXBIT A-Z 41 OR GREATER) JRST CHKHS3 ;YES, GO SEE IF DEVICE IS AVAILABLE XOR AC3,PRJPRG(AC2) ;NO, XOR JOB PROJ,PROG WITH HIGH SEG TRNN AC3,777777 ;SEG AND JOB SAME PROGRAMMER? JRST CHKHS1 ;YES ROT AC1,-3 ;NO, ASSUME SAME PROJECT TLNE AC3,777777 ;SEG AND JOB SAME PROJECT? ROT AC1,-3 ;NO, UNIVERSAL ACCESS RIGHTS CHKHS1: TDNN AC1,JBTSTS(ITEM) ;THIS JOB PROHIBITED FROM READ(WRITE) THE FILE ; WHICH INITIALIZED THE SHARABLE SEG? JRST CPOPJ1 ;NO, GIVE OK RETURN > CHKHS3: SKIPGE TAC,JBTDIR(ITEM) ;NO IS THIS HIGH SEG FROM DTA OR MTA? PUSHJ PDP,DEVPHY ;YES, SEARCH FOR PHYSICAL DEVICE POPJ PDP, ;NO, NOT FOUND MOVE TAC,DEVNAM(DEVDAT) ;GET PHYSICAL DEVICE NAME CAME TAC,SYSTAP ;SYSTEM TAPE? JRST CHKHS2 ;NO TLNN AC1,(111B) ;YES, TRYING TO WRITE(CLEAR UWP OR DEPOSIT) AOS (PDP) ;NO, OK TO READ SYSTEM TAPE POPJ PDP, ;YES, CA'T WRITE SYSTEM TAPE CHKHS2: LDB AC3,PJOBN ;JOB DEVICE ASSIGNED TO, IF ANY JUMPE AC3,CPOPJ1 ;IS NON-SYSTEM DEVICE ASSIGNED? ; ALWAYS READ OR WRITE IF UNASSIGNED CAMN AC3,AC1 ;YES, IT IT ASSIGNED TO THIS JOB? AOS (PDP) ;YES, CAN READ OR WRITE POPJ PDP, ;NO, CANNOT READ ORWRITE ;UUO TO ALLOW PRIVILEGED USER PROGRAM TO LOOK AT ALL OF CORE ; BY HAVING PHYSICAL CORE APPEAR AS HIGH SEG ; ANY PROGRAMS WRITTEN TO USE THIS UO SHOULD BE PROGRAMMED TO USE THE ; PEEK UUO TOO, IN CASE THIS MACHINE OR MONITOR DOES NOT HAVE 2 RELOC. REG. ; OR INSTALLATION DECIDES TO MAKE THIS UUO RESTRICTED ; THIS UUO IS PROVIDED ONLY FOR EFFICIENT, SINCE IT NEED ONLY BE DONE ; ONCE, WHILE PEEK UUO MUST BE DONE FOR EVERY WORD EXAMINED ;CALL: HRRI AC,HIGHEST PYHSICAL ADR. TOAPPEAR IN HIGH SEG ; CALL AC,[SIXBIT /SPY/] OR CALLI AC,42 ; ERROR RETURN, ADR. TOO IGH OR THIS USER CAN'T USE ; THIS UUO, OR NOT 2 RELOC. REG. MACHINE ; OK RETURN, HIGH SEG SETUP IN ADDRESSING SPACE ;NOTE: A SPYSEG APPEARS TO THE SYSTEM AS IF TIS USER DOES NOT HAVE A HIGH SEG ; IN ALL CASES EXCEPT WHEN THE RELOC. HARDWARE IS SET. THIS IS BECAUSE ; THE SIGN BIT OF JBTSGN(JOBNUMBER) IS SET TO INDICATE SPY SEG ; AND THE MONITOR CHECK FOR REAL HIGH SEGS SITH SKIPG INSTR. ; THE RH OF JBTSGN(JOBNUMBER) HAS HIGHEST LEGAL PHY. ADR. ; FOR THIS USER TO LOOK AT(CARE IS TAKEN SINCE THIS IS MUCH BIGGER THAN A ; HIGH SEG NUMBER WHICH IS USUALLY IN RH) INTERN USPY EXTERN TWOREG,GETWDU,JBTSGN USPY: SKIPN TWOREG ;DOES MACHINE HAVE 2 REG. HARDWARE? POPJ PDP, ;NO, ERROR RETURN TO USER PUSHJ PDP,KILHGC ;YES, REMOVE PREVIOUS HIGH SEG FROM LOGICAL ;ADR. SPACE, IF ANY INCLUDING PREVIOUS SPY SEG PUSHJ PDP,GETWDU ;GET USER'S COR ARG ON UUO JUMPE TAC,SETRL1 ;DOES HE WANT TO SPY AT ALL? ; IF 0, SET RELOC HARDWARE AND SKIP RETURN HRLI TAC,SPYSEG!MEDDLE ;YES, FLAG THIS USER AS SPYING MOVEM TAC,JBTSGN(ITEM) ;STORE IGHEST PHYSICAL ADR. USER WANTS JRST SETRL1 ;OK RETURN TO USER AFTER SETTING HARDWARE ;ROUTINE TO SCAN KNOWN SEG TABLE(PRJPRG/JBTNAM) TO SEE IF A SEG IS ALREADY ;IN IT AFTER FILE HAS BEEN WRITTEN OR RENAMED ;CALL: MOVE DEVDAT,DEVICE DATA BLOCK ADDRESS OF DEVICE WITH FILE ; PUSHJ PDP,FNDSEG ; NOT FOUND RETURN, OR FILE EXT WAS NOT SHR, OR DEVICE HAS SHORT DISP TABLE ;C(ITEM)=GARBAGE ; FOUND RETURN, C(ITEM)=HIGH SEG NUMBER(LH=0) ; C(TAC)=DIRECTORY NAME(PROJPROG NO IF DISK, 0 IF MTA OR DTA ; C(TAC1)=FILE NAME ; C(JBUF)=DEVICE OR FILE STRUCTURE NAME ;CALLED FROMRELSEG(CLOSE OUTPUT AND SUCCESSFUL RENAME) ;AND GET AFTER INPUT ;MUST BE CALLED AT UUO LEVEL EXTERN SEGPTR,JBTNAM,CPOPJ,CPOPJ1 FNDSEG: MOVE TAC1,DEVMOD(DEVDAT) ;DEVICE CHARACTERISTICS HLRZ TAC,DEVEXT(DEVDAT) ;FILE EXTENSION TLNE TAC1,DVLNG ;IS DEVICE HAVE FILES(MTA,DTA,DSK)? CAIE TAC,(SIXBIT /SHR/) ;YES, IS EXTENSION SHR? POPJ PDP, ;NO, DO NOT LOOK FOR NAME IN KNOWN TABLE IFN FTDISK,< TLNE TAC1,DVDSK ;IS THIS DEVICE A DISK? SKIPA TAC,DEVPPN(DEVDAT) ;YES, GET PROJECT-PROGRAMMER NUMBER > MOVE TAC,DEVNAM(DEVDAT) ;NO, SET DIR TO 0, MUST BE DTA OR MTA MOVE TAC1,DEVFIL(DEVDAT) ;GET FILE NAME FROM DEVICE DATA BLOCK ; OLD (RATHER THAN NEW) IF RENAME ;ROUTINE SAME AS FNDSEG, EXCEPT DEVICE NOT LOOKED UP(CALLED FROM GET) ;CALL: MOVE TAC,PROJEXT,PROG NO IF DISK, ZERO IF DTA OR MTA ; MOVE TAC1,FILE NAME ; MOVE JBUF,DEVICE NAME OR FILE STRUCTURE NAME ; PUSHJ PDP,SRCSEG ; NOT FOUND RETURN ; FOUND RETURN - ITEM SET UP TO HIGH SEG NUMBER ; LH OF ITEM SET AS SHARABLE(SHRSEG=1) ; (MEDDLE=UWPOFF=SPYSEG=0) SRCSEG: MOVE ITEM,SEGPTR ;POINTER TO JUST HIGH SEGMENTS IN JOB TABLES FNDLOP: CAMN TAC1,JBTNAM(ITEM) ;DO FILE NAMES MATCH? CAME TAC,PRJPRG(ITEM) ;YES, DO DIRECTORY NAMES MATCH? AOBJN ITEM,FNDLOP ;NO, KEEP LOOKING,FINISHED? JUMPGE ITEM,CPOPJ ;YES, FINISHED?(IF YES, GIVE NOT FOUND RETURN) HRLI ITEM,SHRSEG ;YES, THIS MUST BE A MATCH(FLAG SEG AS SHARABLE) JRST CPOPJ1 ;FOUND RETURN ;ROUTINE TO GET WORD FROM HIGH SEGMENT IN CORE ;CALL: MOVE ITEM,JOB NO. ; HRR UUO,RELATIVE(USER) ADDRESS IN HIGH SEGMENT ; PUSHJ P,HGHWRD ; ERROR RETURN, ADR NOT IN HIGH SEG OR NO HIGH SEG ; OK RETURN, CONTENTS OF LOC RETURNED IN TAC ; ABS. ADR. OF LOC RETURNED IN AC TAC1(USED BY DEPOSIT) ;CAN BE CALLED AT CLOCK OR UUO LEVELS ;CALLED FROM E COMMAND AND CALL,INIT UUOS,SAVE AND GET JOBS INTERN HGHWRD EXTERN JBTSGN,JBTADR,CPOPJ1 HGHWRD: TRNE UUO,400000 ;IS ADDRESS GREATER OR EQUAL TO 400000? SKIPG TAC1,JBTSGN(ITEM) ;YES, DOES JOB HAVE A HIGH SEG? POPJ PDP, ;NO, ERROR RETURN - LESS THAN 400000 OR NO HIGH SEG ; OR SPYSEG MOVEI TAC,377777 ;ASSUME LOW SEG IS LESS THAN 400000 WORDS ;SETUP USER ORIGIN-1 OF HIGH SEG SKIPGE PROG ;IS IT(LH OF R IS LENGTH-1 OF LOW SEG)? HLRZ TAC,PROG ;NO, LENGTH-1 OF LOW SEG IS ORIGIN-1 OF HIGH SEG HLRZ TAC1,JBTADR(TAC1) ;GET LENGTH-1 OF HIGH SEG ADDI TAC1,1(TAC) ;FORM HIGHEST LEGAL USER ADR IN HIGH SEG CAIGE TAC1,(UUO) ;IS IT LESS OR EQUAL TO HIGHEST LEGAL ADDRESS? POPJ PDP, ;NO, ERROR RETURN MOVE TAC1,JBTSGN(ITEM) ;YES, GET SEG NUMBER AGAIN HRRZ TAC1,JBTADR(TAC1) ;ABSOLUTE ADR. OF FIRST WORD OF HIGH SEG ;(NOT RELOCATION) SUBI TAC1,1(TAC) ;FORM RELOCATION, SUBTRACT 400000(USUAL) OR ;LENGTH OF LOW SEG IF GREATER ADDI TAC1,(UUO) ;ADD USER ADDRESS TO RELOCATION OF HIGH SEG MOVE TAC,(TAC1) ;GET CONTENTS OF THAT WORD JRST CPOPJ1 ;OK RETURN SEGEND: END