memory.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_MCB

Macros
#define	SEGMENT_TO_MCB(seg)   ((PDOS_MCB)SEG_OFF_TO_PTR((seg), 0))
#define	DOS_ALLOC_HIGH   0x40
#define	DOS_ALLOC_HIGH_LOW   0x80

Typedefs
typedef struct _DOS_MCB	DOS_MCB
typedef struct _DOS_MCB *	PDOS_MCB

Enumerations
enum	DOS_ALLOC_STRATEGY { DOS_ALLOC_FIRST_FIT , DOS_ALLOC_BEST_FIT , DOS_ALLOC_LAST_FIT }

Functions
	C_ASSERT (sizeof(DOS_MCB)==0x10)
WORD	DosAllocateMemory (WORD Size, WORD *MaxAvailable)
BOOLEAN	DosResizeMemory (WORD BlockData, WORD NewSize, WORD *MaxAvailable)
BOOLEAN	DosFreeMemory (WORD BlockData)
BOOLEAN	DosLinkUmb (VOID)
BOOLEAN	DosUnlinkUmb (VOID)
VOID	DosChangeMemoryOwner (WORD Segment, WORD NewOwner)
VOID	DosInitializeUmb (VOID)
VOID	DosInitializeMemory (VOID)

Macro Definition Documentation

DOS_ALLOC_HIGH

#define DOS_ALLOC_HIGH   0x40

Definition at line 17 of file memory.h.

DOS_ALLOC_HIGH_LOW

#define DOS_ALLOC_HIGH_LOW   0x80

Definition at line 18 of file memory.h.

SEGMENT_TO_MCB

#define SEGMENT_TO_MCB

(

seg

)

((PDOS_MCB)SEG_OFF_TO_PTR((seg), 0))

Definition at line 15 of file memory.h.

Typedef Documentation

DOS_MCB

typedef struct _DOS_MCB DOS_MCB

PDOS_MCB

typedef struct _DOS_MCB * PDOS_MCB

Enumeration Type Documentation

DOS_ALLOC_STRATEGY

enum DOS_ALLOC_STRATEGY

Enumerator
DOS_ALLOC_FIRST_FIT
DOS_ALLOC_BEST_FIT
DOS_ALLOC_LAST_FIT

Definition at line 20 of file memory.h.

{
    DOS_ALLOC_FIRST_FIT,
    DOS_ALLOC_BEST_FIT,
    DOS_ALLOC_LAST_FIT
};

Function Documentation

C_ASSERT()

C_ASSERT

(

sizeof(DOS_MCB)

= =0x10

)

DosAllocateMemory()

WORD DosAllocateMemory	(	WORD	Size,
		WORD *	MaxAvailable
	)

Definition at line 136 of file memory.c.

