mirror of https://github.com/sheumann/dmake.git
1235 lines
36 KiB
NASM
1235 lines
36 KiB
NASM
;
|
|
; DESCRIPTION
|
|
; This code is a model independent version of DOS exec that will swap
|
|
; the calling process out to secondary storage prior to running the
|
|
; child. The prototype for calling the exec function is below.
|
|
;
|
|
; exec( int swap, char far *program, char far *cmdtail,
|
|
; int environment_seg, char far *tmpfilename );
|
|
;
|
|
;
|
|
; To assemble this file issue the command:
|
|
;
|
|
; tasm /mx /t /dmmodel exec.asm
|
|
;
|
|
; where 'model' is one of {small, compact, medium, large}, you may
|
|
; also use MASM 5.1 to assemble this file, in this case simply replace
|
|
; 'tasm' with 'masm' in the above command line.
|
|
;
|
|
; AUTHOR
|
|
; Dennis Vadura, dvadura@watdragon.uwaterloo.ca
|
|
; CS DEPT, University of Waterloo, Waterloo, Ont., Canada
|
|
;
|
|
; COPYRIGHT
|
|
; Copyright (c) 1990 by Dennis Vadura. All rights reserved.
|
|
;
|
|
; This program is free software; you can redistribute it and/or
|
|
; modify it under the terms of the GNU General Public License
|
|
; (version 1), as published by the Free Software Foundation, and
|
|
; found in the file 'LICENSE' included with this distribution.
|
|
;
|
|
; This program is distributed in the hope that it will be useful,
|
|
; but WITHOUT ANY WARRANTY; without even the implied warrant of
|
|
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
; GNU General Public License for more details.
|
|
;
|
|
; You should have received a copy of the GNU General Public License
|
|
; along with this program; if not, write to the Free Software
|
|
; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
;
|
|
ifdef have286
|
|
.286 ; define have286 with -D for 80286 processor or better
|
|
mpusha Macro
|
|
pusha
|
|
Endm
|
|
|
|
mpopa Macro
|
|
popa
|
|
Endm
|
|
|
|
else ; 8088/8086 compatible
|
|
mpusha Macro
|
|
push ax
|
|
push cx
|
|
push dx
|
|
push bx
|
|
push sp
|
|
push bp
|
|
push si
|
|
push di
|
|
Endm
|
|
|
|
mpopa Macro
|
|
pop di
|
|
pop si
|
|
pop bp
|
|
add sp,2
|
|
pop bx
|
|
pop dx
|
|
pop cx
|
|
pop ax
|
|
Endm
|
|
endif
|
|
|
|
ifdef msmall
|
|
.model small
|
|
argbase equ 4
|
|
endif
|
|
ifdef mcompact
|
|
.model compact
|
|
argbase equ 4
|
|
endif
|
|
ifdef mmedium
|
|
.model medium
|
|
argbase equ 6
|
|
endif
|
|
ifdef mlarge
|
|
.model large
|
|
argbase equ 6
|
|
endif
|
|
a_swap equ <bp+argbase+0>
|
|
a_prog equ <bp+argbase+2>
|
|
a_tail equ <bp+argbase+6>
|
|
a_env equ <bp+argbase+10>
|
|
a_tmp equ <bp+argbase+12>
|
|
|
|
a_handle equ <bp+argbase>
|
|
|
|
|
|
; Define all useful equ's
|
|
swap_xms equ 0 ; we swapped it out to xms
|
|
swap_ems equ 2 ; we swapped it out to ems
|
|
swap_file equ 4 ; we swapped it out to a file
|
|
seg_no_alloc equ 0 ; this is part of a segment
|
|
seg_alloc equ 1 ; this is a full segment header
|
|
seg_data equ 2 ; this is data for part of a segment
|
|
|
|
|
|
; Define any global/external variables that we will be accessing from here.
|
|
.data
|
|
extrn _errno:word ; Set to dos ret code from exec
|
|
public _Interrupted ; Set to 1 if interrupted 0
|
|
_Interrupted dw 0 ; otherwise
|
|
|
|
.code
|
|
assume cs:@code, ds:@code, ss:@code, es:@code
|
|
|
|
even
|
|
execstack dw 64 dup (?) ; put the temporary exec stack right
|
|
exec_sp label word ; at the start.
|
|
|
|
old_ss dw ? ; save stack seg across exec
|
|
old_sp dw ? ; save stack ptr across exec
|
|
progsize dw ? ; original size of the program
|
|
rootsize dw ? ; size of base root kept during swap
|
|
resend dw ? ; paragraph where resident code ends
|
|
envseg dw ? ; paragraph of environment segment
|
|
psp dw ? ; our own psp
|
|
swap dw ? ; swapping selection flag
|
|
eretcode dw ? ; return code from exec
|
|
interrupted dw ? ; interrupted flag for exec
|
|
arenahead dw ? ; start of memory block list
|
|
alstr dw ? ; allocation strategy save spot
|
|
in_exec dw 0 ; flag, 1 ==> in exec
|
|
|
|
cmdpath db 65 dup(?) ; file to exec
|
|
cmdtail db 129 dup(?) ; its command tail
|
|
fcb db 37 dup(0) ; dummy fcb
|
|
tmpseg db 7 dup(?) ; block header buffer
|
|
|
|
tmpname db 65 dup(0) ; name of temporary file resource
|
|
|
|
even
|
|
tmphandle dw ? ; handle for temporary file
|
|
real_21h dd 0 ; will be DOS's 21h vector if doing -C
|
|
|
|
std_fil_handle dw ? ; file handle for -C file
|
|
std_fil_number db ? ; system file number for -C file
|
|
our_stdout db ? ; sys file number our stdout handle
|
|
|
|
error_rhdr db "exec: Failure reading header block", 0DH, 0AH, '$'
|
|
error_rseg db "exec: Failure reading segment data", 0DH, 0AH, '$'
|
|
error_resize db "exec: Failure on resize", 0DH, 0AH, '$'
|
|
error_free db "exec: Failure to free a block", 0DH, 0AH, '$'
|
|
error_string db "exec: Program swap failure", 0DH, 0AH, '$'
|
|
error_alloc db "exec: Memory blocks don't match", 0DH, 0AH, '$'
|
|
|
|
even
|
|
write_header label word
|
|
whdr_xms_ptr dw word ptr whdr_xms
|
|
whdr_ems_ptr dw word ptr whdr_ems
|
|
whdr_file_ptr dw word ptr whdr_file
|
|
|
|
write_seg label word
|
|
wseg_xms_ptr dw word ptr wseg_xms
|
|
wseg_ems_ptr dw word ptr wseg_ems
|
|
wseg_file_ptr dw word ptr wseg_file
|
|
|
|
read_header label word
|
|
rhdr_xms_ptr dw word ptr rhdr_xms
|
|
rhdr_ems_ptr dw word ptr rhdr_ems
|
|
rhdr_file_ptr dw word ptr rhdr_file
|
|
|
|
read_seg label word
|
|
rseg_xms_ptr dw word ptr rseg_xms
|
|
rseg_ems_ptr dw word ptr rseg_ems
|
|
rseg_file_ptr dw word ptr rseg_file
|
|
|
|
free_resource label word
|
|
free_xms_ptr dw word ptr free_xms_resource
|
|
free_ems_ptr dw word ptr free_ems_resource
|
|
free_file_ptr dw word ptr free_file_resource
|
|
|
|
reset_resource label word
|
|
reset_xms_ptr dw word ptr reset_xms_resource
|
|
reset_ems_ptr dw word ptr reset_ems_resource
|
|
reset_file_ptr dw word ptr reset_file_resource
|
|
|
|
old_ctl_brk label dword
|
|
old_ctl_brk_off dw ?
|
|
old_ctl_brk_seg dw ?
|
|
|
|
old_crit_err label dword
|
|
old_crit_err_off dw ?
|
|
old_crit_err_seg dw ?
|
|
|
|
exec_block label word
|
|
ex_envseg dw ? ; env seg, use parent's if 0
|
|
ex_cmdtail dd ? ; command tail for exec
|
|
ex_fcb1 dd far ptr fcb ; fcb's aren't used by dmake
|
|
ex_fcb2 dd far ptr fcb
|
|
ex_ss dw ? ; saved ss for exec
|
|
ex_sp dw ? ; saved sp for exec
|
|
ex_error dw 0 ; error code for dos exec
|
|
|
|
|
|
; Special 21h (DOS call) handler to tee stdout/stderr writes to the -C file.
|
|
; Ignore 21h calls that aren't writes to 1 or 2; i.e., pass them to DOS handler.
|
|
; If write call was from this process, it's pretty simple to duplicate it
|
|
; to the -C file. If it's from another process, we try to write to its
|
|
; inherited handle. Worst case is where the handle wasn't inherited: someone
|
|
; closed it. In that instance we have to switch to dmake's PSP to do the
|
|
; duplicate write.
|
|
|
|
; Subprocesses do not get their stdout/stderr teed to the -C file if
|
|
; their stdout/stderr no longer points to the file/device that dmake's
|
|
; stdout points to. This is tested by looking at the process's job
|
|
; file table, which is a table that maps process handles to DOS system file
|
|
; table numbers. (The far pointer to the JFT is at the PSP offset 34h.)
|
|
; The JFT is also queried to see if the -C file was inherited.
|
|
|
|
; O_BINARY, O_TEXT problems are ignored here. These are fudged by the
|
|
; C library before it calls DOS; since we're working below that level
|
|
; we don't have to worry about it.
|
|
|
|
simulate_21h Macro
|
|
pushf ;; direct call to DOS
|
|
call cs:[real_21h]
|
|
Endm
|
|
|
|
assume cs:@code, ds:nothing, es:nothing, ss:nothing
|
|
our_21h_handler proc far
|
|
pushf
|
|
cmp ah,40h ; is this a write?
|
|
jne call_dos ; --no
|
|
cmp bx,1 ; write on handle 1 (stdout?)
|
|
je duplicate_it
|
|
cmp bx,2 ; stderr?
|
|
je duplicate_it
|
|
|
|
call_dos:
|
|
popf
|
|
jmp [real_21h] ; far jump to real handler, which will do the sys call
|
|
; and return to the original caller
|
|
|
|
duplicate_it:
|
|
mpusha
|
|
push ds
|
|
push es
|
|
mov bp,sp
|
|
|
|
mov di,std_fil_handle ; handle of the -C file
|
|
|
|
If @CodeSize eq 0
|
|
; Small/compact models allow for quick test of us versus subprocess.
|
|
; False negative (it's us with a different CS) will be picked
|
|
; up by code just below. (Might happen due to call from C library.)
|
|
; False positives would be bad, but can't happen.
|
|
mov ax,[bp+24] ; caller's CS
|
|
cmp ax,@code ; same as us?
|
|
je call_from_dmake
|
|
Endif
|
|
|
|
mov ah,51h ; get PSP ("undocumented version" works in DOS 2.0+)
|
|
simulate_21h ; PSP segment returned in BX
|
|
cmp bx,psp ; our PSP?
|
|
je call_from_dmake ; --yes, no PSP changing needed
|
|
|
|
mov es,bx ; set ES to current (caller's) PSP
|
|
lds bx,es:[34h] ; set DS:BX pointing to caller's job file table
|
|
|
|
mov si,[bp+12] ; file handle caller passed in (known to be 1 or 2)
|
|
mov al,[bx+si] ; system file number corresponding to caller's handle
|
|
cmp al,our_stdout ; same as our stdout?
|
|
jne do_real_write ; no--subprocess must have redirected it
|
|
|
|
mov al,[bx+di] ; see if caller has dup of -C file still open
|
|
cmp al,std_fil_number
|
|
je use_dup ; yes--we can write using caller's PSP
|
|
|
|
; Calling process (or some intermediate process) has closed
|
|
; the -C descriptor. We'll use dmake's (our) -C descriptor, but
|
|
; to do so we'll have to change the PSP. Disable BREAK handling
|
|
; so that ^break doesn't kill the wrong process.
|
|
|
|
mov ax,3300h ; get BREAK flag
|
|
simulate_21h
|
|
mov si,dx ; save BREAK state in SI
|
|
sub dx,dx ; now turn break flag off
|
|
mov ax,3301h
|
|
simulate_21h ; don't want ^Break recoginized while PSP changed
|
|
mov bx,psp ; set dmake's PSP
|
|
mov ah,50h
|
|
simulate_21h
|
|
|
|
mov bx,di ; handle of -C file
|
|
; CX still has caller's count
|
|
mov ds,[bp+2] ; restore caller's DS
|
|
mov dx,[bp+14] ; DS:DX again points to caller's buffer
|
|
mov ah,40h
|
|
simulate_21h ; write the copy
|
|
|
|
mov bx,es ; caller's PSP
|
|
mov ah,50h ; set PSP
|
|
simulate_21h ; restore caller's PSP
|
|
mov dx,si ; break state before we changed it
|
|
mov ax,3301h
|
|
simulate_21h ; restore break state
|
|
|
|
jmp short do_real_write
|
|
|
|
use_dup:
|
|
mov ds,[bp+2] ; restore caller's DS
|
|
mov dx,[bp+14] ; DS:DX again points to caller's buffer
|
|
|
|
call_from_dmake:
|
|
mov bx,di ; handle of -C file
|
|
mov ah,40h ; write
|
|
; CX still has caller's count
|
|
simulate_21h ; write to the file
|
|
|
|
do_real_write:
|
|
pop es
|
|
pop ds
|
|
mpopa
|
|
popf
|
|
jmp [real_21h] ; far jump to real handler, which will do the sys call
|
|
; and return to the original caller
|
|
our_21h_handler endp
|
|
|
|
assume cs:@code, ds:@code, ss:@code, es:@code
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; First define the critical-error and control-brk handlers.
|
|
; The critical error handler simply pops the machine state and returns an
|
|
; access denied result code.
|
|
crit_err_handler proc far
|
|
add sp, 6 ; ip/cs/flags ...
|
|
pop ax
|
|
pop bx
|
|
pop cx
|
|
pop dx
|
|
pop si
|
|
pop di
|
|
pop bp
|
|
pop ds
|
|
pop es
|
|
push bp ; fix up the return flags
|
|
mov bp, sp
|
|
xchg ax, [bp+6] ; get the flag byte.
|
|
or ax, 1 ; set the carry bit
|
|
xchg ax, [bp+6] ; put it back.
|
|
pop bp
|
|
mov ax, 5 ; access denied
|
|
iret
|
|
crit_err_handler endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Here we set the interrupted flag, and terminate the currently running
|
|
; process.
|
|
ctl_brk_handler proc far
|
|
clc ; make sure carry is clear
|
|
inc cs:interrupted ; set the flag
|
|
|
|
; Make certain it isn't us that is going to get terminated.
|
|
; There is a small window where the in_exec flag is set but the child is
|
|
; not running yet, I assume that DOS doesn't test for ctl_brk at that time
|
|
; as it is bussily creating a new process.
|
|
cmp cs:in_exec,0
|
|
je just_return ; note this implies CF == 0
|
|
stc ; set CF to abort child
|
|
just_return: iret
|
|
ctl_brk_handler endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Something really nasty happened, so abort the exec call and exit.
|
|
; This kills the calling process altogether, and is a very nasty way of
|
|
; termination since files may still be open etc.
|
|
abort_exec_rhdr label near
|
|
mov dx, offset error_rhdr
|
|
jmp print_it
|
|
abort_exec_rseg label near
|
|
mov dx, offset error_rseg
|
|
jmp print_it
|
|
abort_exec_resize label near
|
|
mov dx, offset error_resize
|
|
jmp print_it
|
|
abort_exec_free label near
|
|
mov dx, offset error_free
|
|
jmp print_it
|
|
abort_exec_alloc label near
|
|
mov dx, offset error_alloc
|
|
jmp print_it
|
|
abort_exec proc near
|
|
mov dx, offset error_string
|
|
print_it: push dx
|
|
mov bx, [swap]
|
|
call [free_resource+bx]
|
|
mov ax, cs
|
|
mov ds, ax
|
|
pop dx
|
|
mov ah, 9
|
|
int 21H
|
|
kill_program: mov ax, 04cffH ; nuke it!
|
|
int 21H
|
|
abort_exec endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; lodsw/stosw loop to copy data. Called only for word copy operations.
|
|
; ds:si - point at source
|
|
; es:di - point at destination
|
|
; cx - count of bytes to copy.
|
|
copy_data proc near
|
|
shr cx, 1 ; convert to word count
|
|
jnc copy_words
|
|
movsb
|
|
copy_words: rep movsw ; copy the words.
|
|
ret
|
|
copy_data endp
|
|
|
|
|
|
|
|
;=============================================================================
|
|
; THE FOLLOWING SECTION DEALS WITH ALL ROUTINES REQUIRED TO READ XMS RECORDS.
|
|
;=============================================================================
|
|
rhdr_xms proc near
|
|
ret
|
|
rhdr_xms endp
|
|
|
|
rseg_xms proc near
|
|
ret
|
|
rseg_xms endp
|
|
|
|
reset_xms_resource proc near
|
|
ret
|
|
reset_xms_resource endp
|
|
|
|
free_xms_resource proc near
|
|
ret
|
|
free_xms_resource endp
|
|
;=============================================================================
|
|
|
|
|
|
|
|
;=============================================================================
|
|
; THE FOLLOWING SECTION DEALS WITH ALL ROUTINES REQUIRED TO READ EMS RECORDS.
|
|
;=============================================================================
|
|
rhdr_ems proc near
|
|
ret
|
|
rhdr_ems endp
|
|
|
|
rseg_ems proc near
|
|
ret
|
|
rseg_ems endp
|
|
|
|
reset_ems_resource proc near
|
|
ret
|
|
reset_ems_resource endp
|
|
|
|
free_ems_resource proc near
|
|
ret
|
|
free_ems_resource endp
|
|
;=============================================================================
|
|
|
|
|
|
|
|
;=============================================================================
|
|
; THE FOLLOWING SECTION DEALS WITH ALL ROUTINES REQUIRED TO READ FILE RECORDS.
|
|
;=============================================================================
|
|
; This routine reads a segment header from a file.
|
|
; The header is a seven byte record formatted as follows:
|
|
; segment address - of data
|
|
; offset address - of data
|
|
; length in paragraphs - of data
|
|
; mode - 1 => segment header (allocate seg on read)
|
|
; 0 => subsegment, don't allocate on read.
|
|
; The information is placed into the tmpseg data area in the code segment.
|
|
; The routine aborts if an error is detected.
|
|
rhdr_file proc near
|
|
mov dx, offset tmpseg ; read the header record out
|
|
mov cx, 7
|
|
mov bx, [tmphandle]
|
|
mov ah, 03fH
|
|
int 21H
|
|
jnc rhdr_done ; make sure it worked
|
|
jmp abort_exec_rhdr
|
|
|
|
rhdr_done: cmp ax, 7
|
|
je exit_rhdr_file
|
|
or ax, ax
|
|
je signal_eof
|
|
jmp abort_exec_rhdr
|
|
|
|
signal_eof: stc
|
|
exit_rhdr_file: ret
|
|
rhdr_file endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Read a segment from the temporary file whose handle is in cs:tmphandle.
|
|
; The routine aborts if an error is detected.
|
|
rseg_file proc near
|
|
push ds
|
|
mov ds, word ptr cs:tmpseg; Now read the whole segment
|
|
mov dx, word ptr cs:tmpseg+2
|
|
mov cx, word ptr cs:tmpseg+4
|
|
mov bx, cs:tmphandle
|
|
mov ah, 03fH
|
|
int 21H
|
|
pop ds
|
|
jnc rseg_done
|
|
jmp abort_exec_rseg
|
|
|
|
rseg_done: cmp ax, [word ptr tmpseg+4]
|
|
je exit_rseg_file
|
|
jmp abort_exec_rseg ; If we didn't get read full
|
|
exit_rseg_file: ret ; segment then abort
|
|
rseg_file endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Seek to the beginning of the file.
|
|
reset_file_resource proc near
|
|
mov bx, [tmphandle]
|
|
xor cx, cx
|
|
mov dx, cx
|
|
mov ax, 04200H ; seek to begining of file
|
|
int 21H
|
|
ret
|
|
reset_file_resource endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; unlink the temporary file allocated for swapping.
|
|
; We close the file first, and then delete it. We ignore errors here since
|
|
; we can't do anything about them anyway.
|
|
free_file_resource proc near
|
|
mov bx, [tmphandle] ; get the file handle
|
|
mov ah, 03eH ; close the file
|
|
int 21H
|
|
mov dx, offset tmpname ; Now delete the temp file
|
|
mov ah, 041H
|
|
int 21H
|
|
ret
|
|
free_file_resource endp
|
|
;=============================================================================
|
|
|
|
|
|
|
|
;=============================================================================
|
|
; CODE TO SWAP THE IMAGE IN FROM SECONDARY STORAGE
|
|
;=============================================================================
|
|
swap_in proc near
|
|
mov bx, [alstr] ; get previous alloc strategy
|
|
mov ax, 5801H ; and set it back
|
|
int 21H
|
|
mov bx, [swap] ; get type of resource
|
|
call [reset_resource+bx] ; reset the resource
|
|
mov es, [psp] ; resize the program back
|
|
mov bx, [progsize] ; to original size
|
|
mov ah, 04AH
|
|
int 21H
|
|
jnc read_seg_loop
|
|
jmp abort_exec
|
|
|
|
read_seg_loop: mov bx, [swap] ; get type of resource
|
|
call [read_header+bx] ; get seg header
|
|
jc exit_swap_in ; all done
|
|
mov al, [tmpseg+6]
|
|
cmp al, seg_no_alloc ; see if dummy segment header
|
|
je read_seg_loop
|
|
cmp al, seg_alloc ; do we need to do an alloc?
|
|
jne read_data ; nope
|
|
|
|
; Allocate back the memory for a segment that is not the [psp], note that this
|
|
; must come back to the same segment we had previously since other segments
|
|
; may have pointers stored in their variables that point to this segment using
|
|
; segment:offset long pointers.
|
|
mov bx, [word ptr tmpseg+4] ; get count of paragraphs
|
|
mov ah, 048H ; dos_alloc
|
|
int 21H
|
|
jc alloc_error ; oops!
|
|
cmp ax, [word ptr tmpseg] ; did we get the same segment?
|
|
je read_seg_loop ; yup!
|
|
alloc_error: jmp abort_exec_alloc
|
|
|
|
read_data: mov bx, [swap]
|
|
call [read_seg+bx] ; this must succeed, if fail
|
|
jmp read_seg_loop ; we never come back here
|
|
|
|
exit_swap_in: mov bx, [swap] ; all done, so free resource
|
|
call [free_resource+bx]
|
|
ret
|
|
swap_in endp
|
|
|
|
|
|
;=============================================================================
|
|
; CODE TO SWAP THE IMAGE OUT TO SECONDARY STORAGE
|
|
;=============================================================================
|
|
; This routine is called to swap the non-resident portion of the program
|
|
; out to the resource specified by the value of [cs:swap]. If the swap out
|
|
; fails, then appropriate routines are called to free the resources allocated
|
|
; up to that point.
|
|
;
|
|
; The steps used to swap the program out are as follows:
|
|
; - calculate new size of program to remain resident and size to swap
|
|
; out.
|
|
; - write out non-resident portion of current segment
|
|
; - walk DOS allocation chain and write out all other segments owned by
|
|
; the current program that are contiguous with the _psp segment
|
|
; - copy the environment down to low memory
|
|
; - resize the current _psp segment to savesize
|
|
; - free all segments belonging to program except current _psp segment
|
|
swap_out proc near
|
|
mov ax, 05800H ; get memory alocation strategy
|
|
int 021H
|
|
mov [alstr], ax ; and save it for future restoration.
|
|
mov di, [psp] ; compute length of program to current
|
|
mov bx, cs ; value of cs, and find program size
|
|
sub bx, di ; by looking at length stored in
|
|
mov ax, di ; arena header found in front of psp
|
|
dec ax
|
|
mov es, ax
|
|
mov si, es:3 ; si is size of program in paragraphs
|
|
mov [progsize], si ; progsize now contains the size.
|
|
|
|
; Now compute length of program segment to save.
|
|
; Length is: cs - psp + (offset overlay_code_here+15 >> 4)
|
|
mov ax, offset overlay_code_here+15
|
|
shr ax, 1
|
|
shr ax, 1
|
|
shr ax, 1
|
|
shr ax, 1
|
|
add bx, ax ; bx is size of program to keep
|
|
sub si, bx ; si is # of paragraphs to save.
|
|
add di, bx ; di is paragraph to start at
|
|
mov rootsize, bx
|
|
mov resend, di ; cs:resend is saved start para
|
|
mov al, seg_no_alloc ; set no allocation for segment
|
|
call write_segment
|
|
jc abort_swap_out
|
|
|
|
; We have now saved the portion of the program segment that will not remain
|
|
; resident during the exec. We should now walk the DOS allocation chain and
|
|
; write out all other segments owned by the current process.
|
|
save_segments: mov ax, [psp]
|
|
dec ax
|
|
mov es, ax
|
|
mov bx, offset write_segment_data
|
|
call walk_arena_chain
|
|
jc abort_swap_out
|
|
|
|
; Now we must walk the chain of allocated memory blocks again and free
|
|
; all those that are owned by the current process, except the one that is
|
|
; the current process' psp.
|
|
free_segments: mov ax, [psp]
|
|
dec ax
|
|
mov es,ax
|
|
mov bx, offset free_dos_segment
|
|
call walk_arena_chain
|
|
jnc resize_program
|
|
jmp abort_exec_free ; can't fix it up now.
|
|
|
|
; We now resize the program to the size specified by cs:rootsize. This will
|
|
; free most of the memory taken up by the current program segment.
|
|
resize_program: mov es, [psp] ; es is segment to resize.
|
|
mov bx, [rootsize] ; bx is size of segment.
|
|
mov ah, 04aH ; resize memory block
|
|
int 21H
|
|
jnc swap_out_ok
|
|
jmp abort_exec_resize ; disaster
|
|
swap_out_ok: ret
|
|
|
|
; The swap out failed for some reason, so free any allocated resources
|
|
; and set the carry bit.
|
|
abort_swap_out: mov bx, [swap]
|
|
call [free_resource+bx]
|
|
xor ax, ax
|
|
mov [swap], ax ; clear the swap flag
|
|
stc
|
|
ret
|
|
swap_out endp
|
|
|
|
|
|
;=============================================================================
|
|
; CODE TO SET-UP FOR AND EXEC THE CHILD PROCESS
|
|
;=============================================================================
|
|
; Actually execute the program. If cs:swap is set, this code will invoke the
|
|
; swap-out/swap-in code as required.
|
|
do_exec proc near
|
|
cmp [swap], 0 ; does the user want to swap?
|
|
je no_swap_out ; nope
|
|
call init_swap ; figger out where to swap to
|
|
jc no_swap_out ; if carry set then don't swap
|
|
call swap_out
|
|
|
|
no_swap_out: cmp [interrupted], 0 ; were we interrupted?
|
|
jne leave_exec ; yep, so clean up, don't exec
|
|
|
|
; free passed in environment block if it is non zero.
|
|
; This way the parent program does not need to free it.
|
|
mov ax, [envseg]
|
|
or ax, ax
|
|
je setup_block
|
|
push ax
|
|
mov es, ax
|
|
mov ah, 49H
|
|
int 21H
|
|
pop ax
|
|
|
|
; set up the parameter block for the DOS exec call.
|
|
; offset contents
|
|
; 00 segment address of environment to be passed,
|
|
; 0 => use parents env.
|
|
; 02 pointer to command tail for new process.
|
|
; 06 pointer to fcb1
|
|
; 0a pointer to fcb2
|
|
setup_block: mov ax, [envseg]
|
|
mov [ex_envseg], ax
|
|
mov cx, cs
|
|
mov [word ptr ex_cmdtail], offset cmdtail
|
|
mov [word ptr ex_cmdtail+2], cx
|
|
|
|
; set up registers for exec call
|
|
; ds:dx - pointer to pathname of program to execute
|
|
; es:bx - pointer to above parameter block
|
|
mov dx, offset cmdpath
|
|
mov es, cx
|
|
mov bx, offset exec_block
|
|
|
|
; Under DOS 2.x exec is notorious for clobbering registers and guarantees
|
|
; to preserve only cs:ip.
|
|
push ds
|
|
mov [ex_sp], sp
|
|
mov [ex_ss], ss
|
|
mov [ex_error], 0 ; clear exec error code
|
|
inc [in_exec] ; set internal flag
|
|
mov ax, 04b00H
|
|
int 21H
|
|
|
|
; returned from exec, so restore possibly clobbered registers.
|
|
mov ss, cs:ex_ss
|
|
mov sp, cs:ex_sp
|
|
pop ds
|
|
|
|
; check to make certain the exec call worked.
|
|
jnc it_worked
|
|
|
|
; exec call failed. Save return code from msdos.
|
|
mov [ex_error], ax
|
|
jmp leave_exec
|
|
|
|
it_worked: mov ah, 04dH ; get the return code
|
|
int 21H
|
|
cmp ah,1 ; check if terminated by ^C
|
|
jnz nosigint
|
|
inc interrupted ; yes so set flag
|
|
nosigint: xor ah, ah ; 8-bit return code, so clear ah
|
|
mov [eretcode], ax
|
|
|
|
leave_exec: cmp [swap], 0 ; check swap, if non-zero swap back in
|
|
je no_swap_in
|
|
call swap_in
|
|
|
|
; Clear the in_exec after the swap back in. This way we are guaranteed to
|
|
; get parent in and the resources freed should a ^C be hit when we are reading
|
|
; the image in.
|
|
no_swap_in: mov [in_exec], 0
|
|
ret
|
|
do_exec endp
|
|
|
|
|
|
|
|
;==============================================================================
|
|
; Everything past this point is overwriten with the environment and new
|
|
; program after the currently executing program is swapped out.
|
|
;==============================================================================
|
|
overlay_code_here label word
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Figure out where we can swap to and initialize the resource we are going to
|
|
; use. We try XMS, EMS, and a tempfile (if specified), in that order. We set
|
|
; [cs:swap] to the correct value based on which of the resources exists.
|
|
; If none can be used, then [cs:swap] is set to 0, and no swap takes place.
|
|
; The exec code will still attempt to execute the child in this instance, but
|
|
; may fail due to lack of resources. Each swap_out_* routine must provide
|
|
; its own clean-up handler should it not be able to write all program
|
|
; segments to the swap resource.
|
|
init_swap proc near
|
|
mov [swap], 0
|
|
;call init_xms
|
|
;jnc init_done
|
|
;call init_ems
|
|
;jnc init_done
|
|
call init_file
|
|
init_done: ret
|
|
init_swap endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; This routine is used to walk the DOS allocated memory block chain
|
|
; starting at address supplied in the es register. For each block it
|
|
; calls the routine specified by the bx register with the segment length
|
|
; in si, and its address in di. It does not apply the routine to the
|
|
; segment if the segment is the same as the current program's [cs:psp] value.
|
|
memheader struc
|
|
magic db ? ; either 'Z' for end or 'M' for allocated
|
|
owner dw ? ; psp of owner block
|
|
len dw ? ; length in paragraphs of segment
|
|
memheader ends
|
|
|
|
walk_arena_chain proc near
|
|
mov si, word ptr es:3 ; get length
|
|
mov di, es
|
|
inc di
|
|
mov ax, word ptr es:1
|
|
|
|
; Stop the search if the block is NOT owned by us. Ignore our own psp block
|
|
; and our environment segment block.
|
|
cmp ax, cs:psp ; is it owned by us?
|
|
jne walk_done ; NOPE! -- all done
|
|
cmp di, cs:envseg ; skip our environment
|
|
je next_block
|
|
cmp di, cs:psp ; skip our psp
|
|
je next_block
|
|
|
|
; Now save state and call the routine pointed at by [bx].
|
|
push di
|
|
push si
|
|
push bx
|
|
call bx
|
|
pop bx
|
|
pop si
|
|
pop di
|
|
jc exit_walk ; if error then stop
|
|
mov al, byte ptr es:0 ; check if at end
|
|
cmp al, 'Z'
|
|
je walk_done
|
|
|
|
next_block: add di, si ; go on to next segment
|
|
mov es, di
|
|
jmp walk_arena_chain
|
|
walk_done: clc
|
|
exit_walk: ret
|
|
walk_arena_chain endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; This routine takes a dos segment found in the di register and free's it.
|
|
free_dos_segment proc near
|
|
mov es, di ; free dos memory block
|
|
mov ah, 49H
|
|
int 21H
|
|
ret
|
|
free_dos_segment endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Called to invoke write_segment with proper values in the al register. Only
|
|
; ever called from walk_arena_chain, and so al should be set to seg_alloc.
|
|
write_segment_data label near
|
|
mov al, seg_alloc ; and fall through into write_segment
|
|
;-----------------------------------------------------------------------------
|
|
; This routine writes a segment as a block of data segments if the number of
|
|
; paragraphs to write exceeds 0x0fff (rarely the case).
|
|
; It stuffs the info into tmpseg, and then calls wheader and wseg to get the
|
|
; data out.
|
|
;
|
|
; di:dx segment:offset of segment; offset is ALWAYS zero.
|
|
; si number of paragraphs to write.
|
|
; al mode of header to write
|
|
write_segment proc near
|
|
push di
|
|
push si
|
|
xor dx,dx
|
|
mov bx, [swap]
|
|
call [write_header+bx]
|
|
pop si
|
|
pop di
|
|
jc exit_wseg
|
|
|
|
do_io_loop: cmp si, 0 ; are we done yet?
|
|
je exit_wseg ; yup so leave.
|
|
mov cx, si ; # of paragraphs to move
|
|
cmp cx, 0fffH ; see if we have lots to move?
|
|
jle do_io
|
|
mov cx, 0fffH ; reset to max I/O size
|
|
|
|
do_io: push cx ; save # of paragraphs we are writing
|
|
shl cx, 1 ; shift cx by four to the left
|
|
shl cx, 1
|
|
shl cx, 1
|
|
shl cx, 1
|
|
push di ; save the start, and count left
|
|
push si
|
|
mov si, cx
|
|
xor dx,dx
|
|
mov al, seg_data
|
|
mov bx, [swap]
|
|
push bx
|
|
call [write_header+bx]
|
|
pop bx
|
|
call [write_seg+bx]
|
|
pop si
|
|
pop di
|
|
pop dx ; original paragraph count in dx
|
|
jc exit_wseg ; it failed so exit.
|
|
add di, dx ; adjust the pointers, and continue.
|
|
sub si, dx
|
|
jmp do_io_loop
|
|
exit_wseg: ret
|
|
write_segment endp
|
|
|
|
|
|
;=============================================================================
|
|
; THE FOLLOWING SECTION DEALS WITH ALL ROUTINES REQUIRED TO WRITE XMS RECORDS.
|
|
;=============================================================================
|
|
init_xms proc near
|
|
ret
|
|
init_xms endp
|
|
|
|
whdr_xms proc near
|
|
ret
|
|
whdr_xms endp
|
|
|
|
wseg_xms proc near
|
|
ret
|
|
wseg_xms endp
|
|
;=============================================================================
|
|
|
|
|
|
;=============================================================================
|
|
; THE FOLLOWING SECTION DEALS WITH ALL ROUTINES REQUIRED TO WRITE EMS RECORDS.
|
|
;=============================================================================
|
|
init_ems proc near
|
|
ret
|
|
init_ems endp
|
|
|
|
whdr_ems proc near
|
|
ret
|
|
whdr_ems endp
|
|
|
|
wseg_ems proc near
|
|
ret
|
|
wseg_ems endp
|
|
;=============================================================================
|
|
|
|
|
|
;=============================================================================
|
|
; THE FOLLOWING SECTION DEALS WITH ALL ROUTINES REQUIRED TO WRITE FILES.
|
|
;=============================================================================
|
|
;-----------------------------------------------------------------------------
|
|
; Attempt to create a temporary file. If the tempfile name is NIL then return
|
|
; with the cary flag set.
|
|
init_file proc near
|
|
mov al, [tmpname]
|
|
or al, al
|
|
je err_init_file
|
|
mov dx, offset tmpname
|
|
xor cx, cx
|
|
mov ah, 03cH
|
|
int 21H
|
|
jc err_init_file ; if carry set then failure
|
|
mov [tmphandle], ax ; init swapping
|
|
mov [swap], swap_file
|
|
jmp exit_init_file
|
|
err_init_file: stc
|
|
exit_init_file: ret
|
|
init_file endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; This routine writes a segment header to a file.
|
|
; The header is a seven byte record formatted as follows:
|
|
; segment address - of data
|
|
; offset address - of data
|
|
; length in paragraphs - of data
|
|
; mode - 1 => segment header (allocate seg on read)
|
|
; 0 => subsegment, don't allocate on read.
|
|
; Routine takes three arguments:
|
|
; di:dx segment:offset of segment
|
|
; si number of paragraphs to write.
|
|
; al mode of header to write
|
|
whdr_file proc near
|
|
mov [word ptr tmpseg], di ; save the segment/offset
|
|
mov [word ptr tmpseg+2], dx
|
|
mov [word ptr tmpseg+4], si ; save the segment length
|
|
mov [tmpseg+6], al
|
|
mov dx, offset tmpseg ; write the header record out
|
|
mov cx, 7
|
|
mov bx, [tmphandle]
|
|
mov ah, 040H
|
|
int 21H
|
|
jc exit_whdr_file ; make sure it worked
|
|
cmp ax, 7
|
|
je exit_whdr_file ; oh oh, disk is full!
|
|
err_whdr_file: stc
|
|
exit_whdr_file: ret
|
|
whdr_file endp
|
|
|
|
|
|
;-----------------------------------------------------------------------------
|
|
; Write a segment to the temporary file whose handle is in cs:tmphandle
|
|
; Parameters for the write are assumed to be stored in the tmpseg data area.
|
|
; function returns carry set if failed, carry clear otherwise.
|
|
wseg_file proc near
|
|
push ds
|
|
mov ds, word ptr cs:tmpseg ; Now write the whole segment
|
|
mov dx, word ptr cs:tmpseg+2
|
|
mov cx, word ptr cs:tmpseg+4
|
|
mov bx, cs:tmphandle
|
|
mov ah, 040H
|
|
int 21H
|
|
pop ds
|
|
jc exit_wseg_file ; make sure it worked
|
|
cmp ax, [word ptr tmpseg+4]
|
|
je exit_wseg_file
|
|
err_wseg_file: stc ; it failed (usually disk full)
|
|
exit_wseg_file: ret
|
|
wseg_file endp
|
|
;=============================================================================
|
|
|
|
|
|
;=============================================================================
|
|
; _exec: THIS IS THE MAIN ENTRY ROUTINE TO THIS MODULE
|
|
;=============================================================================
|
|
; This is the main entry routine into the swap code and corresponds to the
|
|
; following C function call:
|
|
;
|
|
; exec( int swap, char far *program, char far *cmdtail, int environment_seg,
|
|
; char far *tmpfilename );
|
|
;
|
|
; Exec performs the following:
|
|
; 1. set up the local code segment copies of arguments to the exec call.
|
|
; 2. switch to a local stack frame so that we don't clobber the user
|
|
; stack.
|
|
; 3. save old interrupt vectors for ctrl-brk.
|
|
; 4. install our own handler for the ctrl-brk interrupt, our handler
|
|
; terminates the current running process, and returns with non-zero
|
|
; status code.
|
|
; 5. get our psp
|
|
; 6. setup arguments for exec call
|
|
; 7. exec the program, save result code on return.
|
|
; 8. restore previous ctrl-brk and crit-error handler.
|
|
; 9. restore previous process stack, and segment registers.
|
|
; 10. return from exec with child result code in AX
|
|
; and global _Interrupted flag set to true if child execution was
|
|
; interrupted.
|
|
|
|
; NOTE: When first called the segments here assume the standard segment
|
|
; settings.
|
|
assume cs:@code, ds:DGROUP,es:DGROUP,ss:DGROUP
|
|
|
|
public _exec
|
|
_exec proc
|
|
push bp ; set up the stack frame
|
|
mov bp, sp
|
|
push si ; save registers we shouldn't step on.
|
|
push di
|
|
push ds
|
|
|
|
; set up for copying of parameters passed in with long pointers.
|
|
push cs ; going to use lodsb/stosb, set up es
|
|
pop es ; as destination.
|
|
assume es:@code ; let the assembler know :-)
|
|
cld ; make sure direction is right
|
|
|
|
; Copy all parameters into the bottom of the code segment. After doing so we
|
|
; will immediately switch stacks, so that the user stack is preserved intact.
|
|
mov ax, ss:[a_swap] ; save swap
|
|
mov es:swap, ax
|
|
mov ax, ss:[a_env] ; save env seg to use
|
|
mov es:envseg, ax
|
|
|
|
mov di, offset cs:cmdpath ; copy the command
|
|
lds si, ss:[a_prog] ; 65 bytes worth
|
|
mov cx, 65
|
|
call copy_data
|
|
|
|
mov di, offset cs:cmdtail ; copy the command tail
|
|
lds si, ss:[a_tail] ; 129 bytes worth
|
|
mov cx, 129
|
|
call copy_data
|
|
|
|
mov di, offset cs:tmpname ; copy the temp file name
|
|
lds si, ss:[a_tmp] ; 65 bytes worth.
|
|
mov cx, 65
|
|
call copy_data
|
|
|
|
; Now we save the current ss:sp stack pointer and swap stack to our temporary
|
|
; stack located in the current code segment. At the same time we reset the
|
|
; segment pointers to point into the code segment only.
|
|
swap_stacks: mov ax, ss
|
|
mov es:old_ss, ax
|
|
mov es:old_sp, sp
|
|
mov ax, cs
|
|
mov ds, ax
|
|
mov ss, ax ; set ss first, ints are then
|
|
mov sp, offset cs:exec_sp ; disabled for this instr too
|
|
assume ds:@code, ss:@code ; let the assembler know :-)
|
|
|
|
; Now we save the old control break and critical error handler addresses.
|
|
; We replace them by our own routines found in the resident portion of the
|
|
; swapping exec code.
|
|
set_handlers: mov [interrupted], 0 ; clear interrupted flag
|
|
mov [eretcode], 0 ; clear the return code
|
|
mov ax, 03523H ; get int 23 handler address
|
|
int 21H
|
|
mov cs:old_ctl_brk_off, bx
|
|
mov cs:old_ctl_brk_seg, es
|
|
mov dx, offset ctl_brk_handler
|
|
mov ax, 02523H ; set int 23 handler address
|
|
int 21H
|
|
|
|
mov ax, 03524H ; get int 24 handler address
|
|
int 21H
|
|
mov cs:old_crit_err_off, bx
|
|
mov cs:old_crit_err_seg, es
|
|
mov dx, offset crit_err_handler
|
|
mov ax, 02524H ; set int 24 handler address
|
|
int 21H
|
|
|
|
; Go and execute the child, we've set up all of its parameters. The do_exec
|
|
; routine will attempt to perform a swap of the code if requested to do so by
|
|
; a non-zero value in the variable cs:swap.
|
|
mov ah, 051H ; get the psp
|
|
int 21H
|
|
mov cs:psp, bx
|
|
call do_exec
|
|
|
|
; We're back from the exec, so fix things up the way they were.
|
|
; Restore the old control-break and critical-error handlers.
|
|
lds dx, cs:old_ctl_brk
|
|
mov ax, 02523H
|
|
int 21H
|
|
lds dx, cs:old_crit_err
|
|
mov ax, 02524H
|
|
int 21H
|
|
|
|
; Restore previous program stack segment registers, and data segment.
|
|
mov ax, cs:old_ss
|
|
mov ss, ax ; mov into ss first, that way
|
|
mov sp, cs:old_sp ; no interrupts in this instr.
|
|
pop ds
|
|
|
|
; Tell the assembler we have swaped segments again.
|
|
assume ds:DGROUP,es:DGROUP,ss:DGROUP
|
|
|
|
; Set the global Interrupted flag so that parent can tell it was interrupted.
|
|
mov ax, seg DGROUP:_Interrupted
|
|
mov es, ax
|
|
mov ax, cs:interrupted
|
|
mov es:_Interrupted, ax
|
|
|
|
; Set the global errno value to reflect the success/failure of the DOS
|
|
; exec call.
|
|
mov ax, seg DGROUP:_errno
|
|
mov es, ax
|
|
mov ax, cs:ex_error
|
|
mov es:_errno, ax
|
|
|
|
; Fetch the child's return code, pop rest of stuff off of the stack
|
|
; and return to the caller.
|
|
mov ax, cs:eretcode
|
|
pop di
|
|
pop si
|
|
pop bp
|
|
ret
|
|
_exec endp
|
|
|
|
; void do_hook_std_writes(int handle);
|
|
; This saves the 21h interrupt vector and changes it to point
|
|
; into this code. Argument is the file handle of the -C file.
|
|
|
|
public _do_hook_std_writes
|
|
_do_hook_std_writes proc
|
|
push bp
|
|
mov bp,sp
|
|
push di
|
|
|
|
mov di, ss:[a_handle] ; handle of -C file
|
|
mov std_fil_handle, di
|
|
|
|
mov ah, 51h ; request our PSP
|
|
int 21h
|
|
mov [psp], bx ; save it
|
|
|
|
mov es, bx
|
|
les bx, es:[34h] ; pointer to job file table
|
|
mov al, es:[bx+1] ; system file # of our stdout
|
|
mov [our_stdout], al
|
|
mov al, es:[bx+di] ; system file number of -C file
|
|
mov std_fil_number, al
|
|
|
|
mov ax,3521h ; request vector 21h
|
|
int 21h ; it's returned in ES:BX
|
|
mov word ptr [real_21h], bx
|
|
mov word ptr [real_21h+2], es
|
|
|
|
push ds
|
|
mov ax,cs
|
|
mov ds,ax
|
|
lea dx,our_21h_handler ; DS:DX is the new vector
|
|
mov ax,2521h ; set vector 21h
|
|
int 21h
|
|
|
|
pop ds
|
|
pop di
|
|
pop bp
|
|
ret
|
|
_do_hook_std_writes endp
|
|
|
|
; void do_unhook_std_writes(void);
|
|
; This restores the 21h interrupt vector.
|
|
; The saved vector is zero if it wasn't changed (no -C option).
|
|
|
|
public _do_unhook_std_writes
|
|
_do_unhook_std_writes proc
|
|
push ds
|
|
|
|
lds dx, [real_21h] ; put saved vector into DS:DX
|
|
mov ax, ds
|
|
or ax, dx
|
|
jz unhook_return ; zero means we didn't hook 21h
|
|
|
|
mov ax,2521h ; set vector 21h
|
|
simulate_21h
|
|
|
|
unhook_return: pop ds
|
|
ret
|
|
_do_unhook_std_writes endp
|
|
end
|