T274: armv8: update monitor invocations and cleanup changes
authorSimon Gerber <simon.gerber@inf.ethz.ch>
Fri, 5 Aug 2016 12:46:40 +0000 (14:46 +0200)
committerSimon Gerber <simon.gerber@inf.ethz.ch>
Fri, 5 Aug 2016 12:52:30 +0000 (14:52 +0200)
Closes T274.

Signed-off-by: Simon Gerber <simon.gerber@inf.ethz.ch>

include/arch/aarch64/barrelfish/lmp_chan_arch.h
kernel/arch/armv8/startup_arch.c
kernel/arch/armv8/syscall.c
lib/barrelfish/arch/aarch64/pmap_arch.c
lib/barrelfish/arch/aarch64/sys_debug.c
lib/spawndomain/arch/aarch64/spawn_arch.c
usr/acpi/arch/armv8/acpi_main.c
usr/monitor/include/arch/aarch64/monitor_invocations_arch.h
usr/monitor/include/monitor_invocations.h

index 5c3e665..8625b9f 100644 (file)
@@ -44,16 +44,16 @@ lmp_ep_send(
     uintptr_t arg4
     )
 {
-    uint8_t invoke_bits = get_cap_valid_bits(ep);
-    capaddr_t invoke_cptr = get_cap_addr(ep) >> (CPTR_BITS - invoke_bits);
+    uint8_t invoke_level = get_cap_level(ep);
+    capaddr_t invoke_cptr = get_cap_addr(ep);
 
-    uint8_t send_bits = get_cap_valid_bits(send_cap);
-    capaddr_t send_cptr = get_cap_addr(send_cap) >> (CPTR_BITS - send_bits);
+    uint8_t send_level = get_cap_level(send_cap);
+    capaddr_t send_cptr = get_cap_addr(send_cap);
 
     assert(length_words <= LMP_MSG_LENGTH);
 
     return syscall7((length_words << 28) | ((flags & 0xf) << 24) |
-                    (invoke_bits << 16) | (send_bits << 8) | SYSCALL_INVOKE,
+                    (invoke_level << 16) | (send_level << 8) | SYSCALL_INVOKE,
                     invoke_cptr, send_cptr,
                     arg1, arg2, arg3, arg4).error;
 }
index a2df66f..248eeb6 100644 (file)
@@ -373,7 +373,7 @@ void create_module_caps(struct spawn_state *st)
         assert((base_addr & BASE_PAGE_MASK) == 0);
         assert((remain & BASE_PAGE_MASK) == 0);
 
