register_t cheritest_libcheri_userfn_getstack(void) { struct cheri_stack cs; struct cheri_stack_frame *csfp; u_int stack_depth; int retval; retval = sysarch(CHERI_GET_STACK, &cs); if (retval != 0) cheritest_failure_err("sysarch(CHERI_GET_STACK) failed"); /* Does stack layout look sensible enough to continue? */ if ((cs.cs_tsize % CHERI_FRAME_SIZE) != 0) cheritest_failure_errx( "stack size (%ld) not a multiple of frame size", cs.cs_tsize); stack_depth = cs.cs_tsize / CHERI_FRAME_SIZE; if ((cs.cs_tsp % CHERI_FRAME_SIZE) != 0) cheritest_failure_errx( "stack pointer (%ld) not a multiple of frame size", cs.cs_tsp); /* Validate that two stack frames are found. */ if (cs.cs_tsp != cs.cs_tsize - (register_t)(2 * CHERI_FRAME_SIZE)) cheritest_failure_errx("stack contains %d frames; expected " "2", (cs.cs_tsize - (2 * CHERI_FRAME_SIZE)) / CHERI_FRAME_SIZE); /* Validate that the first is a saved ambient context. */ csfp = &cs.cs_frames[stack_depth - 1]; if (cheri_getbase(csfp->csf_pcc) != cheri_getbase(cheri_getpcc()) || cheri_getlen(csfp->csf_pcc) != cheri_getlen(cheri_getpcc())) cheritest_failure_errx("frame 0: not global code cap"); /* Validate that the second is cheritest_objectp. */ csfp = &cs.cs_frames[stack_depth - 2]; if ((cheri_getbase(csfp->csf_pcc) != cheri_getbase( sandbox_object_getobject(cheritest_objectp).co_codecap)) || cheri_getlen(csfp->csf_pcc) != cheri_getlen( sandbox_object_getobject(cheritest_objectp).co_codecap)) cheritest_failure_errx("frame 1: not sandbox code cap"); return (0); }
static void sb_read_fn(png_structp png_ptr, png_bytep data, png_size_t length) { void *io_ptr = png_get_io_ptr(png_ptr); #if 0 printf("in sb_read_fn, data base 0x%jx offset 0x%jx length 0x%zx (min len 0x%zx)\n", cheri_getbase(data), cheri_getoffset(data), cheri_getlen(data), length); #endif libpng_sb_read_callback(io_ptr, cheri_setlen(data, length), length); }
context_t act_init(context_t own_context, init_info_t* info, size_t init_base, size_t init_entry) { KERNEL_TRACE("init", "activation init"); internel_if.message_send = kernel_seal(act_send_message_get_trampoline(), act_ref_type); internel_if.message_reply = kernel_seal(act_send_return_get_trampoline(), act_sync_ref_type); setup_syscall_interface(&internel_if); kernel_next_act = 0; // This is a dummy. Our first context has already been created reg_frame_t frame; bzero(&frame, sizeof(struct reg_frame)); // Register the kernel (exception) activation act_t * kernel_act = &kernel_acts[0]; act_register(&frame, &kernel_queue.queue, "kernel", status_terminated, NULL, cheri_getbase(cheri_getpcc())); /* The kernel context already exists and we set it here */ kernel_act->context = own_context; // Create and register the init activation KERNEL_TRACE("act", "Retroactively creating init activation"); /* Not a dummy here. We will subset our own c0/pcc for init. init is loaded directly after the kernel */ bzero(&frame, sizeof(struct reg_frame)); size_t length = cheri_getlen(cheri_getdefault()) - init_base; frame.cf_c0 = cheri_setbounds(cheri_setoffset(cheri_getdefault(), init_base), length); capability pcc = cheri_setbounds(cheri_setoffset(cheri_getpcc(), init_base), length); KERNEL_TRACE("act", "assuming init has virtual entry point %lx", init_entry); frame.cf_c12 = frame.cf_pcc = cheri_setoffset(pcc, init_entry); /* provide config info to init. c3 is the conventional register */ frame.cf_c3 = info; act_t * init_act = &kernel_acts[namespace_num_boot]; act_register_create(&frame, &init_queue.queue, "init", status_alive, NULL); /* The boot activation should be the current activation */ sched_schedule(init_act); return init_act->context; }
/* * Unwind the trusted stack by the specified number of frames (or all). */ int cheri_stack_unwind(ucontext_t *uap, register_t ret, u_int op, u_int num_frames) { struct cheri_frame *cfp; struct cheri_stack cs; struct cheri_stack_frame *csfp; u_int stack_size, stack_frames; register_t saved_mcreg0; if (op != CHERI_STACK_UNWIND_OP_N && op != CHERI_STACK_UNWIND_OP_ALL) { errno = EINVAL; return (-1); } /* * Request to unwind zero frames is a no-op: no state transformation * is needed. */ if ((op == CHERI_STACK_UNWIND_OP_N) && (num_frames == 0)) return (0); /* * Retrieve trusted stack and validate before attempting to unwind. */ if (sysarch(CHERI_GET_STACK, &cs) != 0) return (-1); if ((cs.cs_tsize % CHERI_FRAME_SIZE) != 0 || (cs.cs_tsp > cs.cs_tsize) || (cs.cs_tsp % CHERI_FRAME_SIZE) != 0) { errno = ERANGE; return (-1); } /* * See if there is room on the stack for that much unwinding. */ stack_size = cs.cs_tsize / CHERI_FRAME_SIZE; stack_frames = (cs.cs_tsize - cs.cs_tsp) / CHERI_FRAME_SIZE; if (op == CHERI_STACK_UNWIND_OP_ALL) num_frames = stack_frames; if ((num_frames < 0) || (stack_frames < num_frames)) { errno = ERANGE; return (-1); } /* * Restore state from the last frame being unwound. */ csfp = &cs.cs_frames[stack_size - (stack_frames - num_frames) - 1]; #if 0 /* Make sure we will be returning to ambient authority. */ if (cheri_getbase(csfp->csf_pcc) != cheri_getbase(cheri_getpcc()) || cheri_getlen(csfp->csf_pcc) != cheri_getlen(cheri_getpcc())) return (-1); #endif /* * Pop stack desired number of frames. */ cs.cs_tsp += num_frames * CHERI_FRAME_SIZE; assert(cs.cs_tsp <= cs.cs_tsize); #ifdef __CHERI_PURE_CAPABILITY__ cfp = &uap->uc_mcontext.mc_cheriframe; #else cfp = (struct cheri_frame *)uap->uc_mcontext.mc_cp2state; if (cfp == NULL || uap->uc_mcontext.mc_cp2state_len != sizeof(*cfp)) { errno = ERANGE; return (-1); } #endif /* * Zero the capability register file, explicitly restoring $pcc and * $idc from the last trusted-stack frame. */ memset(cfp, 0, sizeof(*cfp)); cfp->cf_idc = csfp->csf_idc; cfp->cf_pcc = csfp->csf_pcc; /* * Zero the general-purpose register file. restore not only $pc, but * also the slot for $zero, which will hold a magic number across * sigcode and sigreturn(). Also set a return value. * * XXXRW: The kernel unwinder sets V1 to the signal number? */ saved_mcreg0 = uap->uc_mcontext.mc_regs[0]; memset(uap->uc_mcontext.mc_regs, 0, sizeof(uap->uc_mcontext.mc_regs)); uap->uc_mcontext.mc_regs[0] = saved_mcreg0; uap->uc_mcontext.mc_pc = cheri_getoffset(cfp->cf_pcc); uap->uc_mcontext.mc_regs[V0] = ret; /* * Update kernel view of trusted stack. */ if (sysarch(CHERI_SET_STACK, &cs) != 0) return (-1); return (0); }
act_control_t *act_register_create(reg_frame_t *frame, queue_t *queue, const char *name, status_e create_in_status, act_control_t *parent) { act_t* act = act_register(frame, queue, name, create_in_status, parent, (size_t)cheri_getbase(frame->cf_pcc)); act->context = create_context(frame); return act_create_sealed_ctrl_ref(act); }