OS_Develop/dos_compilers
OS_Develop/dos_compilers
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
dos_compilers/Logitech Modula-2 v1/TRANSFER.ASM

817 lines
22 KiB
NASM
Raw Permalink Normal View History

Logitech Modula-2 v1.00
2024-07-01 00:16:10 +02:00
;**********************************************************************
;
; Copyrigth (C) 1984 Logitech. All Rights Reserved.
;
; Permission is hereby granted to registered users to use or
; abstract the following program in the implementation of
; customized versions. This permission does not include the
; right to redistribute the source code of this program.
;
;
; Modula-2/86 Run Time Support package
;
; TRANSFER.ASM - Process/Interrupt Module
;
; Release 1.0 - Jan 24 84
;
;*******************************************************
include RTS.INC
data segment public
extrn CUR_PROCESS:byte ;:ProcessDescriptor
extrn CUR_P_PTR:dword
extrn FCT_CODE:byte
WAITING_PROC dd 0FFFF000Fh
rept NBR_ISR-1
dd 0FFFF000Fh
endm
; Room for 8 process descriptors, waiting on an interrupt
INT_VECT_OWNER dw NBR_ISR dup ( NIL_CARD )
; This array holds for every used Interrupt Vector the program id of the owner
TEMP_W dd ?
TEMP_B dd ?
TEMP_P_D ProcessDescriptor <?> ; scratch process descrip.
MASK_8259 EQU 21H ; port address of control word 1
CTRL_W2_8259 EQU 20H ; port address of control word 2
EOI_8259 EQU 20H ; end-of-interrupt code
BASE_8259 EQU 08H ; first interrupt handled by 8259
MAX_PRIO_LEVEL EQU 07H ; priority levels 0..MAX_PRIO_LEVEL
;;; removed jan 24 84:
;OLD_MASK DB NBR_ISR DUP (?)
; ; holds for every ISR the old value of the mask-bit
;NEW_MASK DB NBR_ISR DUP (?)
; ; holds for every used ISR a 1 in the bit, which corresponds
; ; to the mask-bit in the 8259 or a value 0FFH if not handled
; ; by the 8259
PRIORITY_MASKS DB 1,3,7,0FH,1FH,3FH,7FH,0FFH
; his mask may be changed to implement any
; desired priority schema.
data ends
code segment public
extrn RTS_DS:word ; part of code segment
extrn NORM_ADDR:near
extrn COMP_STACK:near
extrn STACK_OVF:near
extrn TERMINATE:near
extrn SAVE_CPU_INFO:near
assume CS:code, DS:data
;------------------------------------------------------------
public TRANSFER
TRANSFER:
;========
; The registers needed for the TRANSFER are already saved.
; Swap the Return Address and the parameters: (interrupts better be off!)
MOV BP, SP
POP WORD PTR TEMP_W ; RetAdd
POP WORD PTR TEMP_W+2 ; RetCodeSeg
POP CUR_PROCESS.PD_FLAGS
; Move the parameters:
POP [BP]
POP 2[BP]
POP 4[BP]
POP 6[BP]
PUSH CUR_PROCESS.PD_FLAGS ; reconstruct interrupt frame
PUSH WORD PTR TEMP_W+2 ; underneath parameters!
PUSH WORD PTR TEMP_W ; flags, segment, offset
MOV CUR_PROCESS.PD_SP, SP ; save SP above parameters..
SUB SP, 8 ; Set SP so parameters can be popped
TRANSFER_BODY:
; This is the part of TRANSFER, that is used for all transfer
; functions: TRANSFER, IOTRANSFER, Interrupt Service Routines.
; Params: 0[SP] ADR of process variable of process to be activated,
; 4[SP] ADR of p. var., where to save the current one
; Get the addr of the NEW process descriptor and copy it into
; the TEMP_P_D area. This is required by the semantic of this function!
PUSH DS
POP ES ; Destination Segment
; In the parameter-list is the addr of the pointer (VARPAR):
POP DI
POP DS
LDS SI, dword ptr [DI]
; save the parameter for the assignement to CUR_P_PTR (see below):
MOV ES: WORD PTR TEMP_B, SI
MOV ES: WORD PTR TEMP_B + 2, DS
MOV DI, OFFSET TEMP_P_D
MOV CX, (size ProcessDescriptor)/2
REP MOVSW ; Copy it into the TEMP_P_D area
; Copy the current-one in the OLD process descriptor:
PUSH ES
POP DS
LES DI, CUR_P_PTR
MOV SI, OFFSET CUR_PROCESS
MOV CX, (size ProcessDescriptor)/2
REP MOVSW
; ... and update the varpar:
POP DI
POP ES ; This is the addr of the varpar
MOV SI,OFFSET CUR_P_PTR ; It holds the original of the P.D.
movsw
movsw
; Update interrupt mask in current process descriptor:
IN AL, MASK_8259
XOR AH, AH
MOV CUR_PROCESS.PD_PRIO_MASK, AX
; check if both processes have the same priority:
CMP AX, TEMP_P_D.PD_PRIO_MASK ; TEMP_P_D is the new one
JE PRIORITY_SET
; we have to change the processor's priority:
MOV AX, TEMP_P_D.PD_PRIO_MASK ; the new one
OUT MASK_8259, AL
PRIORITY_SET:
; Now, we copy the TEMP_P_D area into the CURRENT descriptor:
PUSH DS
POP ES
MOV SI, OFFSET TEMP_P_D
MOV DI, OFFSET CUR_PROCESS
MOV CX, (size ProcessDescriptor)/2
REP MOVSW
; ... and set the pointer to the new process:
MOV SI, OFFSET TEMP_B
MOV DI, OFFSET CUR_P_PTR
movsw
movsw
; Now, we restore the machine state:
MOV SS, CUR_PROCESS.PD_SS
MOV SP, CUR_PROCESS.PD_SP
MOV DS, CUR_PROCESS.PD_DS
PUSH DS ; We'll restore it at the very end
MOV AX, ES
MOV DS, AX
MOV ES, CUR_PROCESS.PD_ES
MOV DI, CUR_PROCESS.PD_DI
MOV SI, CUR_PROCESS.PD_SI
MOV BP, CUR_PROCESS.PD_BP
MOV DX, CUR_PROCESS.PD_DX
MOV CX, CUR_PROCESS.PD_CX
MOV BX, CUR_PROCESS.PD_BX
MOV AX, CUR_PROCESS.PD_AX
POP DS ; The new-one
IRET ; resume the new process!
; END TRANSFER
;------------------------------------------------------------
; Interrupt service routines:
; ==========================
; There is a fix number of interrupts, that can be treated simultanously.
; Here we allow up to 8 or 16 interrupts at a time, depending on the
; value of 'NBR_ISR'.
; The routines ISRn are the entry points to the common Interrupt
; Service Routine (COM_ISR).
; Every routine is 4 bytes long. This fact is used implicitly in COM_ISR
; and in IOTRANSFER. The Call to COM_ISR allows the identification of the
; Interrupt Vector (return addr of the Call).
ISR0: NOP
CALL COM_ISR
ISR1: NOP
CALL COM_ISR
ISR2: NOP
CALL COM_ISR
ISR3: NOP
CALL COM_ISR
ISR4: NOP
CALL COM_ISR
ISR5: NOP
CALL COM_ISR
ISR6: NOP
CALL COM_ISR
ISR7: NOP
CALL COM_ISR
IF NBR_ISR / 8
; This block of 8 Interrupt Service Routines has to be repeated for
; every additional 8259:
ISR8: NOP
CALL COM_ISR
ISR9: NOP
CALL COM_ISR
ISR10: NOP
CALL COM_ISR
ISR11: NOP
CALL COM_ISR
ISR12: NOP
CALL COM_ISR
ISR13: NOP
CALL COM_ISR
ISR14: NOP
CALL COM_ISR
ISR15: NOP
CALL COM_ISR
ENDIF
COM_ISR:
; Common part of the Interrupt Service Routines
; Save all the registers, except SP (has yet to be adjusted)
; and CS, IP, Flags. They are on the stack and will be
; used directly there (in the IRET of the next TRANSFER):
PUSH DS
MOV DS, RTS_DS
POP CUR_PROCESS.PD_DS
MOV CUR_PROCESS.PD_AX, AX
MOV CUR_PROCESS.PD_BX, BX
MOV CUR_PROCESS.PD_CX, CX
MOV CUR_PROCESS.PD_DX, DX
MOV CUR_PROCESS.PD_BP, BP
MOV CUR_PROCESS.PD_SI, SI
MOV CUR_PROCESS.PD_DI, DI
MOV CUR_PROCESS.PD_SS, SS
MOV CUR_PROCESS.PD_ES, ES
; Find the interrupt vector:
POP BX ; Return addr of ISRn
SUB BX, OFFSET ISR1 ; BX is index in table WAITING_PROC
; Complete the update of process descriptor:
MOV CUR_PROCESS.PD_SP, SP
POP CX ; just to get access to the Flags
POP DX
POP AX
MOV CUR_PROCESS.PD_FLAGS, AX
PUSH AX
PUSH DX
PUSH CX
; Push the parameters for the TRANSFER
LES SI, WAITING_PROC [BX] ; get address of PROCESS var
LES SI, ES:DWORD PTR [SI] ; get address of process descriptor
; the interrupted process:
PUSH ES: WORD PTR [SI].PD_INT_PROC+2
PUSH ES: WORD PTR [SI].PD_INT_PROC
; the waiting process:
PUSH WORD PTR WAITING_PROC+2 [BX]
PUSH WORD PTR WAITING_PROC [BX]
; A IOTRANSFER is valid only for 1 single interruption, so we have to
; free the corresponding Interrupt Vector:
CALL FREE_1_VECT
MOV DS, CS: RTS_DS
; Send a EOI to the 8259:
MOV AL, EOI_8259
OUT CTRL_W2_8259, AL
;;; removed jan 24 84:
; ; Before enabling interrupts, we mask the bit in the 8259
; ; that corresponds to the current interrupt:
; ; (BX holds number of used ISR * 2)
; SHR BX, 1 ; byte index
; MOV CL, NEW_MASK [BX]
; CMP CL, 0FFH ; NIL? i.e. not handled by 8259?
; JE INT_CTRL_MASKED
; MOV DL, OLD_MASK [BX]
; IN AL, MASK_8259 ; get current mask
; CMP DL, 0 ; was old bit set?
; JE RESET_BIT
; OR AL, CL ; set it
; JMP BIT_IS_OK
;RESET_BIT:
; NOT CL
; AND AL, CL ; reset it
;BIT_IS_OK:
; OUT MASK_8259, AL
;INT_CTRL_MASKED:
; at the end of the following TRANSFER we are performing
; an IRET, which enables the interrupts.
; Now, we're ready for a TRANSFER:
JMP TRANSFER_BODY
; END Interrupt Service Routines
;------------------------------------------------------------
page
public IOTRANSFER
IOTRANSFER:
;==========
; The registers needed for the TRANSFER are
; already saved.
; Swap the Return Address and the parameters:
MOV BP, SP
POP WORD PTR TEMP_W ; RetAdd
POP WORD PTR TEMP_W+2 ; RetCodeSeg
POP CUR_PROCESS.PD_FLAGS
; Move the paramaters:
POP AX
MOV [BP], AX
POP AX
MOV [BP]+2, AX
POP AX
MOV [BP]+4, AX
POP AX
MOV [BP]+6, AX
POP AX
MOV [BP]+8, AX
; Restore the Return Block:
PUSH CUR_PROCESS.PD_FLAGS
PUSH WORD PTR TEMP_W+2 ; RetCodeSeg
PUSH WORD PTR TEMP_W ; RetAdd
MOV CUR_PROCESS.PD_SP, SP
; Set SP so, that the parameters can be popped:
SUB SP, 10
POP BX ; Interrupt Vector
MOV CUR_PROCESS.PD_INT_VECT, BX
SHL BX, 1
SHL BX, 1
; BX is the offset of the Interrupt Vector
; Find a unused Interrupt Service Routine (ISRn), represented by
; a free entry in the array INT_VECT_OWNER:
MOV DI, OFFSET INT_VECT_OWNER
MOV AX, NIL_CARD
MOV CX, NBR_ISR
INC CX ; Increment it, so we can test for 0
REPNE SCASW ; Scan the array for a NIL
SUB DI, 2 ; It has already been incremented
MOV AX, OFFSET INT_VECT_OWNER
SUB DI, AX ; Get word index
CMP CL, 0
JNE FREE_INT_V
; There is no more free Interrupt Service Routine:
MOV CUR_PROCESS.PD_STATUS, INT_ERR_CODE
JMP TERMINATE
FREE_INT_V:
; BX is the offset of the Interrupt Vector
; DI is the index in INT_VECT_OWNER of
; the first free entry
; Put the program identifier in the array
; INT_VECT_OWNER (used to restore it upon
; termination):
MOV AX, CUR_PROCESS.PD_PROG_ID
MOV INT_VECT_OWNER [DI], AX
; Set in the P.D., where to save the running
; process, when Interrupt will occur. It is
; the 2nd parameter of IOTRANSFER = addr of
; proc. variable:
POP WORD PTR CUR_PROCESS.PD_INT_PROC
POP WORD PTR CUR_PROCESS.PD_INT_PROC + 2
; Put the current process in the array
; WAITING_PROC (the addr of process var):
MOV DX, DI ; save it
SHL DI, 1 ; a pointer-index
POP WORD PTR WAITING_PROC [DI]
POP WORD PTR WAITING_PROC + 2 [DI]
; Restore the parameters for the subsequent
; TRANSFER:
SUB SP, 8
; Save the requested Interrupt Vector and
; put the new one:
MOV AX, 0
MOV ES, AX
MOV AX, ES: [BX]
MOV CUR_PROCESS.PD_OLD_ISR, AX
MOV AX, ES: [BX] + 2
MOV CUR_PROCESS.PD_OLD_ISR + 2, AX
ADD DI, OFFSET ISR0
; Implicit use of the fact, that the ISRn have a size of 4 Bytes!
; DI is the address of the corresponding Interrupt Service Routine
MOV ES: [BX], DI
MOV ES: [BX] + 2, CS
;;; removed jan 24 84:
; ; Before making the TRANSFER, we are going to unmask the corres-
; ; ponding bit in the 8259 Interrupt Controller, to allow this
; ; interrupt to occur:
; ; (DX is the number of used ISR * 2)
; SHR DX, 1 ; byte index
; MOV DI, DX
; MOV NEW_MASK [DI], 0FFH ; NIL, used by ISR
; MOV AX, CUR_PROCESS.PD_INT_VECT
; SUB AX, BASE_8259 ; check, if this interrupt is
; JB INT_CTRL_READY ; handled by 8259
; CMP AX, NBR_ISR
; JAE INT_CTRL_READY
; ; it is handled by the 8259
; MOV CX, AX ; = level inside 8259
; MOV BX, 1 ; = mask for level 0
; SHL BX, CL ; = mask for actual level
; MOV NEW_MASK [DI], BL ;;;; temporarily: only 8 levels
; IN AL, MASK_8259 ; fetch old mask
; MOV CL, AL
; AND CL, BL ; get old value of this bit
; MOV OLD_MASK [DI], CL ; and save it
; ; now unmask the bit:
; NOT BL
; AND AL, BL
; OUT MASK_8259, AL
;INT_CTRL_READY:
; Execute a normal TRANSFER:
JMP TRANSFER_BODY ; No return here
; END IOTRANSFER
;------------------------------------------------------------
page
public NEWPROCESS
NEWPROCESS proc near
PUSH BP
MOV BP, SP
MOV AX, [BP] + 14 ; Offset of process workspace
MOV BX, [BP] + 16 ; Segment of it
MOV CX, AX
ADD CX, (size ProcessDescriptor) + 10 + 15
; Check, if there is room for process
; descr and 'free list header' for
; heap. 15 is needed to round up.
JNC SIZE_OK
JMP STACK_OVF
; Not even enough room for the workspace
SIZE_OK:
ADD AX, (size ProcessDescriptor) + 15
; Free space starts at the
; first paragraph after PD.
; 15 is to round up (worst case).
CALL NORM_ADDR
; Upon return:
; BX = normalised Segment of
; free mem (after P.D.)
; AX = Offset, < 16
; Set the initial values for the heap managment:
MOV TEMP_P_D.PD_HEAP_BASE + 2, BX
MOV TEMP_P_D.PD_HEAP_TOP + 2, BX
MOV TEMP_P_D.PD_HEAP_BASE, 0
MOV TEMP_P_D.PD_HEAP_TOP, 10
; size of a 'FreeElementPtr'
MOV ES, BX ; segment of heap
; put NILs in the header of Free List:
MOV ES: WORD PTR 0, NIL_OFF
MOV ES: WORD PTR 2, NIL_SEG
MOV ES: WORD PTR 4, NIL_OFF
MOV ES: WORD PTR 6, NIL_SEG
MOV ES: WORD PTR 8, 0
; size of free element (redundant)
; See comment under 'Fill in the Default
; Process Descriptor'. For a new process
; however, we must fully install an empty heap,
; since we can not call 'InstallHeap' as
; done in the initialization of the module
; Storage for the MAIN process.
; Compute the initial stack values:
MOV DX, (size ProcessDescriptor) + 15
MOV CL, 4
SHR DX, CL ; compute PD size in paragrafs
MOV AX, [BP] + 14 ; Get offset of Workspace
AND AX, 0FH
JZ SET_STACK ; We loose one paragraph for rounding
INC DX ; (stack and heap start at a parag. address).
SET_STACK:
MOV AX, [BP] + 12 ; Size of process' WSP, in paragrafs
SUB AX, DX ; Size minus proc-descriptor
CALL COMP_STACK ; Sets stack to end of WSP
; BX = SS, AX = SP
; SP has to be set after the return block
; that we're going to put:
SUB AX, SP_INI_SIZE
MOV TEMP_P_D.PD_SP, AX ; Set SP and SS in new descriptor
MOV TEMP_P_D.PD_SS, BX
MOV SI, AX
MOV ES, BX
SUB AX, SP_RESERVE
MOV TEMP_P_D.PD_SP_LIM, AX ; Set Stack Limit
; Stack Limit is actual value
; of SP minus some reserve
; Prepare the error return on the new stack:
; (ES,SI) are the initial stack of this new process.
MOV ES:WORD PTR 8[SI], CS
MOV ES:WORD PTR 6[SI], OFFSET PROCESS_END
; A process should never terminate!
MOV AX, SI
ADD AX, 6
MOV TEMP_P_D.PD_RET_SP, AX
; Return Stack Value (not used)
; Copy the Program End Stack:
MOV CX, CUR_PROCESS.PD_PROG_END
MOV TEMP_P_D.PD_PROG_END, CX
MOV CX, CUR_PROCESS.PD_PROG_END+2
MOV TEMP_P_D.PD_PROG_END+2, CX
; Copy the program IDs from the current process:
MOV AX, CUR_PROCESS.PD_PROG_ID
MOV TEMP_P_D.PD_PROG_ID, AX
MOV AX, CUR_PROCESS.PD_SHARED_ID
MOV TEMP_P_D.PD_SHARED_ID, AX
; Copy the Module Table Header:
MOV AX, CUR_PROCESS.PD_MOD_TABLE
MOV TEMP_P_D.PD_MOD_TABLE, AX
MOV AX, CUR_PROCESS.PD_MOD_TABLE+2
MOV TEMP_P_D.PD_MOD_TABLE+2, AX
; Copy the father process:
MOV AX, CUR_PROCESS.PD_FATHER_PROC
MOV TEMP_P_D.PD_FATHER_PROC, AX
MOV AX, CUR_PROCESS.PD_FATHER_PROC+2
MOV TEMP_P_D.PD_FATHER_PROC+2, AX
; Check if the father process is NIL, in which
; case we have to put the addr of the current PD:
CMP AX, 0FFFFH
JNE NOT_FATHER
MOV AX, CUR_P_PTR
MOV TEMP_P_D.PD_FATHER_PROC, AX
MOV AX, CUR_P_PTR + 2
MOV TEMP_P_D.PD_FATHER_PROC + 2, AX
NOT_FATHER:
; Copy the priority mask from the current process:
MOV AX, CUR_PROCESS.PD_PRIO_MASK
MOV TEMP_P_D.PD_PRIO_MASK, AX
; Set the Continuation Address:
; (We put it on the stack, for a IRET)
MOV AX, [BP] + 18
MOV BX, [BP] + 20
MOV ES: [SI] + 0, AX
MOV ES: [SI] + 2, BX
; Copy the Flags:
MOV CX, CUR_PROCESS.PD_FLAGS
MOV TEMP_P_D.PD_FLAGS, CX
MOV ES: [SI] + 4, CX
; And on stack, for the IRET
; Set Status to Normal:
MOV AX, 0
MOV TEMP_P_D.PD_STATUS, AX
; don't modify AX here!
; Set dynamic link to 0, used by the
; debugger to detect end of calling sequence:
MOV TEMP_P_D.PD_BP, AX
; Set the address of the descriptor in the VAR-PAR:
MOV ES, [BP] + 10 ; addr of varpar
MOV BX, [BP] + 8
MOV DI, [BP] + 14 ; addr of workspace
MOV CX, [BP] + 16
MOV ES: [BX], DI
MOV ES: [BX] + 2, CX
; Copy the new descriptor from the TEMP_P_D
; area into the real workspace:
MOV ES, CX ; (ES,DI) = workspace
MOV SI, OFFSET TEMP_P_D ; (DS,SI) = TEMP_P_D
MOV CX, (size ProcessDescriptor)/2
REP MOVSW
MOV DS, CUR_PROCESS.PD_DS
POP BP
IRET
;------------------------------------------------------------
PROCESS_END:
;===========
; We arrive here, when the code of a process is executed and a
; return from its code is performed. Since a process is not called
; like a procedure, but started through a TRANSFER, this situation
; is illegal:
MOV CUR_PROCESS.PD_STATUS, PROCESS_END_CODE
JMP TERMINATE
NEWPROCESS endp
;------------------------------------------------------------
page
public MON_ENTRY, MON_EXIT
MON_ENTRY:
;=========
; Upon entry: BX holds requested priority level.
; The interrupt controller is set to disable all
; interrupts of the requested or lower levels.
; check the parameter:
CMP BX, MAX_PRIO_LEVEL
JBE LEVEL_OK
MOV BX, MAX_PRIO_LEVEL
LEVEL_OK:
POP SI ; remove return block
POP DX
POP CX
IN AL, MASK_8259
XOR AH, AH
PUSH AX ; save old mask
OR AL, PRIORITY_MASKS [BX]
OUT MASK_8259, AL
MOV CUR_PROCESS.PD_PRIO_MASK, AX
PUSH CX ; restore return block
PUSH DX
PUSH SI
MOV DS, CUR_PROCESS.PD_DS
IRET
MON_EXIT:
;========
; Restore the mask that has been saved on the stack
; at the entry to that procedure. Note that changes
; in the interrupt mask that occured during execution
; of this 'priority procedure' are not conserved!
; If interrupts are treated with IOTRANSFER, such
; changes should never occur.
POP SI ; remove return block
POP DX
POP CX
POP AX ; old mask
MOV CUR_PROCESS.PD_PRIO_MASK, AX
OUT MASK_8259, AL
PUSH CX ; restore return block
PUSH DX
PUSH SI
MOV DS, CUR_PROCESS.PD_DS
IRET
public LISTEN
LISTEN:
;======
; This function lowers the priority and enables interrupts
; tempoarily. Note that changes in the interrupt mask that
; occur during the execution of pending interrupts are not
; conserved, the old mask is restored at the end! If
; interrupts are treated with IOTRANSFER, such changes
; should never occur.
IN AL, MASK_8259
XOR AH, AH ; update current mask
PUSH AX ; and save it
XOR AX, AX
MOV CUR_PROCESS.PD_PRIO_MASK, AX
OUT MASK_8259, AL ; unmask all bits
STI ; Allow all interrupts
NOP ; (there is a one-instruction lag)
MOV CX, 20H
LISTEN_AGAIN:
DEC CX ; we have to wait longer, to give
; all pending interrupts a chance
JNZ LISTEN_AGAIN
CLI
POP AX
MOV CUR_PROCESS.PD_PRIO_MASK, AX
OUT MASK_8259, AL ; restore old mask
MOV DS, CUR_PROCESS.PD_DS
IRET
;------------------------------------------------------------
public GET_INTERRUPT_MASK
GET_INTERRUPT_MASK proc near
IN AL, MASK_8259
XOR AH, AH
RET
GET_INTERRUPT_MASK endp
;------------------------------------------------------------
public REST_INTERRUPT_MASK
REST_INTERRUPT_MASK proc near
OUT MASK_8259, AL
RET
REST_INTERRUPT_MASK endp
;------------------------------------------------------------
FREE_1_VECT proc near
; Upon entry: (ES,SI) hold addr of P.D. that owns the vector.
; BX holds number of used ISR (0..NBR_ISR-1) times 4
; Upon exit: BX holds number of used ISR times 2
; We have to do both:
; a) free its entry in WAITING_PROC and in INT_VECT_OWNER
MOV AX, 0FFFFH ; used as NIL
MOV WAITING_PROC [BX], AX
SHR BX, 1
MOV INT_VECT_OWNER [BX], AX
; b) and to restore the interrupt vector
PUSH ES
MOV AX, 0
MOV ES, AX
POP DS ; DS is segm of waiting process
; and SI is its offset
MOV DI, PD_INT_VECT [SI]
SHL DI, 1
SHL DI, 1 ; multiply by 4, to get addr.
ADD SI, PD_OLD_ISR
MOVSW
MOVSW
RET
FREE_1_VECT endp
public REST_I_V
REST_I_V proc near
MOV AX, CUR_PROCESS.PD_PROG_ID
; AX holds the current ID
MOV DI, NBR_ISR
SHL DI, 1 ; WORD index
NEXT_I_V:
DEC DI
DEC DI
MOV BX, INT_VECT_OWNER [DI]
; BX holds the owner
CMP AX, BX
JE FREE_THIS_ONE
CMP AX, 0 ; 0 is a joker !
JNE I_V_DONE ; It's not 0
CMP BX, NIL_CARD
JE I_V_DONE ; It's NIL
FREE_THIS_ONE:
; This entry is owned by the current program:
MOV BX, DI
SHL BX, 1
LES SI, WAITING_PROC [BX] ; get addr of PROCESS variable
LES SI, ES:DWORD PTR [SI] ; get addr of process descriptor
PUSH DI ; save it
CALL FREE_1_VECT
POP DI
I_V_DONE:
CMP DI, 0
JNE NEXT_I_V
RET
REST_I_V endp
public FREE_INT_VECT
FREE_INT_VECT:
;=============
; Restores the old Interrupt Vectors of all entries, used by the
; current program.
CALL REST_I_V
MOV DS, CUR_PROCESS.PD_DS
IRET
;------------------------------------------------------------
public STOPPED
STOPPED:
;======
; We arrive here when ctrl-break is entered from the
; keyboard.
MOV ES, RTS_DS
; We are coming from a DOS function (which we don't want to
; debug), so we have first to remove the return block that
; points to the DOS:
POP AX
POP AX
POP AX
CALL SAVE_CPU_INFO
; Give the interrupt controller an End-Of-Interrupt.
; There is for sure one that we have to send (for the KBD
; routine that has made the software interrupt to arrive
; here). We might be in a nested ISR (timer has a lower
; priority than KBD), so let's send 2 EOI (it doesn't harm):
MOV AL, EOI_8259
OUT CTRL_W2_8259, AL
OUT CTRL_W2_8259, AL
; Set status to some reasonable value:
MOV FCT_CODE, TERMINATE_FCT
MOV CUR_PROCESS.PD_STATUS, STOP_CODE
JMP TERMINATE
;------------------------------------------------------------
code ends
end

Reference in New Issue Copy Permalink