-        assert(st->modulecn_slot < (1U << st->modulecn->cap.u.cnode.bits));
+        assert(st->modulecn_slot < cnode_get_slots(&st->modulecn->cap));
         // create as DevFrame cap to avoid zeroing memory contents
         err = caps_create_new(ObjType_DevFrame, base_addr, remain,
                               remain, my_core_id,
index e0de7c2..0e1ecc2 100644 (file)
@@ -145,12 +145,12 @@ static struct sysret copy_or_mint(struct capability *root,
     capaddr_t source_croot_ptr = args->arg5;
     capaddr_t source_cptr      = args->arg6;
     uint8_t destcn_level       = args->arg7;
-    uint8_t source_level       = args->arg8;
+    uint8_t source_level       = args->x8;
     uint64_t param1, param2;
     // params only sent if mint operation
     if (mint) {
-        param1 = args->arg9;
-        param2 = args->arg10;
+        param1 = args->x9;
+        param2 = args->x10;
     } else {
         param1 = param2 = 0;
     }
@@ -211,11 +211,11 @@ handle_retype_common(
     // number of new objects
     size_t count               = sa->arg7;
     // Destination cspace cptr
-    capaddr_t dest_cspace_cptr = sa->arg8;
+    capaddr_t dest_cspace_cptr = sa->x8;
     // Destination cnode cptr
-    capaddr_t dest_cnode_cptr  = sa->arg9;
+    capaddr_t dest_cnode_cptr  = sa->x9;
     // Destination slot number
-    capaddr_t dest_slot        = sa->arg10;
+    capaddr_t dest_slot        = sa->x10;
     // Level of destination cnode in destination cspace
     uint8_t dest_cnode_level   = (word >> 16) & 0xF;
 
@@ -267,7 +267,7 @@ handle_create(
     capaddr_t    dest_cptr = sa->arg4;
     uint8_t      dest_level= sa->arg5;
     cslot_t      dest_slot = sa->arg6;
-    printk(LOG_NOTE, "type = %d, bits = %d\n", type, bits);
+    printk(LOG_NOTE, "type = %d, bytes = %zu\n", type, objsize);
 
     return sys_create(root, type, objsize, dest_cptr, dest_level, dest_slot);
 }
@@ -307,32 +307,48 @@ handle_get_state(
 }
 
 static struct sysret
+handle_resize(
+    struct capability* root,
+    arch_registers_state_t* context,
+    int argc
+    )
+{
+    INVOCATION_PRELUDE(5);
+
+    capaddr_t newroot_ptr = sa->arg2;
+    capaddr_t retcn_ptr   = sa->arg3;
+    cslot_t   retslot     = sa->arg4;
+
+    return sys_resize_l1cnode(root, newroot_ptr, retcn_ptr, retslot);
+}
+
+static struct sysret
 handle_map(
     struct capability *ptable,
     arch_registers_state_t *context,
     int argc
     )
 {
-    assert(8 == argc);
+    assert(10 == argc);
 
     struct registers_aarch64_syscall_args* sa = &context->syscall_args;
 
     /* Retrieve arguments */
-    capaddr_t source_cptr   = (capaddr_t)sa->arg2;
-    capaddr_t dest_slot     = ((capaddr_t)sa->arg3) >> 16;
-    int       source_vbits  = ((int)sa->arg3) & 0xff;
-    uintptr_t flags         = (uintptr_t)sa->arg4;
-    uintptr_t offset        = (uintptr_t)sa->arg5;
-    uintptr_t pte_count     = (uintptr_t)sa->arg6;
-    uintptr_t *extra        = (uintptr_t*)sa->arg7;
-    capaddr_t mcn_addr      = extra[0];
-    int       mcn_vbits     = (int)extra[1];
-    cslot_t   mapping_slot  = (cslot_t)extra[2];
-
-
-
-    return sys_map(ptable, dest_slot, source_cptr, source_vbits,
-                   flags, offset, pte_count, mcn_addr, mcn_vbits,
+    capaddr_t source_root_cptr = (capaddr_t)sa->arg2;
+    capaddr_t source_cptr      = (capaddr_t)sa->arg3;
+    uintptr_t flags            = (uintptr_t)sa->arg4;
+    uintptr_t offset           = (uintptr_t)sa->arg5;
+    uintptr_t pte_count        = (uintptr_t)sa->arg6;
+    capaddr_t mcn_root         = (capaddr_t)sa->arg7;
+    capaddr_t mcn_addr         = (capaddr_t)sa->x8;
+    uint32_t  word             = sa->x9;
+    uint8_t   source_level     = word & 0xF;
+    uint8_t   mcn_level        = (word >> 4) & 0xF;
+    cslot_t   mapping_slot     = (word >> 8) & 0xFF;
+    cslot_t   slot             = (word >> 16) & 0xFFFF;
+
+    return sys_map(ptable, slot, source_root_cptr, source_cptr, source_level,
+                   flags, offset, pte_count, mcn_root, mcn_addr, mcn_level,
                    mapping_slot);
 }
 
@@ -407,23 +423,8 @@ handle_mapping_modify(
 /// Different handler for cap operations performed by the monitor
 INVOCATION_HANDLER(monitor_handle_retype)
 {
-    INVOCATION_PRELUDE(8);
-    errval_t err;
-
-    /* lookup root cap for retype:
-     * sa->arg7 is (rootcap_addr | (rootcap_vbits << 32)) */
-    capaddr_t rootcap_addr = sa->arg7 & 0xFFFFFFFF;
-    uint8_t rootcap_vbits = (sa->arg7 >> 32) & 0xFF;
-    struct capability *root;
-    err = caps_lookup_cap(&dcb_current->cspace.cap, rootcap_addr,
-            rootcap_vbits, &root, CAPRIGHTS_READ);
-    if (err_is_fail(err)) {
-        return SYSRET(err_push(err, SYS_ERR_ROOT_CAP_LOOKUP));
-    }
-
-    /* XXX: this hides the last argument which retype_common doesn't know
-     * about */
-    return handle_retype_common(root, true, context, 8);
+    assert(argc == 11);
+    return handle_retype_common(&dcb_current->cspace.cap, true, context, argc);
 }
 
 INVOCATION_HANDLER(monitor_handle_has_descendants)
@@ -633,19 +634,20 @@ INVOCATION_HANDLER(monitor_remote_relations)
 
 INVOCATION_HANDLER(monitor_copy_existing)
 {
-    INVOCATION_PRELUDE(6);
-    capaddr_t cnode_cptr = sa->arg2;
-    int cnode_vbits    = sa->arg3;
-    size_t slot        = sa->arg4;
+    INVOCATION_PRELUDE(7);
+    capaddr_t croot_cptr = sa->arg2;
+    capaddr_t cnode_cptr = sa->arg3;
+    int cnode_level      = sa->arg4;
+    size_t slot          = sa->arg5;
 
     // user pointer to src cap, check access
-    if (!access_ok(ACCESS_READ, sa->arg5, sizeof(struct capability))) {
+    if (!access_ok(ACCESS_READ, sa->arg6, sizeof(struct capability))) {
         return SYSRET(SYS_ERR_INVALID_USER_BUFFER);
     }
     /* Get the raw metadata of the capability to create from user pointer */
-    struct capability *src = (struct capability *)sa->arg5;
+    struct capability *src = (struct capability *)sa->arg6;
 
-    return sys_monitor_copy_existing(src, cnode_cptr, cnode_vbits, slot);
+    return sys_monitor_copy_existing(src, croot_cptr, cnode_cptr, cnode_level, slot);
 }
 
 INVOCATION_HANDLER(monitor_nullify_cap)
index 81e50b9..64d5e4c 100644 (file)
@@ -713,7 +713,8 @@ static errval_t do_single_modify_flags(struct pmap_aarch64 *pmap, genvaddr_t vad
                 // new set of flags with cap permissions.
                 size_t off = ptentry - page->entry;
                 uintptr_t pmap_flags = vregion_flags_to_kpi_paging_flags(flags);
-                err = invoke_mapping_modify_flags(page->mapping, off, pages, pmap_flags);
+                // VA hinting NYI on ARMv8, always passing 0
+                err = invoke_mapping_modify_flags(page->mapping, off, pages, pmap_flags, 0);
                 printf("invoke_frame_modify_flags returned error: %s (%"PRIuERRV")\n",
                         err_getstring(err), err);
                 return err;
index d937805..28ec71b 100644 (file)
@@ -38,11 +38,11 @@ errval_t sys_debug_hardware_timer_read(uintptr_t* v)
 
 errval_t sys_debug_create_irq_src_cap(struct capref cap, uint16_t gsi)
 {
-    uint8_t dcn_vbits = get_cnode_valid_bits(cap);
+    uint8_t dcn_level = get_cnode_level(cap);
     capaddr_t dcn_addr = get_cnode_addr(cap);
 
     struct sysret sr = syscall6(SYSCALL_DEBUG, DEBUG_CREATE_IRQ_SRC_CAP,
-                                dcn_vbits, dcn_addr, cap.slot, gsi);
+                                dcn_level, dcn_addr, cap.slot, gsi);
     return sr.error;
 }
 
index d87d488..6c79ed0 100644 (file)
@@ -163,10 +163,20 @@ errval_t spawn_arch_load(struct spawninfo *si,
         .cnode = si->rootcn,
         .slot  = ROOTCN_SLOT_SEGCN,
     };
-    err = cnode_create_raw(cnode_cap, &si->segcn, DEFAULT_CNODE_SLOTS, NULL);
+    struct capref local_cnode_cap;
+    // XXX: this code assumes that elf_load never needs more than 256 slots for
+    // text frame capabilities.
+    err = cnode_create_l2(&local_cnode_cap, &si->segcn);
+
     if (err_is_fail(err)) {
         return err_push(err, SPAWN_ERR_CREATE_SEGCN);
     }
+    // Copy SegCN into new domain's cspace
+    err = cap_copy(cnode_cap, local_cnode_cap);
+    if (err_is_fail(err)) {
+        return err_push(err, SPAWN_ERR_MINT_SEGCN);
+    }
+
 
     // TLS is NYI
     si->tls_init_base = 0;
index db2dbaf..29bf355 100644 (file)
@@ -75,7 +75,7 @@ static errval_t init_allocators(void)
      * for me with a large framebuffer... -AB 20110810 */
     err = mm_init(&pci_mm_physaddr, ObjType_DevFrame, 0, PADDR_SPACE_SIZE_BITS,
                   1, slab_default_refill, slot_alloc_dynamic,
-                  &devframes_allocator, false);
+                  slot_refill_dynamic, &devframes_allocator, false);
     if (err_is_fail(err)) {
         return err_push(err, MM_ERR_MM_INIT);
     }
index b613386..231347f 100644 (file)
@@ -4,12 +4,12 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2016, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE 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.
+ * ETH Zurich D-INFK, Universitaetstr. 6, CH-8092 Zurich. Attn: Systems Group.
  */
 
 #ifndef MONITOR_INVOCATIONS_ARCH_H
 #include "monitor_debug.h"
 
 static inline errval_t
-invoke_monitor_identify_cap(capaddr_t cap, int bits, struct capability *out)
+invoke_monitor_create_cap(uint64_t *raw, capaddr_t caddr, int level, capaddr_t slot, coreid_t owner)
 {
     DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
-    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,
-                    (uintptr_t)out).error;
-}
-
-static inline errval_t
-invoke_monitor_identify_domains_cap(capaddr_t root_cap, int root_bits,
-                                    capaddr_t cap, int bits,
-                                    struct capability *out)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    uint8_t invoke_bits = get_cap_valid_bits(cap_kernel);
-    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,
-                    cap, bits, (uintptr_t)out).error;
-}
-
-static inline errval_t
-invoke_monitor_nullify_cap(capaddr_t cap, int bits)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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_Nullify_cap << 8)
-                    | SYSCALL_INVOKE, invoke_cptr, cap, bits).error;
-}
-
-static inline errval_t
-invoke_monitor_create_cap(uint64_t *raw, capaddr_t caddr, int bits, capaddr_t slot, coreid_t owner)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    return cap_invoke6(cap_kernel, KernelCmd_Create_cap, caddr, bits, slot,
+    return cap_invoke6(cap_kernel, KernelCmd_Create_cap, caddr, level, slot,
                        owner, (uintptr_t)raw).error;
 }
 
