k-chow/k/memory.c

#include "memory.h"

#include <k/types.h>
#include <stdio.h>

static struct list memory_map = {&memory_map, &memory_map};
static struct cache *memory_map_cache;
static struct cache *metadata_cache;

static void *__memory_reserve_ex(unsigned int base_addr, size_t size, int in_extend);
static void *__cache_alloc(struct cache *cache, int in_extend);

static void cache_initialize(struct cache *c, void *p, size_t sz, size_t bsize)
{
	list_init(&c->freelist);
	list_init(&c->caches);
	c->base = p;
	c->size = sz;
	c->bsize = bsize;

	for (size_t i = 0; i < sz / bsize; ++i) {
		struct list *l = (struct list *)((char *) p + i * bsize);
		list_init(l);
		list_insert(c->freelist.prev, l);
	}
}

static void cache_extend(struct cache *old, void *p, size_t sz, size_t bsize, int in_extend)
{
	struct cache *c = __cache_alloc(metadata_cache, in_extend);
	cache_initialize(c, p, sz, bsize);
	list_insert(old->caches.prev, &c->caches);
}

struct cache *cache_new(void *base, size_t nmemb, size_t bsize)
{
	struct cache *c = cache_alloc(metadata_cache);

	cache_initialize(c, base, nmemb * bsize, bsize);

	return c;
}

static size_t freelist_size(struct cache *cache)
{
	if (list_empty(&cache->freelist))
		return 0;

	size_t len = 1;

	struct list *l = cache->freelist.next;

	for (; l != &cache->freelist; l = l->next) {
		len++;
	}

	return len;
}

static size_t cache_remaining(struct cache *cache)
{
	size_t len = freelist_size(cache);

	struct cache *c;
	list_for_each(c, &cache->caches, caches) {
		len += freelist_size(c);
	}

	return len;
}

static void *__cache_alloc(struct cache *cache, int in_extend)
{
try_alloc:
	if (!list_empty(&cache->freelist)) {
		struct list *l = cache->freelist.next;
		list_remove(l);
		return (void *)l;
	}

	struct cache *c;
	list_for_each(c, &cache->caches, caches) {
		if (!list_empty(&c->freelist)) {
			return cache_alloc(c);
		}
	}

	if (cache_remaining(metadata_cache) <= 2 && !in_extend) {
		void *p = __memory_reserve_ex(0, metadata_cache->size, 1);
		cache_extend(metadata_cache, p,
			     metadata_cache->size,
			     metadata_cache->bsize, 1);
	}

	void *p = memory_reserve(c->size);
	cache_extend(c, p, c->size, c->bsize, 0);

	goto try_alloc;
}

void *cache_alloc(struct cache *cache)
{
	return __cache_alloc(cache, 0);
}

static int cache_try_free(struct cache *cache, void *ptr)
{
	if ((size_t)cache->base <= (size_t)ptr
	 && (size_t)cache->base + cache->size > (size_t)ptr) {
		list_init(ptr);
		list_insert(&cache->freelist, ptr);
		return 1;
	}
	return 0;
}

void cache_free(struct cache *cache, void *ptr)
{
	if (cache_try_free(cache, ptr)) {
		return;
	}
	struct cache *c;
	list_for_each(c, &cache->caches, caches) {
		if (cache_try_free(c, ptr)) {
			return;
		}
	}
	/* FIXME: handle the case when the pointer does not belong to the cache */
}

static void memory_initialize(struct memory_map *m,
			      unsigned addr, unsigned size, int type)
{
	list_init(&m->list);
	m->base_addr = addr;
	m->size = size;
	m->type = type;
}

void memory_dump()
{
	struct memory_map *m;
	list_for_each(m, &memory_map, list) {
		printf("{.base_addr=%p, .length=0x%x, .type=%u}\n",
				m->base_addr, m->size, m->type);
	}
}

extern void *_end[]; /* kernel data end address */

#define BASE_METADATA_CACHE_NMEMB	10

void memory_init(multiboot_info_t *info)
{
	unsigned int last_loaded_addr = info->mods_count
		? ((multiboot_module_t *)info->mods_addr)[info->mods_count - 1].mod_end
		: 0;

	if (last_loaded_addr < (u32)_end) {
		last_loaded_addr = (u32)_end; /* XXX: needs to align up */
	}

	/* take the first good memory region */
	unsigned int reservation_addr = last_loaded_addr;
	unsigned int reservation_len = (BASE_METADATA_CACHE_NMEMB + 1) * sizeof(struct cache);

	unsigned int num_mem_zone = info->mmap_length / sizeof(multiboot_memory_map_t);

	metadata_cache = (void *)reservation_addr;
	cache_initialize(metadata_cache, metadata_cache + 1, BASE_METADATA_CACHE_NMEMB * sizeof(struct cache),
			 sizeof(struct cache));

	memory_map_cache = cache_new((void *)(reservation_addr + reservation_len),
				      num_mem_zone * 2, sizeof(struct memory_map));

	reservation_len += num_mem_zone * 2 * sizeof(struct memory_map);

	multiboot_memory_map_t *map = (void *)info->mmap_addr;

	for (size_t i = 0; i < num_mem_zone; ++i) {
		struct memory_map *m = cache_alloc(memory_map_cache);

		memory_initialize(m, (u32)map[i].addr, (u32)map[i].len,
				  map[i].type - 1);

		list_insert(memory_map.prev, &m->list);
	}

	/* reserve all low memory to avoid overwriting grub data */
	memory_reserve_ex(0, info->mem_lower * 1024);
	/* reserve kernel and fs data */
	memory_reserve_ex(0x100000, last_loaded_addr - 0x100000);
	/* reserve initial cache datas */
	memory_reserve_ex(reservation_addr, reservation_len);
}

static void *memory_split(struct memory_map *m, size_t size)
{
	struct memory_map *t = cache_alloc(memory_map_cache);
	memory_initialize(t, m->base_addr, size, 2);

	list_insert(m->list.prev, &t->list);

	m->size -= size;
	m->base_addr += size;

	return (void *)t->base_addr;
}

static void *__memory_reserve_ex(unsigned int base_addr, size_t size, int in_extend)
{
	if (cache_remaining(memory_map_cache) <= 2 && !in_extend) {
		void *p = __memory_reserve_ex(0, 10 * sizeof(struct cache), 1);
		cache_extend(memory_map_cache, p, 10 * sizeof(struct cache),
				sizeof(struct cache), 0);
	}

	struct memory_map *m;
	list_for_each(m, &memory_map, list) {
		if (m->type)
			continue;

		if (!base_addr && m->size >= size) {
			if (m->size == size) {
				m->type = 2;
				return (void *)m->base_addr;
			}
			return memory_split(m, size);
		} else if (base_addr >= m->base_addr && base_addr < m->base_addr + m->size) {
			if (base_addr + size >= m->base_addr + m->size) {
				return NULL;
			}
			unsigned first_size = base_addr - m->base_addr;
			if (first_size) {
				memory_split(m, first_size);
				return memory_reserve_ex(base_addr, size);
			}

			return memory_split(m, size);
		}
	}

	return NULL;
}

void *memory_reserve_ex(unsigned int base_addr, size_t size)
{
	return __memory_reserve_ex(base_addr, size, 0);
}

void *memory_reserve(size_t size)
{
	return memory_reserve_ex(0, size);
}

void memory_release(void *ptr)
{
	struct memory_map *m;
	list_for_each(m, &memory_map, list) {
		if (m->base_addr == (unsigned int)ptr) {
			m->type = 0;
			/* FIXME: need to merge free blocks */
			return;
		}
	}
}