process.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_DOS_PSP
struct	_DOS_EXEC_PARAM_BLOCK
struct	_DOS_REGISTER_STATE

Macros
#define	DOS_CMDLINE_LENGTH   127
#define	DOS_PROGRAM_NAME_TAG   0x0001
#define	SEGMENT_TO_PSP(seg)   ((PDOS_PSP)SEG_OFF_TO_PTR((seg), 0))

Typedefs
typedef struct _DOS_PSP	DOS_PSP
typedef struct _DOS_PSP *	PDOS_PSP
typedef struct _DOS_EXEC_PARAM_BLOCK	DOS_EXEC_PARAM_BLOCK
typedef struct _DOS_EXEC_PARAM_BLOCK *	PDOS_EXEC_PARAM_BLOCK
typedef struct _DOS_REGISTER_STATE	DOS_REGISTER_STATE
typedef struct _DOS_REGISTER_STATE *	PDOS_REGISTER_STATE

Enumerations
enum	DOS_EXEC_TYPE { DOS_LOAD_AND_EXECUTE = 0x00 , DOS_LOAD_ONLY = 0x01 , DOS_LOAD_OVERLAY = 0x03 }

Functions
VOID	DosClonePsp (WORD DestSegment, WORD SourceSegment)
VOID	DosCreatePsp (WORD Segment, WORD ProgramSize)
VOID	DosSetProcessContext (WORD Segment)
DWORD	DosLoadExecutableInternal (IN DOS_EXEC_TYPE LoadType, IN LPBYTE ExeBuffer, IN DWORD ExeBufferSize, IN LPCSTR ExePath, IN PDOS_EXEC_PARAM_BLOCK Parameters, IN LPCSTR CommandLine OPTIONAL, IN LPCSTR Environment OPTIONAL, IN DWORD ReturnAddress OPTIONAL)
DWORD	DosLoadExecutable (IN DOS_EXEC_TYPE LoadType, IN LPCSTR ExecutablePath, IN PDOS_EXEC_PARAM_BLOCK Parameters, IN LPCSTR CommandLine OPTIONAL, IN LPCSTR Environment OPTIONAL, IN DWORD ReturnAddress OPTIONAL)
WORD	DosCreateProcess (LPCSTR ProgramName, PDOS_EXEC_PARAM_BLOCK Parameters, IN DWORD ReturnAddress OPTIONAL)
VOID	DosTerminateProcess (WORD Psp, BYTE ReturnCode, WORD KeepResident)

Macro Definition Documentation

DOS_CMDLINE_LENGTH

#define DOS_CMDLINE_LENGTH   127

Definition at line 13 of file process.h.

DOS_PROGRAM_NAME_TAG

#define DOS_PROGRAM_NAME_TAG   0x0001

Definition at line 14 of file process.h.

SEGMENT_TO_PSP

#define SEGMENT_TO_PSP

(

seg

)

((PDOS_PSP)SEG_OFF_TO_PTR((seg), 0))

Definition at line 16 of file process.h.

Typedef Documentation

DOS_EXEC_PARAM_BLOCK

typedef struct _DOS_EXEC_PARAM_BLOCK DOS_EXEC_PARAM_BLOCK

DOS_PSP

typedef struct _DOS_PSP DOS_PSP

DOS_REGISTER_STATE

typedef struct _DOS_REGISTER_STATE DOS_REGISTER_STATE

PDOS_EXEC_PARAM_BLOCK

typedef struct _DOS_EXEC_PARAM_BLOCK * PDOS_EXEC_PARAM_BLOCK

PDOS_PSP

typedef struct _DOS_PSP * PDOS_PSP

PDOS_REGISTER_STATE

typedef struct _DOS_REGISTER_STATE * PDOS_REGISTER_STATE

Enumeration Type Documentation

DOS_EXEC_TYPE

enum DOS_EXEC_TYPE

Enumerator
DOS_LOAD_AND_EXECUTE
DOS_LOAD_ONLY
DOS_LOAD_OVERLAY

Definition at line 18 of file process.h.

{
    DOS_LOAD_AND_EXECUTE = 0x00,
    DOS_LOAD_ONLY        = 0x01,
    DOS_LOAD_OVERLAY     = 0x03
} DOS_EXEC_TYPE;

Function Documentation

DosClonePsp()

VOID DosClonePsp	(	WORD	DestSegment,
		WORD	SourceSegment
	)