-static inline errval_t
-invoke_monitor_register(struct capref ep)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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_Register << 8)
-                    | SYSCALL_INVOKE, invoke_cptr, get_cap_addr(ep)).error;
-}
-
 STATIC_ASSERT(ObjType_Num < 0xFFFF, "retype invocation argument packing does not truncate enum objtype");
 static inline errval_t
-invoke_monitor_remote_cap_retype(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
-                                 capaddr_t src, gensize_t offset, enum objtype newtype,
-                                 gensize_t objsize, size_t count, capaddr_t to,
-                                 capaddr_t slot, int bits)
+invoke_monitor_remote_cap_retype(capaddr_t src_root, capaddr_t src, gensize_t offset,
+                                 enum objtype newtype, gensize_t objsize, size_t count,
+                                 capaddr_t to_cspace, capaddr_t to, capaddr_t slot,
+                                 int level)
 {
     DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    assert(bits <= 0xFF);
+    assert(newtype < ObjType_Num);
+    assert(level <= 0xFF);
     assert(slot <= 0xFFFF);
-    return cap_invoke8(cap_kernel, KernelCmd_Retype,
-                       src, offset,
-                       ((uint64_t)slot << 32) | ((uint64_t)bits << 16) | newtype,
-                       objsize, count, to,
-                       ((uint64_t)rootcap_addr | (uint64_t)rootcap_vbits << 32)
-                       ).error;
-}
-
-static inline errval_t
-invoke_monitor_get_cap_owner(capaddr_t root, int rbits, capaddr_t cap, int cbits, coreid_t *ret_owner)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    return cap_invoke6(cap_kernel, KernelCmd_Set_cap_owner, root, rbits, cap, cbits, owner).error;
-}
-
-
-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)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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_lock_cap(capaddr_t root, int rbits, capaddr_t cap, int cbits)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    assert(rbits <= 0xff);
-    assert(cbits <= 0xff);
-    assert(retcnbits <= 0xff);
-
-    return cap_invoke6(cap_kernel, KernelCmd_Delete_last, root, cap,
-                       retcn, retslot, ((cbits<<16)|(rbits<<8)|retcnbits)).error;
-}
-
-static inline errval_t
-invoke_monitor_delete_foreigns(capaddr_t cap, int bits)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    return cap_invoke5(cap_kernel, KernelCmd_Revoke_mark_target,
-                       root, rbits, cap, cbits).error;
+    return cap_invoke10(cap_kernel, KernelCmd_Retype,
+                        src_root, src, offset, ((uint32_t)level << 16) | newtype,
+                        objsize, count, to_cspace, to, slot).error;
 }
 
 static inline errval_t
