DataMuseum.dk

top - metrics - download

    Length: 26810 (0x68ba)
    Notes: pts_type(SC)
    Names: »LDTASK.SC«

└─⟦7a1dcd5a9⟧ Bits:30009673 Philips computer tape "600134"
    └─⟦this⟧ »PTMON/LDTASK.SC« 
└─⟦7b35573c9⟧ Bits:30009690 Philips computer tape "600402"
    └─⟦this⟧ »M:AF/LDTASK.SC« 
└─⟦928b1fd3e⟧ Bits:30009671 Philips computer tape "600131"
    └─⟦this⟧ »PTMON/LDTASK.SC« 
└─⟦f350e1b7a⟧ Bits:30009678 Philips computer tape "600219"
    └─⟦this⟧ »MONGEN/LDTASK.SC« 

PTS(SC)

	IDENT LDTASK 	REL 11.0 81-06-10 870105041100 

			=2,REL 11.0 81-01-26 
			=2,END OF RELOC. CHECK FAILS (SPECIAL CASE)
			=1,PRR 11.0 80-06-12  BOFE 
			=1,CHECK FOR END OF RELOCATION 
* 
**************************************************
* 
*   PHILIPS TERMINAL SYSTEM PTS 
* 
*   LDTASK = LOAD TASK
* 
* 
* 
* 
**************************************************
* 
* 
*   THIS MODULE CONTAINS THE LOAD TASK
*   FOR TOSS MEMORY MANAGEMENT SYSTEMS. 
* 
*   IT CONTAINS TWO ENTRY POINTS: 
* 
*   - LT:DSK   USED IN DISC PAGING SYSTEMS
*   - LT:SWB   USED IN SWAPPABLE WORK BLOCK SYSTEMS 
* 
* 
	EJECT			LDTASK 
* 
* 
*********** 
* ENTRIES * 
*********** 
* 
* 
	ENTRY	LT:DSK	DISC PAGING ENTRY 
	ENTRY	LT:SWB	SWAPPABLE WORK BLOCK ENTRY
	ENTRY	TTABLD	LOAD TASK TTAB
	ENTRY	QLTDSK	ACTIVATE LDTASK AT ENTRY LT:DSK 
	ENTRY	QLTSWB	ACTIVATE LDTASK AT ENTRY LT:SWB 
	ENTRY	QLTASK	ACTIVATE LDTASK 
	ENTRY	LD:ECB	LDTASK ECB AREA 
	ENTRY	LD:BUF	LDTASK BUFFER 
	ENTRY	LD:BUE	END OF BUFFER 
	ENTRY	PQEMTY	PAGE QUEUE EMPTY FLAG 
	ENTRY	LD:STB	LDTASK STACK BASE 
	EJECT			LDTASK 
* 
* 
************* 
* EXTERNALS * 
************* 
* 
* 
	EXTRN	TLSEG1	UPDATE PAGQUE, CSB AND MMU
	EXTRN	TLSEG2	UPDATE CSB AND MMU
	EXTRN	QMEXIT	QUEUE TASK AND EXIT MONITOR TASK
	EXTRN	LKMERR	HALT SYSTEM DUE TO FATAL LKM ERROR
	EXTRN	ACTOT	ACTIVATE TASK
	EXTRN	RELPA2	RELEASE PAGE
	EXTRN	PAGQUE	FREE PAGE QUEUE 
	EXTRN	PAG:QB	QUEUE LINK BACKWARDS
	EXTRN	PAG:PA	PAGE ADDRESS
	EXTRN	PAG:SB	SEGMENT BLOCK ADDRESS 
	EXTRN	SEG:FC	FILE CODE 
	EXTRN	SEG:DS	DISC SECTOR ADDRESS 
	EXTRN	SEG:EL	SEGMENT LENGTH
	EXTRN	SEG:PB	PAGE BLOCK ADDRESS
	EXTRN	SWB:DS	DISC SECTOR ADDRESS OF FIRST COPY 
	EXTRN	SWB:EL	SWB LENGTH (BYTES)
	EXTRN	SWB:NS	SWB LENGTH (SECTORS)
	EXTRN	ECBBA	ECB BUFFER ADDRESS 
	EXTRN	ECBRL	ECB REQUESTED LENGTH 
	EXTRN	ECBEL	ECB EFFECTIVE LENGTH 
	EXTRN	ECBRC	ECB RETURN CODE
	EXTRN	ECBCW1	ECB CONTROL WORD 1
	EXTRN	ECBCW2	ECB CONTROL WORD 2
	EXTRN	TTB:AP	ACB ADDRESS 
	EXTRN	TTB:SA	TTAB SAVE AREA
	EXTRN	TTB:MT	MMU TABLE 
	EXTRN	TTB:CB	CURRENT SEGMENT BASE
	EXTRN	TTB:SP	SEGTAB ADDRESS
	EJECT			LDTASK 
* 
* 
	EXTRN	SCTIPL	PROGRAM LOADING DEVICE
	EXTRN	SCTPSZ	PAGE SIZE 
	EXTRN	ACBLAP	LOGICAL ADDRESS OF PAGES
	EJECT			LDTASK 
