{\colortbl;\red255\green255\blue255;}
\pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\qc\pardirnatural
-\f0\fs28 \cf0 caddr_t}</string>
+\f0\fs28 \cf0 capaddr_t}</string>
</dict>
<key>Wrap</key>
<string>NO</string>
label=lst:bootinfo]
struct bootinfo {
// Base address of small memory caps region
- caddr_t small_untyped_base;
+ capaddr_t small_untyped_base;
// Number of small memory caps
size_t small_untyped_count;
// Base address of large memory caps region
- caddr_t large_untyped_base;
+ capaddr_t large_untyped_base;
// Number of large memory caps
size_t large_untyped_count;
// Number of entries in regions array
*
* \return Error code
*/
-static inline errval_t invoke_cnode_retype(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_retype(struct capref root, capaddr_t cap,
enum objtype newtype, int objbits,
- caddr_t to, caddr_t slot, int bits)
+ capaddr_t to, capaddr_t slot, int bits)
{
assert(cap != CPTR_NULL);
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(newtype <= 0xffff);
assert(objbits <= 0xff);
*
* \return Error code
*/
-static inline errval_t invoke_cnode_mint(struct capref root, caddr_t to,
- caddr_t slot, caddr_t from, int tobits,
+static inline errval_t invoke_cnode_mint(struct capref root, capaddr_t to,
+ capaddr_t slot, capaddr_t from, int tobits,
int frombits, uintptr_t param1,
uintptr_t param2)
{
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(slot <= 0xffff);
assert(tobits <= 0xff);
*
* \return Error code
*/
-static inline errval_t invoke_cnode_copy(struct capref root, caddr_t to,
- caddr_t slot, caddr_t from, int tobits,
+static inline errval_t invoke_cnode_copy(struct capref root, capaddr_t to,
+ capaddr_t slot, capaddr_t from, int tobits,
int frombits)
{
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(slot <= 0xffff);
assert(tobits <= 0xff);
*
* \return Error code
*/
-static inline errval_t invoke_cnode_delete(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_delete(struct capref root, capaddr_t cap,
int bits)
{
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(bits <= 0xff);
invoke_cptr, cap, bits).error;
}
-static inline errval_t invoke_cnode_revoke(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_revoke(struct capref root, capaddr_t cap,
int bits)
{
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(bits <= 0xff);
static inline errval_t invoke_vnode_unmap(struct capref cap, size_t entry)
{
uint8_t invoke_bits = get_cap_valid_bits(cap);
- caddr_t invoke_cptr = get_cap_addr(cap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap) >> (CPTR_BITS - invoke_bits);
return syscall3((invoke_bits << 16) | (VNodeCmd_Unmap << 8) | SYSCALL_INVOKE,
invoke_cptr, entry).error;
struct frame_identity *ret)
{
uint8_t invoke_bits = get_cap_valid_bits(frame);
- caddr_t invoke_cptr = get_cap_addr(frame) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(frame) >> (CPTR_BITS - invoke_bits);
struct sysret sysret =
syscall2((invoke_bits << 16) | (FrameCmd_Identify << 8) | SYSCALL_INVOKE,
struct capref dispframe, bool run)
{
uint8_t root_vbits = get_cap_valid_bits(cspace);
- caddr_t root_caddr = get_cap_addr(cspace) >> (CPTR_BITS - root_vbits);
- caddr_t vtree_caddr = get_cap_addr(vspace);
- caddr_t disp_caddr = get_cap_addr(dispframe);
- caddr_t dd_caddr = get_cap_addr(domdispatcher);
+ capaddr_t root_caddr = get_cap_addr(cspace) >> (CPTR_BITS - root_vbits);
+ capaddr_t vtree_caddr = get_cap_addr(vspace);
+ capaddr_t disp_caddr = get_cap_addr(dispframe);
+ capaddr_t dd_caddr = get_cap_addr(domdispatcher);
uint8_t invoke_bits = get_cap_valid_bits(dispatcher);
- caddr_t invoke_cptr = get_cap_addr(dispatcher) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(dispatcher) >> (CPTR_BITS - invoke_bits);
assert(root_vbits <= 0xff);
* \param dcb Dispatcher capability
*/
static inline errval_t invoke_dispatcher_setup_guest(struct capref dispatcher,
- caddr_t ep_cap,
- caddr_t vnode,
- caddr_t vmkit_guest,
- caddr_t guest_control_cap)
+ capaddr_t ep_cap,
+ capaddr_t vnode,
+ capaddr_t vmkit_guest,
+ capaddr_t guest_control_cap)
{
return LIB_ERR_NOT_IMPLEMENTED;
}
struct capref ep)
{
uint8_t invoke_bits = get_cap_valid_bits(irqcap);
- caddr_t invoke_cptr = get_cap_addr(irqcap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(irqcap) >> (CPTR_BITS - invoke_bits);
return syscall4((invoke_bits << 16) | (IRQTableCmd_Set << 8) | SYSCALL_INVOKE,
invoke_cptr, irq, get_cap_addr(ep)).error;
static inline errval_t invoke_irqtable_delete(struct capref irqcap, int irq)
{
uint8_t invoke_bits = get_cap_valid_bits(irqcap);
- caddr_t invoke_cptr = get_cap_addr(irqcap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(irqcap) >> (CPTR_BITS - invoke_bits);
return syscall3((invoke_bits << 16) | (IRQTableCmd_Delete << 8) | SYSCALL_INVOKE,
invoke_cptr, irq).error;
assert(core_id != NULL);
uint8_t invoke_bits = get_cap_valid_bits(kern_cap);
- caddr_t invoke_cptr = get_cap_addr(kern_cap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(kern_cap) >> (CPTR_BITS - invoke_bits);
struct sysret sysret =
syscall2((invoke_bits << 16) | (KernelCmd_Get_core_id << 8) | SYSCALL_INVOKE,
)
{
uint8_t invoke_bits = get_cap_valid_bits(dispatcher);
- caddr_t invoke_cptr = get_cap_addr(dispatcher) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(dispatcher) >> (CPTR_BITS - invoke_bits);
if (weight > 0xffff)
{
)
{
uint8_t invoke_bits = get_cap_valid_bits(ep);
- caddr_t invoke_cptr = get_cap_addr(ep) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(ep) >> (CPTR_BITS - invoke_bits);
uint8_t send_bits = get_cap_valid_bits(send_cap);
- caddr_t send_cptr = get_cap_addr(send_cap) >> (CPTR_BITS - send_bits);
+ capaddr_t send_cptr = get_cap_addr(send_cap) >> (CPTR_BITS - send_bits);
assert(length_words <= LMP_MSG_LENGTH);
*
* \return Error code
*/
-static inline errval_t invoke_cnode_retype(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_retype(struct capref root, capaddr_t cap,
enum objtype newtype, int objbits,
- caddr_t to, caddr_t slot, int bits)
+ capaddr_t to, capaddr_t slot, int bits)
{
assert(cap != CPTR_NULL);
struct idc_send_msg msg;
*
* \return Error code
*/
-static inline errval_t invoke_cnode_mint(struct capref root, caddr_t to,
- caddr_t slot, caddr_t from, int tobits,
+static inline errval_t invoke_cnode_mint(struct capref root, capaddr_t to,
+ capaddr_t slot, capaddr_t from, int tobits,
int frombits, uint64_t param1,
uint64_t param2)
{
*
* \return Error code
*/
-static inline errval_t invoke_cnode_copy(struct capref root, caddr_t to,
- caddr_t slot, caddr_t from, int tobits,
+static inline errval_t invoke_cnode_copy(struct capref root, capaddr_t to,
+ capaddr_t slot, capaddr_t from, int tobits,
int frombits)
{
struct idc_send_msg msg;
*
* \return Error code
*/
-static inline errval_t invoke_cnode_delete(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_delete(struct capref root, capaddr_t cap,
int bits)
{
struct idc_send_msg msg;
return cap_invoke(root, &msg).error;
}
-static inline errval_t invoke_cnode_revoke(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_revoke(struct capref root, capaddr_t cap,
int bits)
{
struct idc_send_msg msg;
struct capref dispframe, bool run)
{
uint8_t root_vbits = get_cap_valid_bits(cspace);
- caddr_t root_caddr = get_cap_addr(cspace) >> (CPTR_BITS - root_vbits);
- caddr_t vtree_caddr = get_cap_addr(vspace);
- caddr_t disp_caddr = get_cap_addr(dispframe);
- caddr_t dd_caddr = get_cap_addr(domdispatcher);
+ capaddr_t root_caddr = get_cap_addr(cspace) >> (CPTR_BITS - root_vbits);
+ capaddr_t vtree_caddr = get_cap_addr(vspace);
+ capaddr_t disp_caddr = get_cap_addr(dispframe);
+ capaddr_t dd_caddr = get_cap_addr(domdispatcher);
struct idc_send_msg msg;
idc_msg_init(&msg);
* \param dcb Dispatcher capability
*/
static inline errval_t invoke_dispatcher_setup_guest(struct capref dispatcher,
- caddr_t ep_cap,
- caddr_t vnode,
- caddr_t vmkit_guest,
- caddr_t guest_control_cap)
+ capaddr_t ep_cap,
+ capaddr_t vnode,
+ capaddr_t vmkit_guest,
+ capaddr_t guest_control_cap)
{
struct idc_send_msg msg;
idc_msg_init(&msg);
// Implemented in assembler
#if 0 // these are already declared in include/barrelfish/syscalls.h
-extern errval_t sys_yield(caddr_t target);
+extern errval_t sys_yield(capaddr_t target);
extern errval_t sys_nop(void);
extern errval_t sys_print(const char *string, size_t length);
#endif
extern errval_t sys_invoke(uintptr_t *const pvalue,
uint8_t invokebits,
- caddr_t invokecptr,
+ capaddr_t invokecptr,
struct idc_send_msg *const msg);
{
// TODO: XXX: This should have a typedef not a uint8_t
uint8_t invokebits = get_cap_valid_bits(to);
- caddr_t invokecptr = get_cap_addr(to) >> (CPTR_BITS - invokebits);
+ capaddr_t invokecptr = get_cap_addr(to) >> (CPTR_BITS - invokebits);
struct sysret retval;
retval.error = sys_invoke(&retval.value, invokebits, invokecptr, msg);
*
* \return Error code
*/
-static inline errval_t invoke_cnode_retype(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_retype(struct capref root, capaddr_t cap,
enum objtype newtype, int objbits,
- caddr_t to, caddr_t slot, int bits)
+ capaddr_t to, capaddr_t slot, int bits)
{
assert(cap != CPTR_NULL);
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(newtype <= 0xffff);
assert(objbits <= 0xff);
#if defined(__GNUC__) \
&& __GNUC__ == 4 && __GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ <= 4
static __attribute__ ((noinline,unused)) errval_t
-invoke_cnode_mint(struct capref root, caddr_t to, caddr_t slot, caddr_t from,
+invoke_cnode_mint(struct capref root, capaddr_t to, capaddr_t slot, capaddr_t from,
int tobits, int frombits, uintptr_t param1, uintptr_t param2)
#else
-static inline errval_t invoke_cnode_mint(struct capref root, caddr_t to,
- caddr_t slot, caddr_t from, int tobits,
+static inline errval_t invoke_cnode_mint(struct capref root, capaddr_t to,
+ capaddr_t slot, capaddr_t from, int tobits,
int frombits, uintptr_t param1,
uintptr_t param2)
#endif
{
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(slot <= 0xffff);
assert(tobits <= 0xff);
#if defined(__GNUC__) \
&& __GNUC__ == 4 && __GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ <= 4
static __attribute__ ((noinline,unused)) errval_t
-invoke_cnode_copy(struct capref root, caddr_t to,
- caddr_t slot, caddr_t from, int tobits,
+invoke_cnode_copy(struct capref root, capaddr_t to,
+ capaddr_t slot, capaddr_t from, int tobits,
int frombits)
#else
-static inline errval_t invoke_cnode_copy(struct capref root, caddr_t to,
- caddr_t slot, caddr_t from, int tobits,
+static inline errval_t invoke_cnode_copy(struct capref root, capaddr_t to,
+ capaddr_t slot, capaddr_t from, int tobits,
int frombits)
#endif
{
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(slot <= 0xffff);
assert(tobits <= 0xff);
*
* \return Error code
*/
-static inline errval_t invoke_cnode_delete(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_delete(struct capref root, capaddr_t cap,
int bits)
{
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(bits <= 0xff);
invoke_cptr, cap, bits).error;
}
-static inline errval_t invoke_cnode_revoke(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_revoke(struct capref root, capaddr_t cap,
int bits)
{
uint8_t invoke_bits = get_cap_valid_bits(root);
- caddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
assert(bits <= 0xff);
static inline errval_t invoke_vnode_unmap(struct capref cap, size_t entry)
{
uint8_t invoke_bits = get_cap_valid_bits(cap);
- caddr_t invoke_cptr = get_cap_addr(cap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap) >> (CPTR_BITS - invoke_bits);
return syscall3((invoke_bits << 16) | (VNodeCmd_Unmap << 8) | SYSCALL_INVOKE,
invoke_cptr, entry).error;
struct frame_identity *ret)
{
uint8_t invoke_bits = get_cap_valid_bits(frame);
- caddr_t invoke_cptr = get_cap_addr(frame) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(frame) >> (CPTR_BITS - invoke_bits);
struct sysret sysret =
syscall2((invoke_bits << 16) | (FrameCmd_Identify << 8)
struct scc_frame_identity *ret)
{
uint8_t invoke_bits = get_cap_valid_bits(frame);
- caddr_t invoke_cptr = get_cap_addr(frame) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(frame) >> (CPTR_BITS - invoke_bits);
struct sysret sysret =
syscall2((invoke_bits << 16) | (FrameCmd_SCC_Identify << 8)
uint16_t port, uint32_t *data)
{
uint8_t invoke_bits = get_cap_valid_bits(iocap);
- caddr_t invoke_cptr = get_cap_addr(iocap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(iocap) >> (CPTR_BITS - invoke_bits);
assert(cmd <= 0xff);
uint16_t port, uint32_t data)
{
uint8_t invoke_bits = get_cap_valid_bits(iocap);
- caddr_t invoke_cptr = get_cap_addr(iocap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(iocap) >> (CPTR_BITS - invoke_bits);
assert(cmd <= 0xff);
return syscall4((invoke_bits << 16) | (cmd << 8) | SYSCALL_INVOKE,
struct capref dispframe, bool run)
{
uint8_t root_vbits = get_cap_valid_bits(cspace);
- caddr_t root_caddr = get_cap_addr(cspace) >> (CPTR_BITS - root_vbits);
- caddr_t vtree_caddr = get_cap_addr(vspace);
- caddr_t disp_caddr = get_cap_addr(dispframe);
- caddr_t dd_caddr = get_cap_addr(domdispatcher);
+ capaddr_t root_caddr = get_cap_addr(cspace) >> (CPTR_BITS - root_vbits);
+ capaddr_t vtree_caddr = get_cap_addr(vspace);
+ capaddr_t disp_caddr = get_cap_addr(dispframe);
+ capaddr_t dd_caddr = get_cap_addr(domdispatcher);
uint8_t invoke_bits = get_cap_valid_bits(dispatcher);
- caddr_t invoke_cptr = get_cap_addr(dispatcher) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(dispatcher) >> (CPTR_BITS - invoke_bits);
assert(root_vbits <= 0xff);
* \param dcb Dispatcher capability
*/
static inline errval_t invoke_dispatcher_setup_guest(struct capref dispatcher,
- caddr_t ep_cap,
- caddr_t vnode,
- caddr_t vmkit_guest,
- caddr_t guest_control_cap)
+ capaddr_t ep_cap,
+ capaddr_t vnode,
+ capaddr_t vmkit_guest,
+ capaddr_t guest_control_cap)
{
USER_PANIC("NYI");
return LIB_ERR_NOT_IMPLEMENTED;
struct capref ep)
{
uint8_t invoke_bits = get_cap_valid_bits(irqcap);
- caddr_t invoke_cptr = get_cap_addr(irqcap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(irqcap) >> (CPTR_BITS - invoke_bits);
return syscall4((invoke_bits << 16) | (IRQTableCmd_Set << 8) |
SYSCALL_INVOKE, invoke_cptr,
assert(core_id != NULL);
uint8_t invoke_bits = get_cap_valid_bits(kern_cap);
- caddr_t invoke_cptr = get_cap_addr(kern_cap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(kern_cap) >> (CPTR_BITS - invoke_bits);
struct sysret sysret =
syscall2((invoke_bits << 16) | (KernelCmd_Get_core_id << 8) | SYSCALL_INVOKE,
static inline errval_t invoke_ipi_notify_send(struct capref notify_cap)
{
uint8_t invoke_bits = get_cap_valid_bits(notify_cap);
- caddr_t invoke_cptr = get_cap_addr(notify_cap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(notify_cap) >> (CPTR_BITS - invoke_bits);
return syscall2((invoke_bits << 16) | (NotifyCmd_Send << 8) | SYSCALL_INVOKE,
invoke_cptr).error;
uint64_t umsk, bool os)
{
uint8_t invoke_bits = get_cap_valid_bits(dispcap);
- caddr_t invoke_cptr = get_cap_addr(dispcap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(dispcap) >> (CPTR_BITS - invoke_bits);
return syscall7((invoke_bits << 16) | (DispatcherCmd_PerfMon << 8) | SYSCALL_INVOKE,
invoke_cptr, counter, 0, evt, umsk, os ? 1 : 0).error;
uint8_t counter, uint64_t value)
{
uint8_t invoke_bits = get_cap_valid_bits(dispcap);
- caddr_t invoke_cptr = get_cap_addr(dispcap) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(dispcap) >> (CPTR_BITS - invoke_bits);
uint32_t value_lo = value & 0xffffffff, value_hi = value >> 32;
return syscall6((invoke_bits << 16) | (DispatcherCmd_PerfMon << 8) | SYSCALL_INVOKE,
unsigned long release, unsigned short weight)
{
uint8_t invoke_bits = get_cap_valid_bits(dispatcher);
- caddr_t invoke_cptr = get_cap_addr(dispatcher) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(dispatcher) >> (CPTR_BITS - invoke_bits);
return syscall7((invoke_bits << 16) | (DispatcherCmd_Properties << 8) | SYSCALL_INVOKE,
invoke_cptr, (type << 16) | weight, deadline, wcet, period, release).error;
assert(core_id != NULL);
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
struct sysret sysret =
syscall2((invoke_bits << 16) | (KernelCmd_Get_arch_id << 8) | SYSCALL_INVOKE,
uint8_t event, uint8_t perf_umask,
bool kernel, uint8_t counter_id,
uint64_t counter_value,
- caddr_t ep_addr)
+ capaddr_t ep_addr)
{
return ERR_NOTIMP;
}
uintptr_t arg4)
{
uint8_t invoke_bits = get_cap_valid_bits(ep);
- caddr_t invoke_cptr = get_cap_addr(ep) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(ep) >> (CPTR_BITS - invoke_bits);
uint8_t send_bits = get_cap_valid_bits(send_cap);
- caddr_t send_cptr = get_cap_addr(send_cap) >> (CPTR_BITS - send_bits);
+ capaddr_t send_cptr = get_cap_addr(send_cap) >> (CPTR_BITS - send_bits);
assert(length_words <= LMP_MSG_LENGTH);
#define ARCH_X86_32_BARRELFISH_KPI_SYSCALL_OVERFLOW_H
struct remote_retype_syscall_overflow {
- caddr_t rootcap_addr;
+ capaddr_t rootcap_addr;
uint8_t rootcap_vbits;
};
uintptr_t arg10)
{
uint8_t invoke_bits = get_cap_valid_bits(to);
- caddr_t invoke_cptr = get_cap_addr(to) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(to) >> (CPTR_BITS - invoke_bits);
return syscall(SYSCALL_INVOKE, (uint64_t)invoke_cptr << 32 |
(uint64_t)invoke_bits << 16 | 10 << 8, 0,
*
* \return Error code
*/
-static inline errval_t invoke_cnode_retype(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_retype(struct capref root, capaddr_t cap,
enum objtype newtype, int objbits,
- caddr_t to, caddr_t slot, int bits)
+ capaddr_t to, capaddr_t slot, int bits)
{
assert(cap != CPTR_NULL);
return cap_invoke7(root, CNodeCmd_Retype, cap, newtype, objbits, to,
*
* \return Error code
*/
-static inline errval_t invoke_cnode_mint(struct capref root, caddr_t to,
- caddr_t slot, caddr_t from, int tobits,
+static inline errval_t invoke_cnode_mint(struct capref root, capaddr_t to,
+ capaddr_t slot, capaddr_t from, int tobits,
int frombits, uint64_t param1,
uint64_t param2)
{
*
* \return Error code
*/
-static inline errval_t invoke_cnode_copy(struct capref root, caddr_t to,
- caddr_t slot, caddr_t from, int tobits,
+static inline errval_t invoke_cnode_copy(struct capref root, capaddr_t to,
+ capaddr_t slot, capaddr_t from, int tobits,
int frombits)
{
return cap_invoke6(root, CNodeCmd_Copy, to, slot, from,
*
* \return Error code
*/
-static inline errval_t invoke_cnode_delete(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_delete(struct capref root, capaddr_t cap,
int bits)
{
return cap_invoke3(root, CNodeCmd_Delete, cap, bits).error;
}
-static inline errval_t invoke_cnode_revoke(struct capref root, caddr_t cap,
+static inline errval_t invoke_cnode_revoke(struct capref root, capaddr_t cap,
int bits)
{
return cap_invoke3(root, CNodeCmd_Revoke, cap, bits).error;
struct capref dispframe, bool run)
{
uint8_t root_vbits = get_cap_valid_bits(cspace);
- caddr_t root_caddr = get_cap_addr(cspace) >> (CPTR_BITS - root_vbits);
- caddr_t vtree_caddr = get_cap_addr(vspace);
- caddr_t disp_caddr = get_cap_addr(dispframe);
- caddr_t dd_caddr = get_cap_addr(domdispatcher);
+ capaddr_t root_caddr = get_cap_addr(cspace) >> (CPTR_BITS - root_vbits);
+ capaddr_t vtree_caddr = get_cap_addr(vspace);
+ capaddr_t disp_caddr = get_cap_addr(dispframe);
+ capaddr_t dd_caddr = get_cap_addr(domdispatcher);
return cap_invoke7(dispatcher, DispatcherCmd_Setup, root_caddr,
root_vbits, vtree_caddr, disp_caddr, run,
uint8_t event, uint8_t perf_umask,
bool kernel, uint8_t counter_id,
uint64_t counter_value,
- caddr_t ep_addr)
+ capaddr_t ep_addr)
{
return cap_invoke7(perfmon_cap, PerfmonCmd_Activate,
event, perf_umask, counter_id, kernel,
uint64_t arg10)
{
uint8_t send_bits = get_cap_valid_bits(send_cap);
- caddr_t send_cptr = get_cap_addr(send_cap) >> (CPTR_BITS - send_bits);
+ capaddr_t send_cptr = get_cap_addr(send_cap) >> (CPTR_BITS - send_bits);
#ifndef TRACE_DISABLE_LRPC
// Do an LRPC if possible
#endif
uint8_t invoke_bits = get_cap_valid_bits(ep);
- caddr_t invoke_cptr = get_cap_addr(ep) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(ep) >> (CPTR_BITS - invoke_bits);
return syscall(SYSCALL_INVOKE,
(uint64_t)invoke_cptr << 32 | (uint64_t)send_bits << 24 |
* \brief User-level representation of a CNode, its CSpace address and size
*/
struct cnoderef {
- caddr_t address; ///< Base address of CNode in CSpace
+ capaddr_t address; ///< Base address of CNode in CSpace
uint8_t address_bits; ///< Number of valid bits in base address
uint8_t size_bits; ///< Number of slots in the CNode as a power of 2
uint8_t guard_size; ///< Guard size of the CNode
struct capref {
struct cnoderef cnode; ///< CNode this cap resides in
- caddr_t slot; ///< Slot number within CNode
+ capaddr_t slot; ///< Slot number within CNode
};
#define NULL_CAP (struct capref){ .cnode = NULL_CNODE, .slot = 0 }
// XXX: bug still present in 4.4.3
#if defined(__GNUC__) \
&& __GNUC__ == 4 && __GNUC_MINOR__ == 4 && __GNUC_PATCHLEVEL__ <= 3
-static __attribute__((noinline)) caddr_t get_cap_addr(struct capref cap)
+static __attribute__((noinline)) capaddr_t get_cap_addr(struct capref cap)
#else
-static inline caddr_t get_cap_addr(struct capref cap)
+static inline capaddr_t get_cap_addr(struct capref cap)
#endif
{
uint8_t vbits = get_cap_valid_bits(cap);
* Returns the valid bits of the address only, in the least significant bits
* of the result. This is the format needed for CNode invocation parameters.
*/
-static inline caddr_t get_cnode_addr(struct capref cap)
+static inline capaddr_t get_cnode_addr(struct capref cap)
{
return cap.cnode.address >> (CPTR_BITS - cap.cnode.address_bits);
}
uint64_t param2)
{
uint8_t dcn_vbits = get_cnode_valid_bits(dest);
- caddr_t dcn_addr = get_cnode_addr(dest);
+ capaddr_t dcn_addr = get_cnode_addr(dest);
uint8_t scp_vbits = get_cap_valid_bits(src);
- caddr_t scp_addr = get_cap_addr(src) >> (CPTR_BITS - scp_vbits);
+ capaddr_t scp_addr = get_cap_addr(src) >> (CPTR_BITS - scp_vbits);
return invoke_cnode_mint(cap_root, dcn_addr, dest.slot, scp_addr, dcn_vbits,
scp_vbits, param1, param2);
* \param off Offset from source frame to map (must be page-aligned)
*/
static inline errval_t
-vnode_map(struct capref dest, struct capref src, caddr_t slot,
+vnode_map(struct capref dest, struct capref src, capaddr_t slot,
uint64_t attr, uint64_t off)
{
uint8_t dvbits = get_cap_valid_bits(dest);
- caddr_t daddr = get_cap_addr(dest) >> (CPTR_BITS - dvbits);
+ capaddr_t daddr = get_cap_addr(dest) >> (CPTR_BITS - dvbits);
uint8_t svbits = get_cap_valid_bits(src);
- caddr_t saddr = get_cap_addr(src) >> (CPTR_BITS - svbits);
+ capaddr_t saddr = get_cap_addr(src) >> (CPTR_BITS - svbits);
return invoke_cnode_mint(cap_root, daddr, slot, saddr, dvbits, svbits,
attr, off);
{
errval_t err;
uint8_t dcn_vbits = get_cnode_valid_bits(dest);
- caddr_t dcn_addr = get_cnode_addr(dest);
+ capaddr_t dcn_addr = get_cnode_addr(dest);
uint8_t scp_vbits = get_cap_valid_bits(src);
- caddr_t scp_addr = get_cap_addr(src) >> (CPTR_BITS - scp_vbits);
+ capaddr_t scp_addr = get_cap_addr(src) >> (CPTR_BITS - scp_vbits);
err = invoke_cnode_copy(cap_root, dcn_addr, dest.slot, scp_addr, dcn_vbits,
scp_vbits);
* \param yield_to Endpoint capability for dispatcher to which we want to yield
*/
void disp_save(dispatcher_handle_t handle, arch_registers_state_t *state,
- bool yield, caddr_t yield_to);
+ bool yield, capaddr_t yield_to);
void __attribute__((noreturn)) disp_yield_disabled(dispatcher_handle_t handle);
*
* \return Syscall error code (#SYS_ERR_OK on success).
*/
-errval_t sys_yield(caddr_t target);
+errval_t sys_yield(capaddr_t target);
/* Debug/Benchmarking system calls */
errval_t sys_nop(void);
/// Number of entries in page cnode
#define PAGE_CNODE_SLOTS (1UL << PAGE_CNODE_BITS)
-/// Remainder of guard size when subtracting bits from caddr_t bitsize
+/// Remainder of guard size when subtracting bits from capaddr_t bitsize
#define GUARD_REMAINDER(bits) (CPTR_BITS - (bits))
/* Root CNode */
uint8_t length; ///< Length of payload in words
uint8_t invoke_bits; ///< Valid bits in invoke_cptr
uint8_t send_bits; ///< Valid bits in send_cptr
- caddr_t invoke_cptr; ///< Cap to invoke
- caddr_t send_cptr; ///< Cap to send or #CPTR_NULL
+ capaddr_t invoke_cptr; ///< Cap to invoke
+ capaddr_t send_cptr; ///< Cap to send or #CPTR_NULL
} x;
};
/// Incoming LMP endpoint message buffer
struct lmp_endpoint_kern {
- caddr_t recv_cptr; ///< CSpace address of CNode to receive caps
- caddr_t recv_slot; ///< Slot number in #recv_cptr
+ capaddr_t recv_cptr; ///< CSpace address of CNode to receive caps
+ capaddr_t recv_slot; ///< Slot number in #recv_cptr
uint8_t recv_bits; ///< Valid bits in #recv_cptr
uint32_t delivered; ///< Position in buffer (words delivered by kernel)
uint32_t consumed; ///< Position in buffer (words consumed by user)
#define NBBY 8
/// Capability NULL pointer
-#define CPTR_NULL ((caddr_t)0)
+#define CPTR_NULL ((capaddr_t)0)
#ifndef __ASSEMBLER__
#define PRIxFORVADDR PRIxGENVADDR
/* capability addresses */
-typedef uint32_t caddr_t;
+typedef uint32_t capaddr_t;
#define PRIuCADDR PRIu32
#define PRIxCADDR PRIx32
/// Number of bits in a cspace address
-#define CPTR_BITS (sizeof(caddr_t) * NBBY)
+#define CPTR_BITS (sizeof(capaddr_t) * NBBY)
/* slot number */
-typedef caddr_t cslot_t;
+typedef capaddr_t cslot_t;
#define PRIuCSLOT PRIuCADDR
#define PRIxCSLOT PRIxCADDR
struct registers_arm_syscall_args* sa = &context->syscall_args;
- caddr_t odptr = sa->arg2;
- caddr_t cptr = sa->arg3;
+ capaddr_t odptr = sa->arg2;
+ capaddr_t cptr = sa->arg3;
uintptr_t rundepth = sa->arg4;
int depth = rundepth & 0xff;
int run = rundepth >> 8;
- caddr_t vptr = sa->arg5;
- caddr_t dptr = sa->arg6;
+ capaddr_t vptr = sa->arg5;
+ capaddr_t dptr = sa->arg6;
return sys_dispatcher_setup(to, cptr, depth, vptr, dptr, run, odptr);
}
struct registers_arm_syscall_args* sa = &context->syscall_args;
- caddr_t destcn_cptr = sa->arg2;
- caddr_t source_cptr = sa->arg3;
- caddr_t dest_slot = sa->arg4 >> 16;
+ capaddr_t destcn_cptr = sa->arg2;
+ capaddr_t source_cptr = sa->arg3;
+ capaddr_t dest_slot = sa->arg4 >> 16;
int destcn_vbits = (sa->arg4 >> 8) & 0xff;
int source_vbits = sa->arg4 & 0xff;
struct registers_arm_syscall_args* sa = &context->syscall_args;
- caddr_t destcn_cptr = sa->arg2;
- caddr_t source_cptr = sa->arg3;
- caddr_t dest_slot = sa->arg4 >> 16;
+ capaddr_t destcn_cptr = sa->arg2;
+ capaddr_t source_cptr = sa->arg3;
+ capaddr_t dest_slot = sa->arg4 >> 16;
int destcn_vbits = (sa->arg4 >> 8) & 0xff;
int source_vbits = sa->arg4 & 0xff;
struct registers_arm_syscall_args* sa = &context->syscall_args;
// Source capability cptr
- caddr_t source_cptr = sa->arg2;
+ capaddr_t source_cptr = sa->arg2;
uintptr_t word = sa->arg3;
// Type to retype to
enum objtype type = word >> 16;
// Object bits for variable-sized types
uint8_t objbits = (word >> 8) & 0xff;
// Destination cnode cptr
- caddr_t dest_cnode_cptr = sa->arg4;
+ capaddr_t dest_cnode_cptr = sa->arg4;
// Destination slot number
- caddr_t dest_slot = sa->arg5;
+ capaddr_t dest_slot = sa->arg5;
// Valid bits in destination cnode cptr
uint8_t dest_vbits = (word & 0xff);
struct registers_arm_syscall_args* sa = &context->syscall_args;
- caddr_t cptr = (caddr_t)sa->arg2;
+ capaddr_t cptr = (capaddr_t)sa->arg2;
int bits = (int)sa->arg3;
return sys_delete(root, cptr, bits, false);
struct registers_arm_syscall_args* sa = &context->syscall_args;
- caddr_t cptr = (caddr_t)sa->arg2;
+ capaddr_t cptr = (capaddr_t)sa->arg2;
int bits = (int)sa->arg3;
return sys_revoke(root, cptr, bits, false);
struct registers_arm_syscall_args* sa = &context->syscall_args;
- caddr_t ep_caddr = (caddr_t)sa->arg2;
+ capaddr_t ep_caddr = (capaddr_t)sa->arg2;
return sys_monitor_register(ep_caddr);
}
printf("%d: %d, %d, %d, %d, %d, %d\n", argc, sa->arg0, sa->arg1, sa->arg2, sa->arg3, sa->arg4, sa->arg5);
/* Create the cap in the destination */
- caddr_t cnode_cptr = sa->arg2;
+ capaddr_t cnode_cptr = sa->arg2;
int cnode_vbits = sa->arg3;
size_t slot = sa->arg4;
struct capability *src =
//
uint8_t flags = (sa->arg0 >> 24) & 0xf;
uint16_t invoke_bits = (sa->arg0 >> 16) & 0xffff;
- caddr_t invoke_cptr = sa->arg1;
+ capaddr_t invoke_cptr = sa->arg1;
debug(SUBSYS_SYSCALL, "sys_invoke(0x%x(%d))\n", invoke_cptr, invoke_bits);
if (listener->disp) {
uint8_t length_words = (sa->arg0 >> 28) & 0xff;
uint8_t send_bits = (sa->arg0 >> 8) & 0xff;
- caddr_t send_cptr = sa->arg2;
+ capaddr_t send_cptr = sa->arg2;
/* limit length of message from buggy/malicious sender */
length_words = min(length_words, LMP_MSG_LENGTH);
case SYSCALL_YIELD:
if (argc == 2)
{
- r = sys_yield((caddr_t)sa->arg1);
+ r = sys_yield((capaddr_t)sa->arg1);
}
break;
{\r
errval_t err;\r
unsigned int associd;\r
- caddr_t cptr;\r
+ capaddr_t cptr;\r
struct cte *recv;\r
\r
associd = idc_msg_decode_word_or_zero(msg);\r
- cptr = (caddr_t)idc_msg_decode_word_or_zero(msg);\r
+ cptr = (capaddr_t)idc_msg_decode_word_or_zero(msg);\r
\r
err = caps_lookup_slot(&dcb_current->cspace.cap, cptr,\r
CPTR_BITS, &recv, CAPRIGHTS_WRITE);\r
static struct sysret handle_dispatcher_setup(struct capability *to,\r
struct idc_recv_msg *msg)\r
{\r
- caddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
int depth = idc_msg_decode_word_or_zero(msg);\r
- caddr_t vptr = idc_msg_decode_word_or_zero(msg); // CPTR_NULL\r
- caddr_t dptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t vptr = idc_msg_decode_word_or_zero(msg); // CPTR_NULL\r
+ capaddr_t dptr = idc_msg_decode_word_or_zero(msg);\r
bool run = idc_msg_decode_word_or_zero(msg);\r
- caddr_t odptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t odptr = idc_msg_decode_word_or_zero(msg);\r
\r
// The generic code checks that vspace is initialized\r
struct dcb *dcb = to->u.dispatcher.dcb;\r
struct idc_recv_msg *msg,\r
bool from_monitor)\r
{\r
- caddr_t source_cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t source_cptr = idc_msg_decode_word_or_zero(msg);\r
enum objtype type = idc_msg_decode_word_or_zero(msg);\r
uint8_t objbits = idc_msg_decode_word_or_zero(msg);\r
- caddr_t dest_cnode_cptr = idc_msg_decode_word_or_zero(msg);\r
- caddr_t dest_slot = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t dest_cnode_cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t dest_slot = idc_msg_decode_word_or_zero(msg);\r
uint8_t dest_vbits = idc_msg_decode_word_or_zero(msg);\r
\r
return sys_retype(root, source_cptr, type, objbits, dest_cnode_cptr,\r
struct idc_recv_msg *msg, bool mint)\r
{\r
/* Retrive arguments */\r
- caddr_t destcn_cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t destcn_cptr = idc_msg_decode_word_or_zero(msg);\r
cslot_t dest_slot = idc_msg_decode_word_or_zero(msg);\r
- caddr_t source_cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t source_cptr = idc_msg_decode_word_or_zero(msg);\r
int destcn_vbits = idc_msg_decode_word_or_zero(msg);\r
int source_vbits = idc_msg_decode_word_or_zero(msg);\r
uintptr_t param1, param2;\r
struct idc_recv_msg *msg,\r
bool from_monitor)\r
{\r
- caddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
int bits = idc_msg_decode_word_or_zero(msg);\r
return sys_delete(root, cptr, bits, from_monitor);\r
}\r
struct idc_recv_msg *msg,\r
bool from_monitor)\r
{\r
- caddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
int bits = idc_msg_decode_word_or_zero(msg);\r
return sys_revoke(root, cptr, bits, from_monitor);\r
}\r
{\r
errval_t err;\r
\r
- caddr_t root_caddr = idc_msg_decode_word_or_zero(msg);\r
- caddr_t root_vbits = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t root_caddr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t root_vbits = idc_msg_decode_word_or_zero(msg);\r
\r
struct capability *root;\r
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,\r
{\r
errval_t err;\r
\r
- caddr_t root_caddr = idc_msg_decode_word_or_zero(msg);\r
- caddr_t root_vbits = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t root_caddr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t root_vbits = idc_msg_decode_word_or_zero(msg);\r
\r
struct capability *root;\r
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,\r
{\r
errval_t err;\r
\r
- caddr_t root_caddr = idc_msg_decode_word_or_zero(msg);\r
- caddr_t root_vbits = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t root_caddr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t root_vbits = idc_msg_decode_word_or_zero(msg);\r
\r
struct capability *root;\r
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,\r
static struct sysret monitor_handle_register(struct capability *kernel_cap,\r
struct idc_recv_msg *msg)\r
{\r
- caddr_t ep_caddr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t ep_caddr = idc_msg_decode_word_or_zero(msg);\r
return sys_monitor_register(ep_caddr);\r
}\r
\r
struct capability *root,\r
struct idc_recv_msg *msg)\r
{\r
- caddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
uint8_t bits = idc_msg_decode_word_or_zero(msg);\r
struct capability *retbuf = (void *)idc_msg_decode_word_or_zero(msg);\r
\r
{\r
errval_t err;\r
\r
- caddr_t root_caddr = idc_msg_decode_word_or_zero(msg);\r
- caddr_t root_vbits = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t root_caddr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t root_vbits = idc_msg_decode_word_or_zero(msg);\r
\r
struct capability *root;\r
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,\r
struct idc_recv_msg *msg)\r
{\r
struct capability *root = &dcb_current->cspace.cap;\r
- caddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
int bits = idc_msg_decode_word_or_zero(msg);\r
bool remote = (bool)idc_msg_decode_word_or_zero(msg);\r
bool * has_desc = (bool *)idc_msg_decode_word_or_zero(msg);\r
}\r
\r
/* Create the cap in the destination */\r
- caddr_t cnode_cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t cnode_cptr = idc_msg_decode_word_or_zero(msg);\r
int cnode_vbits = idc_msg_decode_word_or_zero(msg);\r
size_t slot = idc_msg_decode_word_or_zero(msg);\r
return SYSRET(caps_create_from_existing(&dcb_current->cspace.cap,\r
static struct sysret monitor_nullify_cap(struct capability *kernel_cap,\r
struct idc_recv_msg *msg)\r
{\r
- caddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
uint8_t bits = idc_msg_decode_word_or_zero(msg);\r
\r
return sys_monitor_nullify_cap(cptr, bits);\r
return SYSRET(err);\r
}\r
\r
- caddr_t slot = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t slot = idc_msg_decode_word_or_zero(msg);\r
struct cte* cte = caps_locate_slot(cnode_copy->u.cnode.cnode, slot);\r
\r
// XXX: Write cap data directly back to user-space\r
static struct sysret monitor_handle_domain_id(struct capability *monitor_cap,\r
struct idc_recv_msg *msg)\r
{\r
- caddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
domainid_t domain_id = idc_msg_decode_word_or_zero(msg);\r
\r
return sys_monitor_domain_id(cptr, domain_id);\r
errval_t err;\r
\r
/* lookup passed cap */\r
- caddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
+ capaddr_t cptr = idc_msg_decode_word_or_zero(msg);\r
err = caps_lookup_cap(&dcb_current->cspace.cap, cptr, CPTR_BITS, &frame,\r
CAPRIGHTS_READ_WRITE);\r
if (err_is_fail(err)) {\r
* modification in the assember.\r
*/\r
errval_t sys_invoke(uintptr_t *const pvalue,\r
- uint8_t validbits, caddr_t cptr,\r
+ uint8_t validbits, capaddr_t cptr,\r
struct idc_send_msg *msg);\r
-errval_t sys_beehive_yield(caddr_t target);\r
+errval_t sys_beehive_yield(capaddr_t target);\r
errval_t sys_lrpc(void);\r
errval_t sys_reboot(void);\r
errval_t sys_nop(void);\r
\r
// XXX TODO: Should be typedef for these, not uint8_t\r
errval_t sys_invoke(uintptr_t *const pvalue,\r
- uint8_t validbits, caddr_t cptr, struct idc_send_msg *msg)\r
+ uint8_t validbits, capaddr_t cptr, struct idc_send_msg *msg)\r
{\r
//printf("sys_invoke: called %u 0x%" PRIxCADDR "\n", validbits, cptr);\r
\r
panic("sys_lrpc: called\n");\r
}\r
\r
-errval_t sys_beehive_yield(caddr_t target)\r
+errval_t sys_beehive_yield(capaddr_t target)\r
{\r
return sys_yield(target).error;\r
}\r
return SYS_ERR_OK;
}
-errval_t rck_register_notification(caddr_t ep, int chanid)
+errval_t rck_register_notification(capaddr_t ep, int chanid)
{
struct cte *recv;
errval_t err;
static uint8_t my_arch_id;
-errval_t ipi_register_notification(caddr_t ep, int chanid)
+errval_t ipi_register_notification(capaddr_t ep, int chanid)
{
struct cte *recv;
errval_t err;
#endif
}
-errval_t irq_table_set(unsigned int nidt, caddr_t endpoint)
+errval_t irq_table_set(unsigned int nidt, capaddr_t endpoint)
{
errval_t err;
struct cte *recv;
static struct sysret handle_dispatcher_setup(struct capability *to,
int cmd, uintptr_t *args)
{
- caddr_t odptr = args[0];
- caddr_t cptr = args[1];
+ capaddr_t odptr = args[0];
+ capaddr_t cptr = args[1];
uintptr_t rundepth = args[2];
int depth = rundepth & 0xff;
bool run = rundepth >> 8;
- caddr_t vptr = args[3];
- caddr_t dptr = args[4];
+ capaddr_t vptr = args[3];
+ capaddr_t dptr = args[4];
return sys_dispatcher_setup(to, cptr, depth, vptr, dptr, run, odptr);
bool from_monitor)
{
// Source capability cptr
- caddr_t source_cptr = args[0];
+ capaddr_t source_cptr = args[0];
// Type to retype to
enum objtype type = args[1] >> 16;
// Object bits for variable-sized types
uint8_t objbits = (args[1] >> 8) & 0xff;
// Destination cnode cptr
- caddr_t dest_cnode_cptr = args[2];
+ capaddr_t dest_cnode_cptr = args[2];
// Destination slot number
- caddr_t dest_slot = args[3];
+ capaddr_t dest_slot = args[3];
// Valid bits in destination cnode cptr
uint64_t dest_vbits = args[1] & 0xff;
uintptr_t *args, bool mint)
{
/* Retrive arguments */
- caddr_t destcn_cptr = args[0];
- caddr_t source_cptr = args[1];
- caddr_t dest_slot = args[2] >> 16;
+ capaddr_t destcn_cptr = args[0];
+ capaddr_t source_cptr = args[1];
+ capaddr_t dest_slot = args[2] >> 16;
int destcn_vbits = (args[2] >> 8) & 0xff;
int source_vbits = args[2] & 0xff;
uintptr_t param1, param2;
static struct sysret handle_delete_common(struct capability *root,
uintptr_t *args, bool from_monitor)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
int bits = args[1];
return sys_delete(root, cptr, bits, from_monitor);
}
uintptr_t *args,
bool from_monitor)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
int bits = args[1];
return sys_revoke(root, cptr, bits, from_monitor);
}
assert(overflow != NULL);
- caddr_t root_caddr = overflow->rootcap_addr;
- caddr_t root_vbits = overflow->rootcap_vbits;
+ capaddr_t root_caddr = overflow->rootcap_addr;
+ capaddr_t root_vbits = overflow->rootcap_vbits;
struct capability *root;
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,
{
errval_t err;
- caddr_t root_caddr = args[0];
- caddr_t root_vbits = args[1];
+ capaddr_t root_caddr = args[0];
+ capaddr_t root_vbits = args[1];
struct capability *root;
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,
{
errval_t err;
- caddr_t root_caddr = args[0];
- caddr_t root_vbits = args[1];
+ capaddr_t root_caddr = args[0];
+ capaddr_t root_vbits = args[1];
struct capability *root;
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,
static struct sysret monitor_handle_register(struct capability *kernel_cap,
int cmd, uintptr_t *args)
{
- caddr_t ep_caddr = args[0];
+ capaddr_t ep_caddr = args[0];
return sys_monitor_register(ep_caddr);
}
struct capability *root,
uintptr_t *args)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
int bits = args[1];
struct capability *retbuf = (void *)args[2];
{
errval_t err;
- caddr_t root_caddr = args[0];
- caddr_t root_vbits = args[1];
+ capaddr_t root_caddr = args[0];
+ capaddr_t root_vbits = args[1];
struct capability *root;
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,
int cmd, uintptr_t *args)
{
struct capability *root = &dcb_current->cspace.cap;
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
int bits = args[1];
bool remote = (bool)args[2];
int cmd, uintptr_t *args)
{
/* Create the cap in the destination */
- caddr_t cnode_cptr = args[0];
+ capaddr_t cnode_cptr = args[0];
int cnode_vbits = args[1];
size_t slot = args[2];
struct capability *src =
static struct sysret monitor_nullify_cap(struct capability *kernel_cap,
int cmd, uintptr_t *args)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
int bits = args[1];
return sys_monitor_nullify_cap(cptr, bits);
return SYSRET(err);
}
- caddr_t slot = args[];
+ capaddr_t slot = args[];
struct cte* cte = caps_locate_slot(cnode_copy->u.cnode.cnode, slot);
// XXX: Write cap data directly back to user-space
static struct sysret monitor_handle_domain_id(struct capability *monitor_cap,
int cmd, uintptr_t *args)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
domainid_t domain_id = args[1];
return sys_monitor_domain_id(cptr, domain_id);
errval_t err;
/* lookup passed cap */
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
err = caps_lookup_cap(&dcb_current->cspace.cap, cptr, CPTR_BITS, &frame,
CAPRIGHTS_READ_WRITE);
if (err_is_fail(err)) {
static struct sysret kernel_rck_register(struct capability *cap,
int cmd, uintptr_t *args)
{
- caddr_t ep = args[0];
+ capaddr_t ep = args[0];
int chanid = args[1];
return SYSRET(rck_register_notification(ep, chanid));
}
int cmd, uintptr_t *args)
{
assert(cap->type == ObjType_Kernel);
- caddr_t ep = args[0];
+ capaddr_t ep = args[0];
int chanid = args[1];
return SYSRET(ipi_register_notification(ep, chanid));
}
case SYSCALL_INVOKE: ; /* Handle capability invocation */
uint8_t flags = (arg0 >> 24) & 0xf;
uint8_t invoke_bits = (arg0 >> 16) & 0xff;
- caddr_t invoke_cptr = arg1;
+ capaddr_t invoke_cptr = arg1;
debug(SUBSYS_SYSCALL, "sys_invoke(0x%x(%d))\n",
invoke_cptr, invoke_bits);
uint8_t length_words = (arg0 >> 28) & 0xf;
uint8_t send_bits = (arg0 >> 8) & 0xff;
- caddr_t send_cptr = args[0];
+ capaddr_t send_cptr = args[0];
/* limit length of message from buggy/malicious sender */
length_words = min(length_words, LMP_MSG_LENGTH);
// Yield the CPU to the next dispatcher
case SYSCALL_YIELD:
- retval = sys_yield((caddr_t)arg1);
+ retval = sys_yield((capaddr_t)arg1);
break;
// NOP system call for benchmarking purposes
#endif
}
-errval_t irq_table_set(unsigned int nidt, caddr_t endpoint)
+errval_t irq_table_set(unsigned int nidt, capaddr_t endpoint)
{
errval_t err;
struct cte *recv;
static struct sysret handle_dispatcher_setup(struct capability *to,
int cmd, uintptr_t *args)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
int depth = args[1];
- caddr_t vptr = args[2];
- caddr_t dptr = args[3];
+ capaddr_t vptr = args[2];
+ capaddr_t dptr = args[3];
bool run = args[4];
- caddr_t odptr = args[5];
+ capaddr_t odptr = args[5];
return sys_dispatcher_setup(to, cptr, depth, vptr, dptr, run, odptr);
}
uintptr_t *args, bool mint)
{
/* Retrive arguments */
- caddr_t destcn_cptr = args[0];
+ capaddr_t destcn_cptr = args[0];
uint64_t dest_slot = args[1];
- caddr_t source_cptr = args[2];
+ capaddr_t source_cptr = args[2];
int destcn_vbits = args[3];
int source_vbits = args[4];
uint64_t param1, param2;
uintptr_t *args,
bool from_monitor)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
int bits = args[1];
return sys_delete(root, cptr, bits, from_monitor);
}
uintptr_t *args,
bool from_monitor)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
int bits = args[1];
return sys_revoke(root, cptr, bits, from_monitor);
}
{
errval_t err;
- caddr_t root_caddr = args[0];
- caddr_t root_vbits = args[1];
+ capaddr_t root_caddr = args[0];
+ capaddr_t root_vbits = args[1];
struct capability *root;
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,
{
errval_t err;
- caddr_t root_caddr = args[0];
- caddr_t root_vbits = args[1];
+ capaddr_t root_caddr = args[0];
+ capaddr_t root_vbits = args[1];
struct capability *root;
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,
{
errval_t err;
- caddr_t root_caddr = args[0];
- caddr_t root_vbits = args[1];
+ capaddr_t root_caddr = args[0];
+ capaddr_t root_vbits = args[1];
struct capability *root;
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,
static struct sysret monitor_handle_register(struct capability *kernel_cap,
int cmd, uintptr_t *args)
{
- caddr_t ep_caddr = args[0];
+ capaddr_t ep_caddr = args[0];
return sys_monitor_register(ep_caddr);
}
struct capability *root,
uintptr_t *args)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
uint8_t bits = args[1];
struct capability *retbuf = (void *)args[2];
{
errval_t err;
- caddr_t root_caddr = args[0];
- caddr_t root_vbits = args[1];
+ capaddr_t root_caddr = args[0];
+ capaddr_t root_vbits = args[1];
struct capability *root;
err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_vbits,
int cmd, uintptr_t *args)
{
struct capability *root = &dcb_current->cspace.cap;
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
int bits = args[1];
bool remote = args[2];
}
/* Create the cap in the destination */
- caddr_t cnode_cptr = args[pos];
+ capaddr_t cnode_cptr = args[pos];
int cnode_vbits = args[pos + 1];
size_t slot = args[pos + 2];
static struct sysret monitor_nullify_cap(struct capability *kernel_cap,
int cmd, uintptr_t *args)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
uint8_t bits = args[1];
return sys_monitor_nullify_cap(cptr, bits);
return SYSRET(err);
}
- caddr_t slot = args[pos];
+ capaddr_t slot = args[pos];
struct cte* cte = caps_locate_slot(cnode_copy->u.cnode.cnode, slot);
// XXX: Write cap data directly back to user-space
errval_t err;
struct dcb *dcb = to->u.dispatcher.dcb;
- caddr_t epp = args[0];
- caddr_t vnodep = args[1];
- caddr_t vmcbp = args[2];
- caddr_t ctrlp = args[3];
+ capaddr_t epp = args[0];
+ capaddr_t vnodep = args[1];
+ capaddr_t vmcbp = args[2];
+ capaddr_t ctrlp = args[3];
// 0. Enable VM extensions
err = vmkit_enable_virtualization();
static struct sysret monitor_handle_domain_id(struct capability *monitor_cap,
int cmd, uintptr_t *args)
{
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
domainid_t domain_id = args[1];
return sys_monitor_domain_id(cptr, domain_id);
errval_t err;
/* lookup passed cap */
- caddr_t cptr = args[0];
+ capaddr_t cptr = args[0];
err = caps_lookup_cap(&dcb_current->cspace.cap, cptr, CPTR_BITS, &frame,
CAPRIGHTS_READ_WRITE);
if (err_is_fail(err)) {
int cmd, uintptr_t *args)
{
assert(cap->type == ObjType_Kernel);
- caddr_t ep = args[0];
+ capaddr_t ep = args[0];
int chanid = args[1];
return SYSRET(ipi_register_notification(ep, chanid));
}
uint8_t counter_id = args[2];
bool kernel = args[3];
uint64_t counter_value = args[4];
- caddr_t ep_addr = args[5];
+ capaddr_t ep_addr = args[5];
errval_t err;
struct capability *ep;
case SYSCALL_INVOKE: /* Handle capability invocation */
{
// unpack "header" word
- caddr_t invoke_cptr = arg0 >> 32;
+ capaddr_t invoke_cptr = arg0 >> 32;
uint8_t send_bits = arg0 >> 24;
uint8_t invoke_bits = arg0 >> 16;
uint8_t length_words = arg0 >> 8;
// Yield the CPU to the next dispatcher
case SYSCALL_YIELD:
- retval = sys_yield((caddr_t)arg0);
+ retval = sys_yield((capaddr_t)arg0);
break;
// NOP system call for benchmarking purposes
*
* \bug Handle rights
*/
-errval_t caps_lookup_slot(struct capability *cnode_cap, caddr_t cptr,
+errval_t caps_lookup_slot(struct capability *cnode_cap, capaddr_t cptr,
uint8_t vbits, struct cte **ret, CapRights rights)
{
/* parameter checking */
}
/* Guard-check (bit-mask of guard in cptr must match guard in cnode cap) */
- caddr_t cptr_guard = (cptr >> (vbits - cnode_cap->u.cnode.guard_size))
+ capaddr_t cptr_guard = (cptr >> (vbits - cnode_cap->u.cnode.guard_size))
& MASK(cnode_cap->u.cnode.guard_size);
if (cptr_guard != cnode_cap->u.cnode.guard) {
debug(SUBSYS_CAPS, "caps_lookup_slot: guard check failed\n"
/**
* Wrapper for caps_lookup_slot returning capability instead of cte.
*/
-errval_t caps_lookup_cap(struct capability *cnode_cap, caddr_t cptr,
+errval_t caps_lookup_cap(struct capability *cnode_cap, capaddr_t cptr,
uint8_t vbits, struct capability **ret, CapRights rights)
{
struct cte *ret_cte;
* Used when sending capabilities across cores. The metadata is sent across
* cores and the receiving monitor can create the new capability on its core.
*/
-errval_t caps_create_from_existing(struct capability *root, caddr_t cnode_cptr,
+errval_t caps_create_from_existing(struct capability *root, capaddr_t cnode_cptr,
int cnode_vbits, cslot_t dest_slot,
struct capability *src)
{
* \return Error code
*/
static errval_t lmp_transfer_cap(struct capability *ep, struct dcb *send,
- caddr_t send_cptr, uint8_t send_bits)
+ capaddr_t send_cptr, uint8_t send_bits)
{
errval_t err;
/* Parameter checking */
*/
errval_t lmp_deliver(struct capability *ep, struct dcb *send,
uintptr_t *payload, size_t len,
- caddr_t send_cptr, uint8_t send_bits)
+ capaddr_t send_cptr, uint8_t send_bits)
{
bool captransfer;
assert(ep != NULL);
uint8_t rck_get_coreid(void);
void rck_send_notification(uint8_t dest, uintptr_t chanid);
void rck_handle_notification(void);
-errval_t rck_register_notification(caddr_t cap, int chanid);
+errval_t rck_register_notification(capaddr_t cap, int chanid);
errval_t rck_delete_notification(int chanid);
int rck_start_core(uint8_t coreid, genvaddr_t entry, struct x86_core_data *core_data);
void rck_reset_lint1(void);
#ifndef IPI_NOTIFY_H
#define IPI_NOTIFY_H
-errval_t ipi_register_notification(caddr_t ep, int chanid);
+errval_t ipi_register_notification(capaddr_t ep, int chanid);
void ipi_handle_notify(void);
struct sysret ipi_raise_notify(coreid_t coreid, uintptr_t chanid);
void ipi_notify_init(void);
void setup_default_idt(void);
-errval_t irq_table_set(unsigned int nidt, caddr_t endpoint);
+errval_t irq_table_set(unsigned int nidt, capaddr_t endpoint);
errval_t irq_table_delete(unsigned int nidt);
#endif
void setup_default_idt(void);
-errval_t irq_table_set(unsigned int nidt, caddr_t endpoint);
+errval_t irq_table_set(unsigned int nidt, capaddr_t endpoint);
errval_t irq_table_delete(unsigned int nidt);
#endif
errval_t caps_create_new(enum objtype type, lpaddr_t addr, size_t bits,
size_t objbits, struct cte *caps);
-errval_t caps_create_from_existing(struct capability *root, caddr_t cnode_cptr,
+errval_t caps_create_from_existing(struct capability *root, capaddr_t cnode_cptr,
int cnode_vbits, cslot_t dest_slot,
struct capability *src);
errval_t caps_copy_to_cnode(struct cte *dest_cnode_cte, cslot_t dest_slot,
errval_t caps_delete(struct cte *cte, bool from_monitor);
errval_t caps_revoke(struct cte *cte, bool from_monitor);
-errval_t caps_lookup_cap(struct capability *cnode_cap, caddr_t cptr,
+errval_t caps_lookup_cap(struct capability *cnode_cap, capaddr_t cptr,
uint8_t vbits, struct capability **ret,
CapRights rights);
-errval_t caps_lookup_slot(struct capability *cnode_cap, caddr_t cptr,
+errval_t caps_lookup_slot(struct capability *cnode_cap, capaddr_t cptr,
uint8_t vbits, struct cte **ret, CapRights rights);
void mdb_remove_recursively(struct cte *cte);
void mdb_insert_recursively(struct cte *cte);
bool captransfer);
errval_t lmp_deliver(struct capability *ep, struct dcb *send,
uintptr_t *payload, size_t payload_len,
- caddr_t send_cptr, uint8_t send_bits);
+ capaddr_t send_cptr, uint8_t send_bits);
/// Deliver an empty LMP as a notification
static inline errval_t lmp_deliver_notification(struct capability *ep)
#include <capabilities.h>
errval_t sys_print(const char *str, size_t length);
-struct sysret sys_yield(caddr_t target);
+struct sysret sys_yield(capaddr_t target);
struct sysret
-sys_dispatcher_setup(struct capability *to, caddr_t cptr, int depth,
- caddr_t vptr, caddr_t dptr, bool run, caddr_t odptr);
+sys_dispatcher_setup(struct capability *to, capaddr_t cptr, int depth,
+ capaddr_t vptr, capaddr_t dptr, bool run, capaddr_t odptr);
struct sysret
sys_dispatcher_properties(struct capability *to,
enum task_type type, unsigned long deadline,
unsigned long wcet, unsigned long period,
unsigned long release, unsigned short weight);
struct sysret
-sys_retype(struct capability *root, caddr_t source_cptr, enum objtype type,
- uint8_t objbits, caddr_t dest_cnode_cptr, cslot_t dest_slot,
+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);
struct sysret
-sys_copy_or_mint(struct capability *root, caddr_t destcn_cptr, cslot_t dest_slot,
- caddr_t source_cptr, int destcn_vbits, int source_vbits,
+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);
-struct sysret sys_delete(struct capability *root, caddr_t cptr, uint8_t bits,
+struct sysret sys_delete(struct capability *root, capaddr_t cptr, uint8_t bits,
bool from_monitor);
-struct sysret sys_revoke(struct capability *root, caddr_t cptr, uint8_t bits,
+struct sysret sys_revoke(struct capability *root, capaddr_t cptr, uint8_t bits,
bool from_monitor);
-struct sysret sys_monitor_register(caddr_t ep_caddr);
+struct sysret sys_monitor_register(capaddr_t ep_caddr);
struct sysret sys_monitor_identify_cap(struct capability *root,
- caddr_t cptr, uint8_t bits,
+ capaddr_t cptr, uint8_t bits,
struct capability *retbuf);
-struct sysret sys_monitor_nullify_cap(caddr_t cptr, uint8_t bits);
+struct sysret sys_monitor_nullify_cap(capaddr_t cptr, uint8_t bits);
struct sysret
sys_dispatcher_setup_guest (struct capability *to,
- caddr_t epp, caddr_t vnodep,
- caddr_t vmcbp, caddr_t ctrlp);
-struct sysret sys_monitor_domain_id(caddr_t cptr, domainid_t domain_id);
-struct sysret sys_trace_setup(struct capability *cap, caddr_t cptr);
+ capaddr_t epp, capaddr_t vnodep,
+ capaddr_t vmcbp, capaddr_t ctrlp);
+struct sysret sys_monitor_domain_id(capaddr_t cptr, domainid_t domain_id);
+struct sysret sys_trace_setup(struct capability *cap, capaddr_t cptr);
#endif
/* FIXME: lots of missing argument checks in this function */
struct sysret
-sys_dispatcher_setup(struct capability *to, caddr_t cptr, int depth,
- caddr_t vptr, caddr_t dptr, bool run, caddr_t odptr)
+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);
* \param dest_vbits Valid bits in destination cnode cptr
*/
struct sysret
-sys_retype(struct capability *root, caddr_t source_cptr, enum objtype type,
- uint8_t objbits, caddr_t dest_cnode_cptr, cslot_t dest_slot,
+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;
* Common code for copying and minting except the mint flag and param passing
*/
struct sysret
-sys_copy_or_mint(struct capability *root, caddr_t destcn_cptr, cslot_t dest_slot,
- caddr_t source_cptr, int destcn_vbits, int source_vbits,
+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;
}
}
-struct sysret sys_delete(struct capability *root, caddr_t cptr, uint8_t bits,
+struct sysret sys_delete(struct capability *root, capaddr_t cptr, uint8_t bits,
bool from_monitor)
{
errval_t err;
return SYSRET(err);
}
-struct sysret sys_revoke(struct capability *root, caddr_t cptr, uint8_t bits,
+struct sysret sys_revoke(struct capability *root, capaddr_t cptr, uint8_t bits,
bool from_monitor)
{
errval_t err;
return SYSRET(err);
}
-struct sysret sys_monitor_register(caddr_t ep_caddr)
+struct sysret sys_monitor_register(capaddr_t ep_caddr)
{
errval_t err;
struct capability *ep;
}
struct sysret sys_monitor_identify_cap(struct capability *root,
- caddr_t cptr, uint8_t bits,
+ capaddr_t cptr, uint8_t bits,
struct capability *retbuf)
{
struct capability *cap;
return SYSRET(SYS_ERR_OK);
}
-struct sysret sys_monitor_nullify_cap(caddr_t cptr, uint8_t bits)
+struct sysret sys_monitor_nullify_cap(capaddr_t cptr, uint8_t bits)
{
struct capability *root = &dcb_current->cspace.cap;
struct cte *cte;
return SYSRET(SYS_ERR_OK);
}
-struct sysret sys_monitor_domain_id(caddr_t cptr, domainid_t domain_id)
+struct sysret sys_monitor_domain_id(capaddr_t cptr, domainid_t domain_id)
{
struct capability *root = &dcb_current->cspace.cap;
struct capability *disp;
return SYSRET(SYS_ERR_OK);
}
-struct sysret sys_yield(caddr_t target)
+struct sysret sys_yield(capaddr_t target)
{
dispatcher_handle_t handle = dcb_current->disp;
struct dispatcher_shared_generic *disp =
*/
void disp_save(dispatcher_handle_t handle,
arch_registers_state_t *state,
- bool yield, caddr_t yield_to)
+ bool yield, capaddr_t yield_to)
{
struct dispatcher_shared_arm *disp =
get_dispatcher_shared_arm(handle);
return syscall3(SYSCALL_PRINT, (uintptr_t)string, (uintptr_t)length).error;
}
-errval_t sys_yield(caddr_t target)
+errval_t sys_yield(capaddr_t target)
{
STATIC_ASSERT_SIZEOF(target, sizeof(uintptr_t));
return syscall2(SYSCALL_YIELD, (uintptr_t) target).error;
* \param yield_to Endpoint capability for dispatcher to which we want to yield\r
*/\r
void disp_save(dispatcher_handle_t handle, arch_registers_state_t *state,\r
- bool yield, caddr_t yield_to)\r
+ bool yield, capaddr_t yield_to)\r
{\r
assert_disabled(curdispatcher() == handle);\r
struct dispatcher_shared_generic *disp =\r
#include <asmoffsets.h>
/*
- * extern errval_t sys_yield(caddr_t target);
+ * extern errval_t sys_yield(capaddr_t target);
*/
.globl _sys_yield
_sys_yield:
/*
* extern errval_t sys_invoke(uintptr_t *const pvalue,
* uint8_t invokebits,
- * caddr_t invokecptr,
+ * capaddr_t invokecptr,
* struct idc_send_msg *const msg);
*/
.globl _sys_invoke
#error "you should have compiled syscall.S instead"
-errval_t sys_yield(caddr_t target)
+errval_t sys_yield(capaddr_t target)
{
// This is painful, perhaps we should just write it all in assembler
struct sysret retval;
* \param yield_to Endpoint capability for dispatcher to which we want to yield
*/
void disp_save(dispatcher_handle_t handle, arch_registers_state_t *state,
- bool yield, caddr_t yield_to)
+ bool yield, capaddr_t yield_to)
{
struct dispatcher_shared_generic *disp =
get_dispatcher_shared_generic(handle);
uint8_t bits)
{
uint8_t cap_bits = get_cnode_valid_bits(slot);
- caddr_t addr = get_cnode_addr(slot);
+ capaddr_t addr = get_cnode_addr(slot);
return syscall5(SYSCALL_DEBUG,
DEBUG_FEIGN_FRAME_CAP, addr, base, bits | (cap_bits << 8) | (slot.slot << 16)).error;
// XXX: sleep hack
uint32_t yield_timeslices = 0;
-errval_t sys_yield(caddr_t target)
+errval_t sys_yield(capaddr_t target)
{
return syscall3(SYSCALL_YIELD, target, yield_timeslices).error;
}
__attribute__((optimize(2)))
#endif
disp_save(dispatcher_handle_t handle, arch_registers_state_t *state,
- bool yield, caddr_t yield_to)
+ bool yield, capaddr_t yield_to)
{
struct dispatcher_shared_generic *disp =
get_dispatcher_shared_generic(handle);
/* For documentation on system calls see include/barrelfish/syscalls.h
*/
-errval_t sys_yield(caddr_t target)
+errval_t sys_yield(capaddr_t target)
{
return syscall2(SYSCALL_YIELD, target).error;
}
* the monitor to ensure consistancy with other cores. Only necessary for
* caps that have been sent remotely.
*/
-static errval_t cap_retype_remote(caddr_t src, enum objtype new_type,
- uint8_t size_bits, caddr_t to, caddr_t slot,
+static errval_t cap_retype_remote(capaddr_t src, enum objtype new_type,
+ uint8_t size_bits, capaddr_t to, capaddr_t slot,
int dcn_vbits)
{
struct monitor_blocking_rpc_client *mrc = get_monitor_blocking_rpc_client();
* Deletes (but does not revoke) the given capability, allowing the CNode slot
* to be reused.
*/
-static errval_t cap_delete_remote(caddr_t src, uint8_t vbits)
+static errval_t cap_delete_remote(capaddr_t src, uint8_t vbits)
{
struct monitor_blocking_rpc_client *mrc = get_monitor_blocking_rpc_client();
errval_t err, remote_cap_err;
* capability itself. If this succeeds, the capability is guaranteed to be
* the only copy in the system.
*/
-static errval_t cap_revoke_remote(caddr_t src, uint8_t vbits)
+static errval_t cap_revoke_remote(capaddr_t src, uint8_t vbits)
{
struct monitor_blocking_rpc_client *mrc = get_monitor_blocking_rpc_client();
errval_t err, remote_cap_err;
// Number of valid bits in destination CNode address
uint8_t dcn_vbits = get_cnode_valid_bits(dest_start);
// Address of the cap to the destination CNode
- caddr_t dcn_addr = get_cnode_addr(dest_start);
+ capaddr_t dcn_addr = get_cnode_addr(dest_start);
// Address of source capability
- caddr_t scp_addr = get_cap_addr(src);
+ capaddr_t scp_addr = get_cap_addr(src);
err = invoke_cnode_retype(cap_root, scp_addr, new_type, size_bits,
dcn_addr, dest_start.slot, dcn_vbits);
{
errval_t err;
uint8_t vbits = get_cap_valid_bits(cap);
- caddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
+ capaddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
err = invoke_cnode_delete(cap_root, caddr, vbits);
{
errval_t err;
uint8_t vbits = get_cap_valid_bits(cap);
- caddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
+ capaddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
err = invoke_cnode_revoke(cap_root, caddr, vbits);
}
// Walk through all the slots in the CNode
- for (pos.slot = 0; pos.slot < (((caddr_t)1) << cnode.size_bits); pos.slot++) {
+ for (pos.slot = 0; pos.slot < (((capaddr_t)1) << cnode.size_bits); pos.slot++) {
// Get cap data
err = debug_cap_identify(pos, &cap);
return (0);
}
memset(&sess, 0, sizeof(sess));
- sess.key = (caddr_t)"123456789abcdefghijklmno";
+ sess.key = (capaddr_t)"123456789abcdefghijklmno";
for (i = 0; ciphers[i].id && count < CRYPTO_ALGORITHM_MAX; i++) {
if (ciphers[i].nid == NID_undef)
return (0);
}
memset(&sess, 0, sizeof(sess));
- sess.mackey = (caddr_t)"123456789abcdefghijklmno";
+ sess.mackey = (capaddr_t)"123456789abcdefghijklmno";
for (i = 0; digests[i].id && count < CRYPTO_ALGORITHM_MAX; i++) {
if (digests[i].nid == NID_undef)
continue;
cryp.ses = sess->ses;
cryp.flags = 0;
cryp.len = inl;
- cryp.src = (caddr_t) in;
- cryp.dst = (caddr_t) out;
+ cryp.src = (capaddr_t) in;
+ cryp.dst = (capaddr_t) out;
cryp.mac = 0;
cryp.op = ctx->encrypt ? COP_ENCRYPT : COP_DECRYPT;
if (ctx->cipher->iv_len) {
- cryp.iv = (caddr_t) ctx->iv;
+ cryp.iv = (capaddr_t) ctx->iv;
if (!ctx->encrypt) {
iiv = in + inl - ctx->cipher->iv_len;
memcpy(save_iv, iiv, ctx->cipher->iv_len);
if ((state->d_fd = get_dev_crypto()) < 0)
return (0);
- sess->key = (caddr_t)key;
+ sess->key = (capaddr_t)key;
sess->keylen = ctx->key_len;
sess->cipher = cipher;
cryp.ses = sess->ses;
cryp.flags = 0;
cryp.len = count;
- cryp.src = (caddr_t) data;
+ cryp.src = (capaddr_t) data;
cryp.dst = NULL;
- cryp.mac = (caddr_t) state->digest_res;
+ cryp.mac = (capaddr_t) state->digest_res;
if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
printf("cryptodev_digest_update: digest failed\n");
return (0);
cryp.len = state->mac_len;
cryp.src = state->mac_data;
cryp.dst = NULL;
- cryp.mac = (caddr_t)md;
+ cryp.mac = (capaddr_t)md;
if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
printf("cryptodev_digest_final: digest failed\n");
return (1);
memset(b, 0, bytes);
- crp->crp_p = (caddr_t) b;
+ crp->crp_p = (capaddr_t) b;
crp->crp_nbits = bits;
for (i = 0, j = 0; i < a->top; i++) {
kop.crk_op = CRK_DSA_SIGN;
/* inputs: dgst dsa->p dsa->q dsa->g dsa->priv_key */
- kop.crk_param[0].crp_p = (caddr_t)dgst;
+ kop.crk_param[0].crp_p = (capaddr_t)dgst;
kop.crk_param[0].crp_nbits = dlen * 8;
if (bn2crparam(dsa->p, &kop.crk_param[1]))
goto err;
kop.crk_op = CRK_DSA_VERIFY;
/* inputs: dgst dsa->p dsa->q dsa->g dsa->pub_key sig->r sig->s */
- kop.crk_param[0].crp_p = (caddr_t)dgst;
+ kop.crk_param[0].crp_p = (capaddr_t)dgst;
kop.crk_param[0].crp_nbits = dlen * 8;
if (bn2crparam(dsa->p, &kop.crk_param[1]))
goto err;
goto err;
kop.crk_iparams = 3;
- kop.crk_param[3].crp_p = (caddr_t) key;
+ kop.crk_param[3].crp_p = (capaddr_t) key;
kop.crk_param[3].crp_nbits = keylen * 8;
kop.crk_oparams = 1;
return (0);
}
memset(&sess, 0, sizeof(sess));
- sess.key = (caddr_t)"123456789abcdefghijklmno";
+ sess.key = (capaddr_t)"123456789abcdefghijklmno";
for (i = 0; ciphers[i].id && count < CRYPTO_ALGORITHM_MAX; i++) {
if (ciphers[i].nid == NID_undef)
return (0);
}
memset(&sess, 0, sizeof(sess));
- sess.mackey = (caddr_t)"123456789abcdefghijklmno";
+ sess.mackey = (capaddr_t)"123456789abcdefghijklmno";
for (i = 0; digests[i].id && count < CRYPTO_ALGORITHM_MAX; i++) {
if (digests[i].nid == NID_undef)
continue;
cryp.ses = sess->ses;
cryp.flags = 0;
cryp.len = inl;
- cryp.src = (caddr_t) in;
- cryp.dst = (caddr_t) out;
+ cryp.src = (capaddr_t) in;
+ cryp.dst = (capaddr_t) out;
cryp.mac = 0;
cryp.op = ctx->encrypt ? COP_ENCRYPT : COP_DECRYPT;
if (ctx->cipher->iv_len) {
- cryp.iv = (caddr_t) ctx->iv;
+ cryp.iv = (capaddr_t) ctx->iv;
if (!ctx->encrypt) {
iiv = in + inl - ctx->cipher->iv_len;
memcpy(save_iv, iiv, ctx->cipher->iv_len);
if ((state->d_fd = get_dev_crypto()) < 0)
return (0);
- sess->key = (caddr_t)key;
+ sess->key = (capaddr_t)key;
sess->keylen = ctx->key_len;
sess->cipher = cipher;
cryp.ses = sess->ses;
cryp.flags = 0;
cryp.len = count;
- cryp.src = (caddr_t) data;
+ cryp.src = (capaddr_t) data;
cryp.dst = NULL;
- cryp.mac = (caddr_t) state->digest_res;
+ cryp.mac = (capaddr_t) state->digest_res;
if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
printf("cryptodev_digest_update: digest failed\n");
return (0);
cryp.len = state->mac_len;
cryp.src = state->mac_data;
cryp.dst = NULL;
- cryp.mac = (caddr_t)md;
+ cryp.mac = (capaddr_t)md;
if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
printf("cryptodev_digest_final: digest failed\n");
return (1);
memset(b, 0, bytes);
- crp->crp_p = (caddr_t) b;
+ crp->crp_p = (capaddr_t) b;
crp->crp_nbits = bits;
for (i = 0, j = 0; i < a->top; i++) {
kop.crk_op = CRK_DSA_SIGN;
/* inputs: dgst dsa->p dsa->q dsa->g dsa->priv_key */
- kop.crk_param[0].crp_p = (caddr_t)dgst;
+ kop.crk_param[0].crp_p = (capaddr_t)dgst;
kop.crk_param[0].crp_nbits = dlen * 8;
if (bn2crparam(dsa->p, &kop.crk_param[1]))
goto err;
kop.crk_op = CRK_DSA_VERIFY;
/* inputs: dgst dsa->p dsa->q dsa->g dsa->pub_key sig->r sig->s */
- kop.crk_param[0].crp_p = (caddr_t)dgst;
+ kop.crk_param[0].crp_p = (capaddr_t)dgst;
kop.crk_param[0].crp_nbits = dlen * 8;
if (bn2crparam(dsa->p, &kop.crk_param[1]))
goto err;
goto err;
kop.crk_iparams = 3;
- kop.crk_param[3].crp_p = (caddr_t) key;
+ kop.crk_param[3].crp_p = (capaddr_t) key;
kop.crk_param[3].crp_nbits = keylen * 8;
kop.crk_oparams = 1;
cryp.flags=0;
cryp.len=inl;
assert((inl&(ctx->cipher->block_size-1)) == 0);
- cryp.src=(caddr_t)in;
- cryp.dst=(caddr_t)out;
+ cryp.src=(capaddr_t)in;
+ cryp.dst=(capaddr_t)out;
cryp.mac=0;
if(ctx->cipher->iv_len)
- cryp.iv=(caddr_t)ctx->iv;
+ cryp.iv=(capaddr_t)ctx->iv;
if(!ctx->encrypt)
memcpy(lb,&in[cryp.len-ctx->cipher->iv_len],ctx->cipher->iv_len);
cryp.ses=ses;
cryp.op=COP_ENCRYPT;/* required to do the MAC rather than check it */
cryp.len=len;
- cryp.src=(caddr_t)data;
- cryp.dst=(caddr_t)data; // FIXME!!!
- cryp.mac=(caddr_t)md;
+ cryp.src=(capaddr_t)data;
+ cryp.dst=(capaddr_t)data; // FIXME!!!
+ cryp.mac=(capaddr_t)md;
if(ioctl(fd, CIOCCRYPT, &cryp) == -1)
{
cryp.flags=0;
cryp.len=inl;
assert((inl&(ctx->cipher->block_size-1)) == 0);
- cryp.src=(caddr_t)in;
- cryp.dst=(caddr_t)out;
+ cryp.src=(capaddr_t)in;
+ cryp.dst=(capaddr_t)out;
cryp.mac=0;
if(ctx->cipher->iv_len)
- cryp.iv=(caddr_t)ctx->iv;
+ cryp.iv=(capaddr_t)ctx->iv;
if(!ctx->encrypt)
memcpy(lb,&in[cryp.len-ctx->cipher->iv_len],ctx->cipher->iv_len);
cryp.ses=ses;
cryp.op=COP_ENCRYPT;/* required to do the MAC rather than check it */
cryp.len=len;
- cryp.src=(caddr_t)data;
- cryp.dst=(caddr_t)data; // FIXME!!!
- cryp.mac=(caddr_t)md;
+ cryp.src=(capaddr_t)data;
+ cryp.dst=(capaddr_t)data; // FIXME!!!
+ cryp.mac=(capaddr_t)md;
if(ioctl(fd, CIOCCRYPT, &cryp) == -1)
{
> toFofType LPAddr = typedef uint64T "lpaddr_t"
> toFofType GenVAddr = typedef uint64T "genvaddr_t"
> toFofType LVAddr = typedef uint64T "lvaddr_t"
-> toFofType CAddr = typedef uint32T "caddr_t"
+> toFofType CAddr = typedef uint32T "capaddr_t"
> toFofType (Pointer s) = typedef uint64T (s ++ "*")
> toFofType CapRights = capRightsT
forvaddr_t entry)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall6((invoke_bits << 16) | (KernelCmd_Spawn_core << 8)
| SYSCALL_INVOKE, invoke_cptr, core_id, cpu_type,
}
static inline errval_t
-invoke_monitor_identify_cap(caddr_t cap, int bits, struct capability *out)
+invoke_monitor_identify_cap(capaddr_t cap, int bits, struct capability *out)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall5((invoke_bits << 16) | (KernelCmd_Identify_cap << 8)
| SYSCALL_INVOKE, invoke_cptr, cap, bits,
}
static inline errval_t
-invoke_monitor_identify_domains_cap(caddr_t root_cap, int root_bits,
- caddr_t cap, int bits,
+invoke_monitor_identify_domains_cap(capaddr_t root_cap, int root_bits,
+ capaddr_t cap, int bits,
struct capability *out)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall7((invoke_bits << 16) | (KernelCmd_Identify_domains_cap << 8)
| SYSCALL_INVOKE, invoke_cptr, root_cap, root_bits,
}
static inline errval_t
-invoke_monitor_nullify_cap(caddr_t cap, int bits)
+invoke_monitor_nullify_cap(capaddr_t cap, int bits)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall4((invoke_bits << 16) | (KernelCmd_Nullify_cap << 8)
| SYSCALL_INVOKE, invoke_cptr, cap, bits).error;
}
static inline errval_t
-invoke_monitor_create_cap(uint64_t *raw, caddr_t caddr, int bits, caddr_t slot)
+invoke_monitor_create_cap(uint64_t *raw, capaddr_t caddr, int bits, capaddr_t slot)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall6((invoke_bits << 16) | (KernelCmd_Create_cap << 8)
| SYSCALL_INVOKE, invoke_cptr, caddr, bits, slot,
}
static inline errval_t
-invoke_monitor_cap_remote(caddr_t cap, int bits, bool is_remote,
+invoke_monitor_cap_remote(capaddr_t cap, int bits, bool is_remote,
bool * has_descendents)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
struct sysret r;
r = syscall5((invoke_bits << 16) | (KernelCmd_Remote_cap << 8)
invoke_monitor_register(struct capref ep)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall3((invoke_bits << 16) | (KernelCmd_Register << 8)
| SYSCALL_INVOKE, invoke_cptr, get_cap_addr(ep)).error;
}
static inline errval_t
-invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, caddr_t slot,
+invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, capaddr_t slot,
struct capability *out)
{
USER_PANIC("NYI");
}
static inline errval_t
-invoke_monitor_remote_cap_retype(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, enum objtype newtype,
- int objbits, caddr_t to, caddr_t slot,
+invoke_monitor_remote_cap_retype(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, enum objtype newtype,
+ int objbits, capaddr_t to, capaddr_t slot,
int bits)
{
assert(src != CPTR_NULL);
}
static inline errval_t
-invoke_monitor_remote_cap_delete(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, int bits) {
+invoke_monitor_remote_cap_delete(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, int bits) {
assert(src != CPTR_NULL);
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall6(invoke_bits << 16 | (MonitorCmd_Delete << 8)
| SYSCALL_INVOKE, invoke_cptr, rootcap_addr,
}
static inline errval_t
-invoke_monitor_remote_cap_revoke(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, int bits) {
+invoke_monitor_remote_cap_revoke(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, int bits) {
assert(src != CPTR_NULL);
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall6(invoke_bits << 16 | (MonitorCmd_Revoke << 8)
| SYSCALL_INVOKE, invoke_cptr, rootcap_addr,
static inline errval_t invoke_monitor_sync_timer(uint64_t synctime)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall4((invoke_bits << 16) | (KernelCmd_Sync_timer << 8)
| SYSCALL_INVOKE, invoke_cptr, synctime >> 32,
assert(arch_id != NULL);
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
struct sysret sysret;
sysret = syscall2((invoke_bits << 16) | (KernelCmd_Get_arch_id << 8)
}
static inline errval_t
-invoke_monitor_identify_cap(caddr_t cap, int bits, struct capability *out)
+invoke_monitor_identify_cap(capaddr_t cap, int bits, struct capability *out)
{
struct idc_send_msg msg;
}
static inline errval_t
-invoke_monitor_nullify_cap(caddr_t cap, int bits)
+invoke_monitor_nullify_cap(capaddr_t cap, int bits)
{
struct idc_send_msg msg;
}
static inline errval_t
-invoke_monitor_create_cap(uint64_t *raw, caddr_t caddr, int bits, caddr_t slot)
+invoke_monitor_create_cap(uint64_t *raw, capaddr_t caddr, int bits, capaddr_t slot)
{
struct idc_send_msg msg;
}
static inline errval_t
-invoke_monitor_cap_remote(caddr_t cap, int bits, bool is_remote,
+invoke_monitor_cap_remote(capaddr_t cap, int bits, bool is_remote,
bool * has_descendents)
{
struct idc_send_msg msg;
}
static inline errval_t
-invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, caddr_t slot,
+invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, capaddr_t slot,
struct capability *out)
{
USER_PANIC("NYI");
#endif
}
static inline errval_t
-invoke_monitor_identify_domains_cap(caddr_t root_cap, int root_bits,
- caddr_t cap, int bits,
+invoke_monitor_identify_domains_cap(capaddr_t root_cap, int root_bits,
+ capaddr_t cap, int bits,
struct capability *out)
{
struct idc_send_msg msg;
}
static inline errval_t
-invoke_monitor_remote_cap_retype(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, enum objtype newtype,
- int objbits, caddr_t to, caddr_t slot,
+invoke_monitor_remote_cap_retype(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, enum objtype newtype,
+ int objbits, capaddr_t to, capaddr_t slot,
int bits)
{
struct idc_send_msg msg;
static inline errval_t
-invoke_monitor_remote_cap_delete(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, int bits)
+invoke_monitor_remote_cap_delete(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, int bits)
{
struct idc_send_msg msg;
}
static inline errval_t
-invoke_monitor_remote_cap_revoke(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, int bits)
+invoke_monitor_remote_cap_revoke(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, int bits)
{
struct idc_send_msg msg;
forvaddr_t entry)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall6((invoke_bits << 16) | (KernelCmd_Spawn_core << 8)
| SYSCALL_INVOKE, invoke_cptr, core_id, cpu_type,
}
static inline errval_t
-invoke_monitor_identify_cap(caddr_t cap, int bits, struct capability *out)
+invoke_monitor_identify_cap(capaddr_t cap, int bits, struct capability *out)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall5((invoke_bits << 16) | (KernelCmd_Identify_cap << 8)
| SYSCALL_INVOKE, invoke_cptr, cap, bits,
}
static inline errval_t
-invoke_monitor_identify_domains_cap(caddr_t root_cap, int root_bits,
- caddr_t cap, int bits,
+invoke_monitor_identify_domains_cap(capaddr_t root_cap, int root_bits,
+ capaddr_t cap, int bits,
struct capability *out)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall7((invoke_bits << 16) | (KernelCmd_Identify_domains_cap << 8)
| SYSCALL_INVOKE, invoke_cptr, root_cap, root_bits,
}
static inline errval_t
-invoke_monitor_nullify_cap(caddr_t cap, int bits)
+invoke_monitor_nullify_cap(capaddr_t cap, int bits)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall4((invoke_bits << 16) | (KernelCmd_Nullify_cap << 8)
| SYSCALL_INVOKE, invoke_cptr, cap, bits).error;
}
static inline errval_t
-invoke_monitor_create_cap(uint64_t *raw, caddr_t caddr, int bits, caddr_t slot)
+invoke_monitor_create_cap(uint64_t *raw, capaddr_t caddr, int bits, capaddr_t slot)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall6((invoke_bits << 16) | (KernelCmd_Create_cap << 8)
| SYSCALL_INVOKE, invoke_cptr, caddr, bits, slot,
}
static inline errval_t
-invoke_monitor_cap_remote(caddr_t cap, int bits, bool is_remote,
+invoke_monitor_cap_remote(capaddr_t cap, int bits, bool is_remote,
bool * has_descendents)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
struct sysret r;
r = syscall5((invoke_bits << 16) | (KernelCmd_Remote_cap << 8)
invoke_monitor_register(struct capref ep)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall3((invoke_bits << 16) | (KernelCmd_Register << 8)
| SYSCALL_INVOKE, invoke_cptr, get_cap_addr(ep)).error;
}
static inline errval_t
-invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, caddr_t slot,
+invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, capaddr_t slot,
struct capability *out)
{
USER_PANIC("NYI");
}
static inline errval_t
-invoke_monitor_remote_cap_retype(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, enum objtype newtype,
- int objbits, caddr_t to, caddr_t slot,
+invoke_monitor_remote_cap_retype(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, enum objtype newtype,
+ int objbits, capaddr_t to, capaddr_t slot,
int bits)
{
assert(src != CPTR_NULL);
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
assert(newtype <= 0xffff);
assert(objbits <= 0xff);
}
static inline errval_t
-invoke_monitor_remote_cap_delete(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, int bits) {
+invoke_monitor_remote_cap_delete(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, int bits) {
assert(src != CPTR_NULL);
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall6(invoke_bits << 16 | (MonitorCmd_Delete << 8)
| SYSCALL_INVOKE, invoke_cptr, rootcap_addr,
}
static inline errval_t
-invoke_monitor_remote_cap_revoke(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, int bits) {
+invoke_monitor_remote_cap_revoke(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, int bits) {
assert(src != CPTR_NULL);
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall6(invoke_bits << 16 | (MonitorCmd_Revoke << 8)
| SYSCALL_INVOKE, invoke_cptr, rootcap_addr,
invoke_monitor_ipi_register(struct capref ep, int chanid)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall4((invoke_bits << 16) | (KernelCmd_IPI_Register << 8)
| SYSCALL_INVOKE, invoke_cptr,
invoke_monitor_ipi_delete(int chanid)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall3((invoke_bits << 16) | (KernelCmd_IPI_Delete << 8)
| SYSCALL_INVOKE, invoke_cptr,
static inline errval_t invoke_monitor_sync_timer(uint64_t synctime)
{
uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
- caddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
+ capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
return syscall4((invoke_bits << 16) | (KernelCmd_Sync_timer << 8)
| SYSCALL_INVOKE, invoke_cptr, synctime >> 32,
}
static inline errval_t
-invoke_monitor_identify_cap(caddr_t cap, int bits, struct capability *out)
+invoke_monitor_identify_cap(capaddr_t cap, int bits, struct capability *out)
{
return cap_invoke4(cap_kernel, KernelCmd_Identify_cap, cap, bits,
(uintptr_t)out).error;
}
static inline errval_t
-invoke_monitor_identify_domains_cap(caddr_t root_cap, int root_bits,
- caddr_t cap, int bits,
+invoke_monitor_identify_domains_cap(capaddr_t root_cap, int root_bits,
+ capaddr_t cap, int bits,
struct capability *out)
{
return cap_invoke6(cap_kernel, KernelCmd_Identify_domains_cap,
static inline errval_t
-invoke_monitor_nullify_cap(caddr_t cap, int bits)
+invoke_monitor_nullify_cap(capaddr_t cap, int bits)
{
return cap_invoke3(cap_kernel, KernelCmd_Nullify_cap, cap, bits).error;
}
static inline errval_t
-invoke_monitor_cap_remote(caddr_t cap, int bits, bool is_remote,
+invoke_monitor_cap_remote(capaddr_t cap, int bits, bool is_remote,
bool * has_descendents)
{
struct sysret r = cap_invoke4(cap_kernel, KernelCmd_Remote_cap, cap, bits,
}
static inline errval_t
-invoke_monitor_create_cap(uint64_t *raw, caddr_t caddr, int bits, caddr_t slot)
+invoke_monitor_create_cap(uint64_t *raw, capaddr_t caddr, int bits, capaddr_t slot)
{
assert(sizeof(struct capability) % sizeof(uint64_t) == 0);
assert(sizeof(struct capability) / sizeof(uint64_t) == 4);
}
static inline errval_t
-invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, caddr_t slot,
+invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, capaddr_t slot,
struct capability *out)
{
return cap_invoke4(cap_kernel, KernelCmd_Iden_cnode_get_cap,
static inline errval_t
-invoke_monitor_remote_cap_retype(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, enum objtype newtype,
- int objbits, caddr_t to, caddr_t slot,
+invoke_monitor_remote_cap_retype(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, enum objtype newtype,
+ int objbits, capaddr_t to, capaddr_t slot,
int bits) {
return cap_invoke9(cap_kernel, MonitorCmd_Retype, rootcap_addr,
rootcap_vbits, src, newtype, objbits, to, slot,
}
static inline errval_t
-invoke_monitor_remote_cap_delete(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, int bits) {
+invoke_monitor_remote_cap_delete(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, int bits) {
return cap_invoke5(cap_kernel, MonitorCmd_Delete, rootcap_addr,
rootcap_vbits, src, bits).error;
}
static inline errval_t
-invoke_monitor_remote_cap_revoke(caddr_t rootcap_addr, uint8_t rootcap_vbits,
- caddr_t src, int bits) {
+invoke_monitor_remote_cap_revoke(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
+ capaddr_t src, int bits) {
return cap_invoke5(cap_kernel, MonitorCmd_Revoke, rootcap_addr,
rootcap_vbits, src, bits).error;
}
}
uint8_t vbits = get_cap_valid_bits(cap);
- caddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
+ capaddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
return invoke_monitor_identify_cap(caddr, vbits, out);
}
* \param vbits Valid bits of the cap to identify
* \param out Struct to return the metadata
*/
-errval_t monitor_domains_cap_identify(struct capref croot, caddr_t cap,
+errval_t monitor_domains_cap_identify(struct capref croot, capaddr_t cap,
int vbits, struct capability *out)
{
assert (out != NULL);
uint8_t rootcap_vbits = get_cap_valid_bits(croot);
- caddr_t rootcap_addr = get_cap_addr(croot) >> (CPTR_BITS - rootcap_vbits);
+ capaddr_t rootcap_addr = get_cap_addr(croot) >> (CPTR_BITS - rootcap_vbits);
return invoke_monitor_identify_domains_cap(rootcap_addr, rootcap_vbits,
bool * has_decendants)
{
uint8_t vbits = get_cap_valid_bits(cap);
- caddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
+ capaddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
return invoke_monitor_cap_remote(caddr, vbits, is_remote, has_decendants);
}
errval_t monitor_nullify_cap(struct capref cap)
{
uint8_t vbits = get_cap_valid_bits(cap);
- caddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
+ capaddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
return invoke_monitor_nullify_cap(caddr, vbits);
}
#endif
}
- caddr_t caddr = get_cnode_addr(dest);
+ capaddr_t caddr = get_cnode_addr(dest);
uint8_t vbits = get_cnode_valid_bits(dest);
size_t slot = dest.slot;
* within that cnode.
*/
errval_t monitor_identify_cnode_get_cap(struct capability *cnode_raw,
- caddr_t slot, struct capability *ret)
+ capaddr_t slot, struct capability *ret)
{
assert(cnode_raw != NULL);
assert(ret != NULL);
* are remote (cross-core) must be retyped through the monitor to maintain
* cross-core consistancy.
*/
-errval_t monitor_retype_remote_cap(struct capref croot, caddr_t src,
+errval_t monitor_retype_remote_cap(struct capref croot, capaddr_t src,
enum objtype newtype, int objbits,
- caddr_t to, caddr_t slot, int bits)
+ capaddr_t to, capaddr_t slot, int bits)
{
uint8_t rootcap_vbits = get_cap_valid_bits(croot);
- caddr_t rootcap_addr = get_cap_addr(croot) >> (CPTR_BITS - rootcap_vbits);
+ capaddr_t rootcap_addr = get_cap_addr(croot) >> (CPTR_BITS - rootcap_vbits);
return invoke_monitor_remote_cap_retype(rootcap_addr, rootcap_vbits, src,
newtype, objbits, to, slot, bits);
* are remote (cross-core) must be deleted through the monitor to maintain
* cross-core consistancy.
*/
-errval_t monitor_delete_remote_cap(struct capref croot, caddr_t src, int bits)
+errval_t monitor_delete_remote_cap(struct capref croot, capaddr_t src, int bits)
{
uint8_t rootcap_vbits = get_cap_valid_bits(croot);
- caddr_t rootcap_addr = get_cap_addr(croot) >> (CPTR_BITS - rootcap_vbits);
+ capaddr_t rootcap_addr = get_cap_addr(croot) >> (CPTR_BITS - rootcap_vbits);
return invoke_monitor_remote_cap_delete(rootcap_addr, rootcap_vbits, src,
bits);
* are remote (cross-core) must be deleted through the monitor to maintain
* cross-core consistancy.
*/
-errval_t monitor_revoke_remote_cap(struct capref croot, caddr_t src, int bits)
+errval_t monitor_revoke_remote_cap(struct capref croot, capaddr_t src, int bits)
{
uint8_t rootcap_vbits = get_cap_valid_bits(croot);
- caddr_t rootcap_addr = get_cap_addr(croot) >> (CPTR_BITS - rootcap_vbits);
+ capaddr_t rootcap_addr = get_cap_addr(croot) >> (CPTR_BITS - rootcap_vbits);
return invoke_monitor_remote_cap_revoke(rootcap_addr, rootcap_vbits, src,
bits);
/* invocations.c */
bool monitor_can_send_cap(struct capability *cap);
errval_t monitor_cap_identify(struct capref cap, struct capability *out);
-errval_t monitor_domains_cap_identify(struct capref croot, caddr_t cap,
+errval_t monitor_domains_cap_identify(struct capref croot, capaddr_t cap,
int vbits, struct capability *out);
errval_t monitor_cap_remote(struct capref cap, bool is_remote, bool * has_dep);
errval_t monitor_cap_create(struct capref dest, struct capability *cap,
coreid_t core_id);
errval_t monitor_identify_cnode_get_cap(struct capability *cnode_raw,
- caddr_t slot, struct capability *ret);
+ capaddr_t slot, struct capability *ret);
errval_t monitor_nullify_cap(struct capref cap);
errval_t monitor_retype_remote_cap(struct capref croot,
- caddr_t src, enum objtype newtype,
- int objbits, caddr_t to, caddr_t slot,
+ capaddr_t src, enum objtype newtype,
+ int objbits, capaddr_t to, capaddr_t slot,
int bits);
-errval_t monitor_delete_remote_cap(struct capref croot, caddr_t src, int bits);
-errval_t monitor_revoke_remote_cap(struct capref croot, caddr_t src, int bits);
+errval_t monitor_delete_remote_cap(struct capref croot, capaddr_t src, int bits);
+errval_t monitor_revoke_remote_cap(struct capref croot, capaddr_t src, int bits);
/* route.c */
struct rcap_st rcap_st; // must always be first
struct monitor_blocking_binding *b;
struct capref croot;
- caddr_t src;
+ capaddr_t src;
uint64_t new_type;
uint8_t size_bits;
- caddr_t to;
- caddr_t slot;
+ capaddr_t to;
+ capaddr_t slot;
int dcn_vbits;
};
struct rcap_st rcap_st; // must always be first
struct monitor_blocking_binding *b;
struct capref croot;
- caddr_t src;
+ capaddr_t src;
uint8_t vbits;
};
struct rcap_st rcap_st; // must always be first
struct monitor_blocking_binding *b;
struct capref croot;
- caddr_t src;
+ capaddr_t src;
uint8_t vbits;
};
&& __GNUC__ == 4 && __GNUC_MINOR__ == 4 && __GNUC_PATCHLEVEL__ <= 3
static __attribute__((noinline)) struct retype_st *
alloc_retype_st(struct monitor_blocking_binding *b, struct capref croot,
- caddr_t src, uint64_t new_type, uint8_t size_bits,
- caddr_t to, caddr_t slot, int dcn_vbits)
+ capaddr_t src, uint64_t new_type, uint8_t size_bits,
+ capaddr_t to, capaddr_t slot, int dcn_vbits)
#else
static struct retype_st *alloc_retype_st(struct monitor_blocking_binding *b,
- struct capref croot, caddr_t src,
+ struct capref croot, capaddr_t src,
uint64_t new_type, uint8_t size_bits,
- caddr_t to, caddr_t slot, int dcn_vbits)
+ capaddr_t to, capaddr_t slot, int dcn_vbits)
#endif
{
struct retype_st * st;
&& __GNUC__ == 4 && __GNUC_MINOR__ == 4 && __GNUC_PATCHLEVEL__ <= 3
static __attribute__((noinline)) struct delete_st *
alloc_delete_st(struct monitor_blocking_binding *b, struct capref croot,
- caddr_t src, uint8_t vbits)
+ capaddr_t src, uint8_t vbits)
#else
static struct delete_st* alloc_delete_st(struct monitor_blocking_binding *b,
- struct capref croot, caddr_t src,
+ struct capref croot, capaddr_t src,
uint8_t vbits)
#endif
{
&& __GNUC__ == 4 && __GNUC_MINOR__ == 4 && __GNUC_PATCHLEVEL__ <= 3
static __attribute__((noinline)) struct revoke_st *
alloc_revoke_st(struct monitor_blocking_binding *b, struct capref croot,
- caddr_t src, uint8_t vbits)
+ capaddr_t src, uint8_t vbits)
#else
static struct revoke_st *alloc_revoke_st(struct monitor_blocking_binding *b,
- struct capref croot, caddr_t src,
+ struct capref croot, capaddr_t src,
uint8_t vbits)
#endif
{
static void remote_cap_retype(struct monitor_blocking_binding *b,
- struct capref croot, caddr_t src,
+ struct capref croot, capaddr_t src,
uint64_t new_type, uint8_t size_bits,
- caddr_t to, caddr_t slot, int dcn_vbits)
+ capaddr_t to, capaddr_t slot, int dcn_vbits)
{
errval_t err;
bool has_descendants;
static void remote_cap_delete(struct monitor_blocking_binding *b,
- struct capref croot, caddr_t src, uint8_t vbits)
+ struct capref croot, capaddr_t src, uint8_t vbits)
{
errval_t err;
static void remote_cap_revoke(struct monitor_blocking_binding *b,
- struct capref croot, caddr_t src, uint8_t vbits)
+ struct capref croot, capaddr_t src, uint8_t vbits)
{
errval_t err;
/* Save state for stackripped reply */
// perform revoke operation on this cap
uint8_t vbits = get_cap_valid_bits(capref);
- caddr_t caddr = get_cap_addr(capref) >> (CPTR_BITS - vbits);
+ capaddr_t caddr = get_cap_addr(capref) >> (CPTR_BITS - vbits);
err = monitor_revoke_remote_cap(cap_root, caddr, vbits);
assert(err_is_ok(err));
#define MAP_VARIABLE 0
#endif
#ifndef MAP_FAILED
-#define MAP_FAILED ((caddr_t) (-1))
+#define MAP_FAILED ((capaddr_t) (-1))
#endif
#if defined(MAP_ANONYMOUS) || defined(MAP_ANON)
# ifndef MAP_FILE
MAP_NORESERVE|
map_mode,
hd->map_fd, (off_t) 0);
- if ((caddr_t) map_result == MAP_FAILED)
+ if ((capaddr_t) map_result == MAP_FAILED)
{
if (map_mode == MAP_FIXED)
{
} while (!st.st_size);
/* preliminarily map admin page to look at the shared_header */
- tmp_header = (struct shm_desc *) mmap((caddr_t) 0, incr,
+ tmp_header = (struct shm_desc *) mmap((capaddr_t) 0, incr,
PROT_READ,
#ifdef MAP_ANONYMOUS
MAP_FILE|
#endif
MAP_SHARED,
hd->map_fd, (off_t) 0);
- if ((caddr_t) tmp_header == MAP_FAILED)
+ if ((capaddr_t) tmp_header == MAP_FAILED)
{
perror("ECLiPSe: can't map shared memory");
return (char *) -1;
start_shared_area = tmp_header->start;
}
lim = tmp_header->lim;
- (void) munmap((caddr_t) tmp_header, incr);
+ (void) munmap((capaddr_t) tmp_header, incr);
/* Now do the real mapping */
if ((char *) mmap(start_shared_area,
#define MAP_VARIABLE 0
#endif
#ifndef MAP_FAILED
-#define MAP_FAILED ((caddr_t) (-1))
+#define MAP_FAILED ((capaddr_t) (-1))
#endif
#if defined(MAP_ANONYMOUS) || defined(MAP_ANON)
# ifndef MAP_FILE
{
int addr_state_save;
int map_flags, map_prot;
- caddr_t map_result;
+ capaddr_t map_result;
#ifdef HAVE_SIGPROCMASK
sigset_t sig_mask;
#endif
MAP_PRIVATE|addr_map_mode;
}
- map_result = mmap((caddr_t) addr,
+ map_result = mmap((capaddr_t) addr,
(size_t) addr_pagesize,
map_prot,
map_flags,
*addr = 0xff;
addr_state = addr_state_save;
}
- (void) munmap((caddr_t) addr,(size_t) addr_pagesize);
+ (void) munmap((capaddr_t) addr,(size_t) addr_pagesize);
if (addr_state != ADDR_FREE) {
if (addr_range_addr != addr)
_write_range(addr_range_addr, (char *) addr, addr_state);
ec_flush(current_err_);
}
#endif
- ad = mmap((caddr_t) addr, bytes, PROT_READ|PROT_WRITE,
+ ad = mmap((capaddr_t) addr, bytes, PROT_READ|PROT_WRITE,
#ifdef MAP_ANONYMOUS
MAP_FIXED|MAP_PRIVATE|MAP_NORESERVE|MAP_ANONYMOUS, -1,
#else
(off_t) 0);
#else
/* remapping with PROT_NONE should free the swap space */
- ad = mmap((caddr_t) addr, bytes, PROT_NONE,
+ ad = mmap((capaddr_t) addr, bytes, PROT_NONE,
#ifdef MAP_ANONYMOUS
MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1,
#else
ec_panic("ALLOC_FIXED not supported","_map_at()");
#else
char *ad;
- ad = mmap((caddr_t) addr, bytes, PROT_NONE,
+ ad = mmap((capaddr_t) addr, bytes, PROT_NONE,
#ifdef MAP_ANONYMOUS
MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1,
#else
ec_panic("Cannot reserve stack space","alloc_stack_pairs()");
#else
#ifdef HAVE_MMAP
- stack_base = (uword *) mmap((caddr_t) 0,(size_t) bytes_allocated,
+ stack_base = (uword *) mmap((capaddr_t) 0,(size_t) bytes_allocated,
#ifdef HAVE_MAP_NORESERVE
PROT_READ|PROT_WRITE,
#else
ec_panic("Cannot allocate stack space","alloc_stack_pairs()");
#else
#ifdef HAVE_MMAP
- stack_base = (uword *) mmap((caddr_t) 0,(size_t) bytes_allocated,
+ stack_base = (uword *) mmap((capaddr_t) 0,(size_t) bytes_allocated,
PROT_READ|PROT_WRITE,
#ifdef MAP_ANONYMOUS
MAP_PRIVATE|MAP_ANONYMOUS, -1,
projects / barrelfish / commitdiff