Definition at line 251 of file process.c.

{
    PDOS_PSP DestPsp    = SEGMENT_TO_PSP(DestSegment);
    PDOS_PSP SourcePsp  = SEGMENT_TO_PSP(SourceSegment);
    LPDWORD IntVecTable = (LPDWORD)((ULONG_PTR)BaseAddress);
 
    /* Literally copy the PSP first */
    RtlCopyMemory(DestPsp, SourcePsp, sizeof(*DestPsp));
 
    /* Save the interrupt vectors */
    DestPsp->TerminateAddress = IntVecTable[0x22];
    DestPsp->BreakAddress     = IntVecTable[0x23];
    DestPsp->CriticalAddress  = IntVecTable[0x24];
 
    /* No parent PSP */
    DestPsp->ParentPsp = 0;
 
    /* Set the handle table pointers to the internal handle table */
    DestPsp->HandleTableSize = DEFAULT_JFT_SIZE;
    DestPsp->HandleTablePtr  = MAKELONG(0x18, DestSegment);
 
    /* Copy the parent handle table without referencing the SFT */
    RtlCopyMemory(FAR_POINTER(DestPsp->HandleTablePtr),
                  FAR_POINTER(SourcePsp->HandleTablePtr),
                  DEFAULT_JFT_SIZE);
}

Referenced by DosInt21h().

DosCreateProcess()

WORD DosCreateProcess	(	LPCSTR	ProgramName,
		PDOS_EXEC_PARAM_BLOCK	Parameters,
		IN DWORD ReturnAddress	OPTIONAL
	)

DosCreatePsp()

VOID DosCreatePsp	(	WORD	Segment,
		WORD	ProgramSize
	)

Definition at line 278 of file process.c.

{
    PDOS_PSP PspBlock   = SEGMENT_TO_PSP(Segment);
    LPDWORD IntVecTable = (LPDWORD)((ULONG_PTR)BaseAddress);
 
    RtlZeroMemory(PspBlock, sizeof(*PspBlock));
 
    /* Set the exit interrupt */
    PspBlock->Exit[0] = 0xCD; // int 0x20
    PspBlock->Exit[1] = 0x20;
 
    /* Set the number of the last paragraph */
    PspBlock->LastParagraph = Segment + ProgramSize;
 
    /* Save the interrupt vectors */
    PspBlock->TerminateAddress = IntVecTable[0x22];
    PspBlock->BreakAddress     = IntVecTable[0x23];
    PspBlock->CriticalAddress  = IntVecTable[0x24];
 
    /* Set the parent PSP */
    PspBlock->ParentPsp = Sda->CurrentPsp;
 
    if (Sda->CurrentPsp != SYSTEM_PSP)
    {
        /* Link to the parent's environment block */
        PspBlock->EnvBlock = SEGMENT_TO_PSP(Sda->CurrentPsp)->EnvBlock;
    }
/*
    else
    {
        PspBlock->EnvBlock = SEG_OFF_TO_PTR(SYSTEM_ENV_BLOCK, 0);
    }
*/
 
    /* Copy the parent handle table */
    DosCopyHandleTable(PspBlock->HandleTable);
 
    /* Set the handle table pointers to the internal handle table */
    PspBlock->HandleTableSize = DEFAULT_JFT_SIZE;
    PspBlock->HandleTablePtr  = MAKELONG(0x18, Segment);
 
    /* Set the DOS version */
    // FIXME: This is here that SETVER stuff enters into action!
    PspBlock->DosVersion = DosData->DosVersion;
 
    /* Set the far call opcodes */
    PspBlock->FarCall[0] = 0xCD; // int 0x21
    PspBlock->FarCall[1] = 0x21;
    PspBlock->FarCall[2] = 0xCB; // retf
}

Referenced by DosInt21h(), and DosLoadExecutableInternal().

DosLoadExecutable()

DWORD DosLoadExecutable	(	IN DOS_EXEC_TYPE	LoadType,
		IN LPCSTR	ExecutablePath,
		IN PDOS_EXEC_PARAM_BLOCK	Parameters,
		IN LPCSTR CommandLine	OPTIONAL,
		IN LPCSTR Environment	OPTIONAL,
		IN DWORD ReturnAddress	OPTIONAL
	)

Definition at line 705 of file process.c.

