/**
* Common code for copying and minting except the mint flag and param passing
*/
struct sysret
sys_copy_or_mint(struct capability *root, capaddr_t destcn_cptr, cslot_t dest_slot,
capaddr_t source_cptr, int destcn_vbits, int source_vbits,
uintptr_t param1, uintptr_t param2, bool mint)
{
errval_t err;
if (!mint) {
param1 = param2 = 0;
}
/* Lookup source cap */
struct cte *src_cap;
err = caps_lookup_slot(root, source_cptr, source_vbits,
&src_cap, CAPRIGHTS_READ);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_SOURCE_CAP_LOOKUP));
}
/* Lookup destination cnode cap */
struct cte *dest_cnode_cap;
err = caps_lookup_slot(root, destcn_cptr, destcn_vbits,
&dest_cnode_cap, CAPRIGHTS_READ_WRITE);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_DEST_CNODE_LOOKUP));
}
/* Perform copy */
if (dest_cnode_cap->cap.type == ObjType_CNode) {
return SYSRET(caps_copy_to_cnode(dest_cnode_cap, dest_slot, src_cap,
mint, param1, param2));
} else {
return SYSRET(SYS_ERR_DEST_TYPE_INVALID);
}
}
struct sysret sys_cap_has_relations(capaddr_t caddr, uint8_t vbits,
uint8_t mask)
{
errval_t err;
struct cte *cap;
err = caps_lookup_slot(&dcb_current->cspace.cap, caddr, vbits, &cap,
CAPRIGHTS_READ);
if (err_is_fail(err)) {
return SYSRET(err);
}
uint8_t res = 0;
if (mask & RRELS_COPY_BIT && has_copies(cap)) {
res |= RRELS_COPY_BIT;
}
if (mask & RRELS_ANCS_BIT && has_ancestors(cap)) {
res |= RRELS_ANCS_BIT;
}
if (mask & RRELS_DESC_BIT && has_descendants(cap)) {
res |= RRELS_DESC_BIT;
}
return (struct sysret) { .error = SYS_ERR_OK, .value = res };
}
/**
* \param root Root CNode to invoke
* \param source_cptr Source capability cptr
* \param type Type to retype to
* \param objbits Object bits for variable-sized types
* \param dest_cnode_cptr Destination cnode cptr
* \param dest_slot Destination slot number
* \param dest_vbits Valid bits in destination cnode cptr
*/
struct sysret
sys_retype(struct capability *root, capaddr_t source_cptr, enum objtype type,
uint8_t objbits, capaddr_t dest_cnode_cptr, cslot_t dest_slot,
uint8_t dest_vbits, bool from_monitor)
{
errval_t err;
/* Parameter checking */
if (type == ObjType_Null || type >= ObjType_Num) {
return SYSRET(SYS_ERR_ILLEGAL_DEST_TYPE);
}
/* Source capability */
struct cte *source_cap;
err = caps_lookup_slot(root, source_cptr, CPTR_BITS, &source_cap,
CAPRIGHTS_READ);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_SOURCE_CAP_LOOKUP));
}
assert(source_cap != NULL);
/* Destination cnode */
struct capability *dest_cnode_cap;
err = caps_lookup_cap(root, dest_cnode_cptr, dest_vbits,
&dest_cnode_cap, CAPRIGHTS_READ_WRITE);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_DEST_CNODE_LOOKUP));
}
if (dest_cnode_cap->type != ObjType_CNode) {
return SYSRET(SYS_ERR_DEST_CNODE_INVALID);
}
return SYSRET(caps_retype(type, objbits, dest_cnode_cap, dest_slot,
source_cap, from_monitor));
}
errval_t ipi_register_notification(capaddr_t ep, int chanid)
{
struct cte *recv;
errval_t err;
err = caps_lookup_slot(&dcb_current->cspace.cap, ep,
2, &recv, CAPRIGHTS_WRITE);
if (err_is_fail(err)) {
return err_push(err, SYS_ERR_IRQ_LOOKUP);
}
assert(recv != NULL);
// Return w/error if cap is not an endpoint
if(recv->cap.type != ObjType_EndPoint) {
return SYS_ERR_IRQ_NOT_ENDPOINT;
}
// Return w/error if no listener on endpoint
if(recv->cap.u.endpoint.listener == NULL) {
return SYS_ERR_IRQ_NO_LISTENER;
}
if(chanid < MAX_CHANIDS) {
// check that we don't overwrite someone else's handler
if (endpoints[chanid].cap.type != ObjType_Null) {
printf("kernel: installing new handler for IPI notification %d\n", chanid);
}
return caps_copy_to_cte(&endpoints[chanid], recv, false, 0, 0);
} else {
return SYS_ERR_IRQ_INVALID;
}
}
struct sysret sys_monitor_delete_foreigns(capaddr_t cptr, uint8_t bits)
{
errval_t err;
struct cte *cte;
err = caps_lookup_slot(&dcb_current->cspace.cap, cptr, bits, &cte, CAPRIGHTS_READ);
if (err_is_fail(err)) {
return SYSRET(err);
}
return SYSRET(caps_delete_foreigns(cte));
}
struct sysret sys_get_state(struct capability *root, capaddr_t cptr, uint8_t bits)
{
errval_t err;
struct cte *slot;
err = caps_lookup_slot(root, cptr, bits, &slot, CAPRIGHTS_READ);
if (err_is_fail(err)) {
return SYSRET(err);
}
distcap_state_t state = distcap_get_state(slot);
return (struct sysret) { .error = SYS_ERR_OK, .value = state };
}
struct sysret sys_revoke(struct capability *root, capaddr_t cptr, uint8_t bits)
{
errval_t err;
struct cte *slot;
err = caps_lookup_slot(root, cptr, bits, &slot, CAPRIGHTS_READ_WRITE);
if (err_is_fail(err)) {
return SYSRET(err);
}
err = caps_revoke(slot);
return SYSRET(err);
}
struct sysret sys_monitor_nullify_cap(capaddr_t cptr, uint8_t bits)
{
struct capability *root = &dcb_current->cspace.cap;
struct cte *cte;
errval_t err = caps_lookup_slot(root, cptr, bits, &cte,
CAPRIGHTS_READ_WRITE);
if (err_is_fail(err)) {
return SYSRET(err);
}
// remove from MDB
remove_mapping(cte);
// zero-out cap entry
assert(!mdb_reachable(cte));
memset(cte, 0, sizeof(*cte));
return SYSRET(SYS_ERR_OK);
}
static errval_t sys_double_lookup(capaddr_t rptr, uint8_t rbits,
capaddr_t tptr, uint8_t tbits,
struct cte **cte)
{
errval_t err;
struct capability *root;
err = caps_lookup_cap(&dcb_current->cspace.cap, rptr, rbits,
&root, CAPRIGHTS_READ);
if (err_is_fail(err)) {
return err_push(err, SYS_ERR_ROOT_CAP_LOOKUP);
}
err = caps_lookup_slot(root, tptr, tbits, cte, CAPRIGHTS_READ);
if (err_is_fail(err)) {
return err_push(err, SYS_ERR_IDENTIFY_LOOKUP);
}
return SYS_ERR_OK;
}
struct sysret sys_monitor_copy_existing(struct capability *src,
capaddr_t cnode_cptr,
uint8_t cnode_vbits,
cslot_t slot)
{
struct cte *copy = mdb_find_equal(src);
if (!copy || copy->mdbnode.in_delete) {
return SYSRET(SYS_ERR_CAP_NOT_FOUND);
}
struct cte *cnode;
errval_t err = caps_lookup_slot(&dcb_current->cspace.cap, cnode_cptr,
cnode_vbits, &cnode, CAPRIGHTS_READ_WRITE);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_SLOT_LOOKUP_FAIL));
}
if (cnode->cap.type != ObjType_CNode) {
return SYSRET(SYS_ERR_CNODE_TYPE);
}
return SYSRET(caps_copy_to_cnode(cnode, slot, copy, false, 0, 0));
}
struct sysret
sys_map(struct capability *ptable, cslot_t slot, capaddr_t source_cptr,
int source_vbits, uintptr_t flags, uintptr_t offset,
uintptr_t pte_count)
{
assert (type_is_vnode(ptable->type));
errval_t err;
/* Lookup source cap */
struct capability *root = &dcb_current->cspace.cap;
struct cte *src_cte;
err = caps_lookup_slot(root, source_cptr, source_vbits, &src_cte,
CAPRIGHTS_READ);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_SOURCE_CAP_LOOKUP));
}
/* Perform map */
// XXX: this does not check if we do have CAPRIGHTS_READ_WRITE on
// the destination cap (the page table we're inserting into)
return SYSRET(caps_copy_to_vnode(cte_for_cap(ptable), slot, src_cte, flags,
offset, pte_count));
}
/* FIXME: lots of missing argument checks in this function */
struct sysret
sys_dispatcher_setup(struct capability *to, capaddr_t cptr, int depth,
capaddr_t vptr, capaddr_t dptr, bool run, capaddr_t odptr)
{
errval_t err = SYS_ERR_OK;
assert(to->type == ObjType_Dispatcher);
struct dcb *dcb = to->u.dispatcher.dcb;
lpaddr_t lpaddr;
/* 1. set cspace root */
if (cptr != CPTR_NULL) {
struct cte *root;
err = caps_lookup_slot(&dcb_current->cspace.cap, cptr, depth,
&root, CAPRIGHTS_READ);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_DISP_CSPACE_ROOT));
}
if (root->cap.type != ObjType_CNode) {
return SYSRET(err_push(err, SYS_ERR_DISP_CSPACE_INVALID));
}
err = caps_copy_to_cte(&dcb->cspace, root, false, 0, 0);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_DISP_CSPACE_ROOT));
}
}
/* 2. set vspace root */
if (vptr != CPTR_NULL) {
struct capability *vroot;
err = caps_lookup_cap(&dcb_current->cspace.cap, vptr, CPTR_BITS,
&vroot, CAPRIGHTS_WRITE);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_DISP_VSPACE_ROOT));
}
// Insert as dispatcher's VSpace root
switch(vroot->type) {
case ObjType_VNode_x86_64_pml4:
dcb->vspace =
(lvaddr_t)gen_phys_to_local_phys(vroot->u.vnode_x86_64_pml4.base);
break;
#ifdef CONFIG_PAE
case ObjType_VNode_x86_32_pdpt:
dcb->vspace =
(lvaddr_t)gen_phys_to_local_phys(vroot->u.vnode_x86_32_pdpt.base);
break;
#else
case ObjType_VNode_x86_32_pdir:
dcb->vspace =
(lvaddr_t)gen_phys_to_local_phys(vroot->u.vnode_x86_32_pdir.base);
break;
#endif
case ObjType_VNode_ARM_l1:
dcb->vspace =
(lvaddr_t)gen_phys_to_local_phys(vroot->u.vnode_arm_l1.base);
break;
default:
return SYSRET(err_push(err, SYS_ERR_DISP_VSPACE_INVALID));
}
}
/* 3. set dispatcher frame pointer */
if (dptr != CPTR_NULL) {
struct cte *dispcte;
err = caps_lookup_slot(&dcb_current->cspace.cap, dptr, CPTR_BITS,
&dispcte, CAPRIGHTS_WRITE);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_DISP_FRAME));
}
struct capability *dispcap = &dispcte->cap;
if (dispcap->type != ObjType_Frame) {
return SYSRET(err_push(err, SYS_ERR_DISP_FRAME_INVALID));
}
/* FIXME: check rights, check size */
lpaddr = gen_phys_to_local_phys(dispcap->u.frame.base);
dcb->disp = local_phys_to_mem(lpaddr);
// Copy the cap to dcb also
err = caps_copy_to_cte(&dcb->disp_cte, dispcte, false, 0, 0);
// If copy fails, something wrong in kernel
assert(err_is_ok(err));
}
/* 5. Make runnable if desired -- Set pointer to ipi_data */
if (run) {
if (dcb->vspace == 0 ||
(!dcb->is_vm_guest &&
(dcb->disp == 0 || dcb->cspace.cap.type != ObjType_CNode))) {
return SYSRET(err_push(err, SYS_ERR_DISP_NOT_RUNNABLE));
}
// XXX: dispatchers run disabled the first time they start
dcb->disabled = 1;
//printf("DCB: %p %.*s\n", dcb, DISP_NAME_LEN, dcb->disp->name);
make_runnable(dcb);
}
/* 6. Copy domain ID off given dispatcher */
if(odptr != CPTR_NULL) {
struct capability *odisp;
err = caps_lookup_cap(&dcb_current->cspace.cap, odptr, CPTR_BITS,
&odisp, CAPRIGHTS_READ_WRITE);
if (err_is_fail(err)) {
return SYSRET(err_push(err, SYS_ERR_DISP_OCAP_LOOKUP));
}
dcb->domain_id = odisp->u.dispatcher.dcb->domain_id;
}
/* 7. (HACK) Set current core id */
{
struct dispatcher_shared_generic *disp =
get_dispatcher_shared_generic(dcb->disp);
disp->curr_core_id = my_core_id;
}
if(!dcb->is_vm_guest) {
struct dispatcher_shared_generic *disp =
get_dispatcher_shared_generic(dcb->disp);
err = trace_new_application(disp->name, (uintptr_t) dcb);
if (err == TRACE_ERR_NO_BUFFER) {
// Try to use the boot buffer.
trace_new_boot_application(disp->name, (uintptr_t) dcb);
}
}
return SYSRET(SYS_ERR_OK);
}
