Subversion Repositories c0or1k

/*
 * Empty virtual and physical pages for
 * creating test scenarios
 *
 * Copyright (C) 2010 B Labs Ltd.
 *
 * Author: Bahadir Balban
 */
#include <l4lib/lib/addr.h>
#include INC_GLUE(memory.h)
#include <l4/generic/cap-types.h>
#include <l4lib/lib/cap.h>
#include <l4/lib/math.h>
#include <stdio.h>
#include <memory.h>
#include <linker.h>
#include <tests.h>
 
/*
 * Declare a statically allocated char buffer
 * with enough bitmap size to cover given size
 */
#define DECLARE_IDPOOL(name, size)	\
	char name[(sizeof(struct id_pool) + ((size >> 12) >> 3))]
 
struct address_pool virtual_page_pool, physical_page_pool;
 
#define PAGE_POOL_SIZE			SZ_16MB
 
DECLARE_IDPOOL(virtual_idpool, PAGE_POOL_SIZE);
DECLARE_IDPOOL(physical_idpool, PAGE_POOL_SIZE);
 
#define virt_to_phys(virtual)	((unsigned long)(virtual) - (unsigned long)(offset))
#define phys_to_virt(physical)	((unsigned long)(physical) + (unsigned long)(offset))
 
 
#define TEST_POOL_TOTAL		5
/*
 * Test page pool
 */
void test_page_pool(void)
{
	void *p[TEST_POOL_TOTAL], *v[TEST_POOL_TOTAL];
 
	/* Allocate test pages */
	for (int i = 0; i < TEST_POOL_TOTAL; i++) {
		v[i] = virtual_page_new(1);
		p[i] = physical_page_new(1);
		dbg_printf("Test allocated: Virtual%d: 0x%p, "
			   "Physical%d, 0x%p\n",
			   i, v[i], i, p[i]);
	}
 
	/* Free test pages */
	for (int i = 0; i < TEST_POOL_TOTAL; i++) {
		virtual_page_free(v[i], 1);
		physical_page_free(p[i], 1);
	}
 
	/* Re-allocate test pages */
	for (int i = 0; i < TEST_POOL_TOTAL; i++) {
		v[i] = virtual_page_new(1);
		p[i] = physical_page_new(1);
		dbg_printf("Test allocated: Virtual%d: 0x%p, "
			   "Physical%d, 0x%p\n",
			   i, v[i], i, p[i]);
	}
 
	/* Free test pages */
	for (int i = 0; i < TEST_POOL_TOTAL; i++) {
		virtual_page_free(v[i], 1);
		physical_page_free(p[i], 1);
	}
 
	/* Allocate in different lengths */
	for (int i = 0; i < TEST_POOL_TOTAL; i++) {
		v[i] = virtual_page_new(i);
		p[i] = physical_page_new(i);
		dbg_printf("Test allocated: Virtual%d: 0x%p, "
			   "Physical%d, 0x%p\n",
			   i, v[i], i, p[i]);
	}
 
	/* Free test pages in different order */
	for (int i = TEST_POOL_TOTAL - 1; i >= 0; i--) {
		virtual_page_free(v[i], 1);
		physical_page_free(p[i], 1);
	}
 
	/* Allocate in different lengths */
	for (int i = 0; i < TEST_POOL_TOTAL; i++) {
		v[i] = virtual_page_new(i);
		p[i] = physical_page_new(i);
		dbg_printf("Test allocated: Virtual%d: 0x%p, "
			   "Physical%d, 0x%p\n",
			   i, v[i], i, p[i]);
	}
 
	/* Free test pages in normal order */
	for (int i = 0; i < TEST_POOL_TOTAL; i++) {
		virtual_page_free(v[i], 1);
		physical_page_free(p[i], 1);
	}
}
 
void page_pool_init(void)
{
	struct capability *physcap, *virtcap;
	unsigned long phys_start, phys_end;
	unsigned long virt_start, virt_end;
 
	/*
	 * Get physmem capability (Must be only one)
	 */
	if (!(physcap = cap_get_physmem(CAP_TYPE_MAP_PHYSMEM))) {
		printf("FATAL: Could not find a physical memory"
		       "capability to use as a page pool.\n");
		BUG();
	}
 
	/*
	 * Get virtmem capability (Must be only one)
	 */
	if (!(virtcap = cap_get_by_type(CAP_TYPE_MAP_VIRTMEM))) {
		printf("FATAL: Could not find a virtual memory"
		       "capability to use as a page pool.\n");
		BUG();
	}
 
	/*
	 * Now initialize physical and virtual page marks
	 * from unused pages. Linker script will help us
	 * on this.
	 */
	/*
	printf("__data_start symbol: %lx\n", (unsigned long)__data_start);
	printf("__data_end symbol: %lx\n", (unsigned long)__data_end);
	printf("__bss_start symbol: %lx\n", (unsigned long)__bss_start);
	printf("__bss_end symbol: %lx\n", (unsigned long)__bss_end);
	printf("__stack_start symbol: %lx\n", (unsigned long)__stack_start);
	printf("__stack_end symbol: %lx\n", (unsigned long)__stack_end);
	printf("__end symbol: %lx\n", (unsigned long)__end);
	*/
 
	phys_start = page_align_up(virt_to_phys(__end) +
				   (unsigned long)lma_start);
	phys_end = __pfn_to_addr(physcap->end);
 
	dbg_printf("%s: Initializing physical range 0x%lx - 0x%lx\n",
		   __FUNCTION__, phys_start, phys_end);
 
	virt_start = page_align_up(__end) + (unsigned long)lma_start;
	virt_end = __pfn_to_addr(virtcap->end);
 
	dbg_printf("%s: Initializing virtual range 0x%lx - 0x%lx\n",
		   __FUNCTION__, virt_start, virt_end);
 
	/* Initialize pools, maximum of PAGE_POOL_SIZE size */
	address_pool_init(&virtual_page_pool,
			  (struct id_pool *)&virtual_idpool,
			  virt_start, min(virt_end,
				  	  virt_start + PAGE_POOL_SIZE));
	address_pool_init(&physical_page_pool,
			  (struct id_pool *)&physical_idpool,
			  phys_start, min(phys_end,
				  	  phys_start + PAGE_POOL_SIZE));
 
	// test_page_pool();
}
 
/*
 * Some tests require page-faulting virtual addresses or
 * differing virtual addresses that map onto the same
 * physical page. These functions provide these pages.
 */
 
void *virtual_page_new(int npages)
{
	return address_new(&virtual_page_pool, npages, PAGE_SIZE);
}
 
void *physical_page_new(int npages)
{
	return address_new(&physical_page_pool, npages, PAGE_SIZE);
}
 
void virtual_page_free(void *address, int npages)
{
	address_del(&virtual_page_pool, address,
		    npages, PAGE_SIZE);
}
 
void physical_page_free(void *address, int npages)
{
	address_del(&physical_page_pool, address,
		    npages, PAGE_SIZE);
}