{
    DWORD Result = ERROR_SUCCESS;
    HANDLE FileHandle = INVALID_HANDLE_VALUE, FileMapping = NULL;
    DWORD FileSize;
    LPBYTE Address = NULL;
    CHAR FullPath[MAX_PATH];
    CHAR ShortFullPath[MAX_PATH];
 
    DPRINT1("DosLoadExecutable(%d, '%s', 0x%p, 0x%p, 0x%p)\n",
            LoadType, ExecutablePath, Parameters, CommandLine, Environment);
 
    /* Try to get the full path to the executable */
    if (GetFullPathNameA(ExecutablePath, sizeof(FullPath), FullPath, NULL))
    {
        /* Get the corresponding short path */
        if (GetShortPathNameA(FullPath, ShortFullPath, sizeof(ShortFullPath)))
        {
            /* Use the shortened full path from now on */
            ExecutablePath = ShortFullPath;
        }
    }
 
    /* Open a handle to the executable */
    FileHandle = CreateFileA(ExecutablePath,
                             GENERIC_READ,
                             FILE_SHARE_READ,
                             NULL,
                             OPEN_EXISTING,
                             FILE_ATTRIBUTE_NORMAL,
                             NULL);
    if (FileHandle == INVALID_HANDLE_VALUE)
    {
        Result = GetLastError();
        goto Cleanup;
    }
 
    /* Get the file size */
    FileSize = GetFileSize(FileHandle, NULL);
 
    /* Create a mapping object for the file */
    FileMapping = CreateFileMapping(FileHandle,
                                    NULL,
                                    PAGE_READONLY,
                                    0,
                                    0,
                                    NULL);
    if (FileMapping == NULL)
    {
        Result = GetLastError();
        goto Cleanup;
    }
 
    /* Map the file into memory */
    Address = (LPBYTE)MapViewOfFile(FileMapping, FILE_MAP_READ, 0, 0, 0);
    if (Address == NULL)
    {
        Result = GetLastError();
        goto Cleanup;
    }
 
    Result = DosLoadExecutableInternal(LoadType,
                                       Address,
                                       FileSize,
                                       ExecutablePath,
                                       Parameters,
                                       CommandLine,
                                       Environment,
                                       ReturnAddress);
 
Cleanup:
    /* Unmap the file*/
    if (Address != NULL) UnmapViewOfFile(Address);
 
    /* Close the file mapping object */
    if (FileMapping != NULL) CloseHandle(FileMapping);
 
    /* Close the file handle */
    if (FileHandle != INVALID_HANDLE_VALUE) CloseHandle(FileHandle);
 
    return Result;
}

Referenced by DosCreateProcess(), DosInt21h(), and DosStartComSpec().

DosLoadExecutableInternal()

DWORD DosLoadExecutableInternal	(	IN DOS_EXEC_TYPE	LoadType,
		IN LPBYTE	ExeBuffer,
		IN DWORD	ExeBufferSize,
		IN LPCSTR	ExePath,
		IN PDOS_EXEC_PARAM_BLOCK	Parameters,
		IN LPCSTR CommandLine	OPTIONAL,
		IN LPCSTR Environment	OPTIONAL,
		IN DWORD ReturnAddress	OPTIONAL
	)

Definition at line 335 of file process.c.

