Replaced caddr_t type with capaddr_t to avoid conflict with libc
authorZeus Gómez Marmolejo <zeus.gomez@bsc.es>
Wed, 28 Dec 2011 15:39:00 +0000 (16:39 +0100)
committerZeus Gómez Marmolejo <zeus.gomez@bsc.es>
Wed, 28 Dec 2011 15:39:00 +0000 (16:39 +0100)
for i in $(find . -type f)
do
  grep -r caddr_t $i
  if [ $? -eq 0 ]
  then
    sed 's/caddr_t/capaddr_t/g' $i > $i.sed
    mv $i.sed $i
  fi
done

66 files changed:
doc/000-overview/graffle/Capabilities_Addr.graffle
doc/010-spec/Spec.tex
include/arch/arm/barrelfish/invocations_arch.h
include/arch/arm/barrelfish/lmp_chan_arch.h
include/arch/beehive/barrelfish/invocations_arch.h
include/arch/beehive/barrelfish/syscall_arch.h
include/arch/x86_32/barrelfish/invocations_arch.h
include/arch/x86_32/barrelfish/lmp_chan_arch.h
include/arch/x86_32/barrelfish_kpi/syscall_overflows_arch.h
include/arch/x86_64/barrelfish/invocations_arch.h
include/arch/x86_64/barrelfish/lmp_chan_arch.h
include/barrelfish/caddr.h
include/barrelfish/capabilities.h
include/barrelfish/dispatch.h
include/barrelfish/syscalls.h
include/barrelfish_kpi/init.h
include/barrelfish_kpi/legacy_idc_buffer.h
include/barrelfish_kpi/lmp.h
include/barrelfish_kpi/types.h
kernel/arch/arm/syscall.c
kernel/arch/beehive/ringbmp.c
kernel/arch/beehive/syscall.c
kernel/arch/scc/rck.c
kernel/arch/x86/ipi_notify.c
kernel/arch/x86_32/irq.c
kernel/arch/x86_32/syscall.c
kernel/arch/x86_64/irq.c
kernel/arch/x86_64/syscall.c
kernel/capabilities.c
kernel/dispatch.c
kernel/include/arch/scc/rck.h
kernel/include/arch/x86/ipi_notify.h
kernel/include/arch/x86_32/irq.h
kernel/include/arch/x86_64/irq.h
kernel/include/capabilities.h
kernel/include/dispatch.h
kernel/include/syscall.h
kernel/syscall.c
lib/barrelfish/arch/arm/dispatch.c
lib/barrelfish/arch/arm/syscalls.c
lib/barrelfish/arch/beehive/dispatch.c
lib/barrelfish/arch/beehive/syscalls.S
lib/barrelfish/arch/beehive/syscalls.c
lib/barrelfish/arch/x86_32/dispatch.c
lib/barrelfish/arch/x86_32/sys_debug.c
lib/barrelfish/arch/x86_32/syscalls.c
lib/barrelfish/arch/x86_64/dispatch.c
lib/barrelfish/arch/x86_64/syscalls.c
lib/barrelfish/capabilities.c
lib/barrelfish/debug.c
lib/openssl-1.0.0d/crypto/engine/eng_cryptodev.c
lib/openssl-1.0.0d/crypto/engine/eng_cryptodev.c.alt
lib/openssl-1.0.0d/crypto/evp/openbsd_hw.c
lib/openssl-1.0.0d/crypto/evp/openbsd_hw.c.alt
tools/hamlet/HamletBackend.lhs
usr/monitor/include/arch/arm/monitor_invocations.h
usr/monitor/include/arch/beehive/monitor_invocations.h
usr/monitor/include/arch/x86_32/monitor_invocations.h
usr/monitor/include/arch/x86_64/monitor_invocations.h
usr/monitor/invocations.c
usr/monitor/monitor.h
usr/monitor/monitor_rpc_server.c
usr/monitor/rcap_db_twopc.c
usr/skb/Shm/src/shared_mem.c
usr/skb/eclipse_kernel/src/addrmap.c
usr/skb/eclipse_kernel/src/mem.c

index 46a1a64..7869558 100644 (file)
@@ -779,7 +779,7 @@ Cap}</string>
 {\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>
index 66132e8..15231a2 100644 (file)
   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
index a5ca8e3..96bba9c 100644 (file)
  *
  * \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);
@@ -72,13 +72,13 @@ static inline errval_t invoke_cnode_retype(struct capref root, caddr_t cap,
  *
  * \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);
@@ -108,12 +108,12 @@ static inline errval_t invoke_cnode_mint(struct capref root, caddr_t to,
  *
  * \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);
@@ -136,11 +136,11 @@ static inline errval_t invoke_cnode_copy(struct capref root, caddr_t to,
  *
  * \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);
 
@@ -148,11 +148,11 @@ static inline errval_t invoke_cnode_delete(struct capref root, caddr_t cap,
                     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);
 
