Make x86_32 compile; some of the monitor invocations are disabled right now.
authorSimon Gerber <simon.gerber@inf.ethz.ch>
Tue, 25 Mar 2014 14:36:50 +0000 (15:36 +0100)
committerSimon Gerber <simon.gerber@inf.ethz.ch>
Tue, 25 Mar 2014 14:37:40 +0000 (15:37 +0100)
18 files changed:
if/intermon.if
include/arch/x86_32/barrelfish/invocations_arch.h
include/arch/x86_32/barrelfish/syscall_arch.h
include/barrelfish/core_state.h
include/target/x86_32/barrelfish_kpi/registers_target.h
kernel/arch/x86_32/startup_arch.c
kernel/arch/x86_32/syscall.c
kernel/cap_delete.c
lib/barrelfish/arch/x86_32/sys_debug.c
usr/monitor/capops/capsend.c
usr/monitor/capops/copy.c
usr/monitor/capops/delete.c
usr/monitor/capops/internal.h
usr/monitor/capops/move.c
usr/monitor/capops/retrieve.c
usr/monitor/capops/retype.c
usr/monitor/capops/revoke.c
usr/monitor/include/arch/x86_32/monitor_invocations_arch.h

index 929210a..48487e3 100644 (file)
@@ -165,7 +165,7 @@ interface intermon "The Interface between monitors" {
     message capops_revoke_done(capop_st st);
 
     // XXX: uint32 for bits? -MN
-    message capops_request_retype(caprep src, int desttype, uint32 destbits, capop_st st);
+    message capops_request_retype(caprep src, uint32 desttype, uint32 destbits, capop_st st);
     message capops_retype_response(errval status, capop_st st);
 
     // ownership / relation messages
index f4a3c81..32e44b6 100644 (file)
  * If you do not find this file, copies can be found by writing to:
  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
  */
+#ifndef INVOCATIONS_ARCH_H
+#define INVOCATIONS_ARCH_H
 
 #include <barrelfish/syscall_arch.h>
 #include <barrelfish_kpi/dispatcher_shared.h>
+#include <barrelfish_kpi/distcaps.h>            // for distcap_state_t
+#include <barrelfish_kpi/syscalls.h>
 #include <barrelfish/caddr.h>
 #include <barrelfish/debug.h>
 
+
+/**
+ * capability invocation syscall wrapper, copied from x86_64 version
+ */
+static inline struct sysret cap_invoke(struct capref to, uintptr_t arg1,
+                                       uintptr_t arg2, uintptr_t arg3,
+                                       uintptr_t arg4, uintptr_t arg5,
+                                       uintptr_t arg6)
+{
+    uint8_t invoke_bits = get_cap_valid_bits(to);
+    capaddr_t invoke_cptr = get_cap_addr(to) >> (CPTR_BITS - invoke_bits);
+
+    // invoke_bits << 16 | cmd << 8 | syscall_invoke
+    uint32_t invocation = ((invoke_bits << 16) | (arg1 << 8) | SYSCALL_INVOKE);
+
+    return syscall(invocation, invoke_cptr, arg2, arg3, arg4, arg5, arg6);
+}
+
+#define cap_invoke6(to, _a, _b, _c, _d, _e, _f)        \
+    cap_invoke(to, _a, _b, _c, _d, _e, _f)
+#define cap_invoke5(to, _a, _b, _c, _d, _e)            \
+    cap_invoke6(to, _a, _b, _c, _d, _e, 0)
+#define cap_invoke4(to, _a, _b, _c, _d)                \
+    cap_invoke5(to, _a, _b, _c, _d, 0)
+#define cap_invoke3(to, _a, _b, _c)                    \
+    cap_invoke4(to, _a, _b, _c, 0)
+#define cap_invoke2(to, _a, _b)                        \
+    cap_invoke3(to, _a, _b, 0)
+#define cap_invoke1(to, _a)                            \
+    cap_invoke2(to, _a, 0)
+
 /**
  * \brief Retype a capability.
  *
@@ -220,6 +255,28 @@ static inline errval_t invoke_cnode_revoke(struct capref root, capaddr_t cap,
                     invoke_cptr, cap, bits).error;
 }
 
+static inline errval_t invoke_cnode_get_state(struct capref root, capaddr_t cap,
+                                              int bits, distcap_state_t *ret)
+{
+    uint8_t invoke_bits = get_cap_valid_bits(root);
+    capaddr_t invoke_cptr = get_cap_addr(root) >> (CPTR_BITS - invoke_bits);
+
+    assert (bits <= 0xff);
+
+    struct sysret sysret =
+        syscall4((invoke_bits << 16) | (CNodeCmd_GetState << 8) | SYSCALL_INVOKE,
+                invoke_cptr, cap, bits);
+
+    assert(ret != NULL);
+    if (err_is_ok(sysret.error)) {
+        *ret = sysret.value;
+    }
+    else {
+        *ret = 0;
+    }
+    return sysret.error;
+}
+
 // XXX: workaround for an inlining bug in gcc 4.3.4
 #if defined(__GNUC__) \
     && __GNUC__ == 4 && __GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ <= 4
@@ -582,3 +639,4 @@ static inline errval_t invoke_idcap_identify(struct capref idcap,
 
     return sysret.error;
 }
+#endif // INVOCATIONS_ARCH_H
index a8afbe6..9830e56 100644 (file)
@@ -15,6 +15,8 @@
 #ifndef ARCH_X86_32_BARRELFISH_SYSCALL_H
 #define ARCH_X86_32_BARRELFISH_SYSCALL_H
 
+#include <barrelfish_kpi/syscalls.h>  // for struct sysret.
+
 /* Always review the generated assembly when changing this! */
 // XXX: noinline for now, until I figured out why GCC doesn't obey the asm
 // constraints
index 7b603da..5672f46 100644 (file)
@@ -23,6 +23,7 @@
 #include <barrelfish/thread_sync.h>
 #include <barrelfish_kpi/paging_arch.h>
 #include <barrelfish_kpi/capabilities.h>
+#include <barrelfish_kpi/init.h> // for CNODE_SLOTS_*
 
 /* DELETEME! I can't find anything that uses this -AB 20120110 */
 #if 0
index b6e43b3..33f4ce3 100644 (file)
@@ -16,7 +16,8 @@
 #ifndef TARGET_X86_32_BARRELFISH_KPI_REGISTERS_H
 #define TARGET_X86_32_BARRELFISH_KPI_REGISTERS_H
 
-#include <barrelfish_kpi/types.h> // for lvaddr_t
+#include <barrelfish_kpi/eflags_arch.h> // for USER_EFLAGS
+#include <barrelfish_kpi/types.h>       // for lvaddr_t
 
 /** \brief Number of registers to be saved for this architecture
  *
index da8fa7f..22c88fb 100644 (file)
@@ -327,21 +327,21 @@ static void init_page_tables(struct spawn_state *st, alloc_phys_func alloc_phys)
     // Map PDPTE into first slot in pagecn
     caps_create_new(ObjType_VNode_x86_32_pdpt,
                     mem_to_local_phys((lvaddr_t)init_pdpte),
-                    BASE_PAGE_BITS, 0,
+                    BASE_PAGE_BITS, 0, my_core_id,
                     caps_locate_slot(CNODE(st->pagecn), pagecn_pagemap++));
 #endif
     // Map PDIR into successive slots in pagecn
     for(size_t i = 0; i < INIT_PDIR_SIZE; i++) {
         caps_create_new(ObjType_VNode_x86_32_pdir,
                         mem_to_local_phys((lvaddr_t)init_pdir) + i * BASE_PAGE_SIZE,
-                        BASE_PAGE_BITS, 0,
+                        BASE_PAGE_BITS, 0, my_core_id,
                         caps_locate_slot(CNODE(st->pagecn), pagecn_pagemap++));
     }
     // Map page tables into successive slots in pagecn
     for(size_t i = 0; i < INIT_PTABLE_SIZE; i++) {
         caps_create_new(ObjType_VNode_x86_32_ptable,
                         mem_to_local_phys((lvaddr_t)init_ptable) + i * BASE_PAGE_SIZE,
-                        BASE_PAGE_BITS, 0,
+                        BASE_PAGE_BITS, 0, my_core_id,
                         caps_locate_slot(CNODE(st->pagecn), pagecn_pagemap++));
     }
     // Connect all page tables to page directories.
@@ -434,7 +434,7 @@ static struct dcb *spawn_init_common(struct spawn_state *st, const char *name,
 
     // Map IO cap in task cnode
     struct cte *iocap = caps_locate_slot(CNODE(st->taskcn), TASKCN_SLOT_IO);
-    err = caps_create_new(ObjType_IO, 0, 0, 0, iocap);
+    err = caps_create_new(ObjType_IO, 0, 0, 0, my_core_id, iocap);
     assert(err_is_ok(err));
 
     /* Set fields in DCB */
@@ -606,7 +606,8 @@ struct dcb *spawn_app_init(struct x86_core_data *core_data,
     // XXX: Create as devframe so the memory is not zeroed out
     err = caps_create_new(ObjType_DevFrame, core_data->urpc_frame_base,
                           core_data->urpc_frame_bits,
-                          core_data->urpc_frame_bits, urpc_frame_cte);
+                          core_data->urpc_frame_bits, core_data->src_core_id,
+                          urpc_frame_cte);
     assert(err_is_ok(err));
     urpc_frame_cte->cap.type = ObjType_Frame;
     lpaddr_t urpc_ptr = gen_phys_to_local_phys(urpc_frame_cte->cap.u.frame.base);
index 4247b97..cdfc582 100644 (file)
@@ -185,32 +185,19 @@ static struct sysret handle_copy(struct capability *root,
     return copy_or_mint(root, args, false);
 }
 
-static struct sysret handle_delete_common(struct capability *root,
-                                          uintptr_t *args, bool from_monitor)
-{
-    capaddr_t cptr = args[0];
-    int bits     = args[1];
-    return sys_delete(root, cptr, bits, from_monitor);
-}
-
 static struct sysret handle_delete(struct capability *root, int cmd, uintptr_t *args)
 {
-    return  handle_delete_common(root, args, false);
-}
-
-static struct sysret handle_revoke_common(struct capability *root,
-                                          uintptr_t *args,
-                                          bool from_monitor)
-{
     capaddr_t cptr = args[0];
     int bits     = args[1];
-    return sys_revoke(root, cptr, bits, from_monitor);
+    return  sys_delete(root, cptr, bits);
 }
 
 static struct sysret handle_revoke(struct capability *root,
                                    int cmd, uintptr_t *args)
 {
-    return  handle_revoke_common(root, args, false);
+    capaddr_t cptr = args[0];
+    int bits     = args[1];
+    return  sys_revoke(root, cptr, bits);
 }
 
 static struct sysret handle_map(struct capability *pgtable,
@@ -250,71 +237,6 @@ static struct sysret handle_unmap(struct capability *pgtable,
     return SYSRET(err);
 }
 
-/// Different handler for cap operations performed by the monitor
-static struct sysret monitor_handle_retype(struct capability *kernel_cap,
-                                           int cmd, uintptr_t *args)
-{
-    errval_t err;
-
-    struct remote_retype_syscall_overflow * overflow =
-        (struct remote_retype_syscall_overflow *) args[0];
-
-    assert(overflow != NULL);
-
-    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,
-                          &root, CAPRIGHTS_READ);
-    if (err_is_fail(err)) {
-        return SYSRET(err_push(err, SYS_ERR_ROOT_CAP_LOOKUP));
-    }
-
-    /* XXX: conceal first word of arguments */
-    return handle_retype_common(root, &args[1], true);
-}
-
-/// Different handler for cap operations performed by the monitor
-static struct sysret monitor_handle_delete(struct capability *kernel_cap,
-                                           int cmd, uintptr_t *args)
-{
-    errval_t err;
-
-    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,
-                          &root, CAPRIGHTS_READ);
-    if (err_is_fail(err)) {
-        return SYSRET(err_push(err, SYS_ERR_ROOT_CAP_LOOKUP));
-    }
-
-    /* XXX: conceal first two words of arguments */
-    return handle_delete_common(root, &args[2], true);
-}
-
-/// Different handler for cap operations performed by the monitor
-static struct sysret monitor_handle_revoke(struct capability *kernel_cap,
-                                           int cmd, uintptr_t *args)
-{
-    errval_t err;
-
-    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,
-                          &root, CAPRIGHTS_READ);
-    if (err_is_fail(err)) {
-        return SYSRET(err_push(err, SYS_ERR_ROOT_CAP_LOOKUP));
-    }
-
-    /* XXX: conceal first two words of arguments */
-    return handle_revoke_common(root, &args[2], true);
-}
-
 static struct sysret monitor_handle_register(struct capability *kernel_cap,
                                              int cmd, uintptr_t *args)
 {
@@ -412,27 +334,6 @@ static struct sysret monitor_identify_domains_cap(struct capability *kernel_cap,
     return monitor_identify_cap_common(kernel_cap, root, &args[2]);
 }
 
-static struct sysret monitor_remote_cap(struct capability *kernel_cap,
-                                        int cmd, uintptr_t *args)
-{
-    struct capability *root = &dcb_current->cspace.cap;
-    capaddr_t cptr = args[0];
-    int bits = args[1];
-    bool remote = (bool)args[2];
-
-    struct cte *cte;
-    errval_t err = caps_lookup_slot(root, cptr, bits, &cte, CAPRIGHTS_WRITE);
-    if (err_is_fail(err)) {
-        return SYSRET(err_push(err, SYS_ERR_IDENTIFY_LOOKUP));
-    }
-
-    set_cap_remote(cte, remote);
-    bool has_desc = has_descendants(cte);
-
-    return (struct sysret){ .error = SYS_ERR_OK, .value = has_desc };
-}
-
-
 static struct sysret monitor_create_cap(struct capability *kernel_cap,
                                         int cmd, uintptr_t *args)
 {
@@ -459,7 +360,7 @@ static struct sysret monitor_create_cap(struct capability *kernel_cap,
 
     return SYSRET(caps_create_from_existing(&dcb_current->cspace.cap,
                                             cnode_cptr, cnode_vbits,
-                                            slot, src));
+                                            slot, owner, src));
 }
 
 static struct sysret monitor_nullify_cap(struct capability *kernel_cap,
@@ -769,16 +670,12 @@ static invocation_handler_t invocations[ObjType_Num][CAP_MAX_CMD] = {
         [KernelCmd_Get_arch_id]  = monitor_get_arch_id,
         [KernelCmd_Identify_cap] = monitor_identify_cap,
         [KernelCmd_Identify_domains_cap] = monitor_identify_domains_cap,
-        [KernelCmd_Remote_cap]   = monitor_remote_cap,
         [KernelCmd_Iden_cnode_get_cap] = monitor_iden_cnode_get_cap,
         [KernelCmd_Create_cap]   = monitor_create_cap,
         [KernelCmd_Nullify_cap]  = monitor_nullify_cap,
         [KernelCmd_Setup_trace]  = handle_trace_setup,
         [KernelCmd_Register]     = monitor_handle_register,
         [KernelCmd_Domain_Id]    = monitor_handle_domain_id,
-        [MonitorCmd_Retype]      = monitor_handle_retype,
-        [MonitorCmd_Delete]      = monitor_handle_delete,
-        [MonitorCmd_Revoke]      = monitor_handle_revoke,
         [KernelCmd_Sync_timer]   = monitor_handle_sync_timer,
 #ifdef __scc__
         [KernelCmd_Spawn_SCC_Core]   = monitor_spawn_scc_core,
@@ -867,7 +764,7 @@ struct sysret sys_syscall(uintptr_t arg0, uintptr_t arg1, uintptr_t *args,
 
             // try to deliver message
             retval.error = lmp_deliver(to, dcb_current, &args[1], length_words,
-                                       send_cptr, send_bits);
+                                       args[0], send_cptr, send_bits);
 
             /* Switch to reciever upon successful delivery with sync flag,
              * or (some cases of) unsuccessful delivery with yield flag */
@@ -1023,7 +920,7 @@ struct sysret sys_syscall(uintptr_t arg0, uintptr_t arg1, uintptr_t *args,
                                         recv_slot);
 
                 retval.error = caps_create_new(ObjType_DevFrame, args[1], bits,
-                        bits, slot);
+                        bits, my_core_id, slot);
             }
             break;
 