{
    DWORD Result = ERROR_SUCCESS;
    WORD Segment = 0;
    WORD EnvBlock = 0;
    WORD ExeSignature;
    WORD LoadSegment;
    WORD MaxAllocSize;
 
    WORD FinalSS, FinalSP;
    WORD FinalCS, FinalIP;
 
    /* Buffer for command line conversion: 1 byte for size; 127 bytes for contents */
    CHAR CmdLineBuffer[1 + DOS_CMDLINE_LENGTH];
 
    DPRINT1("DosLoadExecutableInternal(%d, 0x%p, '%s', 0x%p, 0x%p, 0x%p)\n",
            LoadType, ExeBuffer, ExePath, Parameters, CommandLine, Environment);
 
    if (LoadType != DOS_LOAD_OVERLAY)
    {
        /* If an optional Win32 command line is given... */
        if (CommandLine)
        {
            /* ... convert it into DOS format */
            BYTE CmdLineLen;
 
            PBYTE CmdLineSize  = (PBYTE)CmdLineBuffer;
            LPSTR CmdLineStart = CmdLineBuffer + 1;
            LPSTR CmdLinePtr   = CmdLineStart;
 
            // For debugging purposes
            RtlFillMemory(CmdLineBuffer, sizeof(CmdLineBuffer), 0xFF);
 
            /*
             * Set the command line: it is either an empty command line or has
             * the format: " foo bar ..." (with at least one leading whitespace),
             * and is then always followed by '\r' (and optionally by '\n').
             */
            CmdLineLen = (BYTE)strlen(CommandLine);
            *CmdLineSize = 0;
 
            /*
             * Add the leading space if the command line is not empty
             * and doesn't already start with some whitespace...
             */
            if (*CommandLine && *CommandLine != '\r' && *CommandLine != '\n' &&
                *CommandLine != ' ' && *CommandLine != '\t')
            {
                (*CmdLineSize)++;
                *CmdLinePtr++ = ' ';
            }
 
            /* Compute the number of characters we need to copy from the original command line */
            CmdLineLen = min(CmdLineLen, DOS_CMDLINE_LENGTH - *CmdLineSize);
 
            /* The trailing '\r' or '\n' do not count in the PSP command line size parameter */
            while (CmdLineLen && (CommandLine[CmdLineLen - 1] == '\r' || CommandLine[CmdLineLen - 1] == '\n'))
            {
                CmdLineLen--;
            }
 
            /* Finally, set everything up */
            *CmdLineSize += CmdLineLen;
            RtlCopyMemory(CmdLinePtr, CommandLine, CmdLineLen);
            CmdLineStart[*CmdLineSize] = '\r';
 
            /* Finally make the pointer point to the static buffer */
            CommandLine = CmdLineBuffer;
        }
        else
        {
            /*
             * ... otherwise, get the one from the parameter block.
             * Format of the command line: 1 byte for size; 127 bytes for contents.
             */
            ASSERT(Parameters);
            CommandLine = (LPCSTR)FAR_POINTER(Parameters->CommandLine);
        }
 
        /* If no optional environment is given... */
        if (Environment == NULL)
        {
            ASSERT(Parameters);
            /* ... get the one from the parameter block (if not NULL)... */
            if (Parameters->Environment)
                Environment = (LPCSTR)SEG_OFF_TO_PTR(Parameters->Environment, 0);
            /* ... or the one from the parent (otherwise) */
            else
                Environment = (LPCSTR)SEG_OFF_TO_PTR(SEGMENT_TO_PSP(Sda->CurrentPsp)->EnvBlock, 0);
        }
 
        /* Copy the environment block to DOS memory */
        EnvBlock = DosCopyEnvironmentBlock(Environment, ExePath);
        if (EnvBlock == 0)
        {
            Result = Sda->LastErrorCode;
            goto Cleanup;
        }
    }
 
    /*
     * Check if this is an EXE file or a COM file by looking
     * at the MZ signature:
     * 0x4D5A 'MZ': old signature (stored as 0x5A, 0x4D)
     * 0x5A4D 'ZM': new signature (stored as 0x4D, 0x5A)
     */
    ExeSignature = *(PWORD)ExeBuffer;
    if (ExeSignature == 'MZ' || ExeSignature == 'ZM')
    {
        /* EXE file */
        PIMAGE_DOS_HEADER Header;
        DWORD BaseSize;
        PDWORD RelocationTable;
        PWORD RelocWord;
        WORD RelocFactor;
        WORD i;
 
        /* Get the MZ header */
        Header = (PIMAGE_DOS_HEADER)ExeBuffer;
 
        /* Get the base size of the file, in paragraphs (rounded up) */
#if 0   // Normally this is not needed to check for the number of bytes in the last pages.
        BaseSize = ((((Header->e_cp - (Header->e_cblp != 0)) * 512) + Header->e_cblp) >> 4)
                    - Header->e_cparhdr;
#else
        // e_cp is the number of 512-byte blocks. 512 == (1 << 9)
        // so this corresponds to (1 << 5) number of paragraphs.
        //
        // For DOS compatibility we need to truncate BaseSize to a WORD value.
        // This fact is exploited by some EXEs which are bigger than 1 Mb while
        // being able to load on DOS, the main EXE code loads the remaining data.
 
        BaseSize = ((Header->e_cp << 5) - Header->e_cparhdr) & 0xFFFF;
#endif
 
        if (LoadType != DOS_LOAD_OVERLAY)
        {
            BOOLEAN LoadHigh = FALSE;
            DWORD TotalSize;
 
            /* Find the maximum amount of memory that can be allocated */
            DosAllocateMemory(0xFFFF, &MaxAllocSize);
 
            /* Compute the total needed size, in paragraphs */
            TotalSize = BaseSize + (sizeof(DOS_PSP) >> 4);
 
            /* We must have the required minimum amount of memory. If not, bail out. */
            if (MaxAllocSize < TotalSize + Header->e_minalloc)
            {
                Result = ERROR_NOT_ENOUGH_MEMORY;
                goto Cleanup;
            }
 
            /* Check if the program should be loaded high */
            if (Header->e_minalloc == 0 && Header->e_maxalloc == 0)
            {
                /* Yes it should. Use all the available memory. */
                LoadHigh  = TRUE;
                TotalSize = MaxAllocSize;
            }
            else
            {
                /* Compute the maximum memory size that can be allocated */
                if (Header->e_maxalloc != 0)
                    TotalSize = min(TotalSize + Header->e_maxalloc, MaxAllocSize);
                else
                    TotalSize = MaxAllocSize; // Use all the available memory
            }
 
            /* Try to allocate that much memory */
            Segment = DosAllocateMemory((WORD)TotalSize, NULL);
            if (Segment == 0)
            {
                Result = Sda->LastErrorCode;
                goto Cleanup;
            }
 
            /* The process owns its memory */
            DosChangeMemoryOwner(Segment , Segment);
            DosChangeMemoryOwner(EnvBlock, Segment);
 
            /* Set INT 22h to the return address */
            ((PULONG)BaseAddress)[0x22] = ReturnAddress;
 
            /* Create the PSP and initialize it */
            DosCreatePsp(Segment, (WORD)TotalSize);
            DosInitPsp(Segment, EnvBlock, CommandLine, ExePath);
 
            /* Calculate the segment where the program should be loaded */
            if (!LoadHigh)
                LoadSegment = Segment + (sizeof(DOS_PSP) >> 4);
            else
                LoadSegment = Segment + TotalSize - BaseSize;
 
            RelocFactor = LoadSegment;
        }
        else
        {
            ASSERT(Parameters);
            LoadSegment = Parameters->Overlay.Segment;
            RelocFactor = Parameters->Overlay.RelocationFactor;
        }
 
        /* Copy the program to the code segment */
        RtlCopyMemory(SEG_OFF_TO_PTR(LoadSegment, 0),
                      ExeBuffer + (Header->e_cparhdr << 4),
                      min(ExeBufferSize - (Header->e_cparhdr << 4), BaseSize << 4));
 
        /* Get the relocation table */
        RelocationTable = (PDWORD)(ExeBuffer + Header->e_lfarlc);
 
        /* Perform relocations */
        for (i = 0; i < Header->e_crlc; i++)
        {
            /* Get a pointer to the word that needs to be patched */
            RelocWord = (PWORD)SEG_OFF_TO_PTR(LoadSegment + HIWORD(RelocationTable[i]),
                                              LOWORD(RelocationTable[i]));
 
            /* Add the relocation factor to it */
            *RelocWord += RelocFactor;
        }
 
        /* Set the stack to the location from the header */
        FinalSS = LoadSegment + Header->e_ss;
        FinalSP = Header->e_sp;
 
        /* Set the code segment/pointer */
        FinalCS = LoadSegment + Header->e_cs;
        FinalIP = Header->e_ip;
    }
    else
    {
        /* COM file */
 
        if (LoadType != DOS_LOAD_OVERLAY)
        {
            /* Find the maximum amount of memory that can be allocated */
            DosAllocateMemory(0xFFFF, &MaxAllocSize);
 
            /* Make sure it's enough for the whole program and the PSP */
            if (((DWORD)MaxAllocSize << 4) < (ExeBufferSize + sizeof(DOS_PSP)))
            {
                Result = ERROR_NOT_ENOUGH_MEMORY;
                goto Cleanup;
            }
 
            /* Allocate all of it */
            Segment = DosAllocateMemory(MaxAllocSize, NULL);
            if (Segment == 0)
            {
                Result = Sda->LastErrorCode;
                goto Cleanup;
            }
 
            /* The process owns its memory */
            DosChangeMemoryOwner(Segment , Segment);
            DosChangeMemoryOwner(EnvBlock, Segment);
 
            /* Set INT 22h to the return address */
            ((PULONG)BaseAddress)[0x22] = ReturnAddress;
 
            /* Create the PSP and initialize it */
            DosCreatePsp(Segment, MaxAllocSize);
            DosInitPsp(Segment, EnvBlock, CommandLine, ExePath);
 
            /* Calculate the segment where the program should be loaded */
            LoadSegment = Segment + (sizeof(DOS_PSP) >> 4);
        }
        else
        {
            ASSERT(Parameters);
            LoadSegment = Parameters->Overlay.Segment;
        }
 
        /* Copy the program to the code segment */
        RtlCopyMemory(SEG_OFF_TO_PTR(LoadSegment, 0),
                      ExeBuffer, ExeBufferSize);
 
        /* Set the stack to the last word of the segment */
        FinalSS = Segment;
        FinalSP = 0xFFFE;
 
        /*
         * Set the value on the stack to 0x0000, so that a near return
         * jumps to PSP:0000 which has the exit code.
         */
        *((LPWORD)SEG_OFF_TO_PTR(Segment, 0xFFFE)) = 0x0000;
 
        /* Set the code segment/pointer */
        FinalCS = Segment;
        FinalIP = 0x0100;
    }
 
    if (LoadType == DOS_LOAD_AND_EXECUTE)
    {
        /* Save the program state */
        if (Sda->CurrentPsp != SYSTEM_PSP)
        {
            /* Push the task state */
            DosSaveState();
 
#ifdef ADVANCED_DEBUGGING
            DPRINT1("Sda->CurrentPsp = 0x%04x; Old LastStack = 0x%08x, New LastStack = 0x%08x\n",
                   Sda->CurrentPsp, SEGMENT_TO_PSP(Sda->CurrentPsp)->LastStack, MAKELONG(getSP(), getSS()));
#endif
 
            /* Update the last stack in the PSP */
            SEGMENT_TO_PSP(Sda->CurrentPsp)->LastStack = MAKELONG(getSP(), getSS());
        }
 
        /* Set the initial segment registers */
        setDS(Segment);
        setES(Segment);
 
        /* Set the stack */
        setSS(FinalSS);
        setSP(FinalSP);
 
        /*
         * Set the other registers as in real DOS: some demos expect them so!
         * See http://www.fysnet.net/yourhelp.htm
         * and http://www.beroset.com/asm/showregs.asm
         */
        setDX(Segment);
        setDI(FinalSP);
        setBP(0x091E); // DOS base stack pointer relic value. In MS-DOS 5.0 and Windows' NTVDM it's 0x091C. This is in fact the old SP value inside DosData disk stack.
        setSI(FinalIP);
 
        setAX(0/*0xFFFF*/); // FIXME: fcbcode
        setBX(0/*0xFFFF*/); // FIXME: fcbcode
        setCX(0x00FF);
 
        /*
         * Keep critical flags, clear test flags (OF, SF, ZF, AF, PF, CF)
         * and explicitly set the interrupt flag.
         */
        setEFLAGS((getEFLAGS() & ~0x08D5) | 0x0200);
 
        /* Notify VDDs of process execution */
        VDDCreateUserHook(Segment);
 
        /* Execute */
        DosSetProcessContext(Segment);
        CpuExecute(FinalCS, FinalIP);
    }
    else if (LoadType == DOS_LOAD_ONLY)
    {
        ASSERT(Parameters);
        Parameters->StackLocation = MAKELONG(FinalSP, FinalSS);
        Parameters->EntryPoint    = MAKELONG(FinalIP, FinalCS);
    }
 
Cleanup:
    if (Result != ERROR_SUCCESS)
    {
        /* It was not successful, cleanup the DOS memory */
        if (EnvBlock) DosFreeMemory(EnvBlock);
        if (Segment)  DosFreeMemory(Segment);
    }
 
    return Result;
}

