mango/sandbox/vm/vm_zone.c

#include "socks/queue.h"
#include <socks/types.h>
#include <socks/vm.h>
#include <string.h>
#include <stdio.h>
#include <inttypes.h>
#include <assert.h>
#include <stdlib.h>

static vm_page_t *group_pages_into_block(vm_zone_t *z, phys_addr_t base, phys_addr_t limit, int order)
{
	vm_page_t *first_page = NULL;
	for (phys_addr_t i = base; i < limit; i += VM_PAGE_SIZE) {
		vm_page_t *pg = vm_page_get(i);

		if (order != VM_PAGE_MIN_ORDER) {
			pg->p_flags |= VM_PAGE_HUGE;
		}

		if (i == base) {
			pg->p_flags |= VM_PAGE_HEAD;
			first_page = pg;
		}

		pg->p_order = order;
		pg->p_zone = z;
	}

	return first_page;
}

static void convert_region_to_blocks(vm_zone_t *zone, phys_addr_t base, phys_addr_t limit, int reserved)
{
	size_t block_frames = vm_bytes_to_pages(limit - base + 1);
	printf("adding region %08zx-%08zx (%zu frames) to zone %s\n",
	       base, limit, block_frames, zone->z_info.zd_name);
	int reset_order = 0;

	for (int order = VM_PAGE_MAX_ORDER; order >= VM_PAGE_MIN_ORDER; ) {
		size_t order_frames = vm_page_order_to_pages(order);
		vm_alignment_t order_alignment = vm_page_order_to_alignment(order);

		if (order_frames > block_frames) {
			order--;
			continue;
		}

		if (!VM_CHECK_ALIGN(base, order_alignment)) {
			reset_order = 1;
			order--;
			continue;
		}
		
		printf("%s: %zu %s pages at %08" PRIxPTR "\n",
		       zone->z_info.zd_name,
		       order_frames,
		       reserved == 1 ? "reserved" : "free",
		       base);
		
		phys_addr_t block_limit = base + (order_frames * VM_PAGE_SIZE) - 1;
		vm_page_t *block_page = group_pages_into_block(zone, base, block_limit, order);

		if (reserved == 0) {
			queue_push_back(&zone->z_free_pages[order], &block_page->p_free_list);
		}

		base = block_limit + 1;
		block_frames -= order_frames;

		if (reset_order) {
			order = VM_PAGE_MAX_ORDER;
			reset_order = 0;
		} else {
			order--;
		}

		if (base > limit + 1) {
			printf("too many pages created! %zx > %zx\n", base, limit);
			abort();
		} 

		if (base == limit) {
			break;
		}
	}
}

void vm_zone_init(vm_zone_t *z, const vm_zone_descriptor_t *zone_info)
{
	if (!vm_page_get(zone_info->zd_base)) {
		return;
	}
	
	printf("initialising zone %s (%08zx-%08zx)\n",
	       zone_info->zd_name, zone_info->zd_base, zone_info->zd_limit);
	memset(z, 0x0, sizeof *z);
	memcpy(&z->z_info, zone_info, sizeof *zone_info);

	phys_addr_t block_start = zone_info->zd_base, block_end = zone_info->zd_limit;
	int this_page_reserved = 0, last_page_reserved = -1;

	for (uintptr_t i = zone_info->zd_base; i < zone_info->zd_limit; i += VM_PAGE_SIZE) {
		vm_page_t *pg = vm_page_get(i);
		if (!pg) {
			break;
		}
		
		this_page_reserved = (pg->p_flags & VM_PAGE_RESERVED) ? 1 : 0;

		if (last_page_reserved == -1) {
			last_page_reserved = this_page_reserved;
		}

		if (this_page_reserved == last_page_reserved) {
			block_end = i;
			continue;
		}

		convert_region_to_blocks(z, block_start, block_end + VM_PAGE_SIZE - 1, last_page_reserved);

		block_start = i;
		last_page_reserved = this_page_reserved;
	}

	if (block_start != block_end) {
		convert_region_to_blocks(z, block_start, block_end + VM_PAGE_SIZE - 1, this_page_reserved);
	}
}