* 
* 
***************************************** 
* 
*	CONDITIONAL ASSEMBLY
* 
***************************************** 
* 
*	A PROGRAM VERSION USING TOSS MMU PAGING 
*	IS OBTAINED BY SETTING MMUPAG EQU 1.
* 
MMUPAG	EQU	1
* 
* 
*	A PROGRAM VERSION USING THE EXTENDED INSTRUCTION
*	SET IS OBTAINED BY SETTING CPU852 EQU 0.
* 
CPU852	EQU	0
* 
* 
*	A PROGRAM VERSION INCLUDING TOSS SWAPPABLE WORK 
*	BLOCKS IS OBTAINED BY SETTING SWPBLK EQU 1. 
* 
SWPBLK	EQU	0
* 
* 
*	A PROGRAM VERSION SPECIALIZED FOR THE 857 CPU 
*	IS OBTAINED BY SETTING CPU857 EQU 1.
* 
X:B	EQU	0 
CPU857	EQU	X:B
* 
	EJECT			LDTASK 
* 
* 
*	A PROGRAM VERSION USING TOSS ASSEMBLER PAGING 
*	IS OBTAINED BY SETTING ASMPAG EQU 1.
* 
X:C	EQU	0 
ASMPAG	EQU	X:C
* 
	EJECT			LDTASK 
* 
* 
***************************** 
* ECB, STACK AND DATA AREAS * 
***************************** 
* 
* 
LD:ECB	DATA	0,0,0,0,0,0,0	LDTASK ECB AREA 
* 
LD:BUF	RES	128	INTERMEDIATE BUFFER FOR LOAD TASK
LD:BUE	EQU	*	END OF BUFFER
* 
	RES	4	LDTASK STACK (TWO LEVELS)
LD:STB	EQU	*-2	LOAD TASK STACK BASE 
* 
PQEMTY	DATA	0	PAGE QUEUE EMPTY FLAG 
* 
	IFT	MMUPAG=1 
LD:LAD	DATA	0	LOGICAL ADDRESS POINTER 
	XIF
* 
	EJECT			LDTASK 
* 
* 
**********
* TTABLD *
**********
* 
*	LDTASK TTAB 
* 
	IFT	MMUPAG=1 
	RES	16	LDTASK MMU TABLE
	XIF
* 
	DATA	0	CURRENT SEGMENT BASE (DUMMY)
	DATA	0	SEGMENT TABLE ADDRESS (DUMMY) 
	DATA	0	SEGMENT BLOCK ADDRESS (DUMMY) 
	DATA	0	ACB ADDRESS (DUMMY) 
* 
TTABLD	EQU	*	TTABLD ENTRY 
	DATA	0	DISPATCHER QUEUE LINK 
	DATA	'#L'	TASK IDENTIFICATION
	DATA	49	PRIORITY LEVEL 
	DATA	0	PENDING POINTER 
	DATA	/C4C0	PSW (PROGRAM STATUS WORD) 
	DATA	0	DISPATCH ADDRESS
	DATA	0,0,0,0,0,0,0	REGISTER SAVE AREA, A1-A14
	DATA	0,0,0,0,0,0,0 
	DATA	2	TASK DEVICE TABLE (DUMMY) 
* 
	EJECT			LDTASK 
* 
* 
**********
* LT:SWB *
**********
* 
* 
*   LT:SWB HANDLES THE LOADING/STORING OF SWAPPABLE WORK BLOCKS.
* 
*   INPUT:  A1 = SWAPPABLE WORK BLOCK ADDRESS 
*           A3 = TTAB ADDRESS OF CALLING TASK 
*	   A4 = LKM DATA DIRECTIVE
* 
* 
LT:SWB	EQU	*	LDTASK SWB HANDLING ENTRY
	IFT	SWPBLK=1 
	IFT	MMUPAG=1 
	INH
	LDKL	A5,TTABLD	LDTASK TTAB ADDRESS 
	TL	TTB:MT,A3	LOAD MMU WITH CALLING TASK
	TS	TTB:MT,A5	STORE IN LDTASK MMU TABLE 
	ENB
	XIF
* 
	IFT	SWPBLK=1 
	LDR	A5,A3	TTAB ADDRESS OF CALLING TASK 
	LDR	A7,A4	LKM DATA DIRECTIVE 
	SUR	A9,A9	INDICATE SWB HANDLING (NO SEGBLK)
	LDR*	A3,A1	DISC ADDRESS OF FIRST COPY
	ANK	A3,/FF 
	LD	A4,SWB:DS,A1
	LD	A6,SWB:EL,A1	SWB COPY LENGTH (BYTES)
	LD	A2,SWB:NS,A1	SWB COPY LENGTH (SECTORS)
* 
	EJECT			LDTASK 
* 
*	COMPUTE DISC ADDRESS OF REQUESTED SWB 
* 
	LD	A1,TTB:SA+14,A5 
	ANK	A1,/FF	SWB COPY INDEX
* 
LTS:10	EQU	*
	SUK	A1,1 
