mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2318 lines
67 KiB
2318 lines
67 KiB
PAGE ,132
|
|
TITLE DXBOOT.ASM -- Dos Extender Startup Code
|
|
|
|
; Copyright (c) Microsoft Corporation 1988-1991. All Rights Reserved.
|
|
|
|
;****************************************************************
|
|
;* *
|
|
;* DXBOOT.ASM - Dos Extender Startup Code *
|
|
;* *
|
|
;****************************************************************
|
|
;* *
|
|
;* Module Description: *
|
|
;* *
|
|
;* This module contains real mode initialization code that *
|
|
;* initializes the dos extender itself. This includes *
|
|
;* allocating and initializing the descriptor tables, and *
|
|
;* relocating the dos extender for protected mode operation. *
|
|
;* *
|
|
;****************************************************************
|
|
;* Revision History: *
|
|
;* *
|
|
;* 01/29/92 mattfe Build for MIPS *
|
|
;* 12/19/90 amitc NetHeapSize default made 4k from 8k *
|
|
;* 12/03/90 amitc Added support for 'Win30CommDriver' switch *
|
|
; in system.ini *
|
|
;* 10/09/90 earleh split LDT from GDT and reduced XMS handles *
|
|
;* needed to boot program to 1 *
|
|
;* 08/08/90 earleh DOSX and client privilege ring determined *
|
|
;* by equate in pmdefs.inc *
|
|
;* 05/07/90 jimmat Started VCPI related changes. *
|
|
;* 04/09/90 jimmat Detect if on 286 & 287 installed. *
|
|
;* 04/02/90 jimmat Added PM Int 70h handler. *
|
|
;* 09/27/89 jimmat Changes to use FindFile to locate child *
|
|
;* program. *
|
|
;* 08/29/89 jimmat Now hooks real mode Int 2Fh chain. *
|
|
;* 08/20/89 jimmat Removed A20 code since HIMEM version 2.07 *
|
|
;* now works properly across processor resets. *
|
|
;* 07/28/89 jimmat Int PM Int 30h & 41h to be ignored, not *
|
|
;* reflected to real mode. *
|
|
;* 07/14/89 jimmat Added call to EMMDisable *
|
|
;* 06/16/89 jimmat Ifdef'd combined DOSX/child .EXE code *
|
|
;* 05/22/89 jimmat Added Int 13h/25h/26h/67h hooks. *
|
|
;* 05/18/89 jimmat Added setting of real mode Int 30h hook. *
|
|
;* 03/31/89 jimmat Added Priv Level to selectors during *
|
|
;* relocation and removed some dead code. *
|
|
;* 03/15/89 jimmat Added INT 31h hook *
|
|
;* 03/11/89 jimmat Added support for TSS & LDT & ring 1 *
|
|
;* 03/07/89 jimmat Converted to use WDEB386 debugger *
|
|
;* 02/25/89 (GeneA): added support for combined exe file where *
|
|
;* the Dos Extender and the child reside in the same exe *
|
|
;* file. *
|
|
;* 02/17/89 (GeneA): fixed error handling code during init. *
|
|
;* 02/14/89 (GeneA): added initialization of INT15h vector, *
|
|
;* and changed segment limit of BIOS_CODE segment to *
|
|
;* 64k. *
|
|
;* 02/14/89 (GeneA): added code to copy protected mode code *
|
|
;* segment up into extended memory. Also code to allocate *
|
|
;* and copy GDT and IDT in extended memory. *
|
|
;* 01/31/89 (GeneA): reorganization of code. This module now *
|
|
;* contains only code for initializing the Dos Extender *
|
|
;* itself. *
|
|
;* 01/25/89 (GeneA): moved code for loading and relocating *
|
|
;* the child program here from dxinit.asm *
|
|
;* 01/24/89 (Genea): removed routines for hooking into real *
|
|
;* mode int 2Fh. (part of removing real mode int 2Fh *
|
|
;* interface from the dos extender). *
|
|
;* 12/13/88 (GeneA): created by moving code from DXINIT.ASM *
|
|
;* *
|
|
;****************************************************************
|
|
|
|
.286p
|
|
.287
|
|
|
|
; -------------------------------------------------------
|
|
; INCLUDE FILE DEFINITIONS
|
|
; -------------------------------------------------------
|
|
|
|
.xlist
|
|
.sall
|
|
include segdefs.inc
|
|
include gendefs.inc
|
|
include pmdefs.inc
|
|
include dpmi.inc
|
|
ifdef WOW_x86
|
|
include vdmtib.inc
|
|
endif
|
|
include intmac.inc
|
|
include dbgsvc.inc
|
|
.list
|
|
|
|
; -------------------------------------------------------
|
|
; GENERAL SYMBOL DEFINITIONS
|
|
; -------------------------------------------------------
|
|
|
|
;
|
|
; This structure defines the format of the EXE file header.
|
|
|
|
EXEHDR struc
|
|
|
|
idExeFile dw ? ;magic number to identify EXE file
|
|
cbLastPage dw ? ;number of bytes in last page of the file
|
|
crgbFileLen dw ? ;number of 512 byte pages in the file
|
|
clpRelocLen dw ? ;number of relocation entries in the table
|
|
cparHdrSize dw ? ;number of 16 byte paragraphs in header
|
|
cparMinAlloc dw ?
|
|
cparMaxAlloc dw ?
|
|
segStackInit dw ? ;initial stack segment
|
|
offStackInit dw ? ;initial stack pointer
|
|
wCheckSum dw ?
|
|
offCodeInit dw ? ;initial program counter
|
|
segCodeInit dw ? ;initial code segment
|
|
wRelocOffset dw ? ;byte offset of relocation table
|
|
idOverlay dw ? ;overlay number
|
|
|
|
EXEHDR ends
|
|
|
|
;
|
|
; This structure defines the parameter block to the XMS driver block
|
|
; move function.
|
|
|
|
XMSMOVE struc
|
|
|
|
cbxmsLen dd ? ;length of memory block
|
|
hxmsSource dw ? ;XMS source block handle
|
|
oxmsSource dd ? ;source offset
|
|
hxmsDest dw ? ;XMS destination block handle
|
|
oxmsDest dd ? ;destination offset
|
|
|
|
XMSMOVE ends
|
|
|
|
NOP_OPCODE equ 090h ; NO-OP opcode
|
|
IRET_OPCODE equ 0CFh ; IRET opcode
|
|
FAR_JMP_OPCODE equ 0EAh ; JMP FAR opcode
|
|
SHORT_JMP_OPCODE equ 0EBh ; JMP SHORT opcode
|
|
|
|
; -------------------------------------------------------
|
|
; EXTERNAL SYMBOL DEFINITIONS
|
|
; -------------------------------------------------------
|
|
|
|
extrn PMIntr31:NEAR
|
|
extrn PMIntr13:NEAR
|
|
extrn PMIntr19:NEAR
|
|
extrn PMIntr28:NEAR
|
|
extrn PMIntr25:NEAR
|
|
extrn PMIntr26:NEAR
|
|
extrn PMIntr4B:NEAR
|
|
extrn PMIntrDos:NEAR
|
|
extrn PMIntrMisc:NEAR
|
|
extrn PMIntrVideo:NEAR
|
|
extrn PMIntrMouse:NEAR
|
|
extrn PMIntrIgnore:NEAR
|
|
extrn PMIntrEntryVector:NEAR
|
|
extrn PMFaultEntryVector:NEAR
|
|
extrn ReadINIFile:NEAR
|
|
ifdef NEC_98 ;
|
|
extrn PMIntrSound:NEAR ; for Sound Bios
|
|
extrn PMIntrExDos:NEAR ; for Extend Dos Function
|
|
extrn PMIntr11dummy:NEAR
|
|
extrn PMIntrPrinter:NEAR
|
|
extrn PMIntrCalTi:NEAR
|
|
extrn PMIntrGraph:NEAR
|
|
endif ;NEC_98 ;
|
|
|
|
extrn EMMDisable:NEAR
|
|
extrn FindFIle:NEAR
|
|
|
|
ifdef WOW_x86
|
|
extrn NpxExceptionHandler:near
|
|
extrn EndNpxExceptionHandler:near
|
|
endif
|
|
|
|
extrn RmUnsimulateProc:FAR
|
|
extrn PmUnsimulateProc:FAR
|
|
|
|
extrn PMFaultHandlerIRET:NEAR
|
|
extrn PMFaultHandlerIRETD:NEAR
|
|
extrn PMIntHandlerIRET:NEAR
|
|
extrn PMIntHandlerIRETD:NEAR
|
|
extrn PMDosxIret:NEAR
|
|
extrn PMDosxIretd:NEAR
|
|
|
|
extrn RMCallBackBop:FAR
|
|
extrn RMtoPMReflector:FAR
|
|
|
|
extrn RmSaveRestoreState:far
|
|
extrn PmSaveRestoreState:far
|
|
extrn RmRawModeSwitch:far
|
|
extrn PmRawModeSwitch:far
|
|
extrn DPMI_MsDos_API:far
|
|
extrn VCD_PM_Svc_Call:far
|
|
extrn XmsControl:far
|
|
extrn HungAppExit:far
|
|
|
|
DXPMCODE segment
|
|
extrn CodeEndPM:NEAR
|
|
externFP NSetSegmentDscr
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
; DATA SEGMENT DEFINITIONS
|
|
; -------------------------------------------------------
|
|
|
|
DXDATA segment
|
|
|
|
extrn selGDT:WORD
|
|
extrn segGDT:WORD
|
|
extrn selIDT:WORD
|
|
extrn segIDT:WORD
|
|
extrn bpGDT:FWORD
|
|
extrn bpIDT:FWORD
|
|
extrn sysTSS:WORD
|
|
extrn segPSP:WORD
|
|
extrn selPSP:WORD
|
|
extrn hmemDOSX:WORD
|
|
extrn f286_287:BYTE
|
|
extrn bpRmIVT:FWORD
|
|
extrn fhExeFile:WORD
|
|
extrn idCpuType:WORD
|
|
extrn cdscGDTMax:WORD
|
|
extrn rgbXfrBuf0:BYTE
|
|
extrn rgbXfrBuf1:BYTE
|
|
extrn clpRelocItem:WORD
|
|
extrn plpRelocItem:WORD
|
|
extrn lpfnXMSFunc:DWORD
|
|
ifdef NEC_98 ;
|
|
extrn fPCH98:BYTE ; PC-H98 flag
|
|
extrn fNHmode:BYTE ; NHmode flag
|
|
endif ;NEC_98 ;
|
|
extrn lpfnUserMouseHandler:DWORD
|
|
extrn fUsingHMA:BYTE
|
|
ifdef WOW_x86
|
|
extrn rgwWowStack:word
|
|
extrn FastBop:fword
|
|
endif
|
|
extrn pbHwIntrStack:word
|
|
|
|
IFNDEF WOW_x86
|
|
extrn IretBopTable:BYTE
|
|
ENDIF
|
|
|
|
public fDebug
|
|
fDebug db 0
|
|
|
|
szModName db 'DOSX',0 ;Our module name for use by WDEB386
|
|
|
|
|
|
if DEBUG
|
|
public lpchFileName
|
|
lpchFileName dd ?
|
|
endif
|
|
|
|
|
|
INIFileName db 'SYSTEM.INI',0 ;.INI file to read
|
|
|
|
public NetHeapSize, Int28Filter
|
|
|
|
INIKeywords label byte
|
|
db '[standard]',0
|
|
db 'netheapsize',0
|
|
NetHeapSize dw 4 ;default is 8k
|
|
db 'int28filter',0
|
|
Int28Filter dw 10 ;default is every 10th
|
|
|
|
if DEBUG ;------------------------------------------------------------
|
|
public fTraceDOS
|
|
db 'tracedos',0
|
|
fTraceDOS dw 0
|
|
public fTraceFault
|
|
db 'tracefault',0
|
|
fTraceFault dw 0
|
|
public fTraceA20
|
|
db 'tracea20',0
|
|
fTraceA20 dw 1
|
|
public TrapDOS
|
|
db 'trapdos',0
|
|
TrapDOS dw 0
|
|
db 'tableslow',0
|
|
fTablesLow dw 0
|
|
public fTraceReflect
|
|
db 'tracereflect',0
|
|
fTraceReflect dw 0
|
|
public fTraceMode
|
|
db 'tracemode',0
|
|
fTraceMode dw 0
|
|
endif ;DEBUG --------------------------------------------------------
|
|
db 0
|
|
|
|
szExeExtension db '.exe',0
|
|
|
|
|
|
; The following set of variables are used when copying our Pmode data
|
|
; structures into a HIMEM-allocated block.
|
|
|
|
public lmaIDT,lmaGDT,lmaDXPMCODE
|
|
|
|
CBIDTOFF = 0
|
|
CBGDTOFF = CDSCIDTDEFAULT * 8
|
|
IFNDEF WOW_x86
|
|
CBDXPMCODEOFF = CBGDTOFF + GDT_SIZE
|
|
ELSE
|
|
;
|
|
; Since we have no GDT for wow, we do not need space for it.
|
|
;
|
|
CBDXPMCODEOFF = CBGDTOFF
|
|
ENDIF
|
|
CBTABLESIZE = CBDXPMCODEOFF
|
|
|
|
.errnz CBIDTOFF and 0fh
|
|
.errnz CBGDTOFF and 0fh
|
|
.errnz CBDXPMCODEOFF and 0fh
|
|
|
|
lmaIDT dd CBIDTOFF
|
|
lmaGDT dd CBGDTOFF
|
|
lmaDXPMCODE dd CBDXPMCODEOFF
|
|
lmaLDT dd CBDXPMCODEOFF
|
|
|
|
|
|
extrn rgwStack:WORD
|
|
DXDATA ends
|
|
|
|
|
|
DXSTACK segment
|
|
extrn ResetStack:WORD
|
|
DXSTACK ends
|
|
|
|
; -------------------------------------------------------
|
|
page
|
|
; -------------------------------------------------------
|
|
; CODE SEGMENT VARIABLES
|
|
; -------------------------------------------------------
|
|
|
|
DXCODE segment
|
|
|
|
;************************************************************************
|
|
;
|
|
; REMEMBER... any code segment variables defined in this file
|
|
; will be discarded after initialization.
|
|
;
|
|
;************************************************************************
|
|
|
|
extrn CodeEnd:NEAR
|
|
extrn segDXCode:WORD
|
|
extrn segDXData:WORD
|
|
extrn selDgroup:WORD
|
|
|
|
ErrMsg MACRO name
|
|
extrn ER_&name:BYTE
|
|
ERC_&name equ offset ER_&name
|
|
ENDM
|
|
|
|
ErrMsg CPUTYPE
|
|
ErrMsg DXINIT
|
|
ErrMsg PROTMODE
|
|
ErrMsg NOHIMEM
|
|
ErrMsg EXTMEM
|
|
ErrMsg NOEXE
|
|
|
|
extrn RMInt2FHandler:NEAR
|
|
|
|
extrn PrevInt2FHandler:DWORD
|
|
|
|
szWinKernel db 'krnl386.exe',0
|
|
|
|
lpfnPrevXMS dd 0
|
|
|
|
|
|
DXCODE ends
|
|
|
|
|
|
DXPMCODE segment
|
|
|
|
extrn selDgroupPM:WORD
|
|
|
|
extrn segDXCodePM:WORD
|
|
extrn segDXDataPM:WORD
|
|
|
|
DXPMCODE ends
|
|
|
|
; -------------------------------------------------------
|
|
page
|
|
|
|
DXCODE segment
|
|
assume cs:DXCODE
|
|
; -------------------------------------------------------
|
|
; MAIN INITIALIZATION ROUTINES
|
|
; -------------------------------------------------------
|
|
|
|
; InitDosExtender -- This routine is the executive
|
|
; for initializing the dos extender.
|
|
;
|
|
; Input: none
|
|
; Output: various global tables and variables initialized.
|
|
; Dos Extender relocated for protected mode execution
|
|
; and moved into extended memory.
|
|
; Errors: returns CY set if error occurs, pointer to error message
|
|
; in DX
|
|
; Uses:
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public InitDosExtender
|
|
|
|
InitDosExtender:
|
|
|
|
; Init the key code & data segment variables.
|
|
|
|
mov ax,cs
|
|
mov segDXCode,ax
|
|
|
|
mov ax,ds
|
|
mov segDXData,ax
|
|
mov selDgroup,ax
|
|
|
|
push es
|
|
mov ax,seg DXPMCODE
|
|
mov es,ax
|
|
assume es:DXPMCODE
|
|
|
|
mov selDgroupPM,SEL_DXDATA or STD_RING
|
|
mov segDXCodePM,cs
|
|
mov segDXDataPM,ds
|
|
pop es
|
|
assume es:DGROUP
|
|
|
|
|
|
|
|
; Do an initial shrink of our program memory. This assumes that DXPMCODE
|
|
; is the last segment in program.
|
|
|
|
mov bx,(offset DXPMCODE:CodeEndPM) + 10h
|
|
shr bx,4
|
|
add bx,seg DXPMCODE
|
|
sub bx,segPSP
|
|
mov es,segPSP
|
|
dossvc 4Ah
|
|
|
|
push ds
|
|
pop es
|
|
|
|
|
|
; Determine the type of CPU we are running on and make sure it is
|
|
; at least an 80286.
|
|
|
|
call CheckCPUType
|
|
cmp ax,2
|
|
jae indx14
|
|
mov ax,ERC_CPUTYPE
|
|
jmp indx80
|
|
indx14:
|
|
|
|
|
|
; If running on a 286, see if there is a 287 coprocessor installed
|
|
|
|
ifdef NEC_98 ;
|
|
;------------------- 90/08/15 --------------------
|
|
;check N/H at system area BIOS_FLAG(0:501h)
|
|
;if H mode, fNHmode bit on.
|
|
push es
|
|
push ax
|
|
mov ax,0
|
|
mov es,ax
|
|
test byte ptr es:[501h],8h ;if Hmode
|
|
jz not_Hmode
|
|
mov fNHmode,0FFh ;Now! Running on Hmode!!! 90/07/07
|
|
not_Hmode:
|
|
pop ax
|
|
pop es
|
|
;------------------- 90/08/15 --------------------
|
|
; If running on a 286, see if there is a 287 coprocessor installed
|
|
cmp al,2 ;286 processor?
|
|
jnz EMM_Disable
|
|
test fNHmode,0FFh
|
|
jz Copro_Nmode
|
|
;----- 90/07/04 in -----
|
|
; check co-processor exist at memory-switch
|
|
;----------------- Hmode -----------------
|
|
push ds
|
|
push bx
|
|
;;;;;;;; mov bx,0Eh
|
|
mov bx,0E000h ;90/10/04 bug
|
|
mov ds,bx
|
|
mov bx,3FEAh
|
|
mov al,byte ptr ds:[bx]
|
|
pop bx
|
|
pop ds
|
|
test al,08h ;0=none,1=exists
|
|
jmp Coprocessor
|
|
Copro_Nmode:
|
|
;----------------- Nmode -----------------
|
|
push ds
|
|
push bx
|
|
;;;;;;;; mov bx,0Ah
|
|
mov bx,0A000h ;90/10/04 bug
|
|
mov ds,bx
|
|
mov bx,3FEAh
|
|
mov al,byte ptr ds:[bx]
|
|
pop bx
|
|
pop ds
|
|
test al,08h ;0=none,1=exists
|
|
Coprocessor:
|
|
jz EMM_Disable
|
|
inc f286_287 ; yup, 286 & 287
|
|
EMM_Disable:
|
|
else ;NEC_98 ;
|
|
cmp al,2 ;286 processor?
|
|
jnz @f
|
|
|
|
int 11h ;math coprocessor installed?
|
|
test al,2
|
|
jz @f
|
|
ifndef WOW_x86
|
|
inc f286_287 ; yup, 286 & 287
|
|
endif
|
|
@@:
|
|
endif ;NEC_98 ;
|
|
|
|
; If on a 386 or greater, try to disable the EMM drivers we know about
|
|
|
|
call EMMDisable
|
|
|
|
; Check if the machine is already running in protected mode. If so, we
|
|
; can't run.
|
|
ifndef WOW_x86
|
|
smsw ax
|
|
test ax,1 ;check the protected mode bit
|
|
jz @f
|
|
mov ax,ERC_PROTMODE
|
|
jmp indx80
|
|
endif
|
|
@@:
|
|
|
|
; Get the full pathname of our EXE file, it's needed in a couple of places
|
|
|
|
call GetExeName
|
|
jnc @F
|
|
mov ax,ERC_DXINIT
|
|
jmp indx80
|
|
@@:
|
|
|
|
; Determine if the real mode Int 28h vector points anywhere. If it doesn't
|
|
; then we don't need to reflect Int 28h calls from protected to real mode.
|
|
; The user can still override this by putting a Int28Filter= entry in
|
|
; SYSTEM.INI.
|
|
|
|
push es
|
|
mov ax,3528h
|
|
int 21h
|
|
assume es:NOTHING
|
|
|
|
cmp byte ptr es:[bx],IRET_OPCODE ;Int 28h -> IRET?
|
|
jne @f
|
|
mov Int28Filter,0 ; yes, don't need to reflect
|
|
@@:
|
|
pop es
|
|
assume es:DGROUP
|
|
|
|
; Read SYSTEM.INI for any parameter overrides - NOTE: requires GetExeName
|
|
; having been run first!
|
|
|
|
mov bx,offset INIKeywords
|
|
mov dx,offset INIFileName
|
|
call ReadINIFile
|
|
|
|
; Check that the HIMEM.SYS driver is installed so that we can use it
|
|
; for extended memory management.
|
|
|
|
call SetupHimemDriver
|
|
jnc @F ; Himem is OK.
|
|
mov ax,ERC_NOHIMEM
|
|
jmp indx80
|
|
@@:
|
|
|
|
ifdef NEC_98 ;
|
|
push es
|
|
xor ax, ax
|
|
mov es, ax
|
|
test byte ptr es:[458h], 80h ; if NESA
|
|
jz not_MC
|
|
mov fPCH98, 0FFh ; it's a NPC NESA
|
|
not_MC:
|
|
pop es
|
|
assume es:DGROUP
|
|
endif ;NEC_98 ;
|
|
|
|
; Hook the real mode int vectors
|
|
|
|
mov ax,352Fh ;get previous Int 2Fh vector
|
|
int 21h
|
|
assume es:NOTHING
|
|
|
|
mov word ptr [PrevInt2FHandler],bx
|
|
mov word ptr [PrevInt2FHandler+2],es
|
|
|
|
push ds
|
|
pop es
|
|
assume es:DGROUP
|
|
|
|
mov ax,cs ;point to our rMode Int 2Fh
|
|
mov ds,ax
|
|
assume ds:NOTHING
|
|
mov dx,offset DXCODE:RMInt2FHandler
|
|
mov ax,252Fh
|
|
int 21h
|
|
|
|
push es
|
|
pop ds
|
|
assume ds:DGROUP
|
|
|
|
; Allocate and initialize the descriptor tables and TSS.
|
|
|
|
cCall AllocateExtMem
|
|
jnc indx20
|
|
mov ax,ERC_EXTMEM
|
|
jmp indx80
|
|
indx20:
|
|
|
|
push es
|
|
push bx
|
|
push dx
|
|
push di
|
|
push si
|
|
|
|
;
|
|
; Bop to initialize 32 bit support.
|
|
;
|
|
|
|
mov di, sp ;original stack offset
|
|
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:HungAppExit
|
|
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:XmsControl
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:DPMI_MsDos_API
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:VCD_PM_Svc_Call
|
|
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:PmRawModeSwitch
|
|
push segDXCode
|
|
push offset DXCODE:RmRawModeSwitch
|
|
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:PmSaveRestoreState
|
|
push segDXCode
|
|
push offset DXCODE:RmSaveRestoreState
|
|
|
|
mov bx,cdscGDTMax
|
|
shl bx,3
|
|
dec bx
|
|
push bx ;Initial LDT size
|
|
push selGDT
|
|
|
|
push SEL_DXPMCODE OR STD_RING ;pm reflector seg
|
|
|
|
push segDXCode
|
|
push offset DXCODE:RMtoPMReflector
|
|
push segDXCode
|
|
push offset DXCODE:RMCallBackBop
|
|
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:PMDosxIretd
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:PMDosxIret
|
|
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:PMIntHandlerIRETD
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:PMIntHandlerIRET
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:PMFaultHandlerIRETD
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:PMFaultHandlerIRET
|
|
|
|
push SEL_DXCODE OR STD_RING
|
|
push segDXCode
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push offset DXPMCODE:PmUnsimulateProc
|
|
push segDXCode
|
|
push offset DXCODE:RmUnsimulateProc
|
|
push word ptr CB_STKFRAME
|
|
push segDXData
|
|
mov si,sp ;pass stack offset
|
|
DPMIBOP InitDosxRM
|
|
mov sp, di ;restore stack
|
|
|
|
ifdef WOW_x86
|
|
mov word ptr [FastBop],bx
|
|
mov word ptr [FastBop + 2],dx
|
|
mov word ptr [FastBop + 4],es
|
|
endif
|
|
|
|
pop si
|
|
pop di
|
|
pop dx
|
|
pop bx
|
|
pop es
|
|
|
|
call InitGlobalDscrTable ;set up the GDT
|
|
|
|
call SendDbgNotification ;tell NTSD about our segments
|
|
|
|
call InitIntrDscrTable ;set up the IDT
|
|
|
|
ifndef WOW_x86 ;bugbug
|
|
call InitTaskStateSeg ;set up the TSS
|
|
endif
|
|
|
|
if DEBUG
|
|
|
|
; DOSX is written such that it does not require any segment fix ups for
|
|
; protected mode operation. This wasn't always the case, and it's easy
|
|
; to make create dependencies so the routine CheckDOSXFixUps exists in
|
|
; the debug version to check for segment fix ups in non-initialization
|
|
; code.
|
|
|
|
call CheckDOSXFixUps
|
|
jnc @F
|
|
mov ax,ERC_DXINIT
|
|
jmp short indx80
|
|
@@:
|
|
endif ;DEBUG
|
|
|
|
; Move the Extended memory segment up into extended memory.
|
|
|
|
mov dx,seg DXPMCODE
|
|
call MoveDosExtender
|
|
jc indx80
|
|
|
|
|
|
; Move the GDT and IDT up into extended memory.
|
|
|
|
call MoveDscrTables
|
|
|
|
; Parse the command line, and locate the child exe file
|
|
|
|
call ParseCommandLine
|
|
|
|
IFNDEF WHEN_COMMAND_COM_WORKS
|
|
if WINDOWS ;--------------------------------------------------------
|
|
|
|
; If this is a Windows specific version of DOSX, we only run one child EXE
|
|
; (krnl?86.exe).
|
|
|
|
push ds
|
|
push cs
|
|
pop ds
|
|
assume ds:NOTHING
|
|
|
|
mov si,offset DXCODE:szWinKernel
|
|
mov di,offset RELOC_BUFFER
|
|
|
|
call strcpy
|
|
|
|
pop ds
|
|
assume ds:DGROUP
|
|
|
|
endif ;WINDOWS -------------------------------------------------
|
|
|
|
call FindFile ;setup done by ParseCommandLine
|
|
jnc indx70
|
|
mov ax,ERC_NOEXE
|
|
jmp short indx80
|
|
indx70:
|
|
ENDIF
|
|
|
|
; Initialized okay!
|
|
|
|
clc
|
|
jmp short indx90
|
|
|
|
; Error occured. Free any extended memory blocks allocated and then
|
|
; return the error code.
|
|
|
|
indx80: push ax ;save the error code
|
|
|
|
;
|
|
; If we have allocated an extended memory block, then free it.
|
|
; If we have allocated the HMA, then free it.
|
|
;
|
|
mov dx,hmemDOSX
|
|
or dx,dx
|
|
jz @F
|
|
xmssvc 0Dh
|
|
xmssvc 0Ah
|
|
|
|
@@:
|
|
cmp fUsingHMA,0
|
|
je @F
|
|
xmssvc 2
|
|
@@:
|
|
|
|
indxEXIT:
|
|
pop ax ;restore the error code
|
|
|
|
stc ;set error flag
|
|
|
|
indx90: ret
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; AllocateExtMem -- Allocates memory used by DOSX for
|
|
; system tables and protected mode
|
|
; code.
|
|
; Allocates a temporary buffer in
|
|
; DOS memory for building the
|
|
; IDT and GDT.
|
|
; Input: none
|
|
; Output: none
|
|
; Uses: Flags
|
|
; Error: Carry set if cannot allocate memory.
|
|
;
|
|
; History:
|
|
; 10/05/90 - earleh wrote it
|
|
|
|
assume ds:DGROUP,es:NOTHING,ss:NOTHING
|
|
|
|
cProc AllocateExtMem,<PUBLIC,NEAR>,<ax,bx,dx>
|
|
cBegin
|
|
|
|
; If there is sufficient XMS memory, increase the size of the GDT/LDT
|
|
; up to the max of 8k selectors.
|
|
|
|
add word ptr lmaLDT,offset DXPMCODE:CodeEndPM
|
|
adc word ptr lmaLDT+2,0
|
|
add word ptr lmaLDT,0Fh ;make sure LDT is para aligned
|
|
adc word ptr lmaLDT+2,0
|
|
and word ptr lmaLDT,0FFF0h
|
|
|
|
@@:
|
|
|
|
xmssvc 08h ;Query Free Extended memory
|
|
cmp dx,1024 ;is there more than 1 meg available?
|
|
jb @f
|
|
mov cdscGDTMax,CDSCMAXLDT ; yes, max out the GDT size
|
|
@@:
|
|
mov ax,cdscGDTMax
|
|
xor dx,dx
|
|
shl ax,3
|
|
adc dx,0
|
|
add ax,word ptr lmaLDT
|
|
adc dx,word ptr lmaLDT+2
|
|
add ax,1023d
|
|
adc dx,0 ; DX:AX = total extended memory needed
|
|
shl dx,6
|
|
shr ax,10d
|
|
or dx,ax ; DX = kbytes needed
|
|
mov si,dx ; SI = kbytes needed
|
|
xmssvc 09h ; allocate the XMS block
|
|
or ax,ax
|
|
jz axm_error
|
|
mov hmemDOSX,dx
|
|
xmssvc 0Ch ; lock it, DX:BX = address
|
|
or ax,ax
|
|
jz axm_error
|
|
|
|
axm_address:
|
|
|
|
add word ptr lmaIDT,bx ; relocate tables & Pmode code
|
|
adc word ptr lmaIDT+2,dx
|
|
add word ptr lmaGDT,bx
|
|
adc word ptr lmaGDT+2,dx
|
|
add word ptr lmaDXPMCODE,bx
|
|
adc word ptr lmaDXPMCODE+2,dx
|
|
add word ptr lmaLDT,bx
|
|
adc word ptr lmaLDT+2,dx
|
|
mov bx,(CDSCIDTDEFAULT + GDT_SELECTORS + 1) shr 1
|
|
dossvc 48h ; get a DOS block for building tables
|
|
jc axm_error ; abort if error
|
|
|
|
mov segIDT,ax
|
|
mov selIDT,ax
|
|
add ax,CDSCIDTDEFAULT shr 1
|
|
mov segGDT,ax
|
|
mov selGDT,ax
|
|
|
|
clc
|
|
jmp axm_exit
|
|
axm_error:
|
|
stc
|
|
axm_exit:
|
|
cEnd
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; SetupHimemDriver -- This routine checks that an XMS driver
|
|
; is installed and sets up for calling it.
|
|
;
|
|
; Input: none
|
|
; Output: none
|
|
; Errors: returns CY set if no driver available
|
|
; Uses: AX, all other registers preserved
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public SetupHimemDriver
|
|
|
|
SetupHimemDriver proc near
|
|
|
|
|
|
push bx
|
|
push es
|
|
|
|
; Check to see if there is an XMS driver resident.
|
|
|
|
mov ax,4300h
|
|
int 2Fh
|
|
cmp al,80h
|
|
jnz sthd80
|
|
|
|
; There is an XMS driver resident, so init for calling it.
|
|
|
|
mov ax,4310h
|
|
int 2Fh
|
|
mov word ptr [lpfnXMSFunc],bx
|
|
mov word ptr [lpfnXMSFunc+2],es
|
|
|
|
; Make sure this is the proper XMS/driver version
|
|
|
|
xmssvc 0 ;returns XMS vers in ax, driver vers in bx
|
|
cmp ax,300h ;assume okay if XMS 3.0 or above
|
|
jae @f
|
|
cmp ax,200h ;require at least XMS 2.00
|
|
jb sthd80
|
|
cmp bx,21Ch ;if XMS 2.x, require driver version 2.28+
|
|
jb sthd80 ; (himem used to have minor vers in decimal)
|
|
@@:
|
|
|
|
; Verify that the XMS driver's A20 functions work
|
|
|
|
xmssvc 5 ;local enable
|
|
or ax,ax
|
|
jz sthd80
|
|
|
|
xmssvc 7 ;query A20
|
|
push ax
|
|
|
|
xmssvc 6 ;local disable
|
|
or ax,ax
|
|
|
|
pop ax ;recover query status
|
|
jz sthd80
|
|
|
|
or ax,ax ;should be NZ, (A20 enabled status)
|
|
jz sthd80
|
|
|
|
; Looks good to me...
|
|
|
|
clc
|
|
jmp short sthd90
|
|
|
|
; No XMS driver resident or wrong version or we couldn't enable A20.
|
|
|
|
sthd80: stc
|
|
|
|
sthd90: pop es
|
|
pop bx
|
|
ret
|
|
|
|
SetupHimemDriver endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; MoveDosExtender -- This routine will move the Dos Extender
|
|
; protected mode segment up into extended memory.
|
|
; The himem driver function for moving memory blocks is used.
|
|
; The parameter block for this function is built in rgbXfrBuf0.
|
|
;
|
|
; Input: DX - real mode segment address of the segment to move
|
|
; Output: none
|
|
; Errors: returns CY set if error, Error code in AX
|
|
; Uses: AX used, all else preserved
|
|
; modifies rgbXfrBuf0
|
|
|
|
assume ds:DGROUP,es:NOTHING,ss:NOTHING
|
|
public MoveDosExtender
|
|
|
|
MoveDosExtender proc near
|
|
|
|
push bx
|
|
push cx
|
|
push dx
|
|
push si
|
|
|
|
cmp fUsingHMA,0
|
|
je mvdx40
|
|
|
|
;
|
|
; Our extended memory block is actually the HMA. Enable A20 and do
|
|
; the move ourselves.
|
|
;
|
|
|
|
xmssvc 5 ;local enable
|
|
|
|
push di
|
|
push ds
|
|
push es
|
|
mov cx,offset DXPMCODE:CodeEndPM
|
|
inc cx
|
|
and cx,0FFFEh
|
|
mov di,CBDXPMCODEOFF+10h
|
|
xor si,si
|
|
dec si
|
|
mov es,si
|
|
inc si
|
|
mov ds,dx
|
|
assume ds:NOTHING
|
|
;
|
|
; DS:SI = segIDT:0
|
|
; ES:DI = 0FFFF:CBDXPMCODEOFF+10h
|
|
; CX = code size
|
|
;
|
|
cld
|
|
rep movsb
|
|
pop es
|
|
assume ds:DGROUP
|
|
pop ds
|
|
pop di
|
|
|
|
xmssvc 6 ;local disable
|
|
|
|
jmp mvdx65
|
|
mvdx40:
|
|
; Move the data up into extended memory using the XMS driver's function.
|
|
|
|
mov si,offset DGROUP:rgbXfrBuf0
|
|
mov cx,offset DXPMCODE:CodeEndPM
|
|
inc cx
|
|
and cx,0FFFEh
|
|
mov word ptr [si].cbxmsLen,cx
|
|
mov word ptr [si].oxmsSource+2,dx ;real mode code segment address
|
|
mov ax,hmemDOSX
|
|
mov word ptr [si].hxmsDest,ax
|
|
xor ax,ax
|
|
mov word ptr [si].cbxmsLen+2,ax
|
|
mov [si].hxmsSource,ax
|
|
mov word ptr [si].oxmsSource,ax
|
|
mov word ptr [si].oxmsDest,CBDXPMCODEOFF
|
|
mov word ptr [si].oxmsDest+2,ax
|
|
|
|
xmssvc 0Bh
|
|
|
|
mvdx65:
|
|
clc
|
|
jmp short mvdx90
|
|
|
|
; Error occured
|
|
|
|
mvdx80: stc
|
|
|
|
mvdx90: pop si
|
|
pop dx
|
|
pop cx
|
|
pop bx
|
|
ret
|
|
|
|
MoveDosExtender endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; MoveDscrTables -- This routine will move the GDT
|
|
; and IDT up into extended memory. The himem driver
|
|
; function for moving memory blocks is used. The parameter
|
|
; block for this function is built in rgbXfrBuf0.
|
|
;
|
|
; Input: none
|
|
; Output: none
|
|
; Errors: returns CY set if error occurs. Error code in AX
|
|
; Uses: AX, all else preserved
|
|
; modifies rgbXfrBuf0
|
|
|
|
assume ds:DGROUP,es:NOTHING,ss:NOTHING
|
|
public MoveDscrTables
|
|
|
|
MoveDscrTables proc near
|
|
|
|
push bx
|
|
push si
|
|
push es
|
|
|
|
cmp fUsingHMA,0
|
|
je @F
|
|
|
|
;
|
|
; Our extended memory block is actually the HMA. Enable A20 and do
|
|
; the move ourselves.
|
|
;
|
|
|
|
xmssvc 5 ;local enable
|
|
|
|
push ds
|
|
push di
|
|
push cx
|
|
|
|
mov cx,CBTABLESIZE
|
|
mov di,10h
|
|
xor si,si
|
|
dec si
|
|
mov es,si
|
|
inc si
|
|
mov ds,segIDT
|
|
assume ds:NOTHING
|
|
;
|
|
; DS:SI = segIDT:0
|
|
; ES:DI = 0FFFF:10
|
|
; CX = tables size
|
|
;
|
|
cld
|
|
rep movsb
|
|
pop cx
|
|
pop di
|
|
pop ds
|
|
assume ds:DGROUP
|
|
|
|
xmssvc 6 ;local disable
|
|
|
|
clc
|
|
jmp mvdt_ret
|
|
|
|
@@:
|
|
|
|
; Move the GDT and IDT together.
|
|
|
|
mov si,offset DGROUP:rgbXfrBuf0
|
|
|
|
mov word ptr [si].cbxmsLen,CBTABLESIZE
|
|
mov word ptr [si].cbxmsLen+2,0
|
|
mov ax,segIDT
|
|
mov word ptr [si].oxmsSource+2,ax
|
|
mov ax,hmemDOSX
|
|
mov word ptr [si].hxmsDest,ax
|
|
xor ax,ax
|
|
mov [si].hxmsSource,ax
|
|
mov word ptr [si].oxmsSource,ax
|
|
mov word ptr [si].oxmsDest,ax
|
|
mov word ptr [si].oxmsDest+2,ax
|
|
|
|
xmssvc 0Bh
|
|
IFDEF WOW
|
|
;
|
|
; Move the initialized selectors from the gdt to the ldt
|
|
;
|
|
mov word ptr [si].cbxmsLen,GDT_SIZE
|
|
mov word ptr [si].cbxmsLen+2,0
|
|
mov ax,segGDT
|
|
mov word ptr [si].oxmsSource+2,ax
|
|
mov ax,hmemDOSX
|
|
mov word ptr [si].hxmsDest,ax
|
|
xor ax,ax
|
|
mov word ptr [si].hxmsSource,ax
|
|
mov word ptr [si].oxmsSource,ax
|
|
mov word ptr [si].oxmsDest+2,ax
|
|
mov word ptr [si].oxmsDest,CBTABLESIZE + offset DXPMCODE:CodeEndPM
|
|
|
|
xmssvc 0Bh
|
|
ENDIF
|
|
|
|
mvdt_ret:
|
|
|
|
mov es,segIDT ;free the low memory copy
|
|
dossvc 49h
|
|
|
|
pop es
|
|
pop si
|
|
pop bx
|
|
|
|
ret
|
|
|
|
MoveDscrTables endp
|
|
|
|
; -------------------------------------------------------
|
|
; Send Debugger Notification
|
|
|
|
SendDbgNotification proc near
|
|
IFDEF WOW
|
|
;
|
|
; Send load notification to the debugger for DXDATA
|
|
;
|
|
push 1 ; data
|
|
push ds ; exe name
|
|
push offset EXEC_DXNAME
|
|
push ds ; module name
|
|
push offset szModName
|
|
push 0
|
|
push SEL_DXDATA OR STD_RING
|
|
push DBG_SEGLOAD
|
|
BOP BOP_DEBUGGER
|
|
add sp,16
|
|
;
|
|
; Send load notification to the debugger for DXCODE
|
|
;
|
|
push 0 ; code
|
|
push ds ; exe name
|
|
push offset EXEC_DXNAME
|
|
push ds ; module name
|
|
push offset szModName
|
|
push 1
|
|
push SEL_DXCODE OR STD_RING
|
|
push DBG_SEGLOAD
|
|
BOP BOP_DEBUGGER
|
|
add sp,16
|
|
;
|
|
; Send load notification to the debugger
|
|
;
|
|
push 0 ; code
|
|
push ds ; exe name
|
|
push offset EXEC_DXNAME
|
|
push ds ; module name
|
|
push offset szModName
|
|
push 2
|
|
push SEL_DXPMCODE OR STD_RING
|
|
push DBG_SEGLOAD
|
|
BOP BOP_DEBUGGER
|
|
add sp,16
|
|
ENDIF
|
|
ret
|
|
SendDbgNotification endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; InitGlobalDscrTable -- This function will allocate a memory
|
|
; buffer from DOS and then initialize it as a global
|
|
; descriptor table. It will also initialize all global
|
|
; variables associated with GDT management.
|
|
; Descriptors in the range 0 - SEL_USER are given statically
|
|
; defined meanings. Descriptors from SEL_USER up are defined
|
|
; dynamically when a program is loaded or when dynamic memory
|
|
; management calls occur.
|
|
;
|
|
; NOTE: This routine works in real mode. The buffer where
|
|
; the GDT is built is in low memory.
|
|
;
|
|
; Input: AX - number of descriptors to initialize
|
|
; Output: none
|
|
; Errors: CY set if unable to obtain memory for the GDT
|
|
; Uses: AX used, all other registers preserved
|
|
; bpGDT initialized.
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public InitGlobalDscrTable
|
|
|
|
InitGlobalDscrTable proc near
|
|
|
|
push bx
|
|
push cx
|
|
push dx
|
|
push di
|
|
push es
|
|
|
|
mov word ptr [bpGDT+0],GDT_SIZE - 1
|
|
mov ax,word ptr lmaGDT
|
|
mov word ptr [bpGDT+2],ax
|
|
mov ax,word ptr lmaGDT+2
|
|
mov word ptr [bpGDT+4],ax
|
|
;
|
|
; Start by initializing the GDT to 0.
|
|
;
|
|
mov cx,GDT_SIZE shr 1
|
|
mov es,segGDT
|
|
assume es:NOTHING
|
|
xor ax,ax
|
|
mov di,ax
|
|
rep stosw
|
|
|
|
; Next, initialize the statically defined descriptors.
|
|
;
|
|
; Set up a descriptor for our protected mode code.
|
|
|
|
xor ax,ax ;AX = 0
|
|
mov dx,cs ;our code segment paragraph address
|
|
call B_ParaToLinear ;convert to linear byte address
|
|
mov cx,offset CodeEnd
|
|
cCall NSetSegmentDscr,<SEL_DXCODE,bx,dx,ax,cx,STD_CODE>
|
|
|
|
; Set up another one, but ring 0 this time. Limit should be 0FFFFh
|
|
; or 386 reset to real mode will not work properly.
|
|
|
|
mov cx,0FFFFh
|
|
cCall NSetSegmentDscr,<SEL_DXCODE0,bx,dx,ax,cx,ARB_CODE0>
|
|
;
|
|
; Set up one for the other segment, and a Ring 0 alias.
|
|
;
|
|
mov cx,offset CodeEndPM
|
|
mov bx,word ptr lmaDXPMCODE
|
|
mov dx,word ptr lmaDXPMCODE+2
|
|
cCall NSetSegmentDscr,<SEL_DXPMCODE,dx,bx,0,cx,STD_CODE>
|
|
cCall NSetSegmentDscr,<SEL_NBPMCODE,dx,bx,0,cx,STD_CODE>
|
|
|
|
|
|
ifndef WOW_x86
|
|
cCall NSetSegmentDscr,<SEL_EH,dx,bx,0,cx,EH_CODE>
|
|
else
|
|
cCall NSetSegmentDscr,<SEL_EH,dx,bx,0,cx,STD_CODE>
|
|
endif
|
|
mov cx,0FFFFh
|
|
|
|
; Set up a descriptor for our protected mode data and stack area.
|
|
|
|
mov dx,ds ;our data segment paragraph address
|
|
call B_ParaToLinear ;convert to linear byte address
|
|
cCall NSetSegmentDscr,<SEL_DXDATA,bx,dx,ax,cx,STD_DATA>
|
|
|
|
IFNDEF WOW_x86
|
|
; Set up descriptor for IRET HOOKS
|
|
push dx
|
|
push bx
|
|
add dx,offset IretBopTable
|
|
adc bx,0
|
|
cCall NSetSegmentDscr,<SEL_IRETHOOK,bx,dx,ax,cx,STD_CODE>
|
|
pop bx
|
|
pop dx
|
|
ELSE
|
|
; Set up descriptor for IRET HOOKS
|
|
push dx
|
|
push bx
|
|
add dx,offset FastBop
|
|
adc bx,0
|
|
cCall NSetSegmentDscr,<SEL_IRETHOOK,bx,dx,ax,cx,STD_CODE>
|
|
pop bx
|
|
pop dx
|
|
ENDIF
|
|
|
|
IFNDEF WOW_x86
|
|
; And another one of those for ring 0
|
|
|
|
cCall NSetSegmentDscr,<SEL_DXDATA0,bx,dx,ax,cx,ARB_DATA0>
|
|
ENDIF
|
|
;
|
|
; Set up descriptors pointing to our PSP and environment.
|
|
|
|
mov dx,segPSP ;segment address of the PSP
|
|
call B_ParaToLinear ;convert to linear byte address
|
|
cCall NSetSegmentDscr,<SEL_PSP,bx,dx,ax,cx,STD_DATA>
|
|
mov selPSP,SEL_PSP
|
|
;
|
|
push es
|
|
mov es,segPSP
|
|
assume es:PSPSEG
|
|
mov dx,segEnviron
|
|
call B_ParaToLinear
|
|
cCall NSetSegmentDscr,<SEL_ENVIRON,bx,dx,ax,7FFFH,STD_DATA>
|
|
pop es
|
|
assume es:nothing
|
|
|
|
; Set up a descriptor that points to the GDT.
|
|
|
|
mov dx,word ptr [bpGDT+2] ;get the GDT linear byte address
|
|
mov bx,word ptr [bpGDT+4]
|
|
mov cx,word ptr [bpGDT+0] ;get the GDT segment size
|
|
cCall NSetSegmentDscr,<SEL_GDT,bx,dx,ax,cx,STD_DATA>
|
|
|
|
|
|
; Set up a descriptor for the LDT and an LDT data alias.
|
|
|
|
mov cx,cdscGDTMax ;get count of descriptors
|
|
shl cx,3
|
|
dec cx
|
|
mov dx,word ptr lmaLDT
|
|
mov bx,word ptr lmaLDT+2
|
|
IFNDEF WOW_x86
|
|
cCall NSetSegmentDscr,<SEL_LDT,bx,dx,ax,cx,STD_LDT>
|
|
ENDIF
|
|
cCall NSetSegmentDscr,<SEL_LDT_ALIAS,bx,dx,ax,cx,STD_DATA>
|
|
|
|
; set up a readonly selector to the LDT for the wow kernel
|
|
cCall NSetSegmentDscr,<SEL_WOW_LDT,bx,dx,ax,cx,STD_DATA>
|
|
|
|
; Set up descriptors pointing to the BIOS code and data areas
|
|
|
|
mov cx,0FFFFH ; CX = 0FFFFH
|
|
cCall NSetSegmentDscr,<SEL_BIOSCODE,000fh,ax,ax,cx,STD_CODE>
|
|
|
|
mov dx,40h*16
|
|
cCall NSetSegmentDscr,<SEL_BIOSDATA,ax,dx,ax,cx,STD_DATA>
|
|
|
|
; Set up a descriptor pointing to the real mode interrupt vector table.
|
|
|
|
cCall NSetSegmentDscr,<SEL_RMIVT,ax,ax,ax,cx,STD_DATA>
|
|
|
|
IFNDEF WOW_x86
|
|
; Setup a selector and data alias for the TSS
|
|
|
|
mov dx,ds ;get base address of TSS
|
|
call B_ParaToLinear ; (it may not be para aligned)
|
|
add dx,offset DGROUP:sysTSS
|
|
adc bx,ax
|
|
|
|
mov cx,(TYPE TSS286) - 1
|
|
cCall NSetSegmentDscr,<SEL_TSS,bx,dx,ax,cx,STD_TSS>
|
|
cCall NSetSegmentDscr,<SEL_TSS_ALIAS,bx,dx,ax,cx,STD_DATA>
|
|
|
|
ENDIF
|
|
|
|
;
|
|
; Pass address of HwIntr stack, and form pointer to lockcount in
|
|
; VdmTib. This enables us to coordinate stack switching with
|
|
; the nt kernel and the monitor. These components will switch
|
|
; the stack on Hw Interrupt reflection, dosx will switch it
|
|
; back at iret.
|
|
;
|
|
|
|
push es
|
|
mov ax,SEL_DXDATA or STD_RING
|
|
mov es, ax
|
|
mov bx, pbHwIntrStack
|
|
DPMIBOP InitPmStackInfo
|
|
pop es
|
|
|
|
IFDEF WOW_x86
|
|
;
|
|
; Create a code selector for the NPX emulation exception handler
|
|
;
|
|
mov ax,offset EndNpxExceptionHandler
|
|
sub ax,offset NpxExceptionHandler
|
|
mov bx,offset DXPMCODE:NpxExceptionHandler
|
|
add bx,word ptr lmaDXPMCODE
|
|
mov dx,word ptr lmaDXPMCODE + 2
|
|
cCall NSetSegmentDscr,<SEL_NPXHDLR,dx,bx,0,ax,STD_CODE>
|
|
ENDIF
|
|
|
|
clc ;worked! make sure CY is clear
|
|
|
|
|
|
; All done
|
|
|
|
igdt90: pop es
|
|
pop di
|
|
pop dx
|
|
pop cx
|
|
pop bx
|
|
ret
|
|
|
|
InitGlobalDscrTable endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; InitIntrDscrTable -- This function will initialize the
|
|
; specified memory buffer as an Interrupt Descriptor Table,
|
|
; and set up all of the control variables associated with
|
|
; the IDT.
|
|
;
|
|
; NOTE: This routine works in real mode. The buffer where
|
|
; the IDT is built is in low memory.
|
|
; NOTE: The InitGlobalDscrTable function must be called before
|
|
; this function can be called.
|
|
;
|
|
; Input: AX - number of descriptors to initialize
|
|
; Output: none
|
|
; Errors: CY set if unable to obtain the memory required
|
|
; Uses: AX, all other registers preserved
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public InitIntrDscrTable
|
|
|
|
InitIntrDscrTable proc near
|
|
|
|
push bx
|
|
push cx
|
|
push dx
|
|
push si
|
|
push di
|
|
push es
|
|
|
|
ifndef WOW_x86
|
|
; Save the current pointer to the real mode interrupt vector table.
|
|
|
|
sidt fword ptr bpRmIVT
|
|
endif
|
|
mov es,selIDT
|
|
assume es:NOTHING
|
|
|
|
mov cx,256 ;number of descriptors in table
|
|
shl cx,3 ;convert to count of bytes
|
|
dec cx ;compute segment size limit
|
|
|
|
mov word ptr [bpIDT+0],cx
|
|
mov dx,word ptr lmaIDT
|
|
mov word ptr [bpIDT+2],dx
|
|
mov bx,word ptr lmaIDT+2
|
|
mov word ptr [bpIDT+4],bx
|
|
cCall NSetSegmentDscr,<SEL_IDT,bx,dx,0,cx,STD_DATA>
|
|
|
|
; Fill the IDT with interrupt gates that point to the fault handler and
|
|
; interrupt reflector entry vector.
|
|
|
|
xor di,di
|
|
|
|
mov dx,offset DXPMCODE:PmIntrEntryVector
|
|
mov cx,256
|
|
iidt23: mov es:[di].offDest,dx
|
|
mov es:[di].selDest,SEL_DXPMCODE or STD_RING
|
|
mov es:[di].cwParam,0
|
|
mov es:[di].arbGate,STD_TRAP ; BUGBUG- int gates not set up
|
|
mov es:[di].rsvdGate,0
|
|
add dx,5
|
|
add di,8
|
|
loop iidt23
|
|
|
|
; Now, fix up the ones that don't point to the interrupt reflector.
|
|
|
|
; BUGBUG In dxstrt.asm, these are x86 ONLY.
|
|
mov es:[1h*8].offDest,offset PMIntrIgnore
|
|
mov es:[3h*8].offDest,offset PMIntrIgnore
|
|
ifdef NEC_98 ;
|
|
mov es:[11h*8].offDest,offset PMIntr11dummy
|
|
mov es:[18h*8].offDest,offset PMIntrVideo
|
|
mov es:[1ah*8].offDest,offset PMIntrPrinter
|
|
mov es:[1bh*8].offDest,offset PMIntr13
|
|
mov es:[1ch*8].offDest,offset PMIntrCalTi
|
|
mov es:[1dh*8].offDest,offset PMIntrGraph
|
|
mov es:[1fh*8].offDest,offset PMIntrMisc
|
|
else ;NEC_98 ;
|
|
mov es:[10h*8].offDest,offset PMIntrVideo
|
|
mov es:[13h*8].offDest,offset PMIntr13
|
|
mov es:[15h*8].offDest,offset PMIntrMisc
|
|
mov es:[19h*8].offDest,offset PMIntr19
|
|
endif ;NEC_98 ;
|
|
|
|
mov es:[21h*8].offDest,offset DXPMCODE:PMIntrDos
|
|
mov es:[25h*8].offDest,offset DXPMCODE:PMIntr25
|
|
mov es:[26h*8].offDest,offset DXPMCODE:PMIntr26
|
|
mov es:[28h*8].offDest,offset DXPMCODE:PMIntr28
|
|
mov es:[30h*8].offDest,offset DXPMCODE:PMIntrIgnore
|
|
mov es:[31h*8].offDest,offset DXPMCODE:PMIntr31
|
|
mov es:[33h*8].offDest,offset DXPMCODE:PMIntrMouse
|
|
mov es:[41h*8].offDest,offset DXPMCODE:PMIntrIgnore
|
|
|
|
ifndef WOW_x86
|
|
mov es:[4Bh*8].offDest,offset DXPMCODE:PMIntr4B
|
|
ifdef NEC_98 ;
|
|
; Sound BIOS Int D2h handler
|
|
mov es:[0D2h*8].offDest,offset DXPMCODE:PMIntrSound
|
|
|
|
; Extended DOS Int DCh handler (KANA/KANJI)
|
|
mov es:[0DCh*8].offDest,offset DXPMCODE:PMIntrExDos
|
|
endif ;NEC_98 ;
|
|
endif
|
|
|
|
;
|
|
; Set up the IDT, and dpmi32 state
|
|
;
|
|
mov ax,es ; Idt selector
|
|
mov bx,VDM_INT_16
|
|
DPMIBOP InitIDT
|
|
|
|
mov ax,5 ; handler increment
|
|
mov cx,SEL_DXPMCODE OR STD_RING
|
|
mov dx,offset DXPMCODE:PmFaultEntryVector
|
|
|
|
DPMIBOP InitExceptionHandlers
|
|
|
|
|
|
.286p
|
|
; All done
|
|
|
|
iidt90: pop es
|
|
pop di
|
|
pop si
|
|
pop dx
|
|
pop cx
|
|
pop bx
|
|
ret
|
|
|
|
InitIntrDscrTable endp
|
|
|
|
; -------------------------------------------------------
|
|
;
|
|
; InitTaskStateSeg -- This function initializes the
|
|
; TSS for the DOS Extender.
|
|
;
|
|
; Input: none
|
|
; Output: none
|
|
; Errors: returns CY if unable to allocate memory
|
|
; Uses: all registers preserved
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public InitTaskStateSeg
|
|
|
|
InitTaskStateSeg proc near
|
|
|
|
push ax
|
|
push cx
|
|
push di
|
|
|
|
; As a start, zero out the TSS
|
|
|
|
xor al,al
|
|
mov cx,type TSS286
|
|
mov di,offset DGROUP:sysTSS
|
|
rep stosb
|
|
|
|
; Set the LDT selector
|
|
|
|
mov sysTSS.tss_ldt,SEL_LDT
|
|
|
|
; Set the ring 0 stack seg/pointer, we don't bother to set the others
|
|
; since nothing runs below DOSX's ring. Currently very little code runs
|
|
; ring 0 - just when switching between real/proteted modes.
|
|
|
|
mov sysTSS.tss_ss0,SEL_DXDATA0
|
|
mov sysTSS.tss_sp0,offset DGROUP:ResetStack
|
|
|
|
; That's all it takes
|
|
|
|
pop di
|
|
pop cx
|
|
pop ax
|
|
|
|
clc
|
|
ret
|
|
|
|
InitTaskStateSeg endp
|
|
|
|
; -------------------------------------------------------
|
|
; MISC. STARTUP ROUTINES
|
|
; -------------------------------------------------------
|
|
|
|
; *** CheckCPUType - Set global variable for CPU type
|
|
;
|
|
; This routine relies on Intel-approved code that takes advantage
|
|
; of the documented behavior of the high nibble of the flag word
|
|
; in the REAL MODE of the various processors. The MSB (bit 15)
|
|
; is always a one on the 8086 and 8088 and a zero on the 286 and
|
|
; 386. Bit 14 (NT flag) and bits 13/12 (IOPL bit field) are
|
|
; always zero on the 286, but can be set on the 386.
|
|
;
|
|
; For future compatibility of this test, it is strongly recommended
|
|
; that this specific instruction sequence be used. The exit codes
|
|
; can of course be changed to fit a particular need.
|
|
;
|
|
; CALLABLE FROM REAL MODE ONLY
|
|
;
|
|
; ENTRY: NONE
|
|
;
|
|
; EXIT: AX holds CPU type ( 0=8086,80186; 2=80286; 3=80386; 4=80486 )
|
|
;
|
|
; USES: AX, DS must point to DX data segment
|
|
; idCpuType initialized
|
|
;
|
|
; Modified: 07-31-90 Earleh added code from Kernel, originally
|
|
; supplied by Intel, to check for 80486. Added check
|
|
; for V86 mode just in case a Limulator or something
|
|
; is active.
|
|
;
|
|
assume ds:DGROUP,es:NOTHING,ss:NOTHING
|
|
public CheckCPUType
|
|
|
|
CheckCPUType proc near
|
|
|
|
.8086
|
|
|
|
pushf ; save flags during cpu test
|
|
|
|
pushf
|
|
pop ax ; flags to ax
|
|
|
|
and ax, 0fffh ; clear bits 12-15
|
|
|
|
push ax ; push immediate is bad op-code on 8086
|
|
npopf ; try to put that in the flags
|
|
|
|
pushf
|
|
pop ax ; look at what really went into flags
|
|
|
|
and ah,0f0h ; mask off high flag bits
|
|
cmp ah,0f0h ; Q: was high nibble all ones ?
|
|
mov ax, 0
|
|
jz cidx ; Y: 8086
|
|
.286p
|
|
smsw ax
|
|
test ax,1 ; Protected mode?
|
|
jnz cid386 ; V86! Gotta be at least a 386.
|
|
|
|
push 0f000h ; N: try to set the high bits
|
|
npopf ; ... in the flags
|
|
|
|
pushf
|
|
pop ax ; look at actual flags
|
|
|
|
and ah,0f0h ; Q: any high bits set ?
|
|
mov ax, 2 ; at least 286
|
|
jz cidx ; N: 80286 - exit w/ Z flag set
|
|
; Y: 80386 - Z flag reset
|
|
|
|
; 386 or 486? See if we can set the AC (Alignment check) bit in Eflags
|
|
; Need to insure stack is DWORD aligned for this to work properly
|
|
|
|
.386
|
|
cid386:
|
|
mov ax, 3
|
|
|
|
push cx
|
|
push ebx
|
|
|
|
mov cx,sp ; Assume stack aligned
|
|
and cx,0011b ; set "pop" count
|
|
sub sp,cx ; Move to DWORD aligned
|
|
pushfd ; save entry flags (DWORD)
|
|
push dword ptr 40000h ; AC bit
|
|
popfd
|
|
pushfd
|
|
pop ebx
|
|
popfd ; Recover entry flags (DWORD)
|
|
add sp,cx ; pop off alignment bytes
|
|
test ebx,40000h ; Did AC bit set?
|
|
|
|
pop ebx
|
|
pop cx
|
|
|
|
jz short cidx ; No, 386
|
|
.286p
|
|
inc ax ; At least 80486...
|
|
|
|
cidx:
|
|
mov idCpuType,ax ;store CPU type in global
|
|
npopf ; restore flags after cpu test
|
|
|
|
CheckCPUType endp
|
|
|
|
; -------------------------------------------------------
|
|
; B_ParaToLinear
|
|
;
|
|
; This function will convert a paragraph address in the lower
|
|
; megabyte of memory space into a linear address for use in
|
|
; a descriptor table. This is a local duplicate of the function
|
|
; ParaToLinear in DXUTIL.ASM. This is duplicated here to avoid
|
|
; having to make far calls to it during the initialization.
|
|
;
|
|
; Input: DX - paragraph address
|
|
; Output: DX - lower word of linear address
|
|
; BX - high word of linear address
|
|
; Errors: none
|
|
; Uses: DX, BX used, all else preserved
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
|
|
B_ParaToLinear proc near
|
|
|
|
xor bh,bh
|
|
mov bl,dh
|
|
shr bl,4
|
|
shl dx,4
|
|
ret
|
|
|
|
B_ParaToLinear endp
|
|
|
|
|
|
if DEBUG ;-------------------------------------------------------
|
|
|
|
; -------------------------------------------------------
|
|
; CheckDOSXFixUps -- This routine will check for segment fix ups
|
|
; in non-initialization code that need to be converted from
|
|
; a segment to selector.
|
|
;
|
|
; This routine works by opening the EXE file that we were
|
|
; loaded from and examining the relocation table.
|
|
;
|
|
; 10-09-90 Earleh modified so that references in initialization
|
|
; code are not edited.
|
|
;
|
|
; 11-12-90 JimMat renamed from RelocateDosExtender and it now
|
|
; only checks for fix ups in DEBUG version since all fix ups
|
|
; in post-initialization code have been removed.
|
|
;
|
|
; Input: none
|
|
; Output: none
|
|
; Errors: returns CY set if error occurs
|
|
; Uses: AX, all else preserved
|
|
; modifies lpchFileName
|
|
|
|
assume ds:DGROUP,es:NOTHING,ss:DGROUP
|
|
public CheckDOSXFixUps
|
|
|
|
CheckDOSXFixUps proc near
|
|
|
|
push bp
|
|
mov bp,sp
|
|
push bx
|
|
push dx
|
|
push si
|
|
push di
|
|
push es
|
|
|
|
; Find the path to our exe fie.
|
|
|
|
mov word ptr [lpchFileName],offset EXEC_DXNAME
|
|
mov word ptr [lpchFileName+2],ds
|
|
|
|
; Set up for reading the relocation table from the exe file.
|
|
|
|
call B_InitRelocBuffer
|
|
jc rldx90 ;get out if error
|
|
|
|
; Go down through the relocation table and for each fixup item,
|
|
; patch in our selector.
|
|
|
|
mov bx,segPSP
|
|
add bx,10h ;the relocation table items are relative
|
|
; to the initial load address of our program
|
|
; image which is immediately after the PSP
|
|
|
|
rldx40: call B_GetRelocationItem ;get next relocation table entry
|
|
jz rldx60 ;if end of table, get out
|
|
mov di,ax ;offset of relocation item
|
|
add dx,bx ;adjust relocation item segment for our load
|
|
; address
|
|
mov es,dx ;
|
|
|
|
;
|
|
; Do not fixup instructions in initialization code.
|
|
;
|
|
cmp dx,seg DXCODE
|
|
jne rldx41
|
|
cmp di,offset DXCODE:CodeEnd
|
|
jnc rldx40
|
|
rldx41:
|
|
cmp dx,seg DXPMCODE
|
|
jne rldx42
|
|
cmp di,offset DXPMCODE:CodeEndPM
|
|
jnc rldx40
|
|
rldx42:
|
|
|
|
mov ax,es:[di] ;get the current fixup contents
|
|
cmp ax,seg DXCODE ;is it the mixed mode segment?
|
|
jnz rldx44
|
|
|
|
extrn lCodeSegLoc:WORD
|
|
cmp di,offset DXCODE:lCodeSegLoc ;special far jmp to flush
|
|
jz rldx40 ; pre-fetch queue? ok if so.
|
|
|
|
; Shouldn't get here--tell developer he messed something up!
|
|
|
|
int 3 ;****************************************
|
|
|
|
mov word ptr es:[di],SEL_DXCODE or STD_RING
|
|
jmp short rldx40
|
|
|
|
rldx44: cmp ax,seg DXPMCODE ;is it the protected mode only segment
|
|
jnz rldx40
|
|
|
|
; Shouldn't get here--tell developer he messed something up!
|
|
|
|
int 3 ;****************************************
|
|
|
|
mov word ptr es:[di],SEL_DXPMCODE or STD_RING
|
|
jmp rldx40 ;and repeat for the next one
|
|
|
|
; We have gone through the entire relocation table, so close up the exe file
|
|
|
|
rldx60: mov bx,fhExeFile
|
|
dossvc 3Eh
|
|
;
|
|
clc
|
|
jmp short rldx90
|
|
;
|
|
; Error occured
|
|
rldx80: stc
|
|
;
|
|
; All done
|
|
rldx90: pop es
|
|
pop di
|
|
pop si
|
|
pop dx
|
|
pop bx
|
|
mov sp,bp
|
|
pop bp
|
|
ret
|
|
|
|
CheckDOSXFixUps endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; B_InitRelocBuffer -- This routine will open the EXE
|
|
; file and initialize for reading the relocation table
|
|
; as part of relocating the program for protected mode
|
|
; execution.
|
|
;
|
|
; Input: lpchFileName - pointer to exe file name
|
|
; Output: none
|
|
; Errors: returns CY set if error occurs
|
|
; Uses: AX modified, all other registers preserved
|
|
; sets up static variables:
|
|
; clpRelocItem, plpRelocItem, fhExeFile
|
|
; modifies rgbXfrBuf1 at offset RELOC_BUFFER
|
|
|
|
assume ds:DGROUP,es:NOTHING,ss:NOTHING
|
|
public B_InitRelocBuffer
|
|
|
|
B_InitRelocBuffer proc near
|
|
|
|
push bx
|
|
push cx
|
|
push dx
|
|
push si
|
|
;
|
|
; Open the EXE file.
|
|
push ds
|
|
lds dx,lpchFileName
|
|
mov al,0
|
|
dossvc 3Dh ;attempt to open the exe file
|
|
pop ds
|
|
jc inrl80 ;get out if error occurs
|
|
;
|
|
mov fhExeFile,ax ;store the file handle
|
|
mov bx,ax ;file handle to BX also
|
|
|
|
; Read the EXE file header, so that we can get information about
|
|
; the relocation table.
|
|
mov dx,offset RELOC_BUFFER
|
|
mov si,dx
|
|
mov cx,32
|
|
dossvc 3Fh
|
|
jc inrl80 ;get out if error
|
|
cmp ax,32
|
|
jnz inrl80
|
|
;
|
|
; Get the important values from the exe file header.
|
|
cmp [si].idExeFile,5A4Dh ;make sure it is an EXE file
|
|
jnz inrl80
|
|
|
|
mov ax,[si].clpRelocLen ;number of relocation items
|
|
mov clpRelocItem,ax
|
|
mov plpRelocItem,0FFFFh ;init the pointer to the first one
|
|
; to a bogus value to force the initial
|
|
; buffer to be loaded
|
|
;
|
|
; Get the location of the relocation table, and move the file pointer
|
|
; to its start.
|
|
|
|
xor cx,cx
|
|
mov dx,[si].wRelocOffset
|
|
|
|
mov al,cl
|
|
dossvc 42h
|
|
jnc inrl90
|
|
;
|
|
; Error occured
|
|
inrl80: stc
|
|
;
|
|
; All done
|
|
inrl90: pop si
|
|
pop dx
|
|
pop cx
|
|
pop bx
|
|
ret
|
|
|
|
B_InitRelocBuffer endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; B_GetRelocationItem -- This routine will return the next
|
|
; relocation table entry from the exe file being relocated.
|
|
;
|
|
; Input: none
|
|
; Output: AX - offset of relocation item pointer
|
|
; DX - segment of relocation item pointer
|
|
; Errors: returns ZR true if end of table and no more items
|
|
; Uses: AX, DX modified, all other registers preserved
|
|
|
|
assume ds:DGROUP,es:NOTHING,ss:NOTHING
|
|
public B_GetRelocationItem
|
|
|
|
B_GetRelocationItem proc near
|
|
|
|
push si
|
|
;
|
|
cmp clpRelocItem,0 ;are there any relocation items left?
|
|
jz gtrl90 ;get out if not
|
|
;
|
|
; Check if the buffer is empty. The buffer for the relocation table is
|
|
; at offset RELOC_BUFFER in the buffer rgbXfrBuf1, and is 512 bytes long.
|
|
cmp plpRelocItem,offset RELOC_BUFFER + 512
|
|
jc gtrl40
|
|
;
|
|
; The buffer is empty, so we need to read the next part of it in.
|
|
push cx
|
|
push bx
|
|
push dx
|
|
mov ax,clpRelocItem ;number of items left in file
|
|
shl ax,2 ;multiply by size of relocation item
|
|
jc gtrl22 ;check for overflow
|
|
cmp ax,512 ;check if bigger than the buffer
|
|
jc gtrl24
|
|
gtrl22: mov ax,512 ;use buffer size as size of transfer
|
|
gtrl24: mov cx,ax
|
|
mov dx,offset RELOC_BUFFER
|
|
mov plpRelocItem,dx ;pointer to next reloc item to return
|
|
mov bx,fhExeFile
|
|
dossvc 3Fh
|
|
pop dx
|
|
pop bx
|
|
jc gtrl28 ;if error occured
|
|
cmp ax,cx ;or, if we didn't get as much as we asked
|
|
jnz gtrl28 ; for, we have an error
|
|
pop cx
|
|
jmp short gtrl40
|
|
;
|
|
gtrl28: pop cx
|
|
stc
|
|
jmp short gtrl90
|
|
;
|
|
; Get the next relocation item from the buffer.
|
|
gtrl40: mov si,plpRelocItem
|
|
lods word ptr [si] ;get the offset part of the reloc item
|
|
mov dx,ax
|
|
lods word ptr [si] ;get the segment part of the reloc item
|
|
xchg dx,ax ;put offset in AX, and segment in DX
|
|
mov plpRelocItem,si ;store the updated pointer
|
|
dec clpRelocItem ;and bump the count down by 1
|
|
or si,si ;clear the zero flag
|
|
;
|
|
; All done.
|
|
gtrl90: pop si
|
|
ret
|
|
|
|
B_GetRelocationItem endp
|
|
|
|
endif ;DEBUG --------------------------------------------------------
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; GetExeName -- This routine will put a copy of the complete
|
|
; path name to the dos extender's exe file. In a name
|
|
; buffer in rgbXfrBuf1.
|
|
;
|
|
; Input: none
|
|
; Output: EXEC_DXNAME buffer updated with complete pathname.
|
|
; Errors: returns CY set if environment not correctly built.
|
|
; Uses: all preserved
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:DGROUP
|
|
public GetExeName
|
|
|
|
GetExeName proc near
|
|
|
|
push ax
|
|
push si
|
|
push di
|
|
push ds
|
|
|
|
; The name of the current program is stored at the end of the environment
|
|
; table. There are two bytes of 0 to indicate end of table, a byte
|
|
; with a 1 in it followed by another byte of 0 and then the null terminated
|
|
; string with the current program name.
|
|
|
|
gtxe20: mov ds,segPSP
|
|
assume ds:PSPSEG
|
|
mov ds,segEnviron
|
|
assume ds:NOTHING
|
|
xor si,si
|
|
gtxe22: lods byte ptr [si] ;get next byte from environment
|
|
or al,al ;test if 0
|
|
jnz gtxe22 ;if not, keep looking
|
|
lods byte ptr [si] ;get next byte
|
|
or al,al ;see if it is 0 also
|
|
jnz gtxe22
|
|
|
|
; We have found the double 0 at the end of the environment. So
|
|
; we can now get the name. At the end of the environment is an
|
|
; argc, argv construct. (i.e. a word giving the count of strings
|
|
; followed by an array of strings). Under DOS, argc is always 1,
|
|
; so check that there is a word of 1 here. If not, this environment
|
|
; wasn't built correctly and we don't know what is here.
|
|
|
|
lods word ptr [si]
|
|
cmp ax,1
|
|
jnz gtxe80
|
|
|
|
|
|
; We have the pointer to the name, now copy it.
|
|
|
|
mov di,offset EXEC_DXNAME
|
|
call strcpy
|
|
clc
|
|
jmp short gtxe90
|
|
|
|
; We have an error.
|
|
|
|
gtxe80: stc ;set error condition flag
|
|
|
|
gtxe90: pop ds
|
|
pop di
|
|
pop si
|
|
pop ax
|
|
ret
|
|
|
|
GetExeName endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; COMMAND LINE PARSING ROUTINES
|
|
; -------------------------------------------------------
|
|
; ParseCommandLine -- This function will examine the dos
|
|
; command line that caused the Dos Extender to be exec'd
|
|
; and determine what the user wants done. It will set
|
|
; up the various buffers required for the child program
|
|
; to be loaded.
|
|
;
|
|
; NOTE: the child exe file name read from the command line
|
|
; is placed in RELOC_BUFFER in the case where the child
|
|
; name is specified on the command line. This buffer is
|
|
; used later when reading the relocation table while
|
|
; performing the fixups on the child.
|
|
;
|
|
; Input: none
|
|
; Output: AL - 0 if empty command line, else non-zero
|
|
; parse buffers in rgbXfrBuf1 set up.
|
|
; Errors: none
|
|
; Uses: AX, all else preserved
|
|
|
|
assume ds:DGROUP,es:DGROUP,ss:NOTHING
|
|
public ParseCommandLine
|
|
|
|
ParseCommandLine proc near
|
|
|
|
push si
|
|
push di
|
|
push ds
|
|
|
|
mov ds,segPSP
|
|
assume ds:PSPSEG
|
|
mov si,81h ;pointer to command line in PSP
|
|
|
|
; Skip any white space in front of the child program name.
|
|
|
|
prsc12: lods byte ptr [si]
|
|
cmp al,' '
|
|
jz prsc12
|
|
|
|
dec si
|
|
|
|
; Copy the command line tail following the program name to the command
|
|
; line buffer for use when we load the child.
|
|
|
|
prsc40: push si ;save current point in parse
|
|
mov di,offset EXEC_CMNDLINE + 1
|
|
xor dl,dl ;count characters in command line tail
|
|
prsc42: lods byte ptr [si] ;get the next character
|
|
stos byte ptr [di] ;store it into the output buffer
|
|
cmp al,0Dh ;is it the end of the line?
|
|
jz prsc44
|
|
inc dl ;count the character
|
|
jmp prsc42
|
|
|
|
prsc44: mov es:[EXEC_CMNDLINE],dl ;store the character count
|
|
pop si ;restore the buffer pointer
|
|
|
|
; Now we want to set up the two default FCB's by letting DOS parse the
|
|
; first two parameters on the command line.
|
|
|
|
mov di,offset EXEC_FCB0
|
|
mov al,1
|
|
dossvc 29h
|
|
mov di,offset EXEC_FCB1
|
|
mov al,1
|
|
dossvc 29h
|
|
|
|
prsc90:
|
|
pop ds
|
|
pop di
|
|
pop si
|
|
ret
|
|
|
|
ParseCommandLine endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; strcpy -- copy a null terminated string.
|
|
;
|
|
; Input: DS:SI - pointer to source string
|
|
; ES:DI - pointer to destination buffer
|
|
; Output: ES:DI - pointer to end of destination string
|
|
; Errors: none
|
|
; Uses: DI modified, all else preserved
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public strcpy
|
|
|
|
strcpy proc near
|
|
|
|
push ax
|
|
push si
|
|
stcp10: lods byte ptr [si]
|
|
stos byte ptr [di]
|
|
or al,al
|
|
jnz stcp10
|
|
dec di
|
|
pop si
|
|
pop ax
|
|
ret
|
|
|
|
strcpy endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; strcmpi -- This function will perform a case insensitive
|
|
; comparison of two null terminated strings.
|
|
;
|
|
; Input: DS:SI - string 1
|
|
; ES:DI - string 2
|
|
; Output: ZR if the strings match, else NZ
|
|
; CY set if string 1 less than string 2
|
|
; Errors: none
|
|
; Uses: all registers preserved
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public strcmpi
|
|
|
|
strcmpi proc near
|
|
|
|
push si
|
|
push di
|
|
stcm20: mov al,byte ptr ds:[si]
|
|
call toupper
|
|
mov ah,al
|
|
mov al,byte ptr es:[di]
|
|
call toupper
|
|
cmp ah,al
|
|
jnz stcm90
|
|
or al,ah
|
|
jz stcm90
|
|
inc si
|
|
inc di
|
|
jmp stcm20
|
|
stcm90: pop di
|
|
pop si
|
|
ret
|
|
|
|
strcmpi endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; IsFileNameChar -- This function will examine the
|
|
; character in AL and determine if it is a legal character
|
|
; in an MS-DOS file name.
|
|
;
|
|
; Input: AL - character to test
|
|
; Output: ZR true if character is legal in a file name
|
|
; Errors: none
|
|
; Uses: all registers preserved
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
|
|
IsFileNameChar proc near
|
|
|
|
push ax
|
|
cmp al,20h ;is it a control character
|
|
jbe isfc80 ;if so, it isn't valid
|
|
|
|
cmp al,':'
|
|
jz isfc80
|
|
cmp al,';'
|
|
jz isfc80
|
|
cmp al,','
|
|
jz isfc80
|
|
cmp al,'='
|
|
jz isfc80
|
|
cmp al,'+'
|
|
jz isfc80
|
|
cmp al,'<'
|
|
jz isfc80
|
|
cmp al,'>'
|
|
jz isfc80
|
|
cmp al,'|'
|
|
jz isfc80
|
|
cmp al,'/'
|
|
jz isfc80
|
|
cmp al,'"'
|
|
jz isfc80
|
|
cmp al,'['
|
|
jz isfc80
|
|
cmp al,']'
|
|
jz isfc80
|
|
|
|
xor al,al
|
|
jmp short isfc90
|
|
|
|
; Not a valid file name character
|
|
|
|
isfc80: or al,0FFh
|
|
|
|
isfc90: pop ax
|
|
ret
|
|
|
|
IsFileNameChar endp
|
|
|
|
|
|
; -------------------------------------------------------
|
|
; toupper -- This function will convert the character
|
|
; in AL into upper case.
|
|
;
|
|
; Input: AL - character to convert
|
|
; Output: AL - upper case character
|
|
; Errors: none
|
|
; Uses: AL modified, all else preserved
|
|
|
|
assume ds:NOTHING,es:NOTHING,ss:NOTHING
|
|
public toupper
|
|
|
|
toupper proc near
|
|
|
|
cmp al,'a'
|
|
jb toup90
|
|
cmp al,'z'
|
|
ja toup90
|
|
sub al,'a'-'A'
|
|
toup90:
|
|
ret
|
|
|
|
toupper endp
|
|
|
|
; -------------------------------------------------------
|
|
|
|
DXCODE ends
|
|
|
|
;
|
|
;****************************************************************
|
|
|
|
end
|