{
    WORD Result = 0, Segment = SysVars->FirstMcb, MaxSize = 0;
    PDOS_MCB CurrentMcb;
    BOOLEAN SearchUmb = FALSE;
 
    DPRINT("DosAllocateMemory: Size 0x%04X\n", Size);
 
    DosMemValidate();
 
    if (SysVars->UmbLinked && SysVars->UmbChainStart != 0xFFFF &&
        (Sda->AllocStrategy & (DOS_ALLOC_HIGH | DOS_ALLOC_HIGH_LOW)))
    {
        /* Search UMB first */
        Segment = SysVars->UmbChainStart;
        SearchUmb = TRUE;
    }
 
    while (TRUE)
    {
        /* Get a pointer to the MCB */
        CurrentMcb = SEGMENT_TO_MCB(Segment);
 
        /* Make sure it's valid */
        if (!ValidateMcb(CurrentMcb))
        {
            DPRINT1("The DOS memory arena is corrupted!\n");
            Sda->LastErrorCode = ERROR_ARENA_TRASHED;
            return 0;
        }
 
        /* Only check free blocks */
        if (CurrentMcb->OwnerPsp != 0) goto Next;
 
        /* Combine this free block with adjoining free blocks */
        DosCombineFreeBlocks(Segment);
 
        /* Update the maximum block size */
        if (CurrentMcb->Size > MaxSize) MaxSize = CurrentMcb->Size;
 
        /* Check if this block is big enough */
        if (CurrentMcb->Size < Size) goto Next;
 
        switch (Sda->AllocStrategy & ~(DOS_ALLOC_HIGH | DOS_ALLOC_HIGH_LOW))
        {
            case DOS_ALLOC_FIRST_FIT:
            {
                /* For first fit, stop immediately */
                Result = Segment;
                goto Done;
            }
 
            case DOS_ALLOC_BEST_FIT:
            {
                /* For best fit, update the smallest block found so far */
                if ((Result == 0) || (CurrentMcb->Size < SEGMENT_TO_MCB(Result)->Size))
                {
                    Result = Segment;
                }
 
                break;
            }
 
            case DOS_ALLOC_LAST_FIT:
            {
                /* For last fit, make the current block the result, but keep searching */
                Result = Segment;
                break;
            }
        }
 
Next:
        /* If this was the last MCB in the chain, quit */
        if (CurrentMcb->BlockType == 'Z')
        {
            /* Check if nothing was found while searching through UMBs */
            if ((Result == 0) && SearchUmb && (Sda->AllocStrategy & DOS_ALLOC_HIGH_LOW))
            {
                /* Search low memory */
                Segment = SysVars->FirstMcb;
                SearchUmb = FALSE;
                continue;
            }
 
            break;
        }
 
        /* Otherwise, update the segment and continue */
        Segment += CurrentMcb->Size + 1;
    }
 
Done:
    DosMemValidate();
 
    /* If we didn't find a free block, bail out */
    if (Result == 0)
    {
        DPRINT("DosAllocateMemory FAILED. Maximum available: 0x%04X\n", MaxSize);
        Sda->LastErrorCode = ERROR_NOT_ENOUGH_MEMORY;
        if (MaxAvailable) *MaxAvailable = MaxSize;
        return 0;
    }
 
    /* Get a pointer to the MCB */
    CurrentMcb = SEGMENT_TO_MCB(Result);
 
    /* Check if the block is larger than requested */
    if (CurrentMcb->Size > Size)
    {
        /* It is, split it into two blocks */
        if ((Sda->AllocStrategy & ~(DOS_ALLOC_HIGH | DOS_ALLOC_HIGH_LOW)) != DOS_ALLOC_LAST_FIT)
        {
            PDOS_MCB NextMcb = SEGMENT_TO_MCB(Result + Size + 1);
 
            /* Initialize the new MCB structure */
            NextMcb->BlockType = CurrentMcb->BlockType;
            NextMcb->Size = CurrentMcb->Size - Size - 1;
            NextMcb->OwnerPsp = 0;
 
            /* Update the current block */
            CurrentMcb->BlockType = 'M';
            CurrentMcb->Size = Size;
        }
        else
        {
            /* Save the location of the current MCB */
            PDOS_MCB PreviousMcb = CurrentMcb;
 
            /* Move the current MCB higher */
            Result += CurrentMcb->Size - Size;
            CurrentMcb = SEGMENT_TO_MCB(Result);
 
            /* Initialize the new MCB structure */
            CurrentMcb->BlockType = PreviousMcb->BlockType;
            CurrentMcb->Size = Size;
            CurrentMcb->OwnerPsp = 0;
 
            /* Update the previous block */
            PreviousMcb->BlockType = 'M';
            PreviousMcb->Size -= Size + 1;
        }
    }
 
    /* Take ownership of the block */
    CurrentMcb->OwnerPsp = Sda->CurrentPsp;
    RtlCopyMemory(CurrentMcb->Name, SEGMENT_TO_MCB(Sda->CurrentPsp - 1)->Name, sizeof(CurrentMcb->Name));
 
    DosMemValidate();
 
    /* Return the segment of the data portion of the block */
    return Result + 1;
}

Referenced by DosCopyEnvironmentBlock(), DosCountryInitialize(), DosCreateDeviceEx(), DosInt21h(), DosLoadDriver(), DosLoadExecutableInternal(), DosMouseInitialize(), and DosResizeHandleTable().

DosChangeMemoryOwner()

VOID DosChangeMemoryOwner	(	WORD	Segment,
		WORD	NewOwner
	)

Definition at line 532 of file memory.c.

{
    PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment - 1);
    Mcb->OwnerPsp = NewOwner;
}

Referenced by DosLoadExecutableInternal().

DosFreeMemory()

BOOLEAN DosFreeMemory

(

WORD

BlockData

)

Definition at line 418 of file memory.c.