* 
	IFT	CPU852=1 
	RF(NP)	LTS:20
	ADR	A4,A2	COMPUTE DISC ADDRESS OF REQUESTED SWB
	RF(O)	LTS:15	OVERFLOW
	RB	LTS:10
* 
LTS:15	EQU	*	OVERFLOW CORRECTION
	ADK	A3,1 
	ANKL	A4,/7FFF
	RB	LTS:10
* 
LTS:20	EQU	*
	LDR	A1,A3	DISC ADDRESS OF REQUESTED SWB
	LDR	A2,A4
	XIF
* 
	IFT	SWPBLK=1 
	IFT	CPU852=0 
	MUR	A1 
	DAR	A3 
	XIF
* 
	EJECT			LDTASK 
* 
* 
	IFT	SWPBLK=1 
	LD	A3,TTB:SA+16,A5	MEMORY ADDRESS (LOGICAL)
	ADK	A6,1 
	LDR	A4,A6
	LD	A12,SCTIPL	SWB DISC FILE CODE 
	SUK	A7,19	CHECK LKM DATA DIRECTIVE 
	RF(Z)	LTSWB1	LOAD SWB
	LDKL	A4,/7FFF	PARAMETER TO AVOID INTERMEDIATE BUFFER 
	LDK	A7,/95	PHYSICAL WRITE
	RF	LTSWB2	STORE SWB
	XIF
* 
	EJECT			LDTASK 
* 
* 
**********
* LT:DSK *
**********
* 
* 
*   LT:DSK PERFORMS LOADING OF DISC RESIDENT SEGMENTS INTO CORE.
* 
*   INPUT:  A1 = SEGMENT BLOCK ADDRESS
*           A3 = TTAB ADDRESS OF CALLING TASK 
* 
* 
LT:DSK	EQU	*	LDTASK DISC PAGING ENTRY 
	LDR	A5,A3	TTAB ADDRESS OF CALLING TASK 
	LDR*	A2,A1	SEGMENT STATUS
	RF(NN)	LTD:05	SEGMENT NOT LOADED IN CORE 
* 
*	UPDATE MMU TABLE FOR CALLING TASK (IF MMU), 
*	UPDATE CURRENT SEGMENT BASE,
*	AND REMOVE PAGE FROM PAGQUE.
* 
	LDR	A7,A3	TTAB ADDRESS 
	INH
	CF	A15,TLSEG1
	LDR	A5,A7	TTAB ADDRESS OF CALLING TASK 
	ABL	QMEXIT	QUEUE TASK AND EXIT LDTASK
* 
	EJECT			LDTASK 
* 
*	NO PAGE AVAILABLE. PAUSE LDTASK UNTIL RESTARTED 
*	BY RELPAG WHEN PAGE AVAILABLE AGAIN.
* 
LTD:00	EQU	*
	IM	PQEMTY	INDICATE PAGE QUEUE EMPTY
	LKM
	DATA	5	PAUSE LDTASK
* 
*	TAKE LEAST RECENTLY USED PAGE FROM PAGQUE 
* 
LTD:05	EQU	*
	LD	A2,PAGQUE+2 
	CWK	A2,PAGQUE
	RB(E)	LTD:00	NO PAGE AVAILABLE 
* 
	EJECT			LDTASK 
* 
*	TAKE FOUND PAGE OUT OF PAGQUE 
* 
	INH
	LD	A4,PAG:QB,A2	ADDRESS TO NEXT PAGE BLOCK 
	ST	A4,PAGQUE+2	UPDATE QUEUE ANCHOR 
	LDR*	A6,A2	PAGQUE ADDRESS
	STR	A6,A4	UPDATE QUEUE LINK FORWARD NEXT BLOCK 
	CMR	A2	RESET QUEUE LINK FORWARD THIS BLOCK 
	LD	A4,PAG:SB,A2	OLD SEGMENT BLOCK ADDRESS
	RF(Z)	LTD:10 
	LDKL	A6,/7FFF
	ANRS	A6,A4	INDICATE SEGMENT NOT LOADED ANYMORE 
* 
*	CONNECT PAGBLK AND SEGBLK 
* 
LTD:10	EQU	*
	ST	A2,SEG:PB,A1	SET NEW PAGE BLOCK ADDRESS 
	ST	A1,PAG:SB,A2	SET NEW SEGMENT BLOCK ADDRESS
* 
	IFT	MMUPAG=1 
* 
*	UPDATE MMU TABLE FOR CALLING TASK AND LDTASK
* 
	LDKL	A3,TTABLD	LDTASK TTAB ADDRESS 
	MS	5,TTB:SA+2,A3	SAVE A1-A5 IN TTAB SAVE AREA
	TL	TTB:MT,A5	LOAD MMU WITH CALLING TASK
	TS	TTB:MT,A3	STORE IN LDTASK MMU TABLE 
	LD	A1,TTB:CB,A5	CURRENT SEGMENT BASE ADDRESS 
	ST	A1,TTB:CB,A3
	LD	A1,TTB:AP,A5	GET ACB ADDRESS
	ST	A1,TTB:AP,A3	STORE IN LDTASK'S TTAB 
	LDR	A1,A2
	LDR	A5,A3	LDTASK TTAB ADDRESS
	CF	A15,TLSEG2	UPDATE MMU TABLE FOR LDTASK
	TS	TTB:MT,A5	STORE NEW MMU TABLE FOR CALLING TASK
	XIF
