/* initialise our runtime environment */
static void
init_env(env_t env)
{
allocman_t *allocman;
UNUSED reservation_t virtual_reservation;
UNUSED int error;
/* create an allocator */
allocman = bootstrap_use_current_simple(&env->simple, ALLOCATOR_STATIC_POOL_SIZE, allocator_mem_pool);
assert(allocman);
/* create a vka (interface for interacting with the underlying allocator) */
allocman_make_vka(&env->vka, allocman);
/* create a vspace (virtual memory management interface). We pass
* boot info not because it will use capabilities from it, but so
* it knows the address and will add it as a reserved region */
error = sel4utils_bootstrap_vspace_with_bootinfo_leaky(&env->vspace,
&data, simple_get_pd(&env->simple), &env->vka, seL4_GetBootInfo());
/* fill the allocator with virtual memory */
void *vaddr;
virtual_reservation = vspace_reserve_range(&env->vspace,
ALLOCATOR_VIRTUAL_POOL_SIZE, seL4_AllRights, 1, &vaddr);
assert(virtual_reservation.res);
bootstrap_configure_virtual_pool(allocman, vaddr,
ALLOCATOR_VIRTUAL_POOL_SIZE, simple_get_pd(&env->simple));
}
/*
* Initialize all main data structures.
*
* The code to initialize simple, allocman, vka, and vspace is modeled
* after the "sel4test-driver" app:
* https://github.com/seL4/sel4test/blob/master/apps/sel4test-driver/src/main.c
*/
static void
setup_system()
{
/* initialize boot information */
bootinfo = seL4_GetBootInfo();
/* initialize simple interface */
simple_stable_init_bootinfo(&simple, bootinfo);
//simple_default_init_bootinfo(simple, bootinfo);
/* create an allocator */
allocman_t *allocman;
allocman = bootstrap_use_current_simple(&simple, POOL_SIZE, memPool);
assert(allocman);
/* create a VKA */
allocman_make_vka(&vka, allocman);
/* create a vspace */
UNUSED int err;
err = sel4utils_bootstrap_vspace_with_bootinfo_leaky(&vspace,
&allocData, seL4_CapInitThreadPD, &vka, bootinfo);
assert(err == 0);
/* fill allocator with virtual memory */
void *vaddr;
UNUSED reservation_t vres;
vres = vspace_reserve_range(&vspace, VIRT_POOL_SIZE, seL4_AllRights,
1, &vaddr);
assert(vres.res);
bootstrap_configure_virtual_pool(allocman, vaddr, VIRT_POOL_SIZE,
seL4_CapInitThreadPD);
}
static void
init_allocator(env_t env, test_init_data_t *init_data)
{
UNUSED int error;
UNUSED reservation_t virtual_reservation;
/* initialise allocator */
allocman_t *allocator = bootstrap_use_current_1level(init_data->root_cnode,
init_data->cspace_size_bits, init_data->free_slots.start,
init_data->free_slots.end, ALLOCATOR_STATIC_POOL_SIZE,
allocator_mem_pool);
if (allocator == NULL) {
ZF_LOGF("Failed to bootstrap allocator");
}
allocman_make_vka(&env->vka, allocator);
/* fill the allocator with untypeds */
seL4_CPtr slot;
unsigned int size_bits_index;
for (slot = init_data->untypeds.start, size_bits_index = 0;
slot <= init_data->untypeds.end;
slot++, size_bits_index++) {
cspacepath_t path;
vka_cspace_make_path(&env->vka, slot, &path);
/* allocman doesn't require the paddr unless we need to ask for phys addresses,
* which we don't. */
uintptr_t fake_paddr = 0;
size_t size_bits = init_data->untyped_size_bits_list[size_bits_index];
error = allocman_utspace_add_uts(allocator, 1, &path, &size_bits, &fake_paddr);
if (error) {
ZF_LOGF("Failed to add untyped objects to allocator");
}
}
/* create a vspace */
void *existing_frames[init_data->stack_pages + 2];
existing_frames[0] = (void *) init_data;
existing_frames[1] = seL4_GetIPCBuffer();
assert(init_data->stack_pages > 0);
for (int i = 0; i < init_data->stack_pages; i++) {
existing_frames[i + 2] = init_data->stack + (i * PAGE_SIZE_4K);
}
error = sel4utils_bootstrap_vspace(&env->vspace, &alloc_data, init_data->page_directory, &env->vka, NULL, NULL, existing_frames);
/* switch the allocator to a virtual memory pool */
void *vaddr;
virtual_reservation = vspace_reserve_range(&env->vspace, ALLOCATOR_VIRTUAL_POOL_SIZE,
seL4_AllRights, 1, &vaddr);
if (virtual_reservation.res == 0) {
ZF_LOGF("Failed to switch allocator to virtual memory pool");
}
bootstrap_configure_virtual_pool(allocator, vaddr, ALLOCATOR_VIRTUAL_POOL_SIZE,
env->page_directory);
}
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;
}