1
0
Fork 0
mirror of https://gitlab.com/sortix/sortix.git synced 2023-02-13 20:55:38 -05:00
sortix--sortix/libmaxsi/memory.cpp
2011-08-12 00:55:48 +02:00

468 lines
15 KiB
C++

/******************************************************************************
COPYRIGHT(C) JONAS 'SORTIE' TERMANSEN 2011.
This file is part of LibMaxsi.
LibMaxsi is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
LibMaxsi is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
more details.
You should have received a copy of the GNU Lesser General Public License
along with LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
memory.cpp
Useful functions for manipulating memory, as well as the implementation
of the heap.
******************************************************************************/
#include "platform.h"
#include "memory.h"
#include "error.h"
#include "io.h" // DEBUG
#ifdef SORTIX_KERNEL
#include <sortix/platform.h>
#include <sortix/globals.h> // DEBUG
#include <sortix/iprintable.h> // DEBUG
#include <sortix/log.h> // DEBUG
#include <sortix/memorymanagement.h>
#include <sortix/panic.h>
#endif
#define IsGoodChunkPosition(Chunk) ((uintptr_t) Wilderness + WildernessSize <= (uintptr_t) (Chunk) && (uintptr_t) (Chunk) <= (uintptr_t) HeapStart)
#define IsGoodChunkInfo(Chunk) ( ( (UnusedChunkFooter*) (((byte*) (Chunk)) + (Chunk)->Size - sizeof(UnusedChunkFooter)) )->Size == (Chunk)->Size )
#define IsGoodChunk(Chunk) (IsGoodChunkPosition(Chunk) && (Chunk)->Size >= 32 && IsGoodChunkPosition((uintptr_t) (Chunk) + (Chunk)->Size) && IsGoodChunkInfo(Chunk) )
#define IsGoodUnusedChunk(Chunk) ( IsGoodChunk(Chunk) && ( Chunk->NextUnused == NULL || IsGoodChunkPosition(Chunk->NextUnused) ) )
#define IsGoodUsedChunk(Chunk) ( IsGoodChunk(Chunk) && Chunk->Magic == Magic )
#ifdef PLATFORM_X64
#define IsGoodBinIndex(Index) ( 4 <= Index && Index < 32 )
#else
#define IsGoodBinIndex(Index) ( 5 <= Index && Index < 64 )
#endif
#define IsAligned(Value, Alignment) ( (Value & (Alignment-1)) == 0 )
#define BITS(x) (8UL*sizeof(x))
namespace Maxsi
{
// TODO: How should this API exist? Should it be publicly accessasble?
// Where should the C bindings (if relevant) be declared and defined?
// Is it part of the kernel or the standard library? What should it be
// called? Is it an extension? For now, I'll just leave this here, hidden
// away in libmaxsi until I figure out how libmaxsi/sortix should handle
// facilities currently only available on Sortix.
namespace System
{
namespace Memory
{
bool Allocate(void* /*position*/, size_t /*length*/)
{
// TODO: Implement a syscall for this!
return true;
}
}
}
namespace Memory
{
// This magic word is useful to see if the program has written into the
// chunk's header or footer, which means the program has malfunctioned
// and ought to be terminated.
#ifdef PLATFORM_X64
const size_t Magic = 0xDEADDEADDEADDEADULL;
#else
const size_t Magic = 0xDEADDEAD;
#endif
// All requsted sizes must be a multiple of this.
const size_t Alignment = 16ULL;
// Returns the index of the most significant set bit.
inline size_t BSR(size_t Value)
{
#if 1
ASSERT(Value > 0);
for ( size_t I = 8*sizeof(size_t); I > 0; I-- )
{
if ( Value & ( 1 << (I-1) ) ) { return I-1; }
}
return 0;
#else
size_t Result;
asm("bsr %0, %1" : "=r"(Result) : "r"(Value));
return Result;
#endif
}
// Returns the index of the least significant set bit.
inline size_t BSF(size_t Value)
{
#if 1
ASSERT(Value > 0);
for ( size_t I = 0; I < 8*sizeof(size_t); I++ )
{
if ( Value & ( 1 << I ) ) { return I; }
}
return 0;
#else
size_t Result;
asm("bsf %0, %1" : "=r"(Result) : "r"(Value));
return Result;
#endif
}
// NOTE: BSR(N) = Log2RoundedDown(N).
// NOTE: BSR(N-1)+1 = Log2RoundedUp(N), N > 1.
// PROOF: If X=2^N is a power of two, then BSR(X) = Log2(X) = N.
// If X is not a power of two, then BSR(X) will return the previous
// power of two.
// If we want the next power of two for a non-power-of-two then
// BSR(X)+1 would work. However, this causes problems for X=2^N, where
// it returns a value one too big.
// BSR(X-1)+1 = BSR(X)+1 give the same value for all X that is not a
// power of two. For X=2^N, BSR(X-1)+1 will be one lower, which is
// exactly what we want. QED.
// Now declare some structures that are put around the allocated data.
struct UnusedChunkHeader
{
size_t Size;
UnusedChunkHeader* NextUnused;
};
struct UnusedChunkFooter
{
void* Unused;
size_t Size;
};
struct UsedChunkHeader
{
size_t Size;
size_t Magic;
};
struct UsedChunkFooter
{
size_t Magic;
size_t Size;
};
// How much extra space will our headers use?
const size_t ChunkOverhead = sizeof(UsedChunkHeader) + sizeof(UsedChunkFooter);
size_t GetChunkOverhead() { return ChunkOverhead; }
// A bin for each power of two.
UnusedChunkHeader* Bins[BITS(size_t)];
// INVARIANT: A bit is set for each bin if it contains anything.
size_t BinContainsChunks;
// And south of everything, there is nothing allocated, at which
// extra space can be added on-demand.
// INVARIANT: Wilderness is always page-aligned!
const byte* HeapStart;
const byte* Wilderness;
size_t WildernessSize;
// Initializes the heap system.
void Init()
{
Memory::Set(Bins, 0, sizeof(Bins));
#ifdef SORTIX_KERNEL
Wilderness = (byte*) Sortix::VirtualMemory::heapUpper;
#else
// TODO: This is very 32-bit specific!
Wilderness = (byte*) 0x80000000;
#endif
HeapStart = Wilderness;
WildernessSize = 0;
BinContainsChunks = 0;
}
// Expands the wilderness block (the heap grows downwards).
bool ExpandWilderness(size_t NeededSize)
{
if ( NeededSize <= WildernessSize ) { return true; }
ASSERT(Wilderness != NULL);
// Check if we are going too far down (beneath the NULL position!).
if ( (uintptr_t) Wilderness < NeededSize ) { return false; }
#ifdef SORTIX_KERNEL
// Check if the wilderness would grow larger than the kernel memory area.
if ( ( ((uintptr_t) Wilderness) - Sortix::VirtualMemory::heapLower ) < NeededSize ) { return false; }
#endif
// Figure out how where the new wilderness will be.
uintptr_t NewWilderness = ((uintptr_t) Wilderness) + WildernessSize - NeededSize;
// And now align downwards to the page boundary.
NewWilderness &= ~(0xFFFUL);
ASSERT(NewWilderness < (uintptr_t) Wilderness);
// Figure out where and how much memory we need.
byte* MemoryStart = (byte*) NewWilderness;
size_t MemorySize = (uintptr_t) Wilderness - (uintptr_t) NewWilderness;
#ifndef SORTIX_KERNEL // We are user-space.
// Ask the kernel to map memory to the needed region!
if ( !System::Memory::Allocate(MemoryStart, MemorySize) ) { return false; }
#else // We are Sortix.
// Figure out how many pages we need.
size_t NumPages = MemorySize / 4096;
size_t PagesLeft = NumPages;
ASSERT(NumPages > 0);
// Attempt to allocate and map each of them.
while ( PagesLeft > 0 )
{
PagesLeft--;
// Get a raw unused physical page.
addr_t Page = Sortix::Page::Get();
if ( Page == 0 )
{
// If none is available, simply let the allocation fail
// and unallocate everything we did allocate so far.
while ( PagesLeft < NumPages )
{
PagesLeft++;
addr_t OldVirtual = NewWilderness + 4096 * PagesLeft;
addr_t OldPage = Sortix::VirtualMemory::UnmapKernel(OldVirtual);
Sortix::Page::Put(OldPage);
}
return false;
}
// Map the physical page to a virtual one.
addr_t VirtualAddr = NewWilderness + 4096 * PagesLeft;
Sortix::VirtualMemory::MapKernel(VirtualAddr, Page);
}
#endif
// Update the wilderness information now that it is safe.
Wilderness = MemoryStart;
WildernessSize += MemorySize;
ASSERT(WildernessSize >= NeededSize);
return true;
}
// Allocates a continious memory region of Size bytes that must be deallocated using Free.
DUAL_FUNCTION(void*, malloc, Allocate, (size_t Size))
{
// Always allocate a multiple of alignment (round up to nearest aligned size).
// INVARIANT: Size is always aligned after this statement.
Size = (Size + Alignment - 1) & ~(Alignment-1);
// Account for the overhead of the headers and footers.
Size += ChunkOverhead;
ASSERT((Size & (Alignment-1)) == 0);
// Find the index of the smallest usable bin.
// INVARIANT: Size is always at least ChunkOverhead bytes, thus
// Size-1 will never be 0, and thus BSR is always defined.
size_t MinBinIndex = BSR(Size-1)+1;
ASSERT(IsGoodBinIndex(MinBinIndex));
// Make a bitmask that filters away all bins that are too small.
size_t MinBinMask = ~((1 << MinBinIndex) - 1);
ASSERT( ( (1 << (MinBinIndex-1)) & MinBinMask ) == 0);
// Now filter all bins away that are too small.
size_t AvailableBins = BinContainsChunks & MinBinMask;
// Does any bin contain an usable chunk?
if ( AvailableBins > 0 )
{
// Now find the smallest usable bin.
size_t BinIndex = BSF( AvailableBins );
ASSERT(IsGoodBinIndex(BinIndex));
// And pick the first thing in it.
UnusedChunkHeader* Chunk = Bins[BinIndex];
ASSERT(IsGoodUnusedChunk(Chunk));
// Increment the bin's linked list.
Bins[BinIndex] = Chunk->NextUnused;
ASSERT(Chunk->NextUnused == NULL || IsGoodUnusedChunk(Chunk->NextUnused));
// Find the size of this bin (also the value of this bins flag).
size_t BinSize = 1 << BinIndex;
ASSERT(BinSize >= Size);
// If we emptied the bin, then remove the flag that says this bin is usable.
ASSERT(BinContainsChunks & BinSize);
if ( Chunk->NextUnused == NULL ) { BinContainsChunks ^= BinSize; }
// Figure out where the chunk ends.
uintptr_t ChunkEnd = ((uintptr_t) Chunk) + Chunk->Size;
// If we were to split the chunk into one used part, and one unused part, then
// figure out where the unused part would begin.
uintptr_t NewChunkStart = ((uintptr_t) Chunk) + Size;
// INVARIANT: NewChunkStart is always less or equal to ChunkEnd,
// because Size is less or equal to Chunk->Size (otherwise this
// chunk could not have been selected above).
ASSERT(NewChunkStart <= ChunkEnd);
// INVARIANT: NewChunkStart is aligned because Chunk is (this
// is made sure when chunks are made when expanding into the
// wilderness, when splitting blocks, and when combining them),
// and because Size is aligned (first thing we make sure).
ASSERT( IsAligned(NewChunkStart, Alignment) );
// Find the size of the possible new chunk.
size_t NewChunkSize = ChunkEnd - NewChunkStart;
UsedChunkHeader* ResultHeader = (UsedChunkHeader*) Chunk;
// See if it's worth it to split the chunk into two, if any space is left in it.
if ( NewChunkSize >= sizeof(UnusedChunkHeader) + sizeof(UnusedChunkFooter) )
{
// Figure out which bin to put the new chunk in.
size_t NewBinIndex = BSR(NewChunkSize);
ASSERT(IsGoodBinIndex(NewBinIndex));
// Mark that a chunk is available for this bin.
BinContainsChunks |= (1 << NewBinIndex);
// Now write some headers and footers for the new chunk.
UnusedChunkHeader* NewChunkHeader = (UnusedChunkHeader*) NewChunkStart;
ASSERT(IsGoodChunkPosition(NewChunkStart));
NewChunkHeader->Size = NewChunkSize;
NewChunkHeader->NextUnused = Bins[NewBinIndex];
ASSERT(NewChunkHeader->NextUnused == NULL || IsGoodChunk(NewChunkHeader->NextUnused));
UnusedChunkFooter* NewChunkFooter = (UnusedChunkFooter*) (ChunkEnd - sizeof(UnusedChunkFooter));
NewChunkFooter->Size = NewChunkSize;
NewChunkFooter->Unused = NULL;
// Put the new chunk in front of our linked list.
ASSERT(IsGoodUnusedChunk(NewChunkHeader));
Bins[NewBinIndex] = NewChunkHeader;
// We need to modify our resulting chunk to be smaller.
ResultHeader->Size = Size;
}
// Set the required magic values.
UsedChunkFooter* ResultFooter = (UsedChunkFooter*) ( ((byte*) ResultHeader) + ResultHeader->Size - sizeof(UsedChunkFooter) );
ResultHeader->Magic = Magic;
ResultFooter->Magic = Magic;
ResultFooter->Size = Size;
ASSERT(IsGoodUsedChunk(ResultHeader));
return ((byte*) ResultHeader) + sizeof(UnusedChunkHeader);
}
else
{
// We have no free chunks that are big enough, let's expand our heap into the unknown, if possible.
if ( WildernessSize < Size && !ExpandWilderness(Size) ) { Error::Set(Error::NOMEM); return NULL; }
// Write some headers and footers around our newly allocated data.
UsedChunkHeader* ResultHeader = (UsedChunkHeader*) (Wilderness + WildernessSize - Size);
UsedChunkFooter* ResultFooter = (UsedChunkFooter*) (Wilderness + WildernessSize - sizeof(UsedChunkFooter));
WildernessSize -= Size;
ResultHeader->Size = Size;
ResultHeader->Magic = Magic;
ResultFooter->Size = Size;
ResultFooter->Magic = Magic;
ASSERT(IsGoodUsedChunk(ResultHeader));
return ((byte*) ResultHeader) + sizeof(UsedChunkHeader);
}
}
// Frees a continious memory region allocated by Allocate.
DUAL_FUNCTION(void, free, Free, (void* Addr))
{
// Just ignore NULL-pointers.
if ( Addr == NULL ) { return; }
// Restore the chunk information structures.
UsedChunkHeader* ChunkHeader = (UsedChunkHeader*) ( ((byte*) Addr) - sizeof(UsedChunkHeader) );
UsedChunkFooter* ChunkFooter = (UsedChunkFooter*) ( ((byte*) ChunkHeader) + ChunkHeader->Size - sizeof(UsedChunkFooter) );
ASSERT(IsGoodUsedChunk(ChunkHeader));
// If you suspect a chunk of bein' a witch, report them immediately. I cannot stress that enough. Witchcraft will not be tolerated.
if ( ChunkHeader->Magic != Magic || ChunkFooter->Magic != Magic || ChunkHeader->Size != ChunkFooter->Size )
{
#ifdef SORTIX_KERNEL
Sortix::PanicF("Witchcraft detected!\n", ChunkHeader);
#endif
// TODO: Report witchcraft (terminating the process is probably a good idea).
}
// TODO: Combine this chunk with its neighbors, if they are also unused.
// Calculate which bin this chunk belongs to.
size_t BinIndex = BSR(ChunkHeader->Size);
ASSERT(IsGoodBinIndex(BinIndex));
// Mark that a chunk is available for this bin.
BinContainsChunks |= (1 << BinIndex);
UnusedChunkHeader* UnChunkHeader = (UnusedChunkHeader*) ChunkHeader;
UnusedChunkFooter* UnChunkFooter = (UnusedChunkFooter*) ChunkFooter;
// Now put this chunk back in the linked list.
ASSERT(Bins[BinIndex] == NULL || IsGoodUnusedChunk(Bins[BinIndex]));
UnChunkHeader->NextUnused = Bins[BinIndex];
UnChunkFooter->Unused = NULL;
ASSERT(IsGoodUnusedChunk(UnChunkHeader));
Bins[BinIndex] = UnChunkHeader;
}
DUAL_FUNCTION(void*, memcpy, Copy, (void* Dest, const void* Src, size_t Length))
{
char* D = (char*) Dest; const char* S = (const char*) Src;
for ( size_t I = 0; I < Length; I++ )
{
D[I] = S[I];
}
return Dest;
}
DUAL_FUNCTION(void*, memset, Set, (void* Dest, int Value, size_t Length))
{
byte* D = (byte*) Dest;
for ( size_t I = 0; I < Length; I++ )
{
D[I] = Value & 0xFF;
}
return Dest;
}
}
}