* 
	EJECT			LDTASK 
* 
*	PREPARE FOR READING OF SEGMENT
* 
	ENB
	LD	A3,PAG:PA,A2	PAGE ADDRESS (PHYSICAL)
	LD	A4,SCTPSZ	PAGE SIZE 
	LD	A6,SEG:EL,A1	SEGMENT LENGTH 
	LDR	A9,A1	SAVE SEGMENT BLOCK ADDRESS 
	LD	A12,TTB:SP,A5	SEGTAB ADDRESS
	LD	A12,SEG:FC,A12	SEGMENT DISC FILE CODE 
* 
	IFT	CPU852=1 
	LD	A2,SEG:DS,A1	SEGMENT DISC ADDRESS 
	LDR*	A1,A1 
	XIF
* 
	IFT	CPU852=0 
	MLR	2,A9	DISC SECTOR ADDRESS 
	XIF
* 
	IFT	MMUPAG=0 
	ST*	A3,TTB:CB,A5	UPDATE CURRENT SEGMENT BASE 
	XIF
* 
	EJECT			LDTASK 
* 
* 
	IFT	SWPBLK=1 
* 
* 
**********
* LTSWB1 *
* LTSWB2 *
**********
* 
* 
*   ENTRIES USED BY LDTASK WHEN ACTIVATED AT LT:SWB.
*   BELOW THIS POINT SWB HANDLING IS SIMILAR TO 
*   DISC PAGING HANDLING. 
* 
*   INPUT:  A1 = DISC SECTOR NUMBER, PART 1 
*           A2 =  "      "      "  , PART 2 
*           A3 = MEMORY ADDRESS (LOGICAL) 
*           A4 = SWB SIZE (BYTES) 
*           A5 = TTAB ADDRESS CALLING TASK
*           A6 = SWB SIZE (BYTES) 
*           A7 = ORDER CODE, PHYSICAL WRITE (LTSWB2 ONLY) 
*           A9 = 0 (INDICATES SWB HANDLING BY SETTING SEGBLK ADDRESS = 0) 
*          A12 = DISC FILE CODE 
* 
* 
	XIF
* 
LTSWB1	EQU	*	ENTRY USED BY LT:SWB 
	ANK	A1,/FF 
	LDK	A7,/91	PHYSICAL READ 
* 
	EJECT			LDTASK 
* 
* 
LTSWB2	EQU	*	ENTRY USED BY LT:SWB 
	SRL	A4,1 
	LDR	A11,A4	PAGE/SWB SIZE (WORDS) 
	SRL	A6,1 
	LDR	A10,A6	SEGMENT/SWB SIZE (WORDS)
* 
*	SET ECB PARAMETERS
* 
	LDKL	A8,LD:ECB	LD:ECB ADDRESS
	STR	A12,A8	SET DISC FILE CODE IN ECB 
	CM	ECBEL,A8	RESET EFFECTIVE LENGTH 
	LDR	A12,A3 
	LDKL	A14,LD:STB	LDTASK STACK BASE
* 
	IFT	CPU852=1 
	ST	A1,ECBCW1,A8	SET SECTOR NUMBER IN ECB 
	ST	A2,ECBCW2,A8
	XIF
* 
	IFT	CPU852=0 
	MS	2,ECBCW1,A8	SET SECTOR NUMBER IN ECB
	XIF
* 
	EJECT			LDTASK 
* 
* 
	IFT	MMUPAG=1 
	ECR	A1,A3
* 
	IFT	SWPBLK=1 
	LDR	A9,A9	CHECK SEGBLK ADDRESS (=0 IF SWB) 
	RF(NZ)	LTD:30	DISC PAGING REQUEST
* 
	EJECT			LDTASK 
* 
*	SWB: CONVERT LOGICAL ADDRESS TO PHYSICAL
* 
	SRL	A1,3 
	ANK	A1,/1E	MMUTAB INDEX (5 BITS) 
	ADR	A1,A5	ADD TTAB ADDRESS 
	LC	A1,TTB:MT,A1	PHYSICAL PAGE ADDRESS
	LDR	A2,A1
	ANK	A2,/3C 
	SRC	A2,6 
	ANKL	A3,/FFF 
	ORR	A3,A2
	RF	LTD:40
	XIF
* 
LTD:30	EQU	*
	IFT	MMUPAG=1 
* 
*	SEGMENT: CONVERT PHYSICAL ADDRESS TO LOGICAL
* 
	SLL	A3,2 
	LD	A2,TTB:AP,A5	ACB ADDRESS
	LDR	A12,A3 
	ANKL	A12,/FFF	CONVERT PHYSICAL ADDRESS TO LOGICAL
	OR	A12,ACBLAP,A2 
* 
LTD:40	EQU	*
	SRL	A1,2 
	ANK	A1,/30 
	SCR	A1,A8
	XIF
* 
	EJECT			LDTASK 
