quark-kernel/src/pageallocator.cpp

#include "pageallocator.hpp"
#include "systypes.hpp"
#include "memorymap.hpp"

#define roundUp(n, m) ((n % m == 0) ? n : (n + m - (n % m)))

uint32_t ilog2(uint32_t n, bool roundUp)
{
	uint32_t m = n;
	uint32_t count = 0;
	bool isPowerOfTwo = true;
	while(m)
	{
		if((m & 1) == 1 && m > 1)
		{
			isPowerOfTwo = false;
		}
		count++;
		m >>= 1;
	}
	return count - (isPowerOfTwo ? 1 : (roundUp ? 0 : 1));
}

kernelns::BuddyAllocator::BuddyAllocator()
{

}

kernelns::BuddyAllocator::BuddyAllocator(const kernelns::MemoryMap& memmap,
					char* bitmap, size_t blockCount,
					size_t treeHeight)
{
	this->bitmap = bitmap;
	this->blockSize = 4096;
	this->blockCount = blockCount;
	this->treeHeight = treeHeight;
	for(size_t i = 0; i <= treeHeight; i++)
	{
		for(size_t j = 0; j < (blockCount >> i); j++)
		{
			reserveNode(i, j);
		}
	}
	physaddr_t location = 0x100000;
	for(size_t i = 0; i < memmap.size() && memmap[i].getSize() > 0; i++)
	{
		if(memmap[i].getType() != kernelns::MemoryMap::AVAILABLE)
			continue;
		if(memmap[i].getLocation() > location)
			location = roundUp(memmap[i].getLocation(), 4096);
		while(memmap[i].contains(location, 4096))
		{
			freeNode(0, location / 4096);
			if(isFree(0, getBuddy(location / 4096)))
				merge(0, location / 4096);
			location += 4096;
		}
	}
}

kernelns::BuddyAllocator::BuddyAllocator(char* bitmap, size_t blockSize,
					size_t blockCount, size_t treeHeight)
{
	this->bitmap = bitmap;
	this->blockSize = blockSize;
	this->blockCount = blockCount;
	this->treeHeight = treeHeight;
	for(size_t i = 0; i <= treeHeight; i++)
	{
		for(size_t j = 0; j < (blockCount >> i); j++)
		{
			if(i < treeHeight)
				reserveNode(i, j);
			else
				freeNode(i, j);
		}
	}
}

physaddr_t kernelns::BuddyAllocator::allocate(size_t size)
{
	size_t height = ilog2(roundUp(size, blockSize) / blockSize, true);
	if(height > treeHeight) // Requested block size is greater than maximum
	{
		return 0;
	}
	else
	{
		size_t index = findFreeBlock(height);
		if(index == INVALID) // Failed to find a big enough free block; out of memory
		{
			return 0;
		}
		else
		{
			reserveNode(height, index);
			return nodeToAddress(height, index);
		}
	}
}

void kernelns::BuddyAllocator::free(physaddr_t location, size_t size)
{
	size_t height = ilog2(roundUp(size, blockSize) / blockSize, true);
	if(height <= treeHeight)
	{
		size_t index = addressToNode(height, location);
		freeNode(height, index);
		if(isFree(height, getBuddy(index)))
		{
			merge(height, index);
		}
	}
}

size_t kernelns::BuddyAllocator::freeBlocks() const
{
	size_t count = 0;
	for(size_t j = 0; j < blockCount; j++)
	{
		if(isFree(0, j))
		{
			count++;
		}
	}
	return count;
}

size_t kernelns::BuddyAllocator::maxAllocationSize() const
{
	for(size_t i = treeHeight; i >= 0; i--)
	{
		for(size_t j = 0; j < (blockCount >> i); j++)
		{
			if(isFree(i, j))
			{
				return 1 << i;
			}
		}
	}
	return 0;
}

size_t kernelns::BuddyAllocator::getBlockSize() const
{
	return blockSize;
}

size_t kernelns::BuddyAllocator::getMemorySize() const
{
	return blockCount;
}

size_t kernelns::BuddyAllocator::findFreeBlock(size_t height)
{
	for(size_t i = 0; i < (blockCount >> height); i++)
	{
		if(isFree(height, i))
		{
			return i;
		}
	}
	if(height < treeHeight)
	{
		size_t parentIndex = findFreeBlock(height + 1);
		if(parentIndex != INVALID)
		{	
			return split(height + 1, parentIndex);
		}
	}
	return INVALID;
}

size_t kernelns::BuddyAllocator::split(size_t height, size_t index)
{
	if(height > 0 && isFree(height, index))
	{
		reserveNode(height, index);
		freeNode(height - 1, getChild(index));
		freeNode(height - 1, getBuddy(getChild(index)));
		return getChild(index);
	}
	else
	{
		return INVALID;
	}
}

size_t kernelns::BuddyAllocator::merge(size_t height, size_t index)
{
	if(isFree(height, index) && isFree(height, getBuddy(index)) && height < treeHeight)
	{
		reserveNode(height, index);
		reserveNode(height, getBuddy(index));
		freeNode(height + 1, getParent(index));
		if((height + 1) < treeHeight)
		{
			if(isFree(height + 1, getBuddy(getParent(index))))
			{
				return merge(height + 1, getParent(index));

			}
		}
		return getParent(index);
	}
	else
	{
		return INVALID;
	}
}

size_t kernelns::BuddyAllocator::getBuddy(size_t index)
{
	return index ^ 1;
}

size_t kernelns::BuddyAllocator::getParent(size_t index)
{
	return index / 2;
}

size_t kernelns::BuddyAllocator::getChild(size_t index)
{
	return index * 2;
}

physaddr_t kernelns::BuddyAllocator::nodeToAddress(size_t height, size_t index)
    const
{
	return index * (blockSize << height);
}

size_t kernelns::BuddyAllocator::addressToNode(size_t height,
					      physaddr_t location) const
{
	return location / (blockSize << height);
}

void kernelns::BuddyAllocator::reserveNode(size_t height, size_t index)
{
	size_t bit = (height == 0) ? 0
	    : ((blockCount * 2) - (blockCount >> (height - 1)));
	bit += index;
	bitmap[bit / 8] |= 1 << (bit % 8);
}

void kernelns::BuddyAllocator::freeNode(size_t height, size_t index)
{
	size_t bit = (height == 0) ? 0
	    : ((blockCount * 2) - (blockCount >> (height - 1)));
	bit += index;
	bitmap[bit / 8] &= ~(1 << (bit % 8));
}

bool kernelns::BuddyAllocator::isFree(size_t height, size_t index) const
{
	size_t bit = (height == 0) ? 0
	    : ((blockCount * 2) - (blockCount >> (height - 1)));
	bit += index;
	char data = bitmap[bit / 8] & (1 << (bit % 8));
	if(data == 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}