{
    PDOS_MCB Mcb = SEGMENT_TO_MCB(BlockData - 1);
 
    DPRINT("DosFreeMemory: BlockData 0x%04X\n", BlockData);
 
    if (BlockData == 0)
    {
        Sda->LastErrorCode = ERROR_INVALID_BLOCK;
        return FALSE;
    }
 
    DosMemValidate();
 
    /* Make sure the MCB is valid */
    if (!ValidateMcb(Mcb))
    {
        DPRINT("MCB block type '%c' not valid!\n", Mcb->BlockType);
        Sda->LastErrorCode = ERROR_INVALID_BLOCK;
        return FALSE;
    }
 
    /* Mark the block as free */
    Mcb->OwnerPsp = 0;
 
    return TRUE;
}

Referenced by DosCreateDeviceEx(), DosDeleteDevice(), DosInt21h(), DosLoadDriver(), DosLoadExecutableInternal(), DosMouseCleanup(), DosResizeHandleTable(), and DosTerminateProcess().

DosInitializeMemory()

VOID DosInitializeMemory

(

VOID

)

Definition at line 665 of file memory.c.

{
    PDOS_MCB Mcb;
 
    /* Set the initial allocation strategy to "best fit" */
    Sda->AllocStrategy = DOS_ALLOC_BEST_FIT;
 
    /* Initialize conventional memory; we don't have UMBs yet */
    SysVars->FirstMcb = FIRST_MCB_SEGMENT; // The Arena Head
    SysVars->UmbLinked = FALSE;
    SysVars->UmbChainStart = 0xFFFF;
 
    Mcb = SEGMENT_TO_MCB(SysVars->FirstMcb);
 
    /* Initialize the MCB */
    Mcb->BlockType = 'Z';
    Mcb->Size = USER_MEMORY_SIZE;
    Mcb->OwnerPsp = 0;
}

Referenced by DosKRNLInitialize().

DosInitializeUmb()

VOID DosInitializeUmb

(

VOID

)

Definition at line 582 of file memory.c.

{
    BOOLEAN Result;
    USHORT UmbSegment = 0x0000, PrevSegment;
    USHORT Size;
    PDOS_MCB Mcb, PrevMcb;
 
    ASSERT(SysVars->UmbChainStart == 0xFFFF);
 
    // SysVars->UmbLinked = FALSE;
 
    /* Try to allocate all the UMBs */
    while (TRUE)
    {
        /* Find the maximum amount of memory that can be allocated */
        Size = 0xFFFF;
        Result = UmaDescReserve(&UmbSegment, &Size);
 
        /* If we are out of UMBs, bail out */
        if (!Result && Size == 0) // XMS_STATUS_OUT_OF_UMBS
            break;
 
        /* We should not have succeeded! */
        ASSERT(!Result);
 
        /* 'Size' now contains the size of the biggest UMB block. Request it. */
        Result = UmaDescReserve(&UmbSegment, &Size);
        ASSERT(Result); // XMS_STATUS_SUCCESS
 
        /* If this is our first UMB block, initialize the UMB chain */
        if (SysVars->UmbChainStart == 0xFFFF)
        {
            /* Initialize the link MCB to the UMB area */
            // NOTE: We use the fact that UmbChainStart is still == 0xFFFF
            // so that we initialize this block from 9FFF:0000 up to FFFF:000F.
            // It will be splitted as needed just below.
            Mcb = SEGMENT_TO_MCB(SysVars->FirstMcb + USER_MEMORY_SIZE + 1); // '+1': Readjust the fact that USER_MEMORY_SIZE is based using 0x9FFE instead of 0x9FFF
            Mcb->BlockType = 'Z'; // At the moment it is really the last block
            Mcb->Size = (SysVars->UmbChainStart /* UmbSegment */ - SysVars->FirstMcb - USER_MEMORY_SIZE - 2) + 1;
            Mcb->OwnerPsp = SYSTEM_PSP;
            RtlCopyMemory(Mcb->Name, "SC      ", sizeof("SC      ")-1);
 
#if 0 // Keep here for reference; this will be deleted as soon as it becomes unneeded.
            /* Initialize the UMB area */
            Mcb = SEGMENT_TO_MCB(SysVars->UmbChainStart);
            Mcb->Size = UMB_END_SEGMENT - SysVars->UmbChainStart;
#endif
 
            // FIXME: We should adjust the size of the previous block!!
 
            /* Initialize the start of the UMB chain */
            SysVars->UmbChainStart = SysVars->FirstMcb + USER_MEMORY_SIZE + 1;
        }
 
        /* Split the block */
 
        /* Get the previous block */
        PrevSegment = DosGetPreviousUmb(UmbSegment);
        PrevMcb = SEGMENT_TO_MCB(PrevSegment);
 
        /* Initialize the next block */
        Mcb = SEGMENT_TO_MCB(UmbSegment + /*Mcb->Size*/(Size - 1) + 0);
        // Mcb->BlockType = 'Z'; // FIXME: What if this block happens to be the last one??
        Mcb->BlockType = PrevMcb->BlockType;
        Mcb->Size = PrevMcb->Size - (UmbSegment + Size - PrevSegment) + 1;
        Mcb->OwnerPsp = PrevMcb->OwnerPsp;
        RtlCopyMemory(Mcb->Name, PrevMcb->Name, sizeof(PrevMcb->Name));
 
        /* The previous block is not the latest one anymore */
        PrevMcb->BlockType = 'M';
        PrevMcb->Size = UmbSegment - PrevSegment - 1;
 
        /* Initialize the new UMB block */
        Mcb = SEGMENT_TO_MCB(UmbSegment);
        Mcb->BlockType = 'M'; // 'Z' // FIXME: What if this block happens to be the last one??
        Mcb->Size = Size - 1 - 1; // minus 2 because we need to have one arena at the beginning and one at the end.
        Mcb->OwnerPsp = 0;
        // FIXME: Which MCB name should we use? I need to explore more the docs!
        RtlCopyMemory(Mcb->Name, "UMB     ", sizeof("UMB     ")-1);
        // RtlCopyMemory(Mcb->Name, "SM      ", sizeof("SM      ")-1);
    }
}