* 
* 
	ST	A3,ECBBA,A8	SET BUFFER ADDRESS
* 
	IFT	SWPBLK=1 
	LDR	A9,A9	CHECK SEGBLK ADDRESS (=0 IF SWB) 
	RF(Z)	LTD:45	SWB HANDLING
	XIF
* 
	IFT	ASMPAG=1 
	LDR*	A1,A9	SEGMENT STATUS
	SLL	A1,1	CHECK IF ASSEMBLER SEGMENT
	RF(N)	ASSPAG	YES, ASSEMBLER SEGMENT
	XIF
* 
*	COMPUTE REQUESTED LENGTH AND
*	CHECK IF ONE OR TWO LKM:S NECCESSARY
* 
LTD:45	EQU	*
	ADKL	A10,127	NEXT HIGHER MULTIPLE OF 128 
	ANKL	A10,/7F80 
	SUR	A4,A10	CHECK IF PAGE IS LARGE ENOUGH 
	RF(NN)	LTD:50	OK, JUST ONE LKM NEEDED
	LDR	A10,A6 
	ANKL	A10,/7F80	NEXT LOWER MULTIPLE OF 128
* 
LTD:50	EQU	*
	SUR	A6,A10	REMAINING LENGTH TO MOVE IN 2ND LKM 
	ADR	A10,A10	CONVERT LENGTH TO BYTES
	RF(Z)	LTD:55	INTERMEDIATE BUFFER NEEDED
	ST	A10,ECBRL,A8	SET REQUESTED LENGTH IN ECB
* 
	EJECT			LDTASK 
* 
*	READ/WRITE SEGMENT SWB
* 
	CF	A14,LD:IO	READ/WRITE SEGMENT/SWB
	ADK	A6,0	CHECK IF ANYTHING LEFT TO READ/WRITE
	RF(NP)	LDEXIT	SEGMENT/SWB HANDLING FINISHED
* 
LTD:55	EQU	*
	CF	A14,LDSECT	READ AND MOVE LAST PART OF SEGMENT/SWB 
* 
*	COMMON EXIT FOR DISC PAGING, ASSEMBLER PAGING 
*	AND SWAPPABLE WORK BLOCK HANDLING REQUESTS. 
* 
LDEXIT	EQU	*
	IFT	SWPBLK=1 
	LDR	A9,A9	CHECK SEGBLK ADDRESS (=0 IF SWB) 
	RF(Z)	LDEXI3	SWB HANDLING
	XIF
* 
	LDKL	A4,/8000	INDICATE SEGMENT SUCCESSFULLY LOADED 
* 
LDEXI2	EQU	*
	ORRS	A4,A9 
* 
LDEXI3	EQU	*
	ABL	QMEXIT	QUEUE TASK AND EXIT LDTASK
* 
	EJECT			LDTASK 
* 
* 
**********
* LD:IO  *
**********
* 
* 
*   LDTASK I/O ROUTINE FOR READING/WRITING FROM/TO DISC.
*   IF I/O ERROR IS DETECTED LOADING IS ABORTED AND THE 
*   PAGE IS INSERTED INTO PAGQUE AGAIN. CREDIT APPLICATIONS 
*   ARE RESTARTED AT THE SPECIFIED REENTER ADDRESS. 
* 
*   INPUT:  A5 = TTAB ADDRESS OF CALLING TASK 
*	   A7 = ORDER CODE
*	   A8 = LD:ECB ADDRESS
*	   A9 = SEGBLK ADDRESS (=0 IF SWB)
* 
*   OUTPUT: A2 IS DESTROYED 
* 
* 
LD:IO	EQU	* 
	LKM
	DATA	1 
* 
*	CHECK RETURN CODE AND ABORT IF ERROR
* 
	LD	A2,ECBRC,A8	RETURN CODE 
	ANKL	A2,/FEFF	SKIP RETRY BIT 
	RF(NZ)	LDIO10	DISC ERROR 
	RTN	A14	NO, RETURN 
* 
	EJECT			LDTASK 
* 
*	ERROR: SET RETURN CODE IN A7 OF CALLING TASK
* 
LDIO10	ANK	A2,1 
	NGR	A2,A2
	SUK	A2,2	ERROR, SET RETURN CODE -2 OR -3 
 	ST	A2,TTB:SA+14,A5	SET RETURN CODE IN A7
* 
	IFT	SWPBLK=1 
	LDR	A9,A9	CHECK SEGBLK ADDRESS (=0 IF SWB) 
	RB(Z)	LDEXI3	SWB HANDLING
	XIF
* 
*	INSERT PAGE IN PAGQUE AGAIN 
* 
	LD	A3,SEG:PB,A9	PAGE BLOCK ADDRESS 
	INH
	CF	A15,RELPA2	RELEASE PAGE 
* 
	IFT	ASMPAG=1 
	LDR*	A4,A9	SEGMENT STATUS
	SLL	A4,1	CHECK IF ASSEMBLER SEGMENT
	RF(N)	LDIO20	YES, ASSEMBLER SEGMENT
	XIF