Referenced by DosLoadExecutable(), and DosStartComSpec().

DosSetProcessContext()

VOID DosSetProcessContext

(

WORD

Segment

)

Definition at line 329 of file process.c.

{
    Sda->CurrentPsp = Segment;
    Sda->DiskTransferArea = MAKELONG(0x80, Segment);
}

Referenced by DosInt21h(), DosLoadExecutableInternal(), and DosTerminateProcess().

DosTerminateProcess()

VOID DosTerminateProcess	(	WORD	Psp,
		BYTE	ReturnCode,
		WORD	KeepResident
	)

Definition at line 936 of file process.c.

{
    WORD McbSegment = SysVars->FirstMcb;
    PDOS_MCB CurrentMcb;
    LPDWORD IntVecTable = (LPDWORD)((ULONG_PTR)BaseAddress);
    PDOS_PSP PspBlock = SEGMENT_TO_PSP(Psp);
    LPWORD Stack;
    BYTE TerminationType;
 
    DPRINT("DosTerminateProcess: Psp 0x%04X, ReturnCode 0x%02X, KeepResident 0x%04X\n",
           Psp, ReturnCode, KeepResident);
 
    /* Notify VDDs of process termination */
    VDDTerminateUserHook(Psp);
 
    /* Check if this PSP is its own parent */
    if (PspBlock->ParentPsp == Psp) goto Done;
 
    if (KeepResident == 0)
    {
        WORD i;
        for (i = 0; i < PspBlock->HandleTableSize; i++)
        {
            /* Close the handle */
            DosCloseHandle(i);
        }
    }
 
    /* Free the memory used by the process */
    while (TRUE)
    {
        /* Get a pointer to the MCB */
        CurrentMcb = SEGMENT_TO_MCB(McbSegment);
 
        /* Make sure the MCB is valid */
        if (CurrentMcb->BlockType != 'M' && CurrentMcb->BlockType != 'Z') break;
 
        /* Check if this block was allocated by the process */
        if (CurrentMcb->OwnerPsp == Psp)
        {
            if (KeepResident)
            {
                /* Check if this is the PSP block and we should reduce its size */
                if ((McbSegment + 1) == Psp && KeepResident < CurrentMcb->Size)
                {
                    /* Reduce the size of the block */
                    DosResizeMemory(McbSegment + 1, KeepResident, NULL);
                    break;
                }
            }
            else
            {
                /* Free this entire block */
                DosFreeMemory(McbSegment + 1);
            }
        }
 
        /* If this was the last block, quit */
        if (CurrentMcb->BlockType == 'Z') break;
 
        /* Update the segment and continue */
        McbSegment += CurrentMcb->Size + 1;
    }
 
Done:
    /* Restore the interrupt vectors */
    IntVecTable[0x22] = PspBlock->TerminateAddress;
    IntVecTable[0x23] = PspBlock->BreakAddress;
    IntVecTable[0x24] = PspBlock->CriticalAddress;
 
    /* Update the current PSP with the parent's one */
    if (Psp == Sda->CurrentPsp)
    {
        DosSetProcessContext(PspBlock->ParentPsp);
        if (Sda->CurrentPsp == SYSTEM_PSP)
        {
            // NOTE: we can also use the DOS BIOS exit code.
            CpuUnsimulate();
            return;
        }
    }
 
    /* Save the return code - Normal termination or TSR */
    TerminationType = (KeepResident != 0 ? 0x03 : 0x00);
    Sda->ErrorLevel = MAKEWORD(ReturnCode, TerminationType);
 
#ifdef ADVANCED_DEBUGGING
    DPRINT1("PspBlock->ParentPsp = 0x%04x; Sda->CurrentPsp = 0x%04x\n",
           PspBlock->ParentPsp, Sda->CurrentPsp);
#endif
 
    if (Sda->CurrentPsp != SYSTEM_PSP)
    {
#ifdef ADVANCED_DEBUGGING
        DPRINT1("Sda->CurrentPsp = 0x%04x; Old SS:SP = %04X:%04X going to be LastStack = 0x%08x\n",
               Sda->CurrentPsp, getSS(), getSP(), SEGMENT_TO_PSP(Sda->CurrentPsp)->LastStack);
#endif
 
        /* Restore the parent's stack */
        setSS(HIWORD(SEGMENT_TO_PSP(Sda->CurrentPsp)->LastStack));
        setSP(LOWORD(SEGMENT_TO_PSP(Sda->CurrentPsp)->LastStack));
 
        /* Pop the task state */
        DosRestoreState();
    }
 
    /* Return control to the parent process */
    Stack = (LPWORD)SEG_OFF_TO_PTR(getSS(), getSP());
    Stack[STACK_CS] = HIWORD(PspBlock->TerminateAddress);
    Stack[STACK_IP] = LOWORD(PspBlock->TerminateAddress);
}

Referenced by DosControlBreak(), DosInt20h(), DosInt21h(), and DosInt27h().