.TITLE ILLCOD -- ILLEGAL INSTRUCTION CODE .IDENT /V1/ ; ; ; WRITTEN BY D.B.CURTIS ; SOFTWARE SUPPORT GROUP (R.S.) ; 14-JUN-79 ; FERMILAB ; ; ; VERSION 01 ; EDIT NUMBER = 0001 ; FILE = ILLCODE.MAC ; EDITED BY: D.B.CURTIS 19 JUL 79 11:02 ; ; ; MODIFICATIONS: ; ;+ ; FILE DESCRIPTION ; ; THIS FILE CONTAINS THE CODE THAT IS INSERTED INTO THE EXEC ; POOL AREA BY ISF. ; THIS CODE ALLOWS EXEC ENHANCEMENT BY THE USE OF ILLEGAL INSTRUCTIONS ; THE CODE MUST BE PIC AND LESS THEN 4096 WORDS LONG ;- ; .MCALL PCBDF$,TCBDF$ PCBDF$ ;DEFINE PCB OFFSETS TCBDF$ ;AND TCB OFFSETS .PAGE ;+ ; **-START-ILLEGAL INSTRUCTION CODE ; ; THIS CODE INTERCEPTS THE ILLEGAL INSTRUCTION TRAP ; IT CHECKS IF THE ILLEGAL INSTRUCTION IS ONE OF A NUMBER OF ; CODES AND IF NOT WILL TAKE THE NORMAL ILLEGAL INSTRUCTION ; MECHANISM ; OTHERWISE, A SYSTEM PROCESS IS CREATED WHICH DECODES THE INSTRUCTION ; AND ITS ARGUMENTS AND PERFORMS THE REQUIRED OPERATIONS. ; CURRENTLY, THE FOLLOWING FUNCTIONS EXIST LISTED BY CLASS: ; ; 1) LARGE ARRAY HANDLING ; 2) ?? ; ; INPUTS: ; PROCESSOR AT LEVEL 7 ; 2(SP) = TASK PS ; (SP) = TASK PC ; ; OUTPUTS: ; IF OPERATION ILLEGAL, ILLEGAL INSTRUCTION TRAP IS RETURNED TO THE ; REQUESTING TASK. ; OTHERWISE, ONLY THE RETURNS DOCUMENTED IN EACH CLASS OCCUR ; THESE FUNCTIONS ARE DOCUMENTED IN DOCUMENT # 70 ; ; SIDE EFFECTS: ; ; MODIFIED EXTERNALS ; NONE ; ; OTHER SIDE EFFECTS ; CAUSES A FORK WHICH IMPLIES THAT TASK SWITCHING IS STOPPED ; REMAINS IN SYSTEM STATE FOR PERHAPS SOME CONSIDERABLE TIME ; ; REGISTER USAGE: ; ;- ; ; ROUTINES CALLED ; ; $DIRSV - SWITCHES TO SYSTEM STATE FROM AN INTERRUPT ; $ILINS +4 - $ILINS IS THE ENTRY POINT TO THE ILLEGAL INTERRUPT POINT ; - $ILINS +4 IS JUST AFTER THE $DIRSV AT $ILINS ; - IE $ILINS:: JSR R5,$DIRSV ; ; ; EQUATED SYMBOLS ; ; ; LOCAL MACROS ; .MACRO MOVA,$ADDR,$REG ; ; MACRO TO PLACE AN ADDRESS OF A LABEL IN A REGISTER IN A POSITION ; INDEPENDENT MANNER ; MOV %7,$REG ADD #<$ADDR-.>,$REG .ENDM MOVA ; ; LOCAL DATA -- LOCAL DATA IS AT THE END OF THE MODULE ; .PAGE START: ; FIRST CHECK IF THE INSTRUCTION THAT CAUESD THE TRAP IS OURS MOV R5,-(SP) ;SAVE R5 MOV 2(SP),R5 ;GET PC OF ILL INSTRUCTION MFPI -(R5) ;GET INSTRUCTION CMP #210,(SP)+ ;CHECK IF OURS BEQ 1$ ;IF EQ YES ; IT IS A NORMAL ILLEGAL INSTRUCTION PASS IT TO THE SYSTEM MOV (SP)+,R5 ;ELSE EXIT JMP @START-4 ;NORMOLY ; OUR ILLEGAL INSTRUCTION RESTORE R5 AND BECOME A SYSTEM PROCESS 1$: MOV (SP)+,R5 ;RESTORE R5 JSR R5,@#$DIRSV ;MAKE SYSTEM PROCESS ; ; HERE IS THE KERNAL STACK AT THIS POINT ; WE ARE IN KERNAL STATE AT PROCESSOR PRIORITY 0 ; ; 20(SP) = TASK PS ; 16(SP) = TASK PC ; 14(SP) = R5 ; 12(SP) = R4 ; 10(SP) = R3 ; 6(SP) = R2 ; 4(SP) = R1 ; 2(SP) = R0 ; (SP) = PC ; ; CHECK IF THE ILLEGAL INSTRUCTION STACK HAS THE CORRECT FORMAT ; ; USERS STACK LOOKS LIKE: ; ; TYPE DEPENDENT INFORMATION ABOVE ; 10(SP) = INDEX HIGH PART ; 6(SP) = INDEX LOW PART ; 4(SP) = REGION ID WORD ; 2(SP) = FUNCTION TYPE ; (SP) = RAD50 REPRESENTATION OF "ILL" ; ; CHECK THAT STACK HAS CODE WORD ; **** NOTE R3 WILL SOON EQUAL THE USERS STACK **** ; **** DO NOT USE AS SCRATCH **** MFPI SP ;GET THE USERS STACK POINTER MOV (SP)+,R3 ;AND PUT IN R3 MFPI (R3)+ ;CHECK IF FORMAT IS CORRECT CMP (SP)+,#^RILL ;FIRST WORD ON STACK MUST BE RAD50 ILL BNE FERROR ;IF NOT TREAT AS ILLEGAL INSTRUCTION ; NOW GET THE TYPE ARGUMENT MFPI (R3)+ ;GET THE TYPE ON THE STACK MOV (SP)+,R0 ;AND GET IT CMP #4,R0 ;IS IT PAST MAX? BLO FERROR ;IF LO YES TREAT AS ILLEGAL INSTRUCTION ; GENERATE DISPATCH ADDRESS ASL R0 ;MAKE BYTE INDEX MOVA DISP,R1 ;GET ADDRESS OF DISPATCHER MOV R1,R2 ;SAVE DISPATCHER INDEX ADD R0,R1 ;SET INDEX ADD (R1),R2 ;NOW HAVE GENERATED ADDRESS MOV R2,TYPE ;SAVE JMP ADDRESS ; CHECK REGION ID TO SEE IF REGION EXISTS AND ATTACHED TO THIS TASK MFPI (R3)+ ;GET REGION ID MOV (SP)+,R4 ;SAVE IN R4 MOV @#$TKTCB,R5 ;GET CURRENT TCB ADDRESS CALL SRID ;CHECK IF REGION ID EXISTS ;AND ATTACHED TO TASK BCS FERROR ; ERROR TREAT AS ILLEGAL INSTRUCTION ; GENERATE INDEX INTO REGION MOV A.PCB(R4),R4 ;POINT TO PCB MFPI (R3)+ ;GET LOW INDEX MFPI (R3)+ ;GET HIGH PART OF INDEX MOV (SP)+,IDXH ;DO NOT ALLOW LARGER THEN 32K WORD ;AT THIS TIME BEQ 2$ ADD #2,SP ;ADJUST STACK BACK BR FERROR ;ILLEGAL INSTRUCTION ERROR ONCE AGAIN 2$: MOV (SP),R0 ;GET THE LOW PART OF THE INDEX BIT #1,R0 ;CHECK AND ABORT ODD ADDRESS BNE 4$ MOV R0,IDXL ;SAVE THE INDEX LOW PART ASH #-6,R0 ;MAKE BLOCK ADDRESS CMP P.SIZE(R4),R0 ;CHECK SIZE BHI 3$ ;IF HI OK ELSE GENERATE A 4$: ADD #2,SP ; CARRY SET ON TASK RETURN BR ERROR ; BY BRANCHING TO ERROR THIS TIME ; GENERATE APR 6 MAPPING INTO REGION 3$: BIC #1,22(SP) ;CLEAR CARRY ASSUMING IT ALL WORKS MOV P.REL(R4),R0 ;POINT TO ADDRESS MOD 64. BYTES MOV (SP)+,R1 ;GET INDEX BIC #^C77,R1 ;AND EXTRACT OFFSET INTO BLOCK BIS #140000,R1 ;AND MAKE AN APR 6 ADDRESS MOV @#KISAR6,-(SP) ;SAVE APR6 MAPPING MOV R0,@#KISAR6 ;AND MAP TO REGION JMP @TYPE ;DISPATCH DISP: .WORD F0-DISP ;READ SINGLE WORD .WORD F1-DISP ;WRITE SINGLE WORD .WORD F2-DISP ;READ BLOCK .WORD F3-DISP ;WRITE BLOCK .WORD F4-DISP ;SET BLOCK FERROR: JMP @#$ILINS+4 ;TAKE NORMAL ILLEGAL INSTRUCTION CODE ;EXIT NOTE THAT THE "NORMAL" EXIT IS AT ;$ILINS BUT HERE WE ARE AT SYSTEM STATE ;THE INSTRUCTION AT $ILINS IS A ;"JSR R5,$DIRSV" WHICH WE HAVE ALREADY ;DONE. SO MUCH FOR COMMENTING THIS TRICK F0: ;READ SINGLE WORD ;RESULT RETURNED ON USERS STACK MOV (R1),-(SP) ;GET VALUE MTPI -(R3) ;RETURN VALUE BR LEAV F1: ;WRITE SINGLE WORD ; USERS STACK ARGUMENT 12(SP) = WORD TO WRITE MFPI (R3)+ ;GET VALUE MOV (SP)+,(R1) ;SAVE VALUE BR LEAV F2: ;READ BLOCK ; USERS STACK 12(SP) = VIRTUAL ADDRESS TO TRANSFER BLOCK ; 14(SP) = NUMBER OF BYTES TO TRANSFER MFPI (R3)+ ;GET VERTUAL ADDRESS TO TRANSFER TO MFPI (R3)+ ;GET NUMBER OF BYTES TO TRANSFER CALL BCHK ; BLOCK CHECK BYTES AND INDEX BLOS LEAV1 ;ERROR EXIT MOV (SP)+,R0 ;PUT NUMBER OF BYTES IN R0 MOV (SP)+,R2 ;AND VERTUAL ADDRESS IN R2 ASR R0 ;CONVERT BYTES TO WORDS TST R0 ;PROTECT AGINST 0 LENGTH TRNASFER BEQ ERROR1 MOV R0,-(SP) ;SAVE R0 MOV @#250,MTA ;GET THE ORIGINAL MM ABORT VECTOR MOVA MTC,R0 ;GET THE ADDRESS OF THE MM TRAP ROUTINE MOV R0,@#250 ;AND RESET THE VECTOR MOV (SP)+,R0 ;AND RESTORE R0 ; ; THE ABOVE IS DONE TO PROTECT THE EXEC FROM GETTING A MAPPING ERROR ; FROM TRYING TO ACCESS PRIVALADGED PARTS TO THE USERS TASK IMAGE OR ; OUTSIDE OF THE USERS TASK IMAGE. ; SIMILAR STUFF WILL HAPPEN ON OTHER BLOCK TRANSFER OPERATIONS ; 2$: MOV (R1)+,-(SP) ;GET WORD MTPI (R2)+ ;PUT WORD SOB R0,2$ MOV MTA,@#250 ;RESET MM ABORT VECTOR BR LEAV F3: ;WRITE BLOCK ; USERS STACK 12(SP) = VIRTUAL ADDRESS TO TRANSFER BLOCK ; 14(SP) = NUMBER OF BYTES TO TRANSFER MFPI (R3)+ ;GET VERTUAL ADDRESS TO TRNASFER FROM MFPI (R3)+ ;GET NUMBER OF BYTES TO TRANSFER CALL BCHK ; BLOCK CHECK BYTES AND INDEX BLOS LEAV1 ;ERROR1 EXIT MOV (SP)+,R0 ;PUT BYTE COUNT IN R0 MOV (SP)+,R2 ;GET VERTAUL ADDRESS ASR R0 ;CONVERT TO WORDS BEQ ERROR1 MOV R0,-(SP) ;SAVE R0 MOV @#250,MTA ;GET THE ORIGINAL MM ABORT VECTOR MOVA MTC,R0 ;GET THE ADDRESS OF THE MM TRAP ROUTINE MOV R0,@#250 ;AND RESET THE VECTOR MOV (SP)+,R0 ;AND RESTORE R0 2$: MFPI (R2)+ MOV (SP)+,(R1)+ ;SAVE WORD SOB R0,2$ MOV MTA,@#250 ;RESET MM ABORT VECTOR BR LEAV F4: ;SET BLOCK ; USERS STACK 12(SP) = VALUE TO SET INTO AREA ; 14(SP) = NUMBER OF BYTES TO TRANSFER MFPI (R3)+ ;GET VALUE MFPI (R3)+ ;GET ADDRESS CALL BCHK ; BLOCK CHECK BYTES AND INDEX BLOS LEAV1 ;ERROR1 EXIT MOV (SP)+,R0 ;GET NUMBER OF BYTES TO TRANSFER MOV (SP)+,R2 ASR R0 ;CONVERT TO WORDS BEQ ERROR1 1$: MOV R2,(R1)+ SOB R0,1$ BR LEAV ; LEAV1 IS EXIT BECAUSE OF ILLEGAL ARGUMENTS--ONLY DONE AFTER BCHK LEAV1: ADD #4,SP ;CLEAN OFF STACK ; ERROR1 SETS THE USERS CARRY-- USED WHEN USERS ARGUMENTS ARE ALMOST CORRECT ERROR1: BIS #1,22(SP) ;SET THE USERS CARRY ; LEAVE IS THE NORMAL EXIT POINT LEAV: MOV (SP)+,@#KISAR6 ;RESTORE APR6 MAPPING MOV R3,-(SP) ;SET THE USERS STACK MTPI SP RETURN ERROR: BIS #1,20(SP) ;MAKE CARRY SET RETURN .PAGE ;+ ; **-SRID-SEARCH FOR REGION ID ; ; THIS ROUTINE SEARCHES THE ATTACHMENT QUEUE ON THE TCB TO SEE ; IF THE REQUESTED REGION ID IS VALID FOR THAT TCB ; ; INPUTS: ; R5 = POINTER TO TCB ; R4 = REGION ID ; ; OUTPUTS: ; CARRY SET INDICATES COULD NOT FIND REGION ID (ERROR CONDITION) ; CARRY CLEAR INDICATES ALL OK ; ; SIDE EFFECTS: ; ; MODIFIED EXTERNALS ; ; OTHER SIDE EFFECTS ; NONE ; ; REGISTER USAGE: ; R0 IS MODIFIED, RETURNS A.TCBL OF REGION ATTACHMENT OR 0 IF FAILED ; ;- SRID: MOV T.ATT(R5),R0 ;GET THE ATTACHMENT LIST ADD #A.TCBL,R4 ;POINT TO SUPPOSED ATTACHMENT TCB LINK 10$: CMP R0,R4 ;CHECK IF WE HAVE FOUND IT BEQ 30$ ;IF EQ YES MOV (R0),R0 ;ELSE ADVANCE TO NEXT ATTACHMNET BNE 10$ ;IF EQ REACHED END AND WE HAVE ERRORED SUB #A.TCBL,R4 ;ADJUST R4 AGAIN SEC ;SET CARRY TO SHOW ERROR BR 31$ ;LEAVE 30$: SUB #A.TCBL,R4 ;ADJUST R4 AGAIN CLC ;CLEAR CARRY 31$: RETURN ;RETURN .PAGE ;+ ; **-BCHK-BUFFER ADDRESS CHECK ; ; THIS ROUTINE CHECKS THAT AN INDEX AND BYTE COUNT DO NOT GENERATE ; AN ADDRESS OUTSIDE OF THE REGION ; ; INPUTS: ; 2(SP) = # BYTES ; (SP) = RETURN ADDRESS ; IDXL = LOW PART OF INDEX ; IDXH = HIGH PART OF INDEX ; R4 = POINTER TO PCB ; ; OUTPUTS: ; CONDITION CODES SET TO ALLOW A BLOS TO ERROR OUT ; ; REGISTER USAGE ; R0 IS MODIFIED ; ;- BCHK: CMP #4098.,2(SP) ;CHECK IF PAST MAX LENGTH BLOS 31$ ;IF LO YES MOV R1,-(SP) ;SAVE R1 MOV IDXL,R1 ;GET LOW PART OF INDEX MOV IDXH,R0 ;AND THE HIGH PART ADD 4(SP),R1 ;ADD ON THE BYTE COUNT ADC R0 ;IN A 32 BIT MANNER ASHC #-6,R0 ;MAKE 32. WORD BLOCKS MOV R1,R0 ;MOVE TO R0 MOV (SP)+,R1 ;RESTORE R1 CMP P.SIZE(R4),R0 ;CHECK SIZE 31$: RETURN .PAGE ; CODE TO INTERCEPT MEMORY MANAGEMENT TRAP ; MTC: BIT #340,2(SP) ;CHECK IF IN FORK BEQ 1$ ;IF EQ YES ELSE JMP @MTA ;TAKE NORMAL EXIT 1$: MOV #1,R0 ;STOP SOB LOOP BIC #170000,SR0 ;CLEAR ERROR BITS RTI ; ; ; L O C A L D A T A ; TYPE: .WORD 0 ;CONTAINS ADDRESS OR FUNCTION IDXH: .WORD 0 ;CONTAINS HIGH INDEX IDXL: .WORD 0 ;CONTAINS LOW INDEX MTA: .WORD 0 ;STORAGE FOR MM ABORT VECTOR .END