* 
	LD*	A4,TTB:AP,A5	APPLICATION RESTART ADDRESS 
	ST	A4,TTB:SA,A5	SET NEW DISPATCH ADDRESS 
* 
LDIO20	EQU	*
	LDKL	A4,/100	SEGMENT ERROR BIT 
	RB	LDEXI2
* 
	EJECT			LDTASK 
* 
* 
	IFT	ASMPAG=1 
* 
* 
**********
* ASSPAG *
**********
* 
* 
*   THIS ENTRY IS CALLED FROM THE LDTASK MAIN FLOW
*   WHEN LOADING OF AN ASSEMBLER SEGMENT IS WANTED. 
*   ASSPAG WILL READ ONE SECTOR AT A TIME AND 
*   PERFORM THE NECESSARY RELOCATIONS.
* 
*   INPUT:  A5 = TTAB ADDRESS OF CALLING TASK 
*	   A7 = ORDER CODE, PHYSICAL READ (/91) 
*	   A8 = LD:ECB ADDRESS
*	   A9 = SEGBLK ADDRESS
*	  A10 = SEGMENT LENGTH (WORDS)
*	  A11 = PAGE SIZE (WORDS) 
*	  A12 = PAGE ADDRESS (RELOCATION BASE)
* 
* 
ASSPAG	EQU	*	ASSEMBLER PAGING ENTRY 
	LDK	A1,1 
	SC	A1,ECBRL,A8	REQUESTED LENGTH := 256 
* 
	IFT	MMUPAG=1 
	ST	A12,LD:LAD	SAVE LOGICAL ADDRESS TO PAGE 
	XIF
* 
	EJECT			LDTASK 
* 
* 
	IFT	ASMPAG=1 
* 
*	PREPARE FOR RELOCATION OF ONE SECTOR AND
*	CHECK REMAINING PAGE SIZE. IF NOT LARGE ENOUGH
*	THEN READ (LAST) SECTOR TO INTERMEDIATE BUFFER, 
*	ELSE READ SECTOR DIRECTLY TO ALLOCATED PAGE.
* 
ASS:00	EQU	*	ASSEMBLER PAGING MAIN LOOP ENTRY 
	IFT	MMUPAG=0 
	LD	A1,ECBBA,A8	SEGMENT POINTER 
* 
	XIF
* 
	IFT	ASMPAG=1 
	IFT	MMUPAG=1 
	LD	A1,LD:LAD	GET LOGICAL ADDRESS POINTER 
	XIF
* 
	IFT	ASMPAG=1 
	CWK	A11,128	CHECK REMAINING PAGE SIZE
	RF(L)	ASS:85	INTERMEDIATE BUFFER NEEDED
	SUKL	A11,120	REMAINING PAGE SIZE 
	CF	A14,LD:IO	READ SECTOR 
	LDK	A2,240	CALC ADDRESS TO RELOCATION BITS 
	CWK	A10,120
	RF(NL)	ASS:02
	LDR	A2,A10 
	ADR	A2,A2
* 
ASS:02	EQU	*
	ADR	A2,A1
* 
	EJECT			LDTASK 
* 
*	RELOCATE ONE SEGMENT SECTOR 
* 
ASS:05	EQU	*
	SRL	A2,1	WORD ADDRESS
	LDR	A13,A2	RELOCATION END, THIS SECTOR 
	SLL	A2,1 
* 
ASS:10	EQU	*
	LDK	A3,16	RELOCATION BITS COUNTER
* 
	IFT	MMUPAG=1 
	LDR	A8,A8	CHECK WHERE TO FIND RELOCATION BITS
	RF(Z)	ASS:15	RELOCATION BITS IN LD:BUF 
	ELR	A4,A2	16 RELOCATION BITS 
	RF	ASS:20
	XIF
* 
	IFT	ASMPAG=1 
ASS:15	EQU	*
	LDR*	A4,A2	16 RELOCATION BITS
* 
ASS:20	EQU	*
	RF(NZ)	ASS:40	RELOCATION NEEDED
* 
ASS:25	EQU	*
	LDR	A6,A3	NUMBER OF RELOCATION BITS TO SKIP
	RF	ASS:45
* 
	EJECT			LDTASK 
* 
* 
ASS:30	EQU	*
	SLL	A4,1	NEXT RELOCATION BIT TO TEST 
	RB(Z)	ASS:25	NEXT RELOCATION WORD
* 
ASS:40	EQU	*
	RF(N)	ASS:50	RELOCATION NEEDED 
	SLN	A4,A6	SKIP ALL ZERO BITS 
	ADK	A1,2	INCREMENT SEGMENT POINTER 
* 
ASS:45	EQU	*
	SUR	A3,A6	UPDATE RELOCATION BITS COUNTER 
	SRL	A1,1	WORD ADDRESS FOR SEGMENT POINTER	=1 
	ADR	A1,A6	UPDATE SEGMENT POINTER (WORD)	=1 
	RF(O)	ASS:70	ALL RELOCATED,END OF SECTOR	=1
	SLL	A1,1	BYTE ADDRESS FOR SEGMENT POINTER	=1 
	RF	ASS:60	GO AND CHECK IF END OF SECTOR