@@ -163,7 +163,7 @@ static inline errval_t invoke_cnode_revoke(struct capref root, caddr_t cap,
 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;
@@ -181,7 +181,7 @@ static inline errval_t invoke_frame_identify(struct capref frame,
                                              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,
@@ -237,12 +237,12 @@ invoke_dispatcher(struct capref dispatcher, struct capref domdispatcher,
                   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);
 
@@ -258,10 +258,10 @@ invoke_dispatcher(struct capref dispatcher, struct capref domdispatcher,
  * \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;
 }
@@ -270,7 +270,7 @@ static inline errval_t invoke_irqtable_set(struct capref irqcap, int irq,
                                            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;
@@ -279,7 +279,7 @@ static inline errval_t invoke_irqtable_set(struct capref irqcap, int irq,
 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;
@@ -291,7 +291,7 @@ static inline errval_t invoke_kernel_get_core_id(struct capref kern_cap,
     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,
@@ -313,7 +313,7 @@ invoke_dispatcher_properties(
                             )
 {
     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)
     {
index c55beb6..fea59e9 100644 (file)
@@ -49,10 +49,10 @@ lmp_ep_send(
     )
 {
     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);
 
index b0b6d80..30ccbc4 100644 (file)
@@ -35,9 +35,9 @@
  *
  * \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;
@@ -74,8 +74,8 @@ static inline errval_t invoke_cnode_retype(struct capref root, caddr_t cap,
  *
  * \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)
 {
@@ -119,8 +119,8 @@ static inline errval_t invoke_vnode_unmap(struct capref cap, size_t entry)
  *
  * \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;
@@ -148,7 +148,7 @@ static inline errval_t invoke_cnode_copy(struct capref root, caddr_t to,
  *
  * \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;
@@ -161,7 +161,7 @@ static inline errval_t invoke_cnode_delete(struct capref root, caddr_t cap,
     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;
@@ -251,10 +251,10 @@ invoke_dispatcher(struct capref dispatcher, struct capref domdispatcher,
                   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);
@@ -274,10 +274,10 @@ invoke_dispatcher(struct capref dispatcher, struct capref domdispatcher,
  * \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);
index 1e85fa6..7f93908 100644 (file)
 // 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);
 
 
@@ -54,7 +54,7 @@ cap_invoke(struct capref to, struct idc_send_msg *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);
index 6dc5e8e..de8e81f 100644 (file)
  *
  * \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);
@@ -78,17 +78,17 @@ static inline errval_t invoke_cnode_retype(struct capref root, caddr_t cap,
 #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);
@@ -122,17 +122,17 @@ static inline errval_t invoke_cnode_mint(struct capref root, caddr_t to,
 #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);
@@ -155,11 +155,11 @@ static inline errval_t invoke_cnode_copy(struct capref root, caddr_t to,
  *
  * \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);
 
@@ -167,11 +167,11 @@ static inline errval_t invoke_cnode_delete(struct capref root, caddr_t cap,
                     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);
 
@@ -182,7 +182,7 @@ static inline errval_t invoke_cnode_revoke(struct capref root, caddr_t cap,
 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;
@@ -200,7 +200,7 @@ static inline errval_t invoke_frame_identify(struct capref frame,
                                              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)
@@ -231,7 +231,7 @@ static inline errval_t invoke_scc_frame_identify(struct capref frame,
                                                  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)
@@ -253,7 +253,7 @@ static inline errval_t invoke_iocap_in(struct capref iocap, enum io_cmd cmd,
                                        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);
 
@@ -272,7 +272,7 @@ static inline errval_t invoke_iocap_out(struct capref iocap, enum io_cmd cmd,
                                         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,
@@ -306,12 +306,12 @@ invoke_dispatcher(struct capref dispatcher, struct capref domdispatcher,
                   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);
 
@@ -328,10 +328,10 @@ invoke_dispatcher(struct capref dispatcher, struct capref domdispatcher,
  * \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;
@@ -341,7 +341,7 @@ static inline errval_t invoke_irqtable_set(struct capref irqcap, int irq,
                                            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,
@@ -363,7 +363,7 @@ static inline errval_t invoke_kernel_get_core_id(struct capref kern_cap,
     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,
@@ -379,7 +379,7 @@ static inline errval_t invoke_kernel_get_core_id(struct capref kern_cap,
 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;
@@ -390,7 +390,7 @@ static inline errval_t invoke_perfmon_setup(struct capref dispcap,
                                             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;
@@ -400,7 +400,7 @@ static inline errval_t invoke_perfmon_write(struct capref dispcap,
                                             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,
@@ -414,7 +414,7 @@ invoke_dispatcher_properties(struct capref dispatcher,
                              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;
@@ -426,7 +426,7 @@ invoke_monitor_get_arch_id(uintptr_t *core_id)
     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,
@@ -443,7 +443,7 @@ static inline errval_t invoke_perfmon_activate(struct capref perfmon_cap,
                                                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;
 }
index f5a2710..8dfb767 100644 (file)
@@ -37,10 +37,10 @@ static inline errval_t lmp_ep_send(struct capref ep, lmp_send_flags_t flags,
                                    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);
 
index b521512..089a834 100644 (file)
@@ -16,7 +16,7 @@
 #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;
 };
 
index 41bccab..c4e2388 100644 (file)
@@ -27,7 +27,7 @@ static inline struct sysret cap_invoke(struct capref to, uintptr_t arg1,
                                        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,
@@ -76,9 +76,9 @@ static inline struct sysret cap_invoke(struct capref to, uintptr_t arg1,
  *
  * \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,
@@ -105,8 +105,8 @@ static inline errval_t invoke_cnode_retype(struct capref root, caddr_t cap,
  *
  * \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)
 {
@@ -132,8 +132,8 @@ static inline errval_t invoke_cnode_mint(struct capref root, caddr_t to,
  *
  * \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,
@@ -152,13 +152,13 @@ static inline errval_t invoke_cnode_copy(struct capref root, caddr_t to,
  *
  * \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;
@@ -233,10 +233,10 @@ invoke_dispatcher(struct capref dispatcher, struct capref domdispatcher,
                   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,
@@ -291,7 +291,7 @@ static inline errval_t invoke_perfmon_activate(struct capref perfmon_cap,
                                                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, 
index 2ae7737..534c390 100644 (file)
@@ -39,7 +39,7 @@ static inline errval_t lmp_ep_send(struct capref ep, lmp_send_flags_t flags,
                                    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
@@ -54,7 +54,7 @@ static inline errval_t lmp_ep_send(struct capref ep, lmp_send_flags_t flags,
 #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 |
index 69dbaf3..cf8b6c8 100644 (file)
@@ -24,7 +24,7 @@
  * \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
@@ -39,7 +39,7 @@ struct cnoderef {
 
 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 }
@@ -78,9 +78,9 @@ static inline uint8_t get_cap_valid_bits(struct capref cap)
 // 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);
@@ -106,7 +106,7 @@ static inline uint8_t get_cnode_valid_bits(struct capref 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);
 }
index d754a28..6cbad8f 100644 (file)
@@ -66,9 +66,9 @@ cap_mint(struct capref dest, struct capref src, uint64_t param1,
          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);
@@ -84,13 +84,13 @@ cap_mint(struct capref dest, struct capref src, uint64_t param1,
  * \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);
@@ -111,9 +111,9 @@ static inline errval_t cap_copy(struct capref dest, struct capref src)
 {
     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);
index 29b97e9..f5c8726 100644 (file)
@@ -93,7 +93,7 @@ void disp_switch(dispatcher_handle_t handle, arch_registers_state_t *from_state,
  * \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);
index d13e1f1..826b0d0 100644 (file)
@@ -27,7 +27,7 @@
  *
  * \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);
index d259c52..cac05e6 100644 (file)
@@ -70,7 +70,7 @@
 /// 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 */
index 1f21026..9c8f5c5 100644 (file)
@@ -76,8 +76,8 @@ union idc_send_header {
         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;
 };
 
index db6107f..5dec2b0 100644 (file)
@@ -23,8 +23,8 @@
 
 /// 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)
index 8c3b9e1..d00f659 100644 (file)
@@ -19,7 +19,7 @@
 #define NBBY            8
 
 /// Capability NULL pointer
-#define CPTR_NULL       ((caddr_t)0)
+#define CPTR_NULL       ((capaddr_t)0)
 
 #ifndef __ASSEMBLER__
 
@@ -58,15 +58,15 @@ typedef genvaddr_t forvaddr_t;
 #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
 
index efd4f58..acaceb0 100644 (file)
@@ -41,13 +41,13 @@ handle_dispatcher_setup(
 
     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);
 }
@@ -110,9 +110,9 @@ handle_mint(
 
     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;
 
@@ -131,9 +131,9 @@ handle_copy(
 
     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;
 
@@ -154,16 +154,16 @@ handle_retype_common(
     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);
 
@@ -192,7 +192,7 @@ handle_delete(
 
     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);
@@ -209,7 +209,7 @@ handle_revoke(
 
     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);
@@ -238,7 +238,7 @@ monitor_handle_register(
 
     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);
 }
@@ -257,7 +257,7 @@ monitor_create_cap(
     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 =
@@ -315,7 +315,7 @@ handle_invoke(arch_registers_state_t *context, int argc)
     //
     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);
 
@@ -338,7 +338,7 @@ handle_invoke(arch_registers_state_t *context, int argc)
             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);
 
@@ -492,7 +492,7 @@ void sys_syscall(arch_registers_state_t* context)
         case SYSCALL_YIELD:
             if (argc == 2)
             {
-                r = sys_yield((caddr_t)sa->arg1);
+                r = sys_yield((capaddr_t)sa->arg1);
             }
             break;
 
index 7d03bf2..c87d07b 100644 (file)
@@ -272,11 +272,11 @@ struct sysret bmp_table_set(struct capability *to, struct idc_recv_msg *msg)
 {\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
index eb04df7..fa72475 100644 (file)
@@ -42,12 +42,12 @@ static struct sysret handle_invocation(struct capability *to,
 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
@@ -81,11 +81,11 @@ static struct sysret handle_retype_common(struct capability *root,
                                           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
@@ -105,9 +105,9 @@ static struct sysret copy_or_mint(struct capability *root,
                                   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
@@ -139,7 +139,7 @@ static struct sysret handle_delete_common(struct capability *root,
                                           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
@@ -154,7 +154,7 @@ static struct sysret handle_revoke_common(struct capability *root,
                                           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
@@ -170,8 +170,8 @@ static struct sysret monitor_handle_retype(struct capability *kernel_cap,
 {\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
@@ -189,8 +189,8 @@ static struct sysret monitor_handle_delete(struct capability *kernel_cap,
 {\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
@@ -208,8 +208,8 @@ static struct sysret monitor_handle_revoke(struct capability *kernel_cap,
 {\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
@@ -224,7 +224,7 @@ static struct sysret monitor_handle_revoke(struct capability *kernel_cap,
 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
@@ -315,7 +315,7 @@ static struct sysret monitor_identify_cap_common(struct capability *kernel_cap,
                                                  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
@@ -333,8 +333,8 @@ static struct sysret monitor_identify_domains_cap(struct capability *kernel_cap,
 {\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
@@ -350,7 +350,7 @@ static struct sysret monitor_remote_cap(struct capability *kernel_cap,
                                         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
@@ -383,7 +383,7 @@ static struct sysret monitor_create_cap(struct capability *kernel_cap,
     }\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
@@ -394,7 +394,7 @@ static struct sysret monitor_create_cap(struct capability *kernel_cap,
 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
@@ -420,7 +420,7 @@ static struct sysret monitor_iden_cnode_get_cap(struct capability *kern_cap,
         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
@@ -449,7 +449,7 @@ static struct sysret handle_frame_identify(struct capability *to,
 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
@@ -465,7 +465,7 @@ static struct sysret handle_trace_setup(struct capability *cap,
     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
@@ -673,9 +673,9 @@ static struct sysret handle_invocation(struct capability *to,
  * 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
@@ -714,7 +714,7 @@ STATIC_ASSERT_SIZEOF(syscalls, (sizeof(void*) * (SYSCALL_COUNT+1)));
 \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
@@ -749,7 +749,7 @@ errval_t sys_lrpc(void)
     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
index e36b9b0..85d2b92 100644 (file)
@@ -497,7 +497,7 @@ errval_t rck_get_route(genpaddr_t base, size_t size, uint8_t *route,
     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;
index 837028c..b2cc055 100644 (file)
@@ -39,7 +39,7 @@ static uint64_t notifytail[MAX_CPUS];
 
 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;
index 86ff78f..a2e75fa 100644 (file)
@@ -408,7 +408,7 @@ static void send_user_interrupt(int irq)
 #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;
index a142857..54ef7b6 100644 (file)
 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);
 
@@ -112,15 +112,15 @@ static struct sysret handle_retype_common(struct capability *root,
                                           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;
 
@@ -142,9 +142,9 @@ static struct sysret copy_or_mint(struct capability *root,
                                   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;
@@ -174,7 +174,7 @@ static struct sysret handle_copy(struct capability *root,
 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);
 }
@@ -188,7 +188,7 @@ static struct sysret handle_revoke_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_revoke(root, cptr, bits, from_monitor);
 }
@@ -218,8 +218,8 @@ static struct sysret monitor_handle_retype(struct capability *kernel_cap,
 
     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,
@@ -238,8 +238,8 @@ static struct sysret monitor_handle_delete(struct capability *kernel_cap,
 {
     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,
@@ -258,8 +258,8 @@ static struct sysret monitor_handle_revoke(struct capability *kernel_cap,
 {
     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,
@@ -275,7 +275,7 @@ static struct sysret monitor_handle_revoke(struct capability *kernel_cap,
 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);
 }
 
@@ -320,7 +320,7 @@ static struct sysret monitor_identify_cap_common(struct capability *kernel_cap,
                                                  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];
 
@@ -338,8 +338,8 @@ static struct sysret monitor_identify_domains_cap(struct capability *kernel_cap,
 {
     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,
@@ -356,7 +356,7 @@ static struct sysret monitor_remote_cap(struct capability *kernel_cap,
                                         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];
 
@@ -377,7 +377,7 @@ static struct sysret monitor_create_cap(struct capability *kernel_cap,
                                         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 =
@@ -398,7 +398,7 @@ static struct sysret monitor_create_cap(struct capability *kernel_cap,
 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);
@@ -431,7 +431,7 @@ static struct sysret monitor_iden_cnode_get_cap(struct capability *kern_cap,
         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
@@ -506,7 +506,7 @@ static struct sysret handle_io(struct capability *to, int cmd, uintptr_t *args)
 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);
@@ -522,7 +522,7 @@ static struct sysret handle_trace_setup(struct capability *cap,
     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)) {
@@ -549,7 +549,7 @@ static struct sysret handle_irq_table_delete(struct capability *to, int cmd, uin
 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));
 }
@@ -575,7 +575,7 @@ static struct sysret kernel_ipi_register(struct capability *cap,
                                          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));
 }
@@ -694,7 +694,7 @@ struct sysret sys_syscall(uintptr_t arg0, uintptr_t arg1, uintptr_t *args,
     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);
@@ -721,7 +721,7 @@ struct sysret sys_syscall(uintptr_t arg0, uintptr_t arg1, uintptr_t *args,
 
             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);
@@ -809,7 +809,7 @@ struct sysret sys_syscall(uintptr_t arg0, uintptr_t arg1, uintptr_t *args,
 
         // 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
index aa9bfa3..4bc62a4 100644 (file)
@@ -435,7 +435,7 @@ static void send_user_interrupt(int irq)
 #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;
index bc38932..c1c5d09 100644 (file)
@@ -41,12 +41,12 @@ extern uint64_t user_stack_save;
 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);
 }
@@ -94,9 +94,9 @@ static struct sysret copy_or_mint(struct capability *root,
                                   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;
@@ -129,7 +129,7 @@ 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);
 }
@@ -145,7 +145,7 @@ static struct sysret handle_revoke_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_revoke(root, cptr, bits, from_monitor);
 }
@@ -171,8 +171,8 @@ static struct sysret monitor_handle_retype(struct capability *kernel_cap,
 {
     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,
@@ -191,8 +191,8 @@ static struct sysret monitor_handle_delete(struct capability *kernel_cap,
 {
     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,
@@ -211,8 +211,8 @@ static struct sysret monitor_handle_revoke(struct capability *kernel_cap,
 {
     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,
@@ -228,7 +228,7 @@ static struct sysret monitor_handle_revoke(struct capability *kernel_cap,
 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);
 }
 
@@ -261,7 +261,7 @@ static struct sysret monitor_identify_cap_common(struct capability *kernel_cap,
                                                  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];
 
@@ -279,8 +279,8 @@ static struct sysret monitor_identify_domains_cap(struct capability *kernel_cap,
 {
     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,
@@ -298,7 +298,7 @@ static struct sysret monitor_remote_cap(struct capability *kernel_cap,
                                         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];
 
@@ -330,7 +330,7 @@ static struct sysret monitor_create_cap(struct capability *kernel_cap,
     }
 
     /* 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];
 
@@ -342,7 +342,7 @@ static struct sysret monitor_create_cap(struct capability *kernel_cap,
 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);
@@ -364,7 +364,7 @@ static struct sysret monitor_iden_cnode_get_cap(struct capability *kern_cap,
         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
@@ -410,10 +410,10 @@ handle_dispatcher_setup_guest (struct capability *to, int cmd, uintptr_t *args)
     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();
@@ -496,7 +496,7 @@ handle_dispatcher_setup_guest (struct capability *to, int cmd, uintptr_t *args)
 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);
@@ -512,7 +512,7 @@ static struct sysret handle_trace_setup(struct capability *cap,
     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)) {
@@ -548,7 +548,7 @@ static struct sysret kernel_ipi_register(struct capability *cap,
                                          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));
 }
@@ -587,7 +587,7 @@ static struct sysret performance_counter_activate(struct capability *cap,
     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;
@@ -724,7 +724,7 @@ struct sysret sys_syscall(uint64_t syscall, uint64_t arg0, uint64_t arg1,
     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;
@@ -840,7 +840,7 @@ struct sysret sys_syscall(uint64_t syscall, uint64_t arg0, uint64_t arg1,
 
         // 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
index fbfeb98..2b47d3a 100644 (file)
@@ -573,7 +573,7 @@ static errval_t caps_create(enum objtype type, lpaddr_t lpaddr, uint8_t bits,
  *
  * \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 */
@@ -609,7 +609,7 @@ errval_t caps_lookup_slot(struct capability *cnode_cap, caddr_t cptr,
     }
 
     /* 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"
@@ -652,7 +652,7 @@ errval_t caps_lookup_slot(struct capability *cnode_cap, caddr_t cptr,
 /**
  * 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;
@@ -670,7 +670,7 @@ errval_t caps_lookup_cap(struct capability *cnode_cap, caddr_t cptr,
  * 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)
 {
index f55de94..9839d93 100644 (file)
@@ -262,7 +262,7 @@ void __attribute__ ((noreturn)) dispatch(struct dcb *dcb)
  * \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 */
@@ -455,7 +455,7 @@ errval_t lmp_deliver_payload(struct capability *ep, struct dcb *send,
  */
 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);
index 20cb482..d512941 100644 (file)
@@ -17,7 +17,7 @@ void rck_init(void);
 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);
index f1a5abe..f8b2bd9 100644 (file)
@@ -10,7 +10,7 @@
 #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);
index 182561c..0611c4f 100644 (file)
@@ -203,7 +203,7 @@ struct task_state_segment {
 
 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
index 999f79f..df0d6d2 100644 (file)
@@ -151,7 +151,7 @@ struct task_state_segment {
 
 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
index 30ec2a5..334f8ca 100644 (file)
@@ -50,7 +50,7 @@ static inline struct cte *caps_locate_slot(lpaddr_t cnode, cslot_t offset)
 
 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,
@@ -75,10 +75,10 @@ errval_t is_retypeable(struct cte *src_cte,
 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);
index ef86409..025672a 100644 (file)
@@ -77,7 +77,7 @@ errval_t lmp_deliver_payload(struct capability *ep, struct dcb *send,
                              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)
index c79f169..2e8c8ef 100644 (file)
 #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
index 88c6b14..8126969 100644 (file)
@@ -39,8 +39,8 @@ errval_t sys_print(const char *str, size_t length)
 
 /* 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);
@@ -212,8 +212,8 @@ sys_dispatcher_properties(struct capability *to,
  * \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;
@@ -251,8 +251,8 @@ sys_retype(struct capability *root, caddr_t source_cptr, enum objtype type,
  * 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;
@@ -289,7 +289,7 @@ sys_copy_or_mint(struct capability *root, caddr_t destcn_cptr, cslot_t dest_slot
     }
 }
 
-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;
@@ -303,7 +303,7 @@ struct sysret sys_delete(struct capability *root, caddr_t cptr, uint8_t bits,
     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;
@@ -317,7 +317,7 @@ struct sysret sys_revoke(struct capability *root, caddr_t cptr, uint8_t bits,
     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;
@@ -335,7 +335,7 @@ struct sysret sys_monitor_register(caddr_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 capability *cap;
@@ -352,7 +352,7 @@ struct sysret sys_monitor_identify_cap(struct capability *root,
     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;
@@ -371,7 +371,7 @@ struct sysret sys_monitor_nullify_cap(caddr_t cptr, uint8_t bits)
     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;
@@ -387,7 +387,7 @@ struct sysret sys_monitor_domain_id(caddr_t cptr, domainid_t domain_id)
     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 =
index 7e2116e..ff64ba6 100644 (file)
@@ -155,7 +155,7 @@ void disp_switch(dispatcher_handle_t handle,
  */
 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);
index a5ecf53..217c8d2 100644 (file)
@@ -29,7 +29,7 @@ errval_t sys_print(const char* string, size_t length)
     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;
index 43966c9..e9e6b0f 100644 (file)
@@ -140,7 +140,7 @@ void disp_switch(dispatcher_handle_t handle, arch_registers_state_t *from_state,
  * \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
index 3109287..d4a0baa 100644 (file)
@@ -22,7 +22,7 @@
 #include <asmoffsets.h>
 
 /*
- * extern errval_t sys_yield(caddr_t target);
+ * extern errval_t sys_yield(capaddr_t target);
  */
        .globl _sys_yield
 _sys_yield:
@@ -60,7 +60,7 @@ _sys_print:
 /*
  * 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
index 2b38cb2..2348023 100644 (file)
@@ -22,7 +22,7 @@
 
 #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;
index 2e37d22..46fdfe9 100644 (file)
@@ -198,7 +198,7 @@ void disp_switch(dispatcher_handle_t handle, arch_registers_state_t *from_state,
  * \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);
index e499e2b..eafda46 100644 (file)
@@ -98,7 +98,7 @@ errval_t sys_debug_feign_frame_cap(struct capref slot, lpaddr_t base,
                                    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;
index c4396e9..d60c0dd 100644 (file)
@@ -23,7 +23,7 @@
 // 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;
 }
index c6dad42..a7fcf56 100644 (file)
@@ -215,7 +215,7 @@ void
 __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);
index b5821d8..b314362 100644 (file)
@@ -20,7 +20,7 @@
 /* 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;
 }
index 641ebf4..d3734d7 100644 (file)
@@ -159,8 +159,8 @@ static inline bool backoff(int count)
  * 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();
@@ -191,7 +191,7 @@ static errval_t cap_retype_remote(caddr_t src, enum objtype new_type,
  * 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;
@@ -218,7 +218,7 @@ static errval_t cap_delete_remote(caddr_t src, uint8_t vbits)
  * 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;
@@ -256,9 +256,9 @@ errval_t cap_retype(struct capref dest_start, struct capref src,
     // 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);
@@ -284,7 +284,7 @@ errval_t cap_delete(struct capref cap)
 {
     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);
 
@@ -308,7 +308,7 @@ errval_t cap_revoke(struct capref cap)
 {
     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);
 
index 448d51e..17a6b8b 100644 (file)
@@ -227,7 +227,7 @@ static void walk_cspace(struct cnoderef cnode, uint8_t level)
     }
 
     // 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);
 
index 52f4ca3..b4464b3 100644 (file)
@@ -240,7 +240,7 @@ get_cryptodev_ciphers(const int **cnids)
                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)
@@ -280,7 +280,7 @@ get_cryptodev_digests(const int **cnids)
                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;
@@ -373,14 +373,14 @@ cryptodev_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
        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);
@@ -431,7 +431,7 @@ cryptodev_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
        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;
 
@@ -731,9 +731,9 @@ static int cryptodev_digest_update(EVP_MD_CTX *ctx, const void *data,
        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);
@@ -764,7 +764,7 @@ static int cryptodev_digest_final(EVP_MD_CTX *ctx, unsigned char *md)
                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");
@@ -909,7 +909,7 @@ bn2crparam(const BIGNUM *a, struct crparam *crp)
                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++) {
@@ -1162,7 +1162,7 @@ cryptodev_dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
        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;
@@ -1202,7 +1202,7 @@ cryptodev_dsa_verify(const unsigned char *dgst, int dlen,
        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;
@@ -1280,7 +1280,7 @@ cryptodev_dh_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
                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;
 
index 52f4ca3..b4464b3 100644 (file)
@@ -240,7 +240,7 @@ get_cryptodev_ciphers(const int **cnids)
                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)
@@ -280,7 +280,7 @@ get_cryptodev_digests(const int **cnids)
                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;
@@ -373,14 +373,14 @@ cryptodev_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
        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);
@@ -431,7 +431,7 @@ cryptodev_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
        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;
 
@@ -731,9 +731,9 @@ static int cryptodev_digest_update(EVP_MD_CTX *ctx, const void *data,
        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);
@@ -764,7 +764,7 @@ static int cryptodev_digest_final(EVP_MD_CTX *ctx, unsigned char *md)
                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");
@@ -909,7 +909,7 @@ bn2crparam(const BIGNUM *a, struct crparam *crp)
                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++) {
@@ -1162,7 +1162,7 @@ cryptodev_dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
        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;
@@ -1202,7 +1202,7 @@ cryptodev_dsa_verify(const unsigned char *dgst, int dlen,
        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;
@@ -1280,7 +1280,7 @@ cryptodev_dh_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
                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;
 
index 3831a57..e4f196b 100644 (file)
@@ -168,11 +168,11 @@ static int dev_crypto_cipher(EVP_CIPHER_CTX *ctx,unsigned char *out,
     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);
@@ -333,9 +333,9 @@ static int do_digest(int ses,unsigned char *md,const void *data,int 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)
        {
index 3831a57..e4f196b 100644 (file)
@@ -168,11 +168,11 @@ static int dev_crypto_cipher(EVP_CIPHER_CTX *ctx,unsigned char *out,
     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);
@@ -333,9 +333,9 @@ static int do_digest(int ses,unsigned char *md,const void *data,int 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)
        {
index 0d7534a..aebfb63 100644 (file)
 >           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
 
index ed18960..f078dad 100644 (file)
@@ -36,7 +36,7 @@ invoke_monitor_spawn_core(coreid_t core_id, enum cpu_type cpu_type,
                           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,
@@ -44,10 +44,10 @@ invoke_monitor_spawn_core(coreid_t core_id, enum cpu_type 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,
@@ -55,12 +55,12 @@ invoke_monitor_identify_cap(caddr_t cap, int bits, struct capability *out)
 }
 
 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,
@@ -68,20 +68,20 @@ invoke_monitor_identify_domains_cap(caddr_t root_cap, int 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,
@@ -89,11 +89,11 @@ invoke_monitor_create_cap(uint64_t *raw, caddr_t caddr, int bits, caddr_t 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)
@@ -108,14 +108,14 @@ static inline errval_t
 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");
@@ -138,9 +138,9 @@ invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, caddr_t slot,
 }
 
 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);
@@ -149,12 +149,12 @@ invoke_monitor_remote_cap_retype(caddr_t rootcap_addr, uint8_t rootcap_vbits,
 }
 
 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,
@@ -162,12 +162,12 @@ invoke_monitor_remote_cap_delete(caddr_t rootcap_addr, uint8_t rootcap_vbits,
 }
 
 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,
@@ -210,7 +210,7 @@ invoke_monitor_rck_delete(struct capref kern_cap, int chanid)
 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,
@@ -223,7 +223,7 @@ invoke_monitor_get_arch_id(uintptr_t *arch_id)
     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)
index a3c1554..250fe4f 100644 (file)
@@ -47,7 +47,7 @@ invoke_monitor_spawn_core(coreid_t core_id, enum cpu_type 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)
 {
     struct idc_send_msg msg;
 
@@ -61,7 +61,7 @@ invoke_monitor_identify_cap(caddr_t cap, int bits, struct capability *out)
 }
 
 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;
 
@@ -74,7 +74,7 @@ invoke_monitor_nullify_cap(caddr_t cap, int 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)
 {
     struct idc_send_msg msg;
 
@@ -89,7 +89,7 @@ invoke_monitor_create_cap(uint64_t *raw, caddr_t caddr, int bits, caddr_t 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)
 {
     struct idc_send_msg msg;
@@ -117,7 +117,7 @@ invoke_monitor_register(struct capref ep)
 }
 
 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");
@@ -168,8 +168,8 @@ invoke_domain_id(struct capref cap, uint64_t domain_id)
 #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;
@@ -186,9 +186,9 @@ invoke_monitor_identify_domains_cap(caddr_t root_cap, int root_bits,
 }
 
 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;
@@ -210,8 +210,8 @@ invoke_monitor_remote_cap_retype(caddr_t rootcap_addr, uint8_t rootcap_vbits,
 
 
 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;
     
@@ -226,8 +226,8 @@ invoke_monitor_remote_cap_delete(caddr_t rootcap_addr, uint8_t rootcap_vbits,
 }
 
 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;
 
index 6f8dfe3..159f5d2 100644 (file)
@@ -37,7 +37,7 @@ invoke_monitor_spawn_core(coreid_t core_id, enum cpu_type cpu_type,
                           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,
@@ -45,10 +45,10 @@ invoke_monitor_spawn_core(coreid_t core_id, enum cpu_type 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,
@@ -56,12 +56,12 @@ invoke_monitor_identify_cap(caddr_t cap, int bits, struct capability *out)
 }
 
 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,
@@ -69,20 +69,20 @@ invoke_monitor_identify_domains_cap(caddr_t root_cap, int 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,
@@ -90,11 +90,11 @@ invoke_monitor_create_cap(uint64_t *raw, caddr_t caddr, int bits, caddr_t 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)
@@ -109,14 +109,14 @@ static inline errval_t
 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");
@@ -139,15 +139,15 @@ invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, caddr_t slot,
 }
 
 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);
@@ -164,12 +164,12 @@ invoke_monitor_remote_cap_retype(caddr_t rootcap_addr, uint8_t rootcap_vbits,
 }
 
 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, 
@@ -177,12 +177,12 @@ invoke_monitor_remote_cap_delete(caddr_t rootcap_addr, uint8_t rootcap_vbits,
 }
 
 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, 
@@ -232,7 +232,7 @@ static inline errval_t
 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,
@@ -244,7 +244,7 @@ static inline errval_t
 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,
@@ -254,7 +254,7 @@ invoke_monitor_ipi_delete(int chanid)
 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,
index 0c224dc..e814466 100644 (file)
@@ -35,15 +35,15 @@ invoke_monitor_spawn_core(coreid_t core_id, enum cpu_type 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)
 {
     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,  
@@ -52,13 +52,13 @@ invoke_monitor_identify_domains_cap(caddr_t root_cap, int root_bits,
 
 
 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,
@@ -70,7 +70,7 @@ invoke_monitor_cap_remote(caddr_t cap, int bits, bool is_remote,
 }
 
 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);
@@ -86,7 +86,7 @@ invoke_monitor_register(struct capref ep)
 }
 
 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,
@@ -95,9 +95,9 @@ invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, caddr_t slot,
 
 
 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,
@@ -105,15 +105,15 @@ invoke_monitor_remote_cap_retype(caddr_t rootcap_addr, uint8_t rootcap_vbits,
 }
 
 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;
 }
index 101e93e..e13565b 100644 (file)
@@ -38,7 +38,7 @@ errval_t monitor_cap_identify(struct capref cap, struct capability *out)
     }
 
     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);
 }
 
@@ -52,13 +52,13 @@ errval_t monitor_cap_identify(struct capref cap, struct capability *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,
@@ -77,7 +77,7 @@ errval_t monitor_cap_remote(struct capref cap, bool is_remote,
                             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);
 }
 
@@ -87,7 +87,7 @@ errval_t monitor_cap_remote(struct capref cap, bool is_remote,
 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);
 }
 
@@ -122,7 +122,7 @@ errval_t monitor_cap_create(struct capref dest, struct capability *cap,
 #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;
 
@@ -134,7 +134,7 @@ errval_t monitor_cap_create(struct capref dest, struct capability *cap,
  * 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);
@@ -153,12 +153,12 @@ errval_t monitor_identify_cnode_get_cap(struct capability *cnode_raw,
  * 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);
@@ -169,10 +169,10 @@ errval_t monitor_retype_remote_cap(struct capref croot, caddr_t src,
  * 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);
@@ -183,10 +183,10 @@ errval_t monitor_delete_remote_cap(struct capref croot, caddr_t src, int 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);
index 78adaca..3f8e67f 100644 (file)
@@ -119,20 +119,20 @@ routeid_t mon_allocate_route_id(void);
 /* 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 */
index a0a7547..ad0f152 100644 (file)
@@ -22,11 +22,11 @@ struct retype_st {
     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;
 };
 
@@ -34,7 +34,7 @@ struct delete_st {
     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;
 };
 
@@ -42,7 +42,7 @@ struct revoke_st {
     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;
 };
 
@@ -70,13 +70,13 @@ static void remote_cap_revoke_phase_2(void * st_arg);
     && __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;
@@ -117,10 +117,10 @@ static void free_retype_st(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
 {
@@ -158,10 +158,10 @@ static void free_delete_st(struct delete_st * st)
     && __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
 {
@@ -200,9 +200,9 @@ static void free_revoke_st(struct revoke_st * st)
 
 
 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;
@@ -284,7 +284,7 @@ static void remote_cap_retype_phase_2(void * st_arg)
 
 
 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;
 
@@ -345,7 +345,7 @@ static void remote_cap_delete_phase_2(void * st_arg)
 
 
 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 */
index 798e8e7..a1b988f 100644 (file)
@@ -530,7 +530,7 @@ errval_t rcap_db_remote_revoke (struct capability * cap, coreid_t from_core)
 
     // 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));
 
index e90a48c..e747431 100644 (file)
@@ -75,7 +75,7 @@ extern char   *sbrk();
 #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
@@ -186,7 +186,7 @@ _retry_map_:
            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)
            {
@@ -236,14 +236,14 @@ _retry_map_:
        } 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;
@@ -266,7 +266,7 @@ _retry_map_:
            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,
index 30ef6db..ac0be97 100644 (file)
@@ -74,7 +74,7 @@ extern void   exit(int);
 #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
@@ -189,7 +189,7 @@ _sigsegv_handler(int sig)
 {
     int                addr_state_save;
     int                map_flags, map_prot;
-    caddr_t            map_result;
+    capaddr_t          map_result;
 #ifdef HAVE_SIGPROCMASK
     sigset_t   sig_mask;
 
@@ -218,7 +218,7 @@ _sigsegv_handler(int sig)
 #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,
@@ -232,7 +232,7 @@ _sigsegv_handler(int sig)
            *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);
index 7329c85..d472980 100644 (file)
@@ -169,7 +169,7 @@ _unmap_at(char *addr,       /* page-aligned */
            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
@@ -178,7 +178,7 @@ _unmap_at(char *addr,       /* page-aligned */
            (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
@@ -199,7 +199,7 @@ _unmap_at(char *addr,       /* page-aligned */
        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
@@ -428,7 +428,7 @@ alloc_stack_pairs(int nstacks, char **names, uword *bytes, struct stack_struct *
            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
@@ -457,7 +457,7 @@ alloc_stack_pairs(int nstacks, char **names, uword *bytes, struct stack_struct *
            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,