stv0g/metalsvm
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

updated tests for memory subsystem

Browse source
This commit is contained in:
Steffen Vogel 2014-01-09 14:17:50 +01:00
parent da54e953f9
commit 75633d0697
1 changed files with 54 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
apps/memory.c
View file

@ -34,6 +34,10 @@
#define VIRT_FROM_ADDR 0x100000000000 #define VIRT_FROM_ADDR 0x100000000000
#define VIRT_TO_ADDR 0x200000000000 #define VIRT_TO_ADDR 0x200000000000
extern atomic_int32_t total_page;
extern atomic_int32_t total_allocated_pages;
extern atomic_int32_t total_available_pages;
/** @brief Simple helper to format our test results */ /** @brief Simple helper to format our test results */
static void test(size_t expr, char *fmt, ...) static void test(size_t expr, char *fmt, ...)
{ {
@ -65,7 +69,8 @@ static uint16_t rand()
} }
/** @brief BSD sum algorithm ('sum' Unix command) and used by QEmu */ /** @brief BSD sum algorithm ('sum' Unix command) and used by QEmu */
uint16_t checksum(size_t start, size_t end) { uint16_t checksum(size_t start, size_t end)
{
size_t addr; size_t addr;
uint16_t sum; uint16_t sum;
@ -78,19 +83,22 @@ uint16_t checksum(size_t start, size_t end) {
return sum; return sum;
} }
static int paging_stage2(void *arg) { static int paging_stage2(void *arg)
{
size_t old, new; size_t old, new;
kprintf("PAGING: entering stage 2...\n"); kprintf("PAGING: entering stage 2...\n");
size_t cr3 = read_cr3();
kprintf("cr3 new = %#lx\n", cr3);
old = *((size_t *) arg); old = *((size_t *) arg);
kprintf("old sum: %lu\n", old); kprintf("old sum: %lu\n", old);
new = checksum(VIRT_FROM_ADDR, VIRT_FROM_ADDR + PAGE_COUNT*PAGE_SIZE); new = checksum(VIRT_FROM_ADDR, VIRT_FROM_ADDR + SIZE);
test(old == new, "checksum(%p, %p) = %lu", VIRT_FROM_ADDR, VIRT_FROM_ADDR + PAGE_COUNT*PAGE_SIZE, new); test(old == new, "checksum(%p, %p) = %lu", VIRT_FROM_ADDR, VIRT_FROM_ADDR + SIZE, new);
size_t cr3 = read_cr3(); page_dump(0, -1L);
kprintf("cr3 new = %x\n", cr3);
return 0; return 0;
} }
@ -105,19 +113,31 @@ static void paging(void)
{ {
size_t c, sum; size_t c, sum;
size_t *p1, *p2; size_t *p1, *p2;
size_t virt_from, virt_to, virt_alloc; size_t virt_from, virt_to;
size_t phys; size_t phys;
size_t t;
int ret;
// show original page maps // show original page maps
page_dump(0, 0); t = rdtsc();
page_stats(0, 0, 1); // reset accessed and dirty bits page_dump(0, -1L);
kprintf("delta_t = %lu\n", rdtsc() - t);
t = rdtsc();
page_stats(0, -1L, 1); // reset accessed and dirty bits
kprintf("delta_t = %lu\n", rdtsc() - t);
kprintf("bookkeeping pages:\n");
kprintf(" - total:\t%lu\n", atomic_int32_read(&total_pages));
kprintf(" - alloc:\t%lu\n", atomic_int32_read(&total_allocated_pages));
kprintf(" - avail:\t%lu\n", atomic_int32_read(&total_available_pages));
// allocate physical page frames // allocate physical page frames
phys = get_pages(PAGE_COUNT); phys = get_pages(PAGE_COUNT);
test(phys, "get_pages(%lu) = 0x%lx", PAGE_COUNT, phys); test(phys, "get_pages(%lu) = 0x%lx", PAGE_COUNT, phys);
// create first mapping // create first mapping
virt_from = map_region(VIRT_FROM_ADDR, phys, PAGE_COUNT, MAP_USER_SPACE); virt_from = map_region(VIRT_FROM_ADDR, phys, PAGE_COUNT, 0);
test(virt_from, "map_region(0x%lx, 0x%lx, %lu, 0x%x) = 0x%lx", VIRT_FROM_ADDR, phys, PAGE_COUNT, 0, virt_from); test(virt_from, "map_region(0x%lx, 0x%lx, %lu, 0x%x) = 0x%lx", VIRT_FROM_ADDR, phys, PAGE_COUNT, 0, virt_from);
// check address translation // check address translation
@ -126,7 +146,7 @@ static void paging(void)
// write test data // write test data
p1 = (size_t *) virt_from; p1 = (size_t *) virt_from;
for (c = 0; c < PAGE_COUNT*PAGE_SIZE/sizeof(size_t); c++) { for (c = 0; c < SIZE/sizeof(size_t); c++) {
p1[c] = c; p1[c] = c;
} }
@ -135,8 +155,8 @@ static void paging(void)
test(virt_to, "map_region(0x%lx, 0x%lx, %lu, 0x%x) = 0x%lx", VIRT_TO_ADDR, phys, PAGE_COUNT, 0, virt_to); test(virt_to, "map_region(0x%lx, 0x%lx, %lu, 0x%x) = 0x%lx", VIRT_TO_ADDR, phys, PAGE_COUNT, 0, virt_to);
// show pagings infos again // show pagings infos again
page_dump(0, 0); page_dump(0, -1L);
page_stats(0, 0, 0); page_stats(0, -1L, 0);
// check address translation // check address translation
phys = virt_to_phys(virt_to); phys = virt_to_phys(virt_to);
@ -144,7 +164,7 @@ static void paging(void)
// check if both mapped areas are equal // check if both mapped areas are equal
p2 = (size_t *) virt_to; p2 = (size_t *) virt_to;
for (c = 0; c < PAGE_COUNT*PAGE_SIZE/sizeof(size_t); c++) { for (c = 0; c < SIZE/sizeof(size_t); c++) {
if (p1[c] != p2[c]) if (p1[c] != p2[c])
test(0, "data mismatch: *(%p) != *(%p)", &p1[c], &p2[c]); test(0, "data mismatch: *(%p) != *(%p)", &p1[c], &p2[c]);
} }
@ -158,59 +178,59 @@ static void paging(void)
virt_to = map_region(VIRT_TO_ADDR, phys+PAGE_SIZE, PAGE_COUNT, MAP_REMAP|MAP_USER_SPACE); virt_to = map_region(VIRT_TO_ADDR, phys+PAGE_SIZE, PAGE_COUNT, MAP_REMAP|MAP_USER_SPACE);
test(virt_to, "map_region(0x%lx, 0x%lx, %lu, 0x%x) = 0x%lx (with MAP_REMAP flag)", VIRT_TO_ADDR, phys+PAGE_SIZE, PAGE_COUNT, MAP_REMAP, virt_to); test(virt_to, "map_region(0x%lx, 0x%lx, %lu, 0x%x) = 0x%lx (with MAP_REMAP flag)", VIRT_TO_ADDR, phys+PAGE_SIZE, PAGE_COUNT, MAP_REMAP, virt_to);
// check if data is not equal anymore (we remapped with 1 page offset) // check if data is not equal anymore (we remapped with +PAGE_SIZE offset)
p2 = (size_t *) virt_to; p2 = (size_t *) virt_to;
for (c = 0; c < PAGE_COUNT*PAGE_SIZE/sizeof(size_t); c++) { for (c = 0; c < SIZE/sizeof(size_t); c++) {
if (p1[c] == p2[c]) if (p1[c] == p2[c])
test(0, "data match at *(%p) != *(%p)", &p1[c], &p2[c]); test(0, "data match at *(%p) != *(%p)", &p1[c], &p2[c]);
} }
test(1, "data is unequal"); test(1, "data is unequal");
// test vma_alloc // test unmapping
virt_alloc = map_region(0, phys, PAGE_COUNT, 0); ret = unmap_region(VIRT_TO_ADDR, PAGE_COUNT);
test(virt_alloc, "map_region(0x%lx, 0x%lx, %lu, 0x%x) = 0x%lx", 0, phys, PAGE_COUNT, 0, virt_alloc); test(!ret, "unmap_region(%#lx, %lu) = %u", VIRT_TO_ADDR, PAGE_COUNT, ret);
// data should match against new vm addr page_dump(0, -1L);
p2 = (size_t *) virt_alloc;
for (c = 0; c < PAGE_COUNT*PAGE_SIZE/sizeof(size_t); c++) {
if (p1[c] != p2[c])
test(0, "data mismatch at *(%p) != *(%p)", &p1[c], &p2[c]);
}
test(1, "data is equal");
// calc checksum // calc checksum
sum = checksum(virt_alloc, virt_alloc + PAGE_COUNT*PAGE_SIZE); sum = checksum(virt_from, virt_from + SIZE);
test(sum, "checksum(%p, %p) = %lu", virt_alloc, virt_alloc + PAGE_COUNT*PAGE_SIZE, sum); test(sum, "checksum(%p, %p) = %lu", virt_from, virt_from+SIZE, sum);
size_t cr3 = read_cr3(); size_t cr3 = read_cr3();
kprintf("cr3 old = %x\n", cr3); kprintf("cr3 old = %#lx\n", cr3);
//create_kernel_task(0, paging_stage2, &sum, NORMAL_PRIO); create_kernel_task(0, paging_stage2, &sum, NORMAL_PRIO);
//sleep(3); sleep(5);
} }
/** @brief Test of the VMA allocator */ /** @brief Test of the VMA allocator */
static void vma(void) static void vma(void)
{ {
int ret; int ret;
vma_dump();
// vma_alloc // vma_alloc
size_t a1 = vma_alloc(SIZE, VMA_HEAP); size_t a1 = vma_alloc(SIZE, VMA_HEAP);
test(a1, "vma_alloc(0x%x, 0x%x) = 0x%lx", SIZE, VMA_HEAP, a1); test(a1, "vma_alloc(0x%x, 0x%x) = 0x%lx", SIZE, VMA_HEAP, a1);
vma_dump();
size_t a2 = vma_alloc(SIZE, VMA_HEAP|VMA_USER); size_t a2 = vma_alloc(SIZE, VMA_HEAP|VMA_USER);
test(a2 != 0, "vma_alloc(0x%x, 0x%x) = 0x%lx", SIZE, VMA_HEAP|VMA_USER, a2); test(a2 != 0, "vma_alloc(0x%x, 0x%x) = 0x%lx", SIZE, VMA_HEAP|VMA_USER, a2);
vma_dump(); vma_dump();
// vma_free
ret = vma_free(a1, a1+SIZE);
test(ret >= 0, "vma_free(0x%lx, 0x%lx) = %i", a1, a1+SIZE, ret);
ret = vma_free(a2, a2+SIZE);
test(ret >= 0, "vma_free(0x%lx, 0x%lx) = %i", a2, a2+SIZE, ret);
vma_dump();
// vma_add // vma_add
ret = vma_add(VIRT_FROM_ADDR, VIRT_FROM_ADDR+SIZE, VMA_HEAP|VMA_USER); ret = vma_add(VIRT_FROM_ADDR, VIRT_FROM_ADDR+SIZE, VMA_HEAP|VMA_USER);
test(ret >= 0, "vma_add(0x%lx, 0x%lx, 0x%x) = %u", VIRT_FROM_ADDR, VIRT_FROM_ADDR+SIZE, VMA_HEAP|VMA_USER, ret); test(ret >= 0, "vma_add(0x%lx, 0x%lx, 0x%x) = %u", VIRT_FROM_ADDR, VIRT_FROM_ADDR+SIZE, VMA_HEAP|VMA_USER, ret);
vma_dump();
ret = vma_add(VIRT_FROM_ADDR+SIZE, VIRT_FROM_ADDR+2*SIZE, VMA_HEAP|VMA_USER); ret = vma_add(VIRT_FROM_ADDR+SIZE, VIRT_FROM_ADDR+2*SIZE, VMA_HEAP|VMA_USER);
test(ret >= 0, "vma_add(0x%lx, 0x%lx, 0x%x) = %u", VIRT_FROM_ADDR+SIZE, VIRT_FROM_ADDR+2*SIZE, VMA_HEAP|VMA_USER, ret); test(ret >= 0, "vma_add(0x%lx, 0x%lx, 0x%x) = %u", VIRT_FROM_ADDR+SIZE, VIRT_FROM_ADDR+2*SIZE, VMA_HEAP|VMA_USER, ret);
vma_dump();
ret = vma_add(VIRT_FROM_ADDR-SIZE, VIRT_FROM_ADDR, VMA_HEAP|VMA_USER); ret = vma_add(VIRT_FROM_ADDR-SIZE, VIRT_FROM_ADDR, VMA_HEAP|VMA_USER);
test(ret >= 0, "vma_add(0x%lx, 0x%lx, 0x%x) = %u", VIRT_FROM_ADDR-SIZE, VIRT_FROM_ADDR, VMA_HEAP|VMA_USER, ret); test(ret >= 0, "vma_add(0x%lx, 0x%lx, 0x%x) = %u", VIRT_FROM_ADDR-SIZE, VIRT_FROM_ADDR, VMA_HEAP|VMA_USER, ret);
@ -219,11 +239,9 @@ static void vma(void)
// vma_free // vma_free
ret = vma_free(VIRT_FROM_ADDR-SIZE, VIRT_FROM_ADDR); ret = vma_free(VIRT_FROM_ADDR-SIZE, VIRT_FROM_ADDR);
test(ret >= 0, "vma_free(0x%lx, 0x%lx) = %u", VIRT_FROM_ADDR-SIZE, VIRT_FROM_ADDR, ret); test(ret >= 0, "vma_free(0x%lx, 0x%lx) = %u", VIRT_FROM_ADDR-SIZE, VIRT_FROM_ADDR, ret);
vma_dump();
ret = vma_free(VIRT_FROM_ADDR+SIZE, VIRT_FROM_ADDR+2*SIZE); ret = vma_free(VIRT_FROM_ADDR+SIZE, VIRT_FROM_ADDR+2*SIZE);
test(ret >= 0, "vma_free(0x%lx, 0x%lx) = %u", VIRT_FROM_ADDR+SIZE, VIRT_FROM_ADDR+2*SIZE, ret); test(ret >= 0, "vma_free(0x%lx, 0x%lx) = %u", VIRT_FROM_ADDR+SIZE, VIRT_FROM_ADDR+2*SIZE, ret);
vma_dump();
ret = vma_free(VIRT_FROM_ADDR, VIRT_FROM_ADDR+SIZE); ret = vma_free(VIRT_FROM_ADDR, VIRT_FROM_ADDR+SIZE);
test(ret >= 0, "vma_free(0x%lx, 0x%lx) = %u", VIRT_FROM_ADDR, VIRT_FROM_ADDR+SIZE, ret); test(ret >= 0, "vma_free(0x%lx, 0x%lx) = %u", VIRT_FROM_ADDR, VIRT_FROM_ADDR+SIZE, ret);