* 
	EJECT			LDTASK 
* 
*	RELOCATE ONE WORD 
* 
ASS:50	EQU	*
	IFT	MMUPAG=0 
	ADRS	A12,A1	ADD RELOCATION BASE
	XIF
* 
	IFT	ASMPAG=1 
	IFT	MMUPAG=1 
	ELR	A6,A1	WORD TO RELOCATE 
	ADR	A6,A12	ADD RELOCATION BASE 
	ESR	A6,A1	STORE RELOCATED WORD 
	XIF
* 
	IFT	ASMPAG=1 
	ADK	A1,2	INCREMENT SEGMENT POINTER 
* 
*	CHECK IF END OF SECTOR OR IF NEW RELOCATION WORD NEEDED 
* 
ASS:60	EQU	*
	LDR	A6,A1	SEGMENT POINTER
	SRL	A6,1	WORD ADDRESS
	SUR	A6,A13	COMPARE WITH END OF REL. ADDRESS	=2 
	ADK	A6,0	SET CR	=2 
	RF(NN)	ASS:70	END OF SECTOR	=2 
	SUK	A3,1	DECREMENT RELOCATION BITS COUNTER 
	RB(P)	ASS:30	MORE RELOCATION BITS
	ADK	A2,2	INCREMENT RELOCATION BITS POINTER 
	RB	ASS:10	NEXT RELOCATION BITS WORD
* 
	EJECT			LDTASK 
* 
*	RETURN IF SEGMENT LOADING IS COMPLETED, 
*	ELSE PREPARE FOR READING OF NEXT SECTOR.
* 
ASS:70	EQU	*
	SUKL	A10,120	DECREMENT SEGMENT LENGTH
	RB(NP)	LDEXIT	SEGMENT LOADING COMPLETED
	LDK	A4,240 
* 
	IFT	MMUPAG=0 
	ADS	A4,ECBBA,A8	UPDATE PAGE ADDRESS
	XIF
* 
	IFT	ASMPAG=1 
	IFT	MMUPAG=1 
	ADS	A4,LD:LAD	UPDATE LOGICAL ADDRESS POINTER 
	LDK	A3,0 
	MLR	2,A8	BUFFER ADDRESS
	SLC	A1,4 
	DLL	1
	SRL	A2,1 
	DAR	A3 
	SLL	A2,1 
	DRL	1
	SRC	A1,4 
	MSR	2,A8	SET UPDATED BUFFER ADDRESS IN ECB 
	XIF
* 
	EJECT			LDTASK 
* 
* 
	IFT	ASMPAG=1 
	IM	ECBCW2,A8	INCREMENT SECTOR NUMBER 
	RF(O)	ASS:80	OVERFLOW
	RB	ASS:00	READ NEXT SECTOR TO PAGE 
* 
ASS:80	EQU	*
	LDKL	A4,/7FFF	OVERFLOW CORRECTION
	ANS	A4,ECBCW2,A8 
	IM	ECBCW1,A8 
	RB	ASS:00	READ NEXT SECTOR TO PAGE 
* 
	EJECT			LDTASK 
* 
*	READ LAST SECTOR TO INTERMEDIATE BUFFER.
*	MOVE CODE BUT NOT RELOCATION BITS TO PAGE.
* 
ASS:85	EQU	*
	LDR	A13,A10	SAVE REMAINING SEGMENT LENGTH
	LDR	A6,A10 
	LDR	A11,A12	SAVE RELOCATION BASE 
	LDR	A12,A1	ACTUAL PAGE ADDRESS 
	SUR	A10,A10	MEANS,DON'T UPDATE SEC NBR IN LDSEC2 
	CF	A14,LDSEC2	READ SECTOR AND MOVE IT TO PAGE
	LDR	A1,A12	LOGICAL ADDRESS OF CODE TO RELOCATE 
	LDR	A10,A13
	LDR	A2,A13	REMAINING SEGMENT LENGTH (WORDS)
	ADR	A2,A2	DISPL. IN SECTOR TO RELOCATION BITS
	ADKL	A2,LD:BUF	ADDRESS TO RELOCATION BITS
* 
	IFT	MMUPAG=1 
	SUR	A8,A8	INDICATE RELOCATION BITS IN LD:BUF 
	XIF
* 
	IFT	ASMPAG=1 
	SRL	A1,1 
	ADR	A13,A1	VIRTUAL BEGINNING OF RELOCATION BITS
	LDR	A1,A12	LOGICAL ADDRESS OF CODE TO RELOCATE 
	LDR	A12,A11	RESTORE RELOCATION BASE
	RB	ASS:10	RELOCATE LAST SECTOR AND RETURN
	XIF
* 
	EJECT			LDTASK 