Referenced by DosKRNLInitialize().

DosLinkUmb()

BOOLEAN DosLinkUmb

(

VOID

)

Definition at line 446 of file memory.c.

{
    DWORD Segment = SysVars->FirstMcb;
    PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment);
 
    DPRINT("Linking UMB\n");
 
    /* Check if UMBs are initialized and already linked */
    if (SysVars->UmbChainStart == 0xFFFF) return FALSE;
    if (SysVars->UmbLinked) return TRUE;
 
    DosMemValidate();
 
    /* Find the last block before the start of the UMB chain */
    while (Segment < SysVars->UmbChainStart)
    {
        /* Get a pointer to the MCB */
        Mcb = SEGMENT_TO_MCB(Segment);
 
        /* Make sure it's valid */
        if (!ValidateMcb(Mcb))
        {
            DPRINT1("The DOS memory arena is corrupted!\n");
            Sda->LastErrorCode = ERROR_ARENA_TRASHED;
            return FALSE;
        }
 
        /* If this was the last MCB in the chain, quit */
        if (Mcb->BlockType == 'Z') break;
 
        /* Otherwise, update the segment and continue */
        Segment += Mcb->Size + 1;
    }
 
    /* Make sure it's valid */
    if (Mcb->BlockType != 'Z') return FALSE;
 
    /* Connect the MCB with the UMB chain */
    Mcb->BlockType = 'M';
 
    DosMemValidate();
 
    SysVars->UmbLinked = TRUE;
    return TRUE;
}

Referenced by DosInt21h().

DosResizeMemory()

BOOLEAN DosResizeMemory	(	WORD	BlockData,
		WORD	NewSize,
		WORD *	MaxAvailable
	)

Definition at line 289 of file memory.c.