index a800598..840043e 100644 (file)
@@ -301,7 +301,7 @@ static void caps_mark_revoke_copy(struct cte *cte)
     if (err_is_fail(err)) {
         // this should not happen as there is a copy of the cap
         panic("error while marking/deleting cap copy for revoke:"
-              " 0x%"PRIxGENPADDR"\n", err);
+              " 0x%"PRIuERRV"\n", err);
     }
 }
 
@@ -347,7 +347,7 @@ static void caps_mark_revoke_generic(struct cte *cte)
     else if (err_is_fail(err)) {
         // some serious mojo went down in the cleanup voodoo
         panic("error while marking/deleting descendant cap for revoke:"
-              " 0x%"PRIxGENPADDR"\n", err);
+              " 0x%"PRIuERRV"\n", err);
     }
 }
 
@@ -380,7 +380,7 @@ errval_t caps_delete_foreigns(struct cte *cte)
         err = cleanup_copy(next);
         if (err_is_fail(err)) {
             panic("error while deleting foreign copy for remote_delete:"
-                  " 0x%"PRIxGENPADDR"\n", err);
+                  " 0x%"PRIuERRV"\n", err);
         }
     }
 
@@ -396,7 +396,7 @@ errval_t caps_delete_foreigns(struct cte *cte)
     err = caps_try_delete(cte);
     if (err_is_fail(err)) {
         panic("error while deleting foreign copy for remote_delete:"
-              " 0x%"PRIxGENPADDR"\n", err);
+              " 0x%"PRIuERRV"\n", err);
     }
 
     return SYS_ERR_OK;