* 
* 
**********
* LDSECT *
* LDSEC2 *
**********
* 
* 
*   NOT ROOM ENOUGH IN PAGE FOR LAST SECTOR:
*   READ IT TO MEMORY VIA INTERMEDIATE BUFFER 
* 
*   INPUT:  A6 = NO OF WORDS TO MOVE
*           A8 = LD:ECB ADDRESS 
*	   A9 = SEGBLK ADDRESS (=0 IF SWB)
*          A10 = EFFECTIVE LENGTH, LAST I/O 
*          A12 = LAST USED PAGE ADDRESS, LOGICAL (LDSECT ONLY)
*	      = ACTUAL PAGE ADDRESS, LOGICAL (LDSEC2 ONLY)
* 
*   OUTPUT: A6 = 0
*          A12 = ACTUAL PAGE ADDRESS (LOGICAL)
*           A1-A4, A7, A10 ARE DESTROYED
* 
* 
LDSECT	EQU	*
	ADR	A12,A10	UPDATE DESTINATION POINTER 
* 
	EJECT			LDTASK 
* 
*	SET ECB PARAMETERS
* 
LDSEC2	EQU	*
	IFT	CPU852=1 
	LDKL	A1,LD:BUF	LDTASK BUFFER ADDRESS 
	ST	A1,ECBBA,A8 
	LDK	A2,/80 
	SCR	A2,A8	INDICATE BUFFER NOW IN SYSTEM AREA 
	ADK	A2,/80	A2 := 256 
	ST	A2,ECBRL,A8	SET REQUESTED LENGTH TO ONE SECTOR
	LDKL	A4,/7FFF
	XIF
* 
	IFT	CPU852=0 
	MLK	4
	DATA	LD:BUF,256
	DATA	/80,/7FFF 
	SCR	A3,A8	INDICATE BUFFER NOW IN SYSTEM AREA 
	MS	2,ECBBA,A8	SET BUFFER AND REQUESTED LENGTH
	XIF
* 
	ECR	A2,A10 
	ADS	A2,ECBCW2,A8	UPDATE SECTOR NUMBER
	RF(O)	LDS:30	OVERFLOW
* 
LDS:10	EQU	*
	CF	A14,LD:IO	READ ONE SECTOR TO LD:BUF 
	LDR	A2,A12	DESTINATION POINTER 
	ADR	A6,A6	CONVERT LENGTH TO BYTES
* 
	EJECT			LDTASK 
* 
*	MOVE LAST PART OF SEGMENT/SWB 
* 
	IFT	MMUPAG=1 
	MVSU	A6	MOVE LAST PART OF SEGMENT/SWB
	XIF
* 
LDS:20	EQU	*
	IFT	MMUPAG=0 
	IFT	CPU852=1 
	LDR*	A10,A1	MOVE ONE WORD
	STR	A10,A2 
	ADK	A1,2	INCREMENT BUFFER POINTERS 
	ADK	A2,2 
	SUK	A6,2	DECREMENT COUNTER 
	RB(P)	LDS:20 
	XIF
* 
	IFT	MMUPAG=0 
	IFT	CPU852=0 
	IFT	CPU852=0 
	LDR*	A10,A1	MOVE ONE WORD
	STR	A10,A2 
	ADK	A1,2	INCREMENT BUFFER POINTERS 
	ADK	A2,2 
	SUK	A6,2	DECREMENT COUNTER 
	RB(P)	LDS:20 
	XIF
* 
	IFT	MMUPAG=0 
	IFT	CPU852=0 
	IFT	CPU857=1 
	MVB	A6	MOVE REMAINING PART OF SEGMENT TO PAGE
	XIF
* 
	RTN	A14
* 
LDS:30	EQU	*
	IM	ECBCW1,A8	OVERFLOW CORRECTION 
	ANS	A4,ECBCW2,A8 
	RB	LDS:10
* 
	EJECT			LDTASK 
* 
* 
**********
* QLTDSK *
* QLTSWB *
**********
* 
* 
*   THIS ROUTINE PERFORMS ACTIVATION OF THE LOAD TASK.
* 
*   ACTIVATION IS AT LT:DSK WHEN DISC PAGING REQUEST. 
*   ACTIVATION IS AT LT:SWB WHEN SWAPPABLE WORK BLOCK REQUEST.
* 
*   INPUT:  A1 = SEGMENT BLOCK ADDRESS (LT:DSK) 
*  	      = SWAPPABLE WORK BLOCK ADDRESS (LT:SWB) 
*           A3 = TTAB ADDRESS OF CALLING TASK 
*	   A4 = LKM DATA DIRECTIVE (LT:SWB) 
* 
*   OUTPUT: A2, A5 ARE DESTROYED
* 
* 
QLTSWB	EQU	*	ACTIVATE LDTASK AT ENTRY LT:SWB
	IFT	SWPBLK=1 
	LDKL	A2,LT:SWB	DISPATCH ADDRESS
	RF	QLTASK
	XIF
* 
	IFT	SWPBLK=0 
	ABL	LKMERR	INDICATE SYSGEN ERROR AND HALT SYSTEM 
	XIF
* 
QLTDSK	EQU	*	ACTIVATE LDTASK AT ENTRY LT:DSK
	LDKL	A2,LT:DSK	DISPATCH ADDRESS
* 
	EJECT			LDTASK 
* 
* 
QLTASK	EQU	*
	LDKL	A5,TTABLD	LDTASK TTAB ADDRESS 
	ABL	ACTOT	ACTIVATE LDTASK
* 
* 
* 
	END