seL4_CPtr vmm_create_async_event_notification_cap(vmm_t *vmm, seL4_Word badge) {
if (!(badge & BIT(27))) {
ZF_LOGE("Invalid badge");
return seL4_CapNull;
}
// notification cap
seL4_CPtr ntfn = vmm->plat_callbacks.get_async_event_notification();
// path to notification cap slot
cspacepath_t ntfn_path = {};
vka_cspace_make_path(&vmm->vka, ntfn, &ntfn_path);
// allocate slot to store copy
cspacepath_t minted_ntfn_path = {};
vka_cspace_alloc_path(&vmm->vka, &minted_ntfn_path);
// mint the notification cap
seL4_CapData_t badge_data = seL4_CapData_Badge_new(badge);
int error = vka_cnode_mint(&minted_ntfn_path, &ntfn_path, seL4_AllRights, badge_data);
if (error != seL4_NoError) {
ZF_LOGE("Failed to mint notification cap");
return seL4_CapNull;
}
return minted_ntfn_path.capPtr;
}
int
cnode_mint(env_t env, seL4_CPtr src, seL4_CPtr dest, seL4_Word rights, seL4_CapData_t badge)
{
cspacepath_t src_path, dest_path;
vka_cspace_make_path(&env->vka, src, &src_path);
vka_cspace_make_path(&env->vka, dest, &dest_path);
return vka_cnode_mint(&dest_path, &src_path, rights, badge);
}
/* Binds and IRQ to an endpoint */
static seL4_CPtr
irq_bind(irq_t irq, seL4_CPtr notification_cap, int idx, vka_t* vka, simple_t *simple)
{
seL4_CPtr irq_cap, bnotification_cap;
cspacepath_t irq_path, notification_path, bnotification_path;
seL4_CapData_t badge;
int err;
/* Create an IRQ cap */
err = vka_cspace_alloc(vka, &irq_cap);
if (err != 0) {
ZF_LOGE("Failed to allocate cslot for irq\n");
return seL4_CapNull;
}
vka_cspace_make_path(vka, irq_cap, &irq_path);
err = simple_get_IRQ_control(simple, irq, irq_path);
if (err != seL4_NoError) {
ZF_LOGE("Failed to get cap to irq_number %d\n", irq);
vka_cspace_free(vka, irq_cap);
return seL4_CapNull;
}
/* Badge the provided endpoint. The bit position of the badge tells us the array
* index of the associated IRQ data. */
err = vka_cspace_alloc(vka, &bnotification_cap);
if (err != 0) {
ZF_LOGE("Failed to allocate cslot for irq\n");
vka_cspace_free(vka, irq_cap);
return seL4_CapNull;
}
vka_cspace_make_path(vka, notification_cap, ¬ification_path);
vka_cspace_make_path(vka, bnotification_cap, &bnotification_path);
badge = seL4_CapData_Badge_new(BIT(idx));
err = vka_cnode_mint(&bnotification_path, ¬ification_path, seL4_AllRights, badge);
if (err != seL4_NoError) {
ZF_LOGE("Failed to badge IRQ notification endpoint\n");
vka_cspace_free(vka, irq_cap);
vka_cspace_free(vka, bnotification_cap);
return seL4_CapNull;
}
/* bind the IRQ cap to our badged endpoint */
err = seL4_IRQHandler_SetNotification(irq_cap, bnotification_cap);
if (err != seL4_NoError) {
ZF_LOGE("Failed to bind IRQ handler to notification\n");
vka_cspace_free(vka, irq_cap);
vka_cspace_free(vka, bnotification_cap);
return seL4_CapNull;
}
/* Finally ACK any pending IRQ and enable the IRQ */
seL4_IRQHandler_Ack(irq_cap);
DIRQSERVER("Registered IRQ %d with badge 0x%lx\n", irq, BIT(idx));
return irq_cap;
}
int
vm_install_service(vm_t* vm, seL4_CPtr service, int index, uint32_t b)
{
cspacepath_t src, dst;
seL4_CapData_t badge;
int err;
badge = seL4_CapData_Badge_new(b);
vka_cspace_make_path(vm->vka, service, &src);
dst.root = vm->cspace.cptr;
dst.capPtr = index;
dst.capDepth = VM_CSPACE_SIZE_BITS;
err = vka_cnode_mint(&dst, &src, seL4_AllRights, badge);
return err;
}
int
serial_server_allocate_client_badged_ep(cspacepath_t dest_slot)
{
cspacepath_t server_ep_cspath;
seL4_Word new_badge_value = serial_server_badge_value_alloc();
if (new_badge_value == SERIAL_SERVER_BADGE_VALUE_EMPTY) {
return -1;
}
parent_ep_obj_to_cspath(&server_ep_cspath);
return vka_cnode_mint(&dest_slot, &server_ep_cspath, seL4_AllRights,
seL4_CapData_Badge_new(new_badge_value));
}
static int
map_iopt_set(env_t env, seL4_CPtr *iospace, iopt_cptrs_t *pts, seL4_CPtr *frame)
{
int error;
cspacepath_t master_path, iospace_path;
/* Allocate a random device ID that hopefully doesn't exist have any
* RMRR regions */
error = vka_cspace_alloc(&env->vka, iospace);
test_assert(!error);
vka_cspace_make_path(&env->vka, *iospace, &iospace_path);
vka_cspace_make_path(&env->vka, env->io_space, &master_path);
error = vka_cnode_mint(&iospace_path, &master_path, seL4_AllRights,(DOMAIN_ID << 16) | FAKE_PCI_DEVICE);
test_eq(error, seL4_NoError);
error = map_iopt_from_iospace(env, *iospace, pts, frame);
return error;
}
int
vm_create(const char* name, int priority,
seL4_CPtr vmm_endpoint, seL4_Word vm_badge,
vka_t *vka, simple_t *simple, vspace_t *vmm_vspace,
ps_io_ops_t* io_ops,
vm_t* vm)
{
seL4_CapData_t null_cap_data = {{0}};
seL4_CapData_t cspace_root_data;
cspacepath_t src, dst;
int err;
vm->name = name;
vm->ndevices = 0;
vm->onode_head = NULL;
vm->entry_point = NULL;
vm->vka = vka;
vm->simple = simple;
vm->vmm_vspace = vmm_vspace;
vm->io_ops = io_ops;
vm->vchan_num_cons = 0;
vm->vchan_cons = NULL;
/* Create a cspace */
err = vka_alloc_cnode_object(vka, VM_CSPACE_SIZE_BITS, &vm->cspace);
assert(!err);
vka_cspace_make_path(vka, vm->cspace.cptr, &src);
cspace_root_data = seL4_CapData_Guard_new(0, 32 - VM_CSPACE_SIZE_BITS);
dst.root = vm->cspace.cptr;
dst.capPtr = VM_CSPACE_SLOT;
dst.capDepth = VM_CSPACE_SIZE_BITS;
err = vka_cnode_mint(&dst, &src, seL4_AllRights, cspace_root_data);
assert(!err);
/* Create a vspace */
err = vka_alloc_page_directory(vka, &vm->pd);
assert(!err);
err = simple_ASIDPool_assign(simple, vm->pd.cptr);
assert(err == seL4_NoError);
err = sel4utils_get_vspace(vmm_vspace, &vm->vm_vspace, &vm->data, vka, vm->pd.cptr,
&vm_object_allocation_cb, (void*)vm);
assert(!err);
/* Badge the endpoint */
vka_cspace_make_path(vka, vmm_endpoint, &src);
err = vka_cspace_alloc_path(vka, &dst);
assert(!err);
err = vka_cnode_mint(&dst, &src, seL4_AllRights, seL4_CapData_Badge_new(vm_badge));
assert(!err);
/* Copy it to the cspace of the VM for fault IPC */
src = dst;
dst.root = vm->cspace.cptr;
dst.capPtr = VM_FAULT_EP_SLOT;
dst.capDepth = VM_CSPACE_SIZE_BITS;
err = vka_cnode_copy(&dst, &src, seL4_AllRights);
assert(!err);
/* Create TCB */
err = vka_alloc_tcb(vka, &vm->tcb);
assert(!err);
err = seL4_TCB_Configure(vm_get_tcb(vm), VM_FAULT_EP_SLOT, priority - 1,
vm->cspace.cptr, cspace_root_data,
vm->pd.cptr, null_cap_data, 0, seL4_CapNull);
assert(!err);
/* Create VCPU */
err = vka_alloc_vcpu(vka, &vm->vcpu);
assert(!err);
err = seL4_ARM_VCPU_SetTCB(vm->vcpu.cptr, vm_get_tcb(vm));
assert(!err);
/* Initialise fault system */
vm->fault = fault_init(vm);
assert(vm->fault);
return err;
}