index eafda46..d6ffc9c 100644 (file)
@@ -94,6 +94,12 @@ errval_t sys_debug_set_breakpoint(uintptr_t addr, uint8_t mode, uint8_t length)
                     DEBUG_SET_BREAKPOINT, addr, mode, length).error;
 }
 
+errval_t sys_debug_cap_trace_ctrl(bool enable, genpaddr_t start, gensize_t size)
+{
+    return syscall5(SYSCALL_DEBUG,
+                    DEBUG_TRACE_PMEM_CTRL, enable, start, size).error;
+}
+
 errval_t sys_debug_feign_frame_cap(struct capref slot, lpaddr_t base,
                                    uint8_t bits)
 {
index cf4b251..03b31e7 100644 (file)
@@ -220,7 +220,7 @@ struct find_cap_broadcast_st {
 static errval_t
 find_cap_broadcast_send_cont(struct intermon_binding *b, intermon_caprep_t *caprep, struct capsend_mc_st *st)
 {
-    return intermon_capops_find_cap__tx(b, NOP_CONT, *caprep, (genvaddr_t)st);
+    return intermon_capops_find_cap__tx(b, NOP_CONT, *caprep, (uintptr_t)st);
 }
 
 errval_t
@@ -326,7 +326,8 @@ void
 find_cap_result__rx_handler(struct intermon_binding *b, errval_t result, genvaddr_t st)
 {
     // if we receive a positive result, immediately forward to caller
-    struct find_cap_broadcast_st *fc_bc_st = (struct find_cap_broadcast_st*)st;
+    lvaddr_t lst = (lvaddr_t)st;
+    struct find_cap_broadcast_st *fc_bc_st = (struct find_cap_broadcast_st*)lst;
     if (err_is_ok(result)) {
         if (!fc_bc_st->found) {
             fc_bc_st->found = true;
@@ -363,7 +364,8 @@ struct find_descendants_mc_st {
 static errval_t
 find_descendants_send_cont(struct intermon_binding *b, intermon_caprep_t *caprep, struct capsend_mc_st *mc_st)
 {
-    return intermon_capops_find_descendants__tx(b, NOP_CONT, *caprep, (genvaddr_t)mc_st);
+    lvaddr_t lst = (lvaddr_t)mc_st;
+    return intermon_capops_find_descendants__tx(b, NOP_CONT, *caprep, (genvaddr_t)lst);
 }
 
 errval_t
@@ -447,7 +449,8 @@ find_descendants__rx_handler(struct intermon_binding *b, intermon_caprep_t capre
 void
 find_descendants_result__rx_handler(struct intermon_binding *b, errval_t status, genvaddr_t st)
 {
-    struct find_descendants_mc_st *mc_st = (struct find_descendants_mc_st*)st;
+    lvaddr_t lst = (lvaddr_t) st;
+    struct find_descendants_mc_st *mc_st = (struct find_descendants_mc_st*)lst;
 
     if (err_is_ok(status)) {
         // found result
@@ -485,7 +488,8 @@ struct update_owner_broadcast_st {
 static errval_t
 update_owner_broadcast_send_cont(struct intermon_binding *b, intermon_caprep_t *caprep, struct capsend_mc_st *bc_st)
 {
-    return intermon_capops_update_owner__tx(b, NOP_CONT, *caprep, (genvaddr_t)bc_st);
+    lvaddr_t lst = (lvaddr_t)bc_st;
+    return intermon_capops_update_owner__tx(b, NOP_CONT, *caprep, (genvaddr_t)lst);
 }
 
 errval_t
@@ -556,7 +560,8 @@ owner_updated(coreid_t owner, genvaddr_t st)
 void
 owner_updated__rx_handler(struct intermon_binding *b, genvaddr_t st)
 {
-    struct update_owner_broadcast_st *uo_bc_st = (struct update_owner_broadcast_st*)st;
+    lvaddr_t lst = (lvaddr_t)st;
+    struct update_owner_broadcast_st *uo_bc_st = (struct update_owner_broadcast_st*)lst;
     if (!capsend_handle_mc_reply(&uo_bc_st->bc)) {
         // broadcast is not complete
         return;
index b8bf681..83ff49a 100644 (file)
@@ -139,7 +139,7 @@ owner_copy_send__rdy(struct intermon_binding *b,
 {
     DEBUG_CAPOPS("owner_copy_send__rdy: ->%p, %p\n", b, e);
     struct owner_copy_msg_st *msg_st = (struct owner_copy_msg_st*)e;
-    struct cap_copy_rpc_st *rpc_st = (struct cap_copy_rpc_st*)(msg_st->st);
+    struct cap_copy_rpc_st *rpc_st = (struct cap_copy_rpc_st*)((lvaddr_t)msg_st->st);
     assert(rpc_st);
     errval_t err;
 
@@ -172,7 +172,7 @@ owner_copy__enq(struct capref capref, struct capability *cap, coreid_t from,
     if (err_is_fail(err)) {
         // rpc_st hasn't been set up so we have to do failure handling manually
         if (from == my_core_id) {
-            result_handler(err, 0, 0, 0, (void*)st);
+            result_handler(err, 0, 0, 0, (void*)(lvaddr_t)st);
         }
         else {
             err2 = recv_copy_result__enq(from, err, 0, 0, 0, st);
@@ -256,7 +256,7 @@ null_shortcircuit:
     msg_st->queue_elem.cont = owner_copy_send__rdy;
     capability_to_caprep(cap, &msg_st->caprep);
     msg_st->owner_relations = remote_relations;
-    msg_st->st = (genvaddr_t)rpc_st;
+    msg_st->st = (lvaddr_t)rpc_st;
 
     // enqueue message
     err = capsend_target(dest, (struct msg_queue_elem*)msg_st);
@@ -296,7 +296,7 @@ request_copy_send__rdy(struct intermon_binding *b,
     struct request_copy_msg_st *msg_st = (struct request_copy_msg_st*)e;
     err = intermon_capops_request_copy__tx(b, NOP_CONT, msg_st->dest,
                                            msg_st->caprep,
-                                           (genvaddr_t)msg_st->st);
+                                           (lvaddr_t)msg_st->st);
     if (err_is_fail(err)) {
         assert(msg_st->st);
         struct cap_copy_rpc_st *rpc_st = (struct cap_copy_rpc_st*)msg_st->st;
@@ -328,7 +328,7 @@ request_copy__enq(struct capref capref, coreid_t dest, bool give_away,
         result_handler(err, 0, 0, 0, st);
         return;
     }
-    rpc_st->st = (genvaddr_t)st;
+    rpc_st->st = (lvaddr_t)st;
     rpc_st->from = my_core_id;
     rpc_st->delete_after = give_away;
     rpc_st->is_last = false;
@@ -416,7 +416,7 @@ recv_copy_result__src(errval_t status, capaddr_t capaddr, uint8_t vbits,
     // call result handler
     DEBUG_CAPOPS("result_handler: %p\n", rpc_st->result_handler);
     if (rpc_st->result_handler) {
-        rpc_st->result_handler(status, capaddr, vbits, slot, (void*)rpc_st->st);
+        rpc_st->result_handler(status, capaddr, vbits, slot, (void*)((lvaddr_t)rpc_st->st));
     }
 
     free(rpc_st);
@@ -432,7 +432,7 @@ recv_copy_result__rx(struct intermon_binding *b, errval_t status,
 {
     assert(st);
     DEBUG_CAPOPS("recv_copy_result__rx: %p, %s\n", b, err_getstring(status));
-    struct cap_copy_rpc_st *rpc_st = (struct cap_copy_rpc_st*)st;
+    struct cap_copy_rpc_st *rpc_st = (struct cap_copy_rpc_st*)((lvaddr_t)st);
     rpc_st->recv_handler(status, capaddr, vbits, slot, rpc_st);
 }
 
@@ -605,7 +605,7 @@ capops_copy(struct capref capref, coreid_t dest, bool give_away,
         memset(&cap, sizeof(cap), 0);
         cap.type = ObjType_Null;
         owner_copy__enq(capref, &cap, my_core_id, dest, give_away,
-                result_handler, (genvaddr_t)st);
+                result_handler, (lvaddr_t)st);
         return;
     }
 
@@ -651,7 +651,7 @@ capops_copy(struct capref capref, coreid_t dest, bool give_away,
 
         // sending copy from here/owner
         owner_copy__enq(capref, &cap, my_core_id, dest, give_away,
-                        result_handler, (genvaddr_t)st);
+                        result_handler, (lvaddr_t)st);
     }
 
     return;
index c4995b3..474b06b 100644 (file)
@@ -142,7 +142,7 @@ delete_remote__send(struct intermon_binding *b, intermon_caprep_t *caprep,
                     struct capsend_mc_st *st)
 {
     return intermon_capops_delete_remote__tx(b, NOP_CONT, *caprep,
-                                             (genvaddr_t)st);
+                                             (lvaddr_t)st);
 }
 
 static void
@@ -236,7 +236,7 @@ delete_remote_result__rx(struct intermon_binding *b, errval_t status,
                          genvaddr_t st)
 {
     errval_t err;
-    struct delete_remote_mc_st *mc_st = (struct delete_remote_mc_st*)st;
+    struct delete_remote_mc_st *mc_st = (struct delete_remote_mc_st*)(lvaddr_t)st;
     struct delete_st *del_st = mc_st->del_st;
 
     // XXX: do something with received errors?
index cc01eb1..6c8ebd7 100644 (file)
@@ -97,7 +97,7 @@ void retrieve_result__rx(struct intermon_binding *b,
                          errval_t status, uint8_t relations,
                          genvaddr_t st);
 void retype_request__rx(struct intermon_binding *b, intermon_caprep_t srcrep,
-                        int desttype, uint32_t destbits, genvaddr_t st);
+                        uint32_t desttype, uint32_t destbits, genvaddr_t st);
 void retype_response__rx(struct intermon_binding *b, errval_t status,
                                  genvaddr_t st);
 void revoke_mark__rx(struct intermon_binding *b,
index 86c8255..aa5fe98 100644 (file)
@@ -46,7 +46,7 @@ move_request_send_cont(struct intermon_binding *b, struct intermon_msg_queue_ele
 {
     errval_t err;
     struct move_request_msg_st *msg_st = (struct move_request_msg_st*)e;
-    err = intermon_capops_move_request__tx(b, NOP_CONT, msg_st->caprep, msg_st->relations, (genvaddr_t)msg_st->st);
+    err = intermon_capops_move_request__tx(b, NOP_CONT, msg_st->caprep, msg_st->relations, (lvaddr_t)msg_st->st);
     if (err_is_fail(err)) {
         struct cap_move_rpc_st *rpc_st = (struct cap_move_rpc_st*)msg_st->st;
         if (rpc_st->result_handler) {
@@ -236,7 +236,7 @@ move_result__rx_handler(struct intermon_binding *b, errval_t status, genvaddr_t
     struct intermon_state *inter_st = (struct intermon_state*)b->st;
     coreid_t from = inter_st->core_id;
     assert(from != my_core_id);
-    struct cap_move_rpc_st *rpc_st = (struct cap_move_rpc_st*)st;
+    struct cap_move_rpc_st *rpc_st = (struct cap_move_rpc_st*)(lvaddr_t)st;
 
     caplock_unlock(rpc_st->capref);
     rpc_st->result_handler(status, rpc_st->st);
index 72f0291..332fb37 100644 (file)
@@ -127,7 +127,7 @@ retrieve_owner__send(struct intermon_binding *b,
     GOTO_IF_ERR(err, report_error);
 
     capability_to_caprep(&st->rawcap, &caprep);
-    err = intermon_capops_retrieve_request__tx(b, NOP_CONT, caprep, (genvaddr_t)st);
+    err = intermon_capops_retrieve_request__tx(b, NOP_CONT, caprep, (lvaddr_t)st);
     GOTO_IF_ERR(err, report_error);
 
     return;
@@ -227,7 +227,7 @@ retrieve_result__rx(struct intermon_binding *b, errval_t status,
                     uint8_t relations, genvaddr_t st)
 {
     errval_t err;
-    struct retrieve_rpc_st *rst = (struct retrieve_rpc_st*)st;
+    struct retrieve_rpc_st *rst = (struct retrieve_rpc_st*)(lvaddr_t)st;
 
     if (err_is_fail(status)) {
         err = status;
index ea76360..d1601ab 100644 (file)
@@ -139,7 +139,7 @@ retype_request_check__rx(errval_t status, void *st)
 
 void
 retype_request__rx(struct intermon_binding *b, intermon_caprep_t srcrep,
-                   int desttype, uint32_t destbits, genvaddr_t st)
+                   uint32_t desttype, uint32_t destbits, genvaddr_t st)
 {
     errval_t err;
 
@@ -200,7 +200,7 @@ retype_result__rx(errval_t status, struct retype_request_st *req_st)
 void
 retype_response__rx(struct intermon_binding *b, errval_t status, genvaddr_t st)
 {
-    struct retype_request_st *req_st = (struct retype_request_st*)st;
+    struct retype_request_st *req_st = (struct retype_request_st*)(lvaddr_t)st;
     retype_result__rx(status, req_st);
 }
 
@@ -216,7 +216,7 @@ retype_request__send(struct intermon_binding *b, struct intermon_msg_queue_elem
     err = intermon_capops_request_retype__tx(b, NOP_CONT, req_st->caprep,
                                              req_st->check.type,
                                              req_st->check.objbits,
-                                             (genvaddr_t)req_st);
+                                             (lvaddr_t)req_st);
 
     if (err_is_fail(err)) {
         retype_result__rx(err, req_st);
index b8fe695..ca5c308 100644 (file)
@@ -164,7 +164,7 @@ revoke_mark__send(struct intermon_binding *b,
     ptrdiff_t off = offsetof(struct revoke_master_st, revoke_mc_st);
     st = (struct revoke_master_st*)((char*)mc_st - off);
     return intermon_capops_revoke_mark__tx(b, NOP_CONT, *caprep,
-                                           (genvaddr_t)st);
+                                           (lvaddr_t)st);
 }
 
 void
@@ -229,7 +229,7 @@ revoke_ready__rx(struct intermon_binding *b, genvaddr_t st)
 {
     errval_t err;
 
-    struct revoke_master_st *rvk_st = (struct revoke_master_st*)st;
+    struct revoke_master_st *rvk_st = (struct revoke_master_st*)(lvaddr_t)st;
     if (!capsend_handle_mc_reply(&rvk_st->revoke_mc_st)) {
         // multicast not complete
         return;
@@ -253,7 +253,7 @@ revoke_commit__send(struct intermon_binding *b,
     struct revoke_master_st *st;
     ptrdiff_t off = offsetof(struct revoke_master_st, revoke_mc_st);
     st = (struct revoke_master_st*)((char*)mc_st - off);
-    return intermon_capops_revoke_commit__tx(b, NOP_CONT, (genvaddr_t)st);
+    return intermon_capops_revoke_commit__tx(b, NOP_CONT, (lvaddr_t)st);
 }
 
 void
@@ -337,7 +337,7 @@ void
 revoke_done__rx(struct intermon_binding *b,
                 genvaddr_t st)
 {
-    struct revoke_master_st *rvk_st = (struct revoke_master_st*)st;
+    struct revoke_master_st *rvk_st = (struct revoke_master_st*)(lvaddr_t)st;
     if (!capsend_handle_mc_reply(&rvk_st->revoke_mc_st)) {
         // multicast not complete
         return;
index 41fcde1..2f9fe49 100644 (file)
 
 #include <barrelfish/syscall_arch.h>
 #include <barrelfish/caddr.h>
+#include <barrelfish/invocations_arch.h>
 #include <barrelfish_kpi/syscall_overflows_arch.h>
+#include <barrelfish_kpi/cpu.h>
+#include <barrelfish_kpi/syscalls.h>
  
 /**
  * \brief Spawn a new core.
@@ -45,6 +48,34 @@ invoke_monitor_spawn_core(coreid_t core_id, enum cpu_type cpu_type,
 }
 
 static inline errval_t
+invoke_monitor_remote_relations(capaddr_t root_cap, int root_bits,
+                                capaddr_t cap, int bits,
+                                uint8_t relations, uint8_t mask,
+                                uint8_t *ret_remote_relations)
+{
+    struct sysret r = cap_invoke6(cap_kernel, KernelCmd_Remote_relations,
+                                  root_cap, root_bits, cap, bits,
+                                  ((uint16_t)relations) | (((uint16_t)mask)<<8));
+    if (err_is_ok(r.error) && ret_remote_relations) {
+        *ret_remote_relations = r.value;
+    }
+    return r.error;
+}
+
+static inline errval_t
+invoke_monitor_cap_has_relations(capaddr_t caddr, uint8_t bits, uint8_t mask,
+                                 uint8_t *res)
+{
+    assert(res);
+    struct sysret ret = cap_invoke4(cap_kernel, KernelCmd_Cap_has_relations,
+                                    caddr, bits, mask);
+    if (err_is_ok(ret.error)) {
+        *res = ret.value;
+    }
+    return ret.error;
+}
+
+static inline errval_t
 invoke_monitor_identify_cap(capaddr_t cap, int bits, struct capability *out)
 {
     uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
@@ -91,22 +122,6 @@ invoke_monitor_create_cap(uint64_t *raw, capaddr_t caddr, int bits,
 }
 
 static inline errval_t
-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);
-    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)
-                 | SYSCALL_INVOKE, invoke_cptr, cap, bits, is_remote);
-    if (err_is_ok(r.error)) {
-        *has_descendents = r.value;
-    }
-    return r.error;
-}
-
-static inline errval_t
 invoke_monitor_register(struct capref ep)
 {
     uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
@@ -139,103 +154,6 @@ invoke_monitor_identify_cnode_get_cap(uint64_t *cnode_raw, capaddr_t slot,
 #endif
 }
 
-static inline errval_t
-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);
-    capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
-    
-    assert(newtype <= 0xffff);
-    assert(objbits <= 0xff);
-    assert(bits <= 0xff);
-
-    struct remote_retype_syscall_overflow rootcap_struct = {
-        .rootcap_addr = rootcap_addr,
-        .rootcap_vbits = rootcap_vbits,
-    }; 
-
-    return syscall7(invoke_bits << 16 | (MonitorCmd_Retype << 8)
-                    | SYSCALL_INVOKE, invoke_cptr, (uintptr_t)&rootcap_struct,
-                    src, (newtype << 16) | (objbits << 8) | bits, to, slot).error;
-}
-
-static inline errval_t
-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);
-    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, 
-                    rootcap_vbits, src, bits).error;
-}
-
-static inline errval_t
-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);
-    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, 
-                    rootcap_vbits, src, bits).error;
-}
-
-static inline errval_t
-invoke_monitor_get_cap_owner(capaddr_t cap, int bits, coreid_t *res)
-{
-    assert(res);
-    uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
-    capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
-
-    struct sysret sysret;
-    sysret = syscall3((invoke_bits << 16) | (KernelCmd_Get_cap_owner << 8)
-                      | SYSCALL_INVOKE, invoke_cptr, cap, bits);
-    if (err_is_ok(sysret.error)) {
-        *res = sysret.value;
-    }
-    return sysret.error;
-}
-
-static inline errval_t
-invoke_monitor_set_cap_owner(capaddr_t cap, int bits, coreid_t owner)
-{
-    uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
-    capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
-
-    return syscall4((invoke_bits << 16) | (KernelCmd_Set_cap_owner << 8)
-                    | SYSCALL_INVOKE, invoke_cptr, cap, bits, owner).error;
-}
-
-static inline errval_t
-invoke_monitor_lock_cap(capaddr_t cap, int bits)
-{
-    uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
-    capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
-
-    return syscall3((invoke_bits << 16) | (KernelCmd_Lock_cap << 8)
-                    | SYSCALL_INVOKE, invoke_cptr, cap, bits).error;
-}
-
-static inline errval_t
-invoke_monitor_unlock_cap(capaddr_t cap, int bits)
-{
-    uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
-    capaddr_t invoke_cptr = get_cap_addr(cap_kernel) >> (CPTR_BITS - invoke_bits);
-
-    return syscall3((invoke_bits << 16) | (KernelCmd_Unlock_cap << 8)
-                    | SYSCALL_INVOKE, invoke_cptr, cap, bits).error;
-}
-
 /**
  * \brief Set up tracing in the kernel
  *
@@ -323,4 +241,124 @@ static inline errval_t invoke_monitor_spawn_scc_core(uint8_t id,
 }
 #endif
 
+static inline errval_t
+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) {
+    USER_PANIC("NYI");
+#if 0
+    return cap_invoke9(cap_kernel, KernelCmd_Retype, rootcap_addr, 
+                       rootcap_vbits, src, newtype, objbits, to, slot,
+                       bits).error;
+#endif
+}
+
+static inline errval_t
+invoke_monitor_copy_existing(uint64_t *raw, capaddr_t cn_addr, int cn_bits, cslot_t slot)
+{
+    USER_PANIC("NYI");
+#if 0
+    assert(sizeof(struct capability) == 4*sizeof(uint64_t));
+    return cap_invoke8(cap_kernel, KernelCmd_Copy_existing,
+                       raw[0], raw[1], raw[2], raw[3],
+                       cn_addr, cn_bits, slot).error;
+#endif
+}
+
+static inline errval_t
+invoke_monitor_get_cap_owner(capaddr_t root, int rbits, capaddr_t cap, int cbits, coreid_t *ret_owner)
+{
+    struct sysret sysret = cap_invoke5(cap_kernel, KernelCmd_Get_cap_owner,
+                                       root, rbits, cap, cbits);
+    if (err_is_ok(sysret.error)) {
+        *ret_owner = sysret.value;
+    }
+    return sysret.error;
+}
+
+static inline errval_t
+invoke_monitor_set_cap_owner(capaddr_t root, int rbits, capaddr_t cap, int cbits, coreid_t owner)
+{
+    return cap_invoke6(cap_kernel, KernelCmd_Set_cap_owner, root, rbits, cap, cbits, owner).error;
+}
+
+static inline errval_t
+invoke_monitor_lock_cap(capaddr_t root, int rbits, capaddr_t cap, int cbits)
+{
+    return cap_invoke5(cap_kernel, KernelCmd_Lock_cap, root, rbits, cap, cbits).error;
+}
+
+static inline errval_t
+invoke_monitor_unlock_cap(capaddr_t root, int rbits, capaddr_t cap, int cbits)
+{
+    return cap_invoke5(cap_kernel, KernelCmd_Unlock_cap, root, rbits, cap, cbits).error;
+}
+
+static inline errval_t
+invoke_monitor_delete_last(capaddr_t root, int rbits, capaddr_t cap, int cbits,
+                           capaddr_t retcn, int retcnbits, cslot_t retslot)
+{
+    USER_PANIC("NYI");
+#if 0
+    return cap_invoke8(cap_kernel, KernelCmd_Delete_last, root, rbits, cap,
+                       cbits, retcn, retcnbits, retslot).error;
+#endif
+}
+
+static inline errval_t
+invoke_monitor_delete_foreigns(capaddr_t cap, int bits)
+{
+    return cap_invoke3(cap_kernel, KernelCmd_Delete_foreigns, cap, bits).error;
+}
+
+static inline errval_t
+invoke_monitor_revoke_mark_target(capaddr_t root, int rbits,
+                                  capaddr_t cap, int cbits)
+{
+    return cap_invoke5(cap_kernel, KernelCmd_Revoke_mark_target,
+                       root, rbits, cap, cbits).error;
+}
+
+static inline errval_t
+invoke_monitor_revoke_mark_relations(uint64_t *raw_base)
+{
+    assert(sizeof(struct capability) % sizeof(uint64_t) == 0);
+    assert(sizeof(struct capability) / sizeof(uint64_t) == 4);
+    return cap_invoke5(cap_kernel, KernelCmd_Revoke_mark_relations,
+                       raw_base[0], raw_base[1],
+                       raw_base[2], raw_base[3]).error;
+}
+
+static inline errval_t
+invoke_monitor_delete_step(capaddr_t retcn, int retcnbits, cslot_t retslot)
+{
+    return cap_invoke4(cap_kernel, KernelCmd_Delete_step,
+                       retcn, retcnbits, retslot).error;
+}
+
+static inline errval_t
+invoke_monitor_clear_step(capaddr_t retcn, int retcnbits, cslot_t retslot)
+{
+    return cap_invoke4(cap_kernel, KernelCmd_Clear_step,
+                       retcn, retcnbits, retslot).error;
+}
+
+static inline errval_t
+invoke_monitor_has_descendants(uint64_t *raw, bool *res)
+{
+    USER_PANIC("NYI");
+#if 0
+    assert(sizeof(struct capability) % sizeof(uint64_t) == 0);
+    assert(sizeof(struct capability) / sizeof(uint64_t) == 4);
+    struct sysret sysret;
+    sysret = cap_invoke5(cap_kernel, KernelCmd_Has_descendants,
+                         raw[0], raw[1], raw[2], raw[3]);
+    if (err_is_ok(sysret.error)) {
+        *res = sysret.value;
+    }
+    return sysret.error;
+#endif
+}
+
 #endif