reactos/subsystems/mvdm/dos/command.S

352 lines
9.1 KiB
ArmAsm
Raw Normal View History

/*
* PROJECT: ReactOS Virtual DOS Machine
* LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+)
* PURPOSE: DOS32 command.com for NTVDM
* COPYRIGHT: Copyright 2015-2018 Hermes Belusca-Maito
*/
/* INCLUDES *******************************************************************/
#include <asm.inc>
#include "asmxtras.inc"
#include <isvbop.inc>
#define NDEBUG
/* DEFINES ********************************************************************/
#define MAX_PATH 260
#define DOS_CMDLINE_LENGTH 127
#define DOS_VERSION HEX(0005) // MAKEWORD(5, 00)
#define NTDOS_VERSION HEX(3205) // MAKEWORD(5, 50)
#define SYSTEM_PSP HEX(08)
#define BOP .byte HEX(C4), HEX(C4),
// #define BOP_START_DOS HEX(2C)
#define BOP_CMD HEX(54)
/**** PSP MEMBERS ****/
#define PSP_VAR(x) es:[x]
#define PSP HEX(0000)
#define ParentPsp HEX(0016) // word
#define EnvBlock HEX(002C) // word
#define CmdLineLen HEX(0080) // byte
#define CmdLineStr HEX(0081) // byte[DOS_CMDLINE_LENGTH]
/**** DATA stored inside the stack ****/
#define CmdLine BaseStack // Command line for the program to be started
#define PgmName [CmdLine + (1 + DOS_CMDLINE_LENGTH)]
// WARNING! Using the VAL(x) macro doesn't work with GCC/GAS (because it inserts
// a spurious space in front of the parameter when the macro is expanded).
// So that: 'VAL(foo)' is expanded to: '\ foo', instead of '\foo' as one would expect.
/* NEXT_CMD structure */
STRUCT(NEXT_CMD, 2)
FIELD_DECL(EnvBlockSeg, word, 0)
FIELD_DECL(EnvBlockLen, word, 0)
FIELD_DECL(CurDrive , word, 0)
FIELD_DECL(NumDrives , word, 1)
FIELD_DECL(CmdLineSeg , word, 0)
FIELD_DECL(CmdLineOff , word, 0)
FIELD_DECL(Unknown0 , word, 2)
FIELD_DECL(ExitCode , word, 3)
FIELD_DECL(Unknown1 , word, 4)
FIELD_DECL(Unknown2 , long, 5)
FIELD_DECL(CodePage , word, 6)
FIELD_DECL(Unknown3 , word, 7)
FIELD_DECL(Unknown4 , word, 8)
FIELD_DECL(AppNameSeg , word, 0)
FIELD_DECL(AppNameOff , word, 0)
FIELD_DECL(AppNameLen , word, 0)
FIELD_DECL(Flags , word, 0)
ENDS(NEXT_CMD)
/* DOS_EXEC_PARAM_BLOCK structure */
STRUCT(DOS_EXEC_PARAM_BLOCK, 2)
FIELD_DECL(EnvSeg, word, 0) // Use parent's environment (ours)
FIELD_DECL(CmdLineOff, word, OFF(CmdLine))
FIELD_DECL(CmdLineSeg, word, 0)
FIELD_DECL(Fcb1Off, word, OFF(Fcb1))
FIELD_DECL(Fcb1Seg, word, 0)
FIELD_DECL(Fcb2Off, word, OFF(Fcb2))
FIELD_DECL(Fcb2Seg, word, 0)
ENDS(DOS_EXEC_PARAM_BLOCK)
/* RESIDENT CODE AND DATA *****************************************************/
.code16
// .org HEX(0100)
ASSUME CS:.text, DS:.text, ES:.text
/* CODE *******************************/
EntryPoint:
jmp Main
.align 2
ResidentMain:
/*
* Relocate our stack.
* Our local stack is big enough for holding the command line and the path
* to the executable to start, plus a full DOS_REGISTER_STATE and for one pusha 16-bit.
*
* FIXME: enlarge it for pushing the needed Load&Exec data.
*/
cli
mov ax, ds
mov ss, ax
mov bp, offset BaseStack
lea sp, [bp + (1 + DOS_CMDLINE_LENGTH) + MAX_PATH + 255]
sti
/* Resize ourselves */
mov bx, sp // Get size in bytes...
// sub bx, offset PSP_VAR(PSP)
add bx, HEX(0F) // (for rounding to the next paragraph)
shr bx, 4 // ... then the number of paragraphs
mov ah, HEX(4A)
int HEX(21)
/* Check whether we need to start the 32-bit command interpreter */
BOP BOP_CMD, HEX(10) // Check whether we were started from a new console (SessionId != 0)
test al, al // and we are not reentering (32-bit process starting a 16-bit process).
jz Run
cmp word ptr OldParentPsp, SYSTEM_PSP // Check whether our parent is SYSTEM
je Run
#ifndef NDEBUG
/********************************/
mov dx, offset Msg1
mov ah, HEX(09)
int HEX(21)
/********************************/
#endif
BOP BOP_CMD, HEX(0A) // Start 32-bit COMSPEC
jnc Quit
/* Loop for new commands to run */
Run:
/* Initialize the NextCmd structure */
mov word ptr FIELD(NextCmd, EnvBlockSeg), ds
mov word ptr FIELD(NextCmd, EnvBlockLen), 0 // FIXME
mov word ptr FIELD(NextCmd, CmdLineSeg), ds
mov word ptr FIELD(NextCmd, CmdLineOff), offset CmdLine
mov word ptr FIELD(NextCmd, AppNameSeg), ds
mov word ptr FIELD(NextCmd, AppNameOff), offset PgmName
/* Wait for the next command */
#ifndef NDEBUG
/********************************/
mov dx, offset Msg2
mov ah, HEX(09)
int HEX(21)
/********************************/
#endif
// FIXME: Initialize memory with structure for holding CmdLine etc...
// mov ds, seg NextCmd
mov dx, offset NextCmd
BOP BOP_CMD, HEX(01)
/* Quit if we shell-out */
jc Quit
/* Initialize the DosLoadExec structure */
// mov word ptr FIELD(DosLoadExec, EnvSeg), 0
mov word ptr FIELD(DosLoadExec, CmdLineSeg), ds
mov word ptr FIELD(DosLoadExec, Fcb1Seg), ds
mov word ptr FIELD(DosLoadExec, Fcb2Seg), ds
/* Run the command */
mov ds, word ptr FIELD(NextCmd, AppNameSeg)
mov dx, word ptr FIELD(NextCmd, AppNameOff)
// mov es, seg DosLoadExec
mov bx, offset DosLoadExec
pusha // Save the registers in case stuff go wrong
// FIXME: Save also SS !!
mov ax, HEX(4B00)
int HEX(21)
popa // Restore the registers
// FIXME: Restore also SS !!
/* Retrieve and set its exit code. Also detect whether
* we need to continue or whether we need to quit. */
// xor ax, ax
// mov ah, HEX(4D)
mov ax, HEX(4D00)
int HEX(21)
/* Send exit code back to NTVDM */
mov dx, ax
BOP BOP_CMD, HEX(0B)
/* If we don't shell-out, go and get a new app! */
jc Run
mov al, HEX(00) // ERROR_SUCCESS
Quit:
mov bl, al // Save AL in BL
#ifndef NDEBUG
/********************************/
cmp al, HEX(0A)
jne XXXX
mov dx, offset Msg3
mov ah, HEX(09)
int HEX(21)
XXXX:
/********************************/
#endif
#ifndef NDEBUG
/* Say bye-bye */
// mov ds, seg QuitMsg
mov dx, offset QuitMsg
mov ah, HEX(09)
int HEX(21)
#endif
/* Restore our old parent PSP */
mov ax, word ptr OldParentPsp
mov PSP_VAR(ParentPsp), ax
mov al, bl // Restore AL from BL
Exit:
/* Return to caller (with possible error code in AL) */
mov ah, HEX(4C)
int HEX(21)
int 3
/* Does not return */
/* DATA *******************************/
#ifndef NDEBUG
QuitMsg:
.ascii "Bye bye!", CR, LF, "$"
/********************************/
Msg1: .ascii "Starting COMSPEC...", CR, LF, "$"
Msg2: .ascii "Waiting for new command...", CR, LF, "$"
Msg3: .ascii "Bad environment!", CR, LF, "$"
/********************************/
#endif
OldParentPsp: .word 0
CurrentPsp: .word 0
// BOP_CMD, HEX(01) "Get a new app to start" structure
VAR_STRUCT(NextCmd, NEXT_CMD)
// DOS INT 21h, AH=4Bh "Load and Execute" structure
VAR_STRUCT(DosLoadExec, DOS_EXEC_PARAM_BLOCK)
// Blank FCB blocks needed for DOS INT 21h, AH=4Bh
Fcb1:
.byte 0
.space 11, ' '
.space 25, 0
Fcb2:
.byte 0
.space 11, ' '
.space 25, 0
// The stack resides at the end of the resident code+data
// and it overwrites the transient part.
BaseStack:
/* TRANSIENT CODE AND DATA ****************************************************/
/* DATA *******************************/
#ifndef NDEBUG
WelcomeMsg:
.ascii "ReactOS DOS32 Command", CR, LF, \
"Copyright (C) ReactOS Team 2015" , CR, LF, "$"
#endif
VerErrMsg:
.ascii "Incorrect DOS version", CR, LF, "$"
/* CODE *******************************/
.align 2
Main:
/* Setup segment registers */
mov ax, cs // cs contains the PSP segment on entry
mov ds, ax
mov es, ax
// mov fs, ax
// mov gs, ax
/* Stack is set to cs:FFFE down to cs:09xx by the DOS.
* We will need to relocate it before we resize ourselves. */
/*
* Verify DOS version:
* - Check whether we are on DOS 5+ (subject to SETVER);
* - If so, check our real DOS version and see
* whether we are running on NTVDM (version 5.50).
*/
mov ax, HEX(3000)
int HEX(21)
cmp ax, DOS_VERSION // AH:AL contains minor:major version number
jne VerErr
mov ax, HEX(3306)
int HEX(21)
cmp bx, NTDOS_VERSION // BH:BL contains minor:major version number
je Continue
VerErr:
/* Display wrong version error message and exit */
// mov ds, seg VerErrMsg
mov dx, offset VerErrMsg
mov ah, HEX(09)
int HEX(21)
jmp Exit
Continue:
/* Save our PSP */
mov word ptr CurrentPsp, cs
/*
* The DOS way:
*
* mov ah, HEX(51) // DOS 2+ internal, or HEX(62) since DOS 3+
* int HEX(21)
* mov word ptr CurrentPsp, bx
*/
/* Save our old parent PSP */
mov ax, PSP_VAR(ParentPsp)
mov word ptr OldParentPsp, ax
/* Give us shell privileges: set our PSP as our new parent */
mov ax, word ptr CurrentPsp
mov PSP_VAR(ParentPsp), ax
#ifndef NDEBUG
/* Say hello */
// mov ds, seg WelcomeMsg
mov dx, offset WelcomeMsg
mov ah, HEX(09)
int HEX(21)
#endif
/* Jump to resident code */
jmp ResidentMain
.endcode16
END
/* EOF */