Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-06 12:45:16 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/subsystems/mvdm/ntvdm/dos/dos32krnl/memory.c

686 lines
20 KiB
C
Raw Blame History

/*
* COPYRIGHT: GPL - See COPYING in the top level directory
* PROJECT: ReactOS Virtual DOS Machine
* FILE: subsystems/mvdm/ntvdm/dos/dos32krnl/memory.c
* PURPOSE: DOS32 Memory Manager
* PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
* Hermes Belusca-Maito (hermes.belusca@sfr.fr)
*/
/* INCLUDES *******************************************************************/
#include "ntvdm.h"
#define NDEBUG
#include <debug.h>
#include "emulator.h"
#include "bios/umamgr.h" // HACK until we correctly call XMS services for UMBs.
#include "dos.h"
#include "dos/dem.h"
#include "memory.h"
#include "process.h"
#include "himem.h"
// FIXME: Should be dynamically initialized!
#define FIRST_MCB_SEGMENT (SYSTEM_ENV_BLOCK + 0x200) // old value: 0x1000
#define USER_MEMORY_SIZE (0x9FFE - FIRST_MCB_SEGMENT)
/*
* Activate this line if you want run-time DOS memory arena integrity validation
* (useful to know whether this is an application, or DOS kernel itself, which
* messes up the DOS memory arena).
*/
// #define DBG_MEMORY
/* PRIVATE VARIABLES **********************************************************/
/* PUBLIC VARIABLES ***********************************************************/
/* PRIVATE FUNCTIONS **********************************************************/
static inline BOOLEAN ValidateMcb(PDOS_MCB Mcb)
{
return (Mcb->BlockType == 'M' || Mcb->BlockType == 'Z');
}
/*
* This is a helper function to help us detecting
* when the DOS arena starts to become corrupted.
*/
#ifdef DBG_MEMORY
static VOID DosMemValidate(VOID)
{
WORD PrevSegment, Segment = SysVars->FirstMcb;
PDOS_MCB CurrentMcb;
PrevSegment = Segment;
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! (CurrentMcb = 0x%04X; PreviousMcb = 0x%04X)\n", Segment, PrevSegment);
return;
}
PrevSegment = Segment;
/* If this was the last MCB in the chain, quit */
if (CurrentMcb->BlockType == 'Z') return;
/* Otherwise, update the segment and continue */
Segment += CurrentMcb->Size + 1;
}
}
#else
#define DosMemValidate()
#endif
static VOID DosCombineFreeBlocks(WORD StartBlock)
{
/* NOTE: This function is always called with valid MCB blocks */
PDOS_MCB CurrentMcb = SEGMENT_TO_MCB(StartBlock), NextMcb;
/* If the block is not free, quit */
if (CurrentMcb->OwnerPsp != 0) return;
/*
* Loop while the current block is not the last one. It can happen
* that the block is not the last one at the beginning, but becomes
* the last one at the end of the process. This happens in the case
* where its next following blocks are free but not combined yet,
* and they are terminated by a free last block. During the process
* all the blocks are combined together and we end up in the situation
* where the current (free) block is followed by the last (free) block.
* At the last step of the algorithm the current block becomes the
* last one.
*/
while (CurrentMcb->BlockType != 'Z')
{
/* Get a pointer to the next MCB */
NextMcb = SEGMENT_TO_MCB(StartBlock + CurrentMcb->Size + 1);
/* Make sure it's valid */
if (!ValidateMcb(NextMcb))
{
DPRINT1("The DOS memory arena is corrupted!\n");
Sda->LastErrorCode = ERROR_ARENA_TRASHED;
return;
}
/* Check if the next MCB is free */
if (NextMcb->OwnerPsp == 0)
{
/* Combine them */
CurrentMcb->Size += NextMcb->Size + 1;
CurrentMcb->BlockType = NextMcb->BlockType;
NextMcb->BlockType = 'I';
}
else
{
/* No more adjoining free blocks */
break;
}
}
}
/* PUBLIC FUNCTIONS ***********************************************************/
WORD DosAllocateMemory(WORD Size, WORD *MaxAvailable)
{
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;
}
BOOLEAN DosResizeMemory(WORD BlockData, WORD NewSize, WORD *MaxAvailable)
{
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;
}
BOOLEAN DosFreeMemory(WORD BlockData)
{
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;
}
BOOLEAN DosLinkUmb(VOID)
{
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;
}
BOOLEAN DosUnlinkUmb(VOID)
{
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;
}
VOID DosChangeMemoryOwner(WORD Segment, WORD NewOwner)
{
PDOS_MCB Mcb = SEGMENT_TO_MCB(Segment - 1);
Mcb->OwnerPsp = NewOwner;
}
/*
* Some information about DOS UMBs:
* http://textfiles.com/virus/datut010.txt
* http://www.asmcommunity.net/forums/topic/?id=30884
*/
WORD DosGetPreviousUmb(WORD UmbSegment)
{
PDOS_MCB CurrentMcb;
WORD Segment, PrevSegment = 0; // FIXME: or use UmbChainStart ??
if (SysVars->UmbChainStart == 0xFFFF)
return 0;
/* Start scanning the UMB chain */
Segment = SysVars->UmbChainStart;
while (TRUE)
{
/* Get a pointer to the MCB */
CurrentMcb = SEGMENT_TO_MCB(Segment);
/* Make sure it's valid */
if (!ValidateMcb(CurrentMcb))
{
DPRINT1("The UMB DOS memory arena is corrupted!\n");
Sda->LastErrorCode = ERROR_ARENA_TRASHED;
return 0;
}
/* We went over the UMB segment, quit */
if (Segment >= UmbSegment) break;
PrevSegment = Segment;
/* If this was the last MCB in the chain, quit */
if (CurrentMcb->BlockType == 'Z') break;
/* Otherwise, update the segment and continue */
Segment += CurrentMcb->Size + 1;
}
return PrevSegment;
}
VOID DosInitializeUmb(VOID)
{
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);
}
}
VOID DosInitializeMemory(VOID)
{
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;
}
/* EOF */
Reference in a new issue View git blame Copy permalink