static void
map_unity_ram(vm_t* vm)
{
/* Dimensions of physical memory that we'll use. Note that we do not map the entirety of RAM.
*/
static const uintptr_t paddr_start = RAM_BASE;
static const uintptr_t paddr_end = 0x60000000;
int err;
uintptr_t start;
reservation_t res;
unsigned int bits = 21;
res = vspace_reserve_range_at(&vm->vm_vspace, (void*)paddr_start, paddr_end - paddr_start, seL4_AllRights, 1);
assert(res.res);
for (start = paddr_start;; start += BIT(bits)) {
cspacepath_t frame;
err = vka_cspace_alloc_path(vm->vka, &frame);
assert(!err);
err = simple_get_frame_cap(vm->simple, (void*)start, bits, &frame);
if (err) {
vka_cspace_free(vm->vka, frame.capPtr);
break;
}
err = vspace_map_pages_at_vaddr(&vm->vm_vspace, &frame.capPtr, &bits, (void*)start, 1, bits, res);
assert(!err);
}
}
allocman_t *test_use_current_cspace_bootinfo() {
int error;
allocman_t *allocman;
vspace_alloc_t vspace;
vka_t *vka;
allocman = bootstrap_use_bootinfo(seL4_GetBootInfo(), sizeof(initial_mem_pool), initial_mem_pool);
assert(allocman);
vka = allocman_mspace_alloc(allocman, sizeof(*vka), &error);
assert(!error);
allocman_make_vka(vka, allocman);
sel4util_get_vspace_alloc_leaky(&vspace, seL4_CapInitThreadPD, vka, seL4_GetBootInfo());
reservation_t *reservation = vspace_reserve_range_at(&vspace, VIRTUAL_START, MEM_POOL_SIZE, seL4_AllRights, 1);
assert(reservation);
bootstrap_configure_virtual_pool(allocman, VIRTUAL_START, MEM_POOL_SIZE, seL4_CapInitThreadPD);
error = allocman_fill_reserves(allocman);
assert(!error);
return allocman;
}
static void
map_unity_ram(vm_t* vm)
{
int err;
uintptr_t start;
reservation_t res;
unsigned int bits = 21;
res = vspace_reserve_range_at(&vm->vm_vspace, (void*)RAM_START, RAM_END - RAM_START, seL4_AllRights, 1);
assert(res.res);
for (start = RAM_START;; start += BIT(bits)) {
cspacepath_t frame;
err = vka_cspace_alloc_path(vm->vka, &frame);
assert(!err);
err = simple_get_frame_cap(vm->simple, (void*)start, bits, &frame);
if (err) {
vka_cspace_free(vm->vka, frame.capPtr);
break;
}
err = vspace_map_pages_at_vaddr(&vm->vm_vspace, &frame.capPtr, &bits, (void*)start, 1, bits, res);
assert(!err);
}
}
int
vm_copyout_atags(vm_t* vm, struct atag_list* atags, uint32_t addr)
{
vspace_t *vm_vspace, *vmm_vspace;
void* vm_addr, *vmm_addr, *buf;
reservation_t res;
vka_t* vka;
vka_object_t frame;
size_t size;
struct atag_list* atag_cur;
int err;
vka = vm->vka;
vm_addr = (void*)(addr & ~0xfff);
vm_vspace = vm_get_vspace(vm);
vmm_vspace = vm->vmm_vspace;
/* Make sure we don't cross a page boundary
* NOTE: the next page will usually be used by linux for PT!
*/
for (size = 0, atag_cur = atags; atag_cur != NULL; atag_cur = atag_cur->next) {
size += atags_size_bytes(atag_cur);
}
size += 8; /* NULL tag */
assert((addr & 0xfff) + size < 0x1000);
/* Create a frame (and a copy for the VMM) */
err = vka_alloc_frame(vka, 12, &frame);
assert(!err);
if (err) {
return -1;
}
/* Map the frame to the VMM */
vmm_addr = vspace_map_pages(vmm_vspace, &frame.cptr, NULL, seL4_AllRights, 1, 12, 0);
assert(vmm_addr);
/* Copy in the atags */
buf = vmm_addr + (addr & 0xfff);
for (atag_cur = atags; atag_cur != NULL; atag_cur = atag_cur->next) {
int tag_size = atags_size_bytes(atag_cur);
DVM("ATAG copy 0x%x<-0x%x %d\n", (uint32_t)buf, (uint32_t)atag_cur->hdr, tag_size);
memcpy(buf, atag_cur->hdr, tag_size);
buf += tag_size;
}
/* NULL tag terminator */
memset(buf, 0, 8);
/* Unmap the page and map it into the VM */
vspace_unmap_pages(vmm_vspace, vmm_addr, 1, 12, NULL);
res = vspace_reserve_range_at(vm_vspace, vm_addr, 0x1000, seL4_AllRights, 0);
assert(res.res);
if (!res.res) {
vka_free_object(vka, &frame);
return -1;
}
err = vspace_map_pages_at_vaddr(vm_vspace, &frame.cptr, NULL, vm_addr, 1, 12, res);
vspace_free_reservation(vm_vspace, res);
assert(!err);
if (err) {
printf("Failed to provide memory\n");
vka_free_object(vka, &frame);
return -1;
}
return 0;
}