@@ -200,22 +57,6 @@ invoke_monitor_revoke_mark_relations(uint64_t *raw_base)
 }
 
 static inline errval_t
-invoke_monitor_delete_step(capaddr_t retcn, int retcnbits, cslot_t retslot)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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)
 {
     DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
@@ -231,6 +72,14 @@ invoke_monitor_has_descendants(uint64_t *raw, bool *res)
     return sysret.error;
 }
 
+static inline errval_t
+invoke_monitor_is_retypeable(uint64_t *raw, gensize_t offset,
+                             gensize_t objsize, size_t count)
+{
+    assert(sizeof(struct capability) <= 4*sizeof(uint64_t));
+    return cap_invoke5(cap_kernel, KernelCmd_Is_retypeable,
+                       (uintptr_t)raw, offset, objsize, count).error;
+}
 
 /**
  * \brief Set up tracing in the kernel
@@ -252,106 +101,23 @@ invoke_domain_id(struct capref cap, uint64_t domain_id)
     return LIB_ERR_NOT_IMPLEMENTED;
 }
 
-static inline errval_t
-invoke_monitor_rck_register(struct capref kern_cap, struct capref ep,
-                            int chanid)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    USER_PANIC("NYI");
-    return LIB_ERR_NOT_IMPLEMENTED;
-}
-
-static inline errval_t
-invoke_monitor_rck_delete(struct capref kern_cap, int chanid)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    USER_PANIC("NYI");
-    return LIB_ERR_NOT_IMPLEMENTED;
-}
-
 static inline errval_t invoke_monitor_sync_timer(uint64_t synctime)
 {
     DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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_Sync_timer << 8)
-                    | SYSCALL_INVOKE, invoke_cptr, synctime >> 32,
-                    synctime & 0xffffffff).error;
+    // XXX: could do cap_invoke1() here, as we have 64 bit GP registers
+    return cap_invoke2(cap_kernel, synctime >> 32, synctime & 0xffffffff).error;
 }
 
 static inline errval_t
-invoke_monitor_get_arch_id(uintptr_t *arch_id)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    assert(arch_id != NULL);
-
-    struct sysret sysret = cap_invoke1(cap_kernel, KernelCmd_Get_arch_id);
-    if (err_is_ok(sysret.error)) {
-        *arch_id = sysret.value;
-    }
-    return sysret.error;
-}
-
-static inline errval_t
-invoke_monitor_ipi_register(struct capref ep, int chanid)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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_IPI_Register << 8)
-                    | SYSCALL_INVOKE, invoke_cptr,
-                    get_cap_addr(ep),
-                    chanid).error;
-}
-
-static inline errval_t
-invoke_monitor_ipi_delete(int chanid)
-{
-    DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
-    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_IPI_Delete << 8)
-                    | SYSCALL_INVOKE, invoke_cptr,
-                    chanid).error;
-}
-
-static inline errval_t
-invoke_monitor_copy_existing(uint64_t *raw, capaddr_t cn_addr, int cn_bits, cslot_t slot)
+invoke_monitor_copy_existing(uint64_t *raw, capaddr_t croot_addr, capaddr_t cn_addr,
+                             int cn_level, cslot_t slot)
 {
     DEBUG_INVOCATION("%s: called from %p\n", __FUNCTION__, __builtin_return_address(0));
     // XXX: this is assumed in client code of this function!
     assert(sizeof(struct capability) <= 4*sizeof(uint64_t));
 
-    return cap_invoke5(cap_kernel, KernelCmd_Copy_existing,
-                       cn_addr, cn_bits, slot, (uintptr_t)raw).error;
-}
-
-static inline errval_t
-invoke_monitor_add_kcb(uintptr_t kcb_base)
-{
-    assert(kcb_base);
-    return cap_invoke2(cap_kernel, KernelCmd_Add_kcb, kcb_base).error;
-}
-
-static inline errval_t
-invoke_monitor_remove_kcb(uintptr_t kcb_base)
-{
-    assert(kcb_base);
-    return cap_invoke2(cap_kernel, KernelCmd_Remove_kcb, kcb_base).error;
-}
-
-static inline errval_t
-invoke_monitor_suspend_kcb_scheduler(bool suspend)
-{
-    return cap_invoke2(cap_kernel, KernelCmd_Suspend_kcb_sched, suspend).error;
-}
-
-static inline errval_t invoke_get_platform_info(uintptr_t pi)
-{
-    return cap_invoke2(cap_kernel, KernelCmd_Get_platform, pi).error;
+    return cap_invoke6(cap_kernel, KernelCmd_Copy_existing,
+                       croot_addr, cn_addr, cn_level, slot, (uintptr_t)raw).error;
 }
 
 #endif
index 3f46d12..b2b968f 100644 (file)
@@ -1,10 +1,10 @@
 /*
- * Copyright (c) 2007, 2008, 2009, 2010, 2011, 2012, ETH Zurich.
+ * Copyright (c) 2007, 2008, 2009, 2010, 2011, 2012, 2016, ETH Zurich.
  * All rights reserved.
  *
  * This file is distributed under the terms in the attached LICENSE 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.
+ * ETH Zurich D-INFK, Universitaetstr. 6, CH-8092 Zurich. Attn: Systems Group.
  */
 
 #ifndef MONITOR_INVOCATIONS_H