{
    BOOLEAN Success = TRUE;
    WORD Segment = BlockData - 1, ReturnSize = 0, NextSegment;
    PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment), NextMcb;
 
    DPRINT("DosResizeMemory: BlockData 0x%04X, NewSize 0x%04X\n",
           BlockData, NewSize);
 
    DosMemValidate();
 
    /* Make sure this is a valid and allocated block */
    if (BlockData == 0 || !ValidateMcb(Mcb) || Mcb->OwnerPsp == 0)
    {
        Sda->LastErrorCode = ERROR_INVALID_BLOCK;
        Success = FALSE;
        goto Done;
    }
 
    ReturnSize = Mcb->Size;
 
    /* Check if we need to expand or contract the block */
    if (NewSize > Mcb->Size)
    {
        /* We can't expand the last block */
        if (Mcb->BlockType == 'Z')
        {
            DPRINT("Cannot expand memory block 0x%04X: this is the last block (size 0x%04X)!\n", Segment, Mcb->Size);
            Sda->LastErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            Success = FALSE;
            goto Done;
        }
 
        /* Get the pointer and segment of the next MCB */
        NextSegment = Segment + Mcb->Size + 1;
        NextMcb = SEGMENT_TO_MCB(NextSegment);
 
        /* Make sure it's valid */
        if (!ValidateMcb(NextMcb))
        {
            DPRINT1("The DOS memory arena is corrupted!\n");
            Sda->LastErrorCode = ERROR_ARENA_TRASHED;
            return FALSE;
        }
 
        /* Make sure the next segment is free */
        if (NextMcb->OwnerPsp != 0)
        {
            DPRINT("Cannot expand memory block 0x%04X: next segment is not free!\n", Segment);
            Sda->LastErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            Success = FALSE;
            goto Done;
        }
 
        /* Combine this free block with adjoining free blocks */
        DosCombineFreeBlocks(NextSegment);
 
        /* Set the maximum possible size of the block */
        ReturnSize += NextMcb->Size + 1;
 
        if (ReturnSize < NewSize)
        {
            DPRINT("Cannot expand memory block 0x%04X: insufficient free segments available!\n", Segment);
            Sda->LastErrorCode = ERROR_NOT_ENOUGH_MEMORY;
            Success = FALSE;
            goto Done;
        }
 
        /* Maximize the current block */
        Mcb->Size = ReturnSize;
        Mcb->BlockType = NextMcb->BlockType;
 
        /* Invalidate the next block */
        NextMcb->BlockType = 'I';
 
        /* Check if the block is larger than requested */
        if (Mcb->Size > NewSize)
        {
            DPRINT("Block too large, reducing size from 0x%04X to 0x%04X\n",
                   Mcb->Size, NewSize);
 
            /* It is, split it into two blocks */
            NextMcb = SEGMENT_TO_MCB(Segment + NewSize + 1);
 
            /* Initialize the new MCB structure */
            NextMcb->BlockType = Mcb->BlockType;
            NextMcb->Size = Mcb->Size - NewSize - 1;
            NextMcb->OwnerPsp = 0;
 
            /* Update the current block */
            Mcb->BlockType = 'M';
            Mcb->Size = NewSize;
        }
    }
    else if (NewSize < Mcb->Size)
    {
        DPRINT("Shrinking block from 0x%04X to 0x%04X\n",
               Mcb->Size, NewSize);
 
        /* Just split the block */
        NextSegment = Segment + NewSize + 1;
        NextMcb = SEGMENT_TO_MCB(NextSegment);
        NextMcb->BlockType = Mcb->BlockType;
        NextMcb->Size = Mcb->Size - NewSize - 1;
        NextMcb->OwnerPsp = 0;
 
        /* Update the MCB */
        Mcb->BlockType = 'M';
        Mcb->Size = NewSize;
 
        /* Combine this free block with adjoining free blocks */
        DosCombineFreeBlocks(NextSegment);
    }
 
Done:
    /* Check if the operation failed */
    if (!Success)
    {
        DPRINT("DosResizeMemory FAILED. Maximum available: 0x%04X\n", ReturnSize);
 
        /* Return the maximum possible size */
        if (MaxAvailable) *MaxAvailable = ReturnSize;
    }
 
    DosMemValidate();
 
    return Success;
}

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

DosUnlinkUmb()

BOOLEAN DosUnlinkUmb

(

VOID

)

Definition at line 492 of file memory.c.

{
    DWORD Segment = SysVars->FirstMcb;
    PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment);
 
    DPRINT("Unlinking UMB\n");
 
    /* Check if UMBs are initialized and already unlinked */
    if (SysVars->UmbChainStart == 0xFFFF) return FALSE;
    if (!SysVars->UmbLinked) return TRUE;
 
    DosMemValidate();
 
    /* Find the last block before the start of the UMB chain */
    while (Segment < SysVars->UmbChainStart)
    {
        /* Get a pointer to the MCB */
        Mcb = SEGMENT_TO_MCB(Segment);
 
        /* Make sure it's valid */
        if (!ValidateMcb(Mcb))
        {
            DPRINT1("The DOS memory arena is corrupted!\n");
            Sda->LastErrorCode = ERROR_ARENA_TRASHED;
            return FALSE;
        }
 
        /* Advance to the next MCB */
        Segment += Mcb->Size + 1;
    }
 
    /* Mark the MCB as the last MCB */
    Mcb->BlockType = 'Z';
 
    DosMemValidate();
 
    SysVars->UmbLinked = FALSE;
    return TRUE;
}

Referenced by DosInt21h().