T258: Delete GPT cspace functionality and rename new functions
authorSimon Gerber <simon.gerber@inf.ethz.ch>
Fri, 5 Aug 2016 09:53:58 +0000 (11:53 +0200)
committerSimon Gerber <simon.gerber@inf.ethz.ch>
Fri, 5 Aug 2016 09:54:00 +0000 (11:54 +0200)
This commit deletes all the old GPT cnode code, and renames the new two-level
functions to the "old" names (e.g. caps_lookup_slot() is now a two-level
cspace function).

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

37 files changed:
capabilities/caps.hl
include/barrelfish/slot_alloc.h
include/barrelfish_kpi/capabilities.h
include/barrelfish_kpi/distcaps.h
include/mm/slot_alloc.h
kernel/arch/arm/irq.c
kernel/arch/armv7/syscall.c
kernel/arch/armv8/startup_arch.c
kernel/arch/armv8/syscall.c
kernel/arch/k1om/startup_arch.c
kernel/arch/x86/ipi_notify.c
kernel/arch/x86_32/syscall.c
kernel/arch/x86_64/irq.c
kernel/arch/x86_64/startup_arch.c
kernel/arch/x86_64/syscall.c
kernel/cap_delete.c
kernel/capabilities.c
kernel/dispatch.c
kernel/include/capabilities.h
kernel/monitor.c
kernel/sys_debug.c
kernel/syscall.c
lib/barrelfish/Hakefile
lib/barrelfish/debug.c
lib/barrelfish/init.c
lib/barrelfish/slot_alloc/multi_slot_alloc.c [deleted file]
lib/barrelfish/slot_alloc/slot_alloc.c
lib/barrelfish/slot_alloc/slot_alloc_2.c [deleted file]
lib/barrelfish/slot_alloc/twolevel_slot_alloc.c
lib/mdb/mdb_tree.c
lib/mm/Hakefile
lib/mm/slot_alloc.c
lib/mm/slot_alloc_2.c [deleted file]
tools/asmoffsets/asmoffsets.c
tools/schedsim/simulator.c
usr/mem_serv/mem_serv.c
usr/mem_serv_dist/mem_serv.c

index 4a6aea3..bd92920 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2010, 2012, 2015, ETH Zurich.
+ * Copyright (c) 2009, 2010, 2012, 2015, 2016, ETH Zurich.
  * Copyright (c) 2015, Hewlett Packard Enterprise Development LP.
  * All rights reserved.
  *
@@ -22,8 +22,6 @@
 /* XXX: these must match the corresponding OBJBITS definitions in
  * barrelfish_kpi/capabilities.h */
 
-/* Size of CNode entry: */
-define cte_size 6;
 /* Size of L2 CNode: L2 resolves 8 bits of Cap address space */
 define l2cn_size 16384;
 /* Size of DCB: */
@@ -73,26 +71,6 @@ cap RAM from PhysAddr from_self {
     size gensize bytes;     /* Size of region in bytes */
 };
 
-cap CNode from RAM {
-    /* CNode table, stores further capabilities */
-
-    lpaddr cnode;           /* Base address of CNode */
-    caddr guard;            /* Bitmask already resolved when reaching this CNode */
-    uint8 bits;             /* Number of bits this CNode resolves */
-    caprights rightsmask;
-    uint8 guard_size;       /* Number of bits in guard */
-
-    /**
-      Address and size may also be specified with some very limited
-      expressions.
-    **/
-
-    /* Shouldn't this be mem_to_phys(cnode)? (causes breakage) -MN */
-    address { cnode };
-    size_bits { bits + cte_size };
-
-};
-
 cap L1CNode from RAM {
     /* Level 1 CNode table, resizable */
     address lpaddr cnode;               /* Base address of CNode */
index 6b14e05..81bb6a7 100644 (file)
@@ -54,7 +54,6 @@ struct slot_allocator_list {
 struct multi_slot_allocator {
     struct slot_allocator a;      ///< Public data
 
-    struct slot_allocator *top;   ///< Top level of the two level allocator
     struct slot_allocator_list *head; ///< List of single slot allocators
     struct slot_allocator_list *reserve; ///< One single allocator in reserve
 
@@ -65,7 +64,6 @@ struct multi_slot_allocator {
 
 struct range_slot_allocator {
     struct capref cnode_cap;     ///< capref for the L1 cnode
-    cslot_t rootcn_slot;         ///< L1 slot of L2 cnode in this allocator
     struct cnoderef cnode;       ///< cnoderef for the cnode to allocate from
     struct cnode_meta *meta;     ///< Linked list of meta data
     struct slab_allocator slab;      ///< Slab allocation
@@ -88,14 +86,6 @@ cslot_t single_slot_alloc_freecount(struct single_slot_allocator *s);
 errval_t single_slot_alloc_resize(struct single_slot_allocator *this,
                                   cslot_t newslotcount);
 
-errval_t multi_slot_alloc_init(struct multi_slot_allocator *ret,
-                               cslot_t nslots, cslot_t *retslots);
-errval_t multi_slot_alloc_init_raw(struct multi_slot_allocator *ret,
-                                   cslot_t nslots, struct capref top_cap,
-                                   struct cnoderef top_cnode,
-                                   void *top_buf, void *head_buf,
-                                   void *reserve_buf, size_t bufsize);
-
 errval_t two_level_slot_alloc_init(struct multi_slot_allocator *ret);
 errval_t two_level_slot_alloc_init_raw(struct multi_slot_allocator *ret,
                                        struct capref initial_cap,
@@ -105,7 +95,6 @@ errval_t two_level_slot_alloc_init_raw(struct multi_slot_allocator *ret,
                                        void *head_buf, void *reserve_buf, size_t bufsize);
 
 errval_t slot_alloc_init(void);
-errval_t slot_alloc_init_2(void);
 struct slot_allocator *get_default_slot_allocator(void);
 errval_t slot_alloc(struct capref *ret);
 
index 140ae7c..ca6b9fd 100644 (file)
@@ -62,7 +62,7 @@ struct dcb;
 
 static inline bool type_is_vnode(enum objtype type)
 {
-    STATIC_ASSERT(48 == ObjType_Num, "Check VNode definitions");
+    STATIC_ASSERT(47 == ObjType_Num, "Check VNode definitions");
 
     return (type == ObjType_VNode_x86_64_pml4 ||
             type == ObjType_VNode_x86_64_pdpt ||
@@ -81,7 +81,7 @@ static inline bool type_is_vnode(enum objtype type)
 
 static inline bool type_is_vroot(enum objtype type)
 {
-    STATIC_ASSERT(48 == ObjType_Num, "Check VNode definitions");
+    STATIC_ASSERT(47 == ObjType_Num, "Check VNode definitions");
 
     return (type == ObjType_VNode_x86_64_pml4 ||
 #ifdef CONFIG_PAE
@@ -103,7 +103,7 @@ static inline bool type_is_vroot(enum objtype type)
 static inline size_t vnode_objbits(enum objtype type)
 {
     // This function should be emitted by hamlet or somesuch.
-    STATIC_ASSERT(48 == ObjType_Num, "Check VNode definitions");
+    STATIC_ASSERT(47 == ObjType_Num, "Check VNode definitions");
 
     if (type == ObjType_VNode_x86_64_pml4 ||
         type == ObjType_VNode_x86_64_pdpt ||
@@ -149,7 +149,7 @@ static inline size_t vnode_objbits(enum objtype type)
 static inline size_t vnode_objsize(enum objtype type)
 {
     // This function should be emitted by hamlet or somesuch.
-    STATIC_ASSERT(48 == ObjType_Num, "Check VNode definitions");
+    STATIC_ASSERT(47 == ObjType_Num, "Check VNode definitions");
 
     if (type == ObjType_VNode_x86_64_pml4 ||
         type == ObjType_VNode_x86_64_pdpt ||
@@ -192,7 +192,7 @@ static inline size_t vnode_objsize(enum objtype type)
  */
 static inline size_t vnode_entry_bits(enum objtype type) {
     // This function should be emitted by hamlet or somesuch.
-    STATIC_ASSERT(48 == ObjType_Num, "Check VNode definitions");
+    STATIC_ASSERT(47 == ObjType_Num, "Check VNode definitions");
 
     if (type == ObjType_VNode_x86_64_pml4 ||
         type == ObjType_VNode_x86_64_pdpt ||
@@ -249,11 +249,9 @@ static inline size_t vnode_entry_bits(enum objtype type) {
  * @return Number of page table entries in bits
  */
 static inline size_t cnode_get_slots(struct capability *cnode) {
-    STATIC_ASSERT(48 == ObjType_Num, "Check CNode definitions");
+    STATIC_ASSERT(47 == ObjType_Num, "Check CNode definitions");
 
     switch (cnode->type) {
-        case ObjType_CNode:
-            return 1UL << cnode->u.cnode.bits;
         case ObjType_L1CNode:
             return cnode->u.l1cnode.allocated_bytes / (1UL << OBJBITS_CTE);
         case ObjType_L2CNode:
@@ -266,7 +264,7 @@ static inline size_t cnode_get_slots(struct capability *cnode) {
 
 static inline enum objtype get_mapping_type(enum objtype captype)
 {
-    STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all mapping types");
+    STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all mapping types");
 
     switch (captype) {
         case ObjType_Frame:
@@ -305,7 +303,7 @@ static inline enum objtype get_mapping_type(enum objtype captype)
 
 static inline bool type_is_mapping(enum objtype type)
 {
-    STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all mapping types");
+    STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all mapping types");
 
     switch (type) {
         case ObjType_Frame_Mapping:
@@ -332,7 +330,7 @@ static inline bool type_is_mapping(enum objtype type)
 
 static inline bool type_is_mappable(enum objtype type)
 {
-    STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all mappable types");
+    STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all mappable types");
 
     switch (type) {
         case ObjType_Frame:
index 7ed3577..4b561d1 100644 (file)
@@ -40,14 +40,13 @@ distcap_state_is_foreign(distcap_state_t state)
  * Predicates related to sharing capabilities
  */
 
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 static inline bool
 distcap_needs_locality(enum objtype type)
 {
     switch (type) {
     case ObjType_PhysAddr:
     case ObjType_RAM:
-    case ObjType_CNode:
     case ObjType_L1CNode:
     case ObjType_L2CNode:
     case ObjType_FCNode:
@@ -89,7 +88,7 @@ distcap_needs_locality(enum objtype type)
     }
 }
 
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 static inline bool
 distcap_is_moveable(enum objtype type)
 {
index efe4c17..67e3e92 100644 (file)
@@ -16,6 +16,8 @@
 #define MM_SLOT_ALLOC_H
 
 #include <sys/cdefs.h>
+#include <errors/errno.h>
+#include <barrelfish/caddr.h>
 
 __BEGIN_DECLS
 
@@ -25,40 +27,14 @@ typedef errval_t (*slot_refill_t)(void *inst);
 
 /// Implementations of above interface
 errval_t slot_alloc_prealloc(void *inst, uint64_t nslots, struct capref *ret);
-errval_t slot_alloc_prealloc_2(void *inst, uint64_t nslots, struct capref *ret);
 errval_t slot_alloc_basecn(void *inst, uint64_t nslots, struct capref *ret);
 errval_t slot_alloc_dynamic(void *inst, uint64_t nslots, struct capref *ret);
 errval_t slot_refill_dynamic(void *inst);
 
 struct mm; // forward declaration
 
-//XXX: added alignment to workaround an arm-gcc bug
-//which generated (potentially) unaligned access code to those fields
-
-/// Instance data for pre-allocating slot allocator
-struct slot_prealloc {
-    uint8_t maxslotbits;            ///< Maximum number of slots per allocation
-    uint8_t cnode_size_bits;        ///< Size of created cnodes
-
-    struct cnoderef top_cnode __attribute__ ((aligned(4)));    ///< Top-level cnode
-    struct capref top_cnode_slot __attribute__ ((aligned(4))); ///< Location to place top-level cnode
-    uint64_t top_used;              ///< Slots used in top-level cnode
-
-    /// Metadata for next place from which to allocate slots
-    struct {
-        struct capref cap;        ///< Next cap to allocate
-        uint64_t free;              ///< Number of free slots including cap
-    } meta[2] __attribute__ ((aligned(4)));
-
-    /// Which entry in meta array we are currently allocating from
-    uint8_t current;
-
-    /// RAM allocator to allocate space for new cnodes
-    struct mm *mm;
-};
-
 /// Instance data for pre-allocating slot allocator for 2 level cspace
-struct slot_prealloc_2 {
+struct slot_prealloc {
     uint8_t maxslotbits;            ///< Maximum number of slots per allocation
 
     /// Metadata for next place from which to allocate slots
@@ -75,19 +51,13 @@ struct slot_prealloc_2 {
 };
 
 /// Initialiser for the pre-allocating implementation
-errval_t slot_prealloc_init(struct slot_prealloc *slot_alloc, struct capref top,
-                            uint8_t maxslotbits, uint8_t cnode_size_bits,
-                            struct capref initial_cnode, uint64_t initial_space,
-                            struct mm *ram_mm);
+errval_t slot_prealloc_init(struct slot_prealloc *slot_alloc,
+                            uint8_t maxslotbits, struct capref initial_cnode,
+                            uint64_t initial_space, struct mm *ram_mm);
 
 /// Refill function for the pre-allocating implementation
 errval_t slot_prealloc_refill(struct slot_prealloc *inst);
 
-errval_t slot_prealloc_init_2(struct slot_prealloc_2 *slot_alloc,
-                              uint8_t maxslotbits, struct capref initial_cnode,
-                              uint64_t initial_space, struct mm *ram_mm);
-errval_t slot_prealloc_refill_2(struct slot_prealloc_2 *inst);
-
 /// Instance data for simple base-cnode allocator
 struct slot_alloc_basecn {
     struct capref cap;          ///< Next cap to allocate
index 7e273f4..1717d10 100644 (file)
@@ -39,8 +39,8 @@ errval_t irq_table_set(unsigned int nidt, capaddr_t endpoint)
     errval_t err;
     struct cte *recv;
 
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, endpoint, 
-                             2, &recv, CAPRIGHTS_WRITE);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, endpoint,
+                           2, &recv, CAPRIGHTS_WRITE);
     if (err_is_fail(err)) {
         return err_push(err, SYS_ERR_IRQ_LOOKUP);
     }
index 48862b0..94b3051 100644 (file)
@@ -354,8 +354,8 @@ handle_unmap(
 
     errval_t err;
     struct cte *mapping = NULL;
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, mapping_cptr, mapping_level,
-                             &mapping, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, mapping_cptr, mapping_level,
+                           &mapping, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         printk(LOG_NOTE, "%s: caps_lookup_slot: %ld\n", __FUNCTION__, err);
         return SYSRET(err_push(err, SYS_ERR_CAP_NOT_FOUND));
@@ -869,15 +869,6 @@ static invocation_t invocations[ObjType_Num][CAP_MAX_CMD] = {
     [ObjType_DevFrame] = {
         [FrameCmd_Identify] = handle_frame_identify,
     },
-    [ObjType_CNode] = {
-        [CNodeCmd_Copy]     = handle_copy,
-        [CNodeCmd_Mint]     = handle_mint,
-        [CNodeCmd_Retype]   = handle_retype,
-        [CNodeCmd_Delete]   = handle_delete,
-        [CNodeCmd_Revoke]   = handle_revoke,
-        [CNodeCmd_Create]   = handle_create,
-        [CNodeCmd_GetState] = handle_get_state,
-    },
     [ObjType_L1CNode] = {
         [CNodeCmd_Copy]     = handle_copy,
         [CNodeCmd_Mint]     = handle_mint,
@@ -981,9 +972,9 @@ handle_invoke(arch_registers_state_t *context, int argc)
     struct sysret r = { .error = SYS_ERR_OK, .value = 0 };
 
     struct capability* to;
-    r.error = caps_lookup_cap_2(&dcb_current->cspace.cap,
-                                invoke_cptr, invoke_level,
-                                &to, CAPRIGHTS_READ);
+    r.error = caps_lookup_cap(&dcb_current->cspace.cap,
+                              invoke_cptr, invoke_level,
+                              &to, CAPRIGHTS_READ);
     if (err_is_ok(r.error))
     {
         assert(to != NULL);
index 52acb67..0330d5f 100644 (file)
@@ -31,7 +31,7 @@
 #include <global.h>
 #include <kcb.h>
 
-#define CNODE(cte)              (cte)->cap.u.cnode.cnode
+#define CNODE(cte)              get_address(&(cte)->cap)
 #define UNUSED(x)               (x) = (x)
 
 #define STARTUP_PROGRESS()      debug(SUBSYS_STARTUP, "%s:%d\n",          \
index f154852..d44bfe7 100644 (file)
@@ -845,15 +845,6 @@ static invocation_t invocations[ObjType_Num][CAP_MAX_CMD] = {
     [ObjType_DevFrame] = {
         [FrameCmd_Identify] = handle_frame_identify,
     },
-    [ObjType_CNode] = {
-        [CNodeCmd_Copy]     = handle_copy,
-        [CNodeCmd_Mint]     = handle_mint,
-        [CNodeCmd_Retype]   = handle_retype,
-        [CNodeCmd_Delete]   = handle_delete,
-        [CNodeCmd_Revoke]   = handle_revoke,
-        [CNodeCmd_Create]   = handle_create,
-        [CNodeCmd_GetState] = handle_get_state,
-    },
     [ObjType_VNode_AARCH64_l1] = {
        [VNodeCmd_Map]   = handle_map,
        [VNodeCmd_Unmap] = handle_unmap,
index 7652250..21ace68 100644 (file)
@@ -37,7 +37,7 @@
 #include <xeon_phi/xeon_phi.h>
 
 /// Quick way to find the base address of a cnode capability
-#define CNODE(cte)     (cte)->cap.u.cnode.cnode
+#define CNODE(cte)     get_address(&(cte)->cap)
 
 /**
  * init's needed boot pages.
index 1198e26..ac12146 100644 (file)
@@ -44,8 +44,8 @@ errval_t ipi_register_notification(capaddr_t ep, int chanid)
     struct cte *recv;
     errval_t err;
 
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, ep,
-                             2, &recv, CAPRIGHTS_WRITE);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, ep,
+                           2, &recv, CAPRIGHTS_WRITE);
     if (err_is_fail(err)) {
         return err_push(err, SYS_ERR_IRQ_LOOKUP);
     }
index 3f0a567..3e01861 100644 (file)
@@ -831,7 +831,7 @@ static invocation_handler_t invocations[ObjType_Num][CAP_MAX_CMD] = {
     [ObjType_DevFrame] = {
         [FrameCmd_Identify] = handle_frame_identify,
     },
-    [ObjType_CNode] = {
+    [ObjType_L1CNode] = {
         [CNodeCmd_Copy]   = handle_copy,
         [CNodeCmd_Mint]   = handle_mint,
         [CNodeCmd_Retype] = handle_retype,
index 05e3e22..ed9980a 100644 (file)
@@ -526,7 +526,7 @@ errval_t irq_debug_create_src_cap(uint8_t dcn_level, capaddr_t dcn, capaddr_t ou
     out_cap.cap.u.irqsrc.controller = ioapic_controller_id;
 
     struct cte * cn;
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, dcn, dcn_level, &cn, CAPRIGHTS_WRITE);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, dcn, dcn_level, &cn, CAPRIGHTS_WRITE);
     if(err_is_fail(err)){
         return err;
     }
@@ -570,8 +570,8 @@ errval_t irq_table_alloc_dest_cap(uint8_t dcn_level, capaddr_t dcn, capaddr_t ou
         out_cap.cap.u.irqdest.vector = i;
 
         struct cte * cn;
-        err = caps_lookup_slot_2(&dcb_current->cspace.cap, dcn, dcn_level,
-                                 &cn, CAPRIGHTS_WRITE);
+        err = caps_lookup_slot(&dcb_current->cspace.cap, dcn, dcn_level,
+                               &cn, CAPRIGHTS_WRITE);
         if(err_is_fail(err)){
             return err;
         }
@@ -588,8 +588,8 @@ errval_t irq_connect(struct capability *dest_cap, capaddr_t endpoint_adr)
     struct cte *endpoint;
 
     // Lookup & check message endpoint cap
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, endpoint_adr,
-                             2, &endpoint, CAPRIGHTS_WRITE);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, endpoint_adr,
+                           2, &endpoint, CAPRIGHTS_WRITE);
     if (err_is_fail(err)) {
         return err_push(err, SYS_ERR_IRQ_LOOKUP_EP);
     }
index 5d28a5e..485c52f 100644 (file)
@@ -34,7 +34,7 @@
 #include <arch/x86/start_aps.h>
 
 /// Quick way to find the base address of a cnode capability
-#define CNODE(cte)     (cte)->cap.u.cnode.cnode
+#define CNODE(cte)     get_address(&(cte)->cap)
 
 /**
  * init's needed boot pages.
index d325568..cf7ceac 100644 (file)
@@ -231,15 +231,6 @@ static struct sysret handle_resize(struct capability *root,
     return sys_resize_l1cnode(root, newroot_ptr, retcn_ptr, retslot);
 }
 
-#if 1
-static struct sysret handle_cnode_cmd_obsolete(struct capability *root,
-                                               int cmd, uintptr_t *args)
-{
-    panic("Trying to invoke GPT CNode: command %d", cmd);
-    return SYSRET(LIB_ERR_NOT_IMPLEMENTED);
-}
-#endif
-
 static struct sysret handle_unmap(struct capability *pgtable,
                                   int cmd, uintptr_t *args)
 {
@@ -248,8 +239,8 @@ static struct sysret handle_unmap(struct capability *pgtable,
 
     errval_t err;
     struct cte *mapping;
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, cptr, level,
-                             &mapping, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, cptr, level,
+                           &mapping, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_CAP_NOT_FOUND));
     }
@@ -435,8 +426,8 @@ static struct sysret monitor_identify_domains_cap(struct capability *kernel_cap,
     capaddr_t root_level = args[1];
 
     struct capability *root;
-    err = caps_lookup_cap_2(&dcb_current->cspace.cap, root_caddr, root_level,
-                            &root, CAPRIGHTS_READ);
+    err = caps_lookup_cap(&dcb_current->cspace.cap, root_caddr, root_level,
+                          &root, CAPRIGHTS_READ);
 
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_ROOT_CAP_LOOKUP));
@@ -697,8 +688,8 @@ handle_dispatcher_setup_guest (struct capability *to, int cmd, uintptr_t *args)
     // Monitor endpoint for exits of this geust
     struct cte *ep_cte;
 
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, epp, 2,
-                             &ep_cte, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, epp, 2,
+                           &ep_cte, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -712,8 +703,8 @@ handle_dispatcher_setup_guest (struct capability *to, int cmd, uintptr_t *args)
 
     // Domain vspace
     struct capability *vnode_cap;
-    err = caps_lookup_cap_2(&dcb_current->cspace.cap, vnodep, 2,
-                            &vnode_cap, CAPRIGHTS_WRITE);
+    err = caps_lookup_cap(&dcb_current->cspace.cap, vnodep, 2,
+                          &vnode_cap, CAPRIGHTS_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -725,8 +716,8 @@ handle_dispatcher_setup_guest (struct capability *to, int cmd, uintptr_t *args)
 
     // VMCB
     struct cte *vmcb_cte;
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, vmcbp, 2,
-                             &vmcb_cte, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, vmcbp, 2,
+                           &vmcb_cte, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -741,8 +732,8 @@ handle_dispatcher_setup_guest (struct capability *to, int cmd, uintptr_t *args)
 
     // guest control
     struct cte *ctrl_cte;
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, ctrlp, 2,
-                             &ctrl_cte, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, ctrlp, 2,
+                           &ctrl_cte, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -838,8 +829,8 @@ static struct sysret handle_trace_setup(struct capability *cap,
 
     /* lookup passed cap */
     capaddr_t cptr = args[0];
-    err = caps_lookup_cap_2(&dcb_current->cspace.cap, cptr, 2, &frame,
-                            CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_cap(&dcb_current->cspace.cap, cptr, 2, &frame,
+                          CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -1000,8 +991,8 @@ static struct sysret performance_counter_activate(struct capability *cap,
 
     if(ep_addr!=0) {
 
-        err = caps_lookup_cap_2(&dcb_current->cspace.cap, ep_addr, 2, &ep,
-                                CAPRIGHTS_READ);
+        err = caps_lookup_cap(&dcb_current->cspace.cap, ep_addr, 2, &ep,
+                              CAPRIGHTS_READ);
         if(err_is_fail(err)) {
             return SYSRET(err);
         }
@@ -1149,17 +1140,6 @@ static invocation_handler_t invocations[ObjType_Num][CAP_MAX_CMD] = {
     [ObjType_DevFrame] = {
         [FrameCmd_Identify] = handle_frame_identify,
     },
-    [ObjType_CNode] = {
-        [CNodeCmd_Copy]   = handle_cnode_cmd_obsolete,
-        [CNodeCmd_Mint]   = handle_cnode_cmd_obsolete,
-        [CNodeCmd_Retype] = handle_cnode_cmd_obsolete,
-        [CNodeCmd_Create] = handle_cnode_cmd_obsolete,
-        [CNodeCmd_Delete] = handle_cnode_cmd_obsolete,
-        [CNodeCmd_Revoke] = handle_cnode_cmd_obsolete,
-        [CNodeCmd_GetState] = handle_cnode_cmd_obsolete,
-        [CNodeCmd_Resize] = handle_cnode_cmd_obsolete,
-
-    },
     [ObjType_L1CNode] = {
         [CNodeCmd_Copy]   = handle_copy,
         [CNodeCmd_Mint]   = handle_mint,
@@ -1335,8 +1315,8 @@ struct sysret sys_syscall(uint64_t syscall, uint64_t arg0, uint64_t arg1,
 
         // Capability to invoke
         struct capability *to = NULL;
-        retval.error = caps_lookup_cap_2(&dcb_current->cspace.cap, invoke_cptr,
-                                         invoke_level, &to, CAPRIGHTS_READ);
+        retval.error = caps_lookup_cap(&dcb_current->cspace.cap, invoke_cptr,
+                                       invoke_level, &to, CAPRIGHTS_READ);
         if (err_is_fail(retval.error)) {
             break;
         }
index 1a7cd3f..a46a80f 100644 (file)
@@ -55,7 +55,8 @@ static errval_t caps_try_delete(struct cte *cte)
         return cleanup_copy(cte);
     }
     else if (cte->mdbnode.remote_copies
-             || cte->cap.type == ObjType_CNode
+             || cte->cap.type == ObjType_L1CNode
+             || cte->cap.type == ObjType_L2CNode
              || cte->cap.type == ObjType_Dispatcher)
     {
         return SYS_ERR_DELETE_LAST_OWNED;
@@ -96,11 +97,13 @@ errval_t caps_delete_last(struct cte *cte, struct cte *ret_ram_cap)
     // other CNodes or dcbs, at which point they are scheduled for final
     // deletion, which only happens when the clear lists are empty.
 
-    if (cte->cap.type == ObjType_CNode) {
+    if (cte->cap.type == ObjType_L1CNode ||
+        cte->cap.type == ObjType_L2CNode)
+    {
         debug(SUBSYS_CAPS, "deleting last copy of cnode: %p\n", cte);
         // Mark all non-Null slots for deletion
-        for (cslot_t i = 0; i < (1<<cte->cap.u.cnode.bits); i++) {
-            struct cte *slot = caps_locate_slot(cte->cap.u.cnode.cnode, i);
+        for (cslot_t i = 0; i < cnode_get_slots(&cte->cap); i++) {
+            struct cte *slot = caps_locate_slot(get_address(&cte->cap), i);
             caps_mark_revoke_generic(slot);
         }
 
@@ -110,11 +113,6 @@ errval_t caps_delete_last(struct cte *cte, struct cte *ret_ram_cap)
 
         return SYS_ERR_OK;
     }
-    else if (cte->cap.type == ObjType_L1CNode || cte->cap.type == ObjType_L2CNode)
-    {
-        printk(LOG_WARN, "delete last NYI for L1/L2 CNode");
-        return SYS_ERR_NOT_IMPLEMENTED;
-    }
     else if (cte->cap.type == ObjType_Dispatcher)
     {
         debug(SUBSYS_CAPS, "deleting last copy of dispatcher: %p\n", cte);
@@ -203,6 +201,7 @@ cleanup_copy(struct cte *cte)
 /**
  * \brief Cleanup the last cap copy for an object and the object itself
  */
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all RAM-backed cap types");
 static errval_t
 cleanup_last(struct cte *cte, struct cte *ret_ram_cap)
 {
@@ -228,18 +227,11 @@ cleanup_last(struct cte *cte, struct cte *ret_ram_cap)
         // NB: ObjType_PhysAddr and ObjType_DevFrame caps are *not* RAM-backed!
         switch(cap->type) {
         case ObjType_RAM:
-            ram.base = cap->u.ram.base;
-            ram.bytes = cap->u.ram.bytes;
-            break;
-
         case ObjType_Frame:
-            ram.base = cap->u.frame.base;
-            ram.bytes = cap->u.frame.bytes;
-            break;
-
-        case ObjType_CNode:
-            ram.base = cap->u.cnode.cnode;
-            ram.bytes = 1UL << (cap->u.cnode.bits + OBJBITS_CTE);
+        case ObjType_L1CNode:
+        case ObjType_L2CNode:
+            ram.base = get_address(cap);
+            ram.bytes = get_size(cap);
             break;
 
         case ObjType_Dispatcher:
@@ -614,16 +606,19 @@ errval_t caps_clear_step(struct cte *ret_ram_cap)
     // some sanity checks
 #define CHECK_SLOT(slot) do { \
     assert((slot)->cap.type == ObjType_Null \
-           || (slot)->cap.type == ObjType_CNode \
+           || (slot)->cap.type == ObjType_L1CNode \
+           || (slot)->cap.type == ObjType_L2CNode \
            || (slot)->cap.type == ObjType_Dispatcher); \
     if ((slot)->cap.type != ObjType_Null) { \
         assert((slot)->mdbnode.in_delete); \
     } \
 } while (0)
 
-    if (cte->cap.type == ObjType_CNode) {
-        for (cslot_t i = 0; i < (1<<cte->cap.u.cnode.bits); i++) {
-            struct cte *slot = caps_locate_slot(cte->cap.u.cnode.cnode, i);
+    if (cte->cap.type == ObjType_L1CNode ||
+        cte->cap.type == ObjType_L2CNode)
+    {
+        for (cslot_t i = 0; i < cnode_get_slots(&cte->cap); i++) {
+            struct cte *slot = caps_locate_slot(get_address(&cte->cap), i);
             CHECK_SLOT(slot);
         }
     }
index 8e188b4..d637a8c 100644 (file)
@@ -55,7 +55,7 @@ void caps_trace_ctrl(uint64_t types, genpaddr_t start, gensize_t size)
 
 struct capability monitor_ep;
 
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 int sprint_cap(char *buf, size_t len, struct capability *cap)
 {
     switch (cap->type) {
@@ -68,17 +68,6 @@ int sprint_cap(char *buf, size_t len, struct capability *cap)
         return snprintf(buf, len, "RAM cap (0x%" PRIxGENPADDR ":0x%zx)",
                         cap->u.ram.base, cap->u.ram.bytes);
 
-    case ObjType_CNode: {
-        int ret = snprintf(buf, len, "CNode cap "
-                           "(bits %u, rights mask 0x%" PRIxCAPRIGHTS ")",
-                           cap->u.cnode.bits, cap->u.cnode.rightsmask);
-        if (cap->u.cnode.guard_size != 0 && ret < len) {
-            ret += snprintf(&buf[ret], len - ret, " (guard 0x%" PRIxCADDR ":%u)",
-                            cap->u.cnode.guard, cap->u.cnode.guard_size);
-        }
-        return ret;
-    }
-
     case ObjType_L1CNode: {
         int ret = snprintf(buf, len, "L1 CNode cap "
                            "(base=%#"PRIxGENPADDR", allocated bytes %#"PRIxGENSIZE
@@ -362,7 +351,7 @@ static errval_t set_cap(struct capability *dest, struct capability *src)
 
 // If you create more capability types you need to deal with them
 // in the table below.
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 static size_t caps_max_numobjs(enum objtype type, gensize_t srcsize, gensize_t objsize)
 {
     switch(type) {
@@ -376,13 +365,6 @@ static size_t caps_max_numobjs(enum objtype type, gensize_t srcsize, gensize_t o
             return srcsize / objsize;
         }
 
-    case ObjType_CNode:
-        if (srcsize < sizeof(struct cte) || objsize > (srcsize / sizeof(struct cte))) {
-            return 0;
-        } else {
-            return srcsize / objsize / (1UL << OBJBITS_CTE);
-        }
-
     case ObjType_L1CNode:
         if (srcsize < OBJSIZE_L2CNODE || objsize < OBJSIZE_L2CNODE) {
             // disallow L1 CNode to be smaller than 16kB.
@@ -472,7 +454,7 @@ static size_t caps_max_numobjs(enum objtype type, gensize_t srcsize, gensize_t o
  *
  * For the meaning of the parameters, see the 'caps_create' function.
  */
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 
 static errval_t caps_zero_objects(enum objtype type, lpaddr_t lpaddr,
                                   gensize_t objsize, size_t count)
@@ -500,17 +482,6 @@ static errval_t caps_zero_objects(enum objtype type, lpaddr_t lpaddr,
         TRACE(KERNEL, BZERO, 0);
         break;
 
-    case ObjType_CNode:
-        // scale objsize by size of slot for CNodes; objsize for CNodes given
-        // in slots.
-        objsize *= sizeof(struct cte);
-        debug(SUBSYS_CAPS, "CNode: zeroing %zu bytes @%#"PRIxLPADDR"\n",
-                (size_t)objsize * count, lpaddr);
-        TRACE(KERNEL, BZERO, 1);
-        memset((void*)lvaddr, 0, objsize * count);
-        TRACE(KERNEL, BZERO, 0);
-        break;
-
     case ObjType_L1CNode:
     case ObjType_L2CNode:
         debug(SUBSYS_CAPS, "L%dCNode: zeroing %zu bytes @%#"PRIxLPADDR"\n",
@@ -590,7 +561,7 @@ static errval_t caps_zero_objects(enum objtype type, lpaddr_t lpaddr,
  */
 // If you create more capability types you need to deal with them
 // in the table below.
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 
 static errval_t caps_create(enum objtype type, lpaddr_t lpaddr, gensize_t size,
                             gensize_t objsize, size_t count, coreid_t owner,
@@ -700,29 +671,6 @@ static errval_t caps_create(enum objtype type, lpaddr_t lpaddr, gensize_t size,
         }
         break;
 
-    case ObjType_CNode:
-        assert((1UL << OBJBITS_CTE) >= sizeof(struct cte));
-        // TODO: make CNodes not be power-of-two sized
-        // (deferred to new CSpace layout)
-        assert((1UL << log2cl(objsize)) == objsize);
-
-        for(dest_i = 0; dest_i < count; dest_i++) {
-            // Initialize type specific fields
-            temp_cap.u.cnode.cnode =
-                lpaddr + dest_i * sizeof(struct cte) * objsize;
-            temp_cap.u.cnode.bits = log2cl(objsize);
-            temp_cap.u.cnode.guard = 0;
-            temp_cap.u.cnode.guard_size = 0;
-            // XXX: Handle rights!
-            temp_cap.u.cnode.rightsmask = CAPRIGHTS_ALLRIGHTS;
-            // Insert the capability
-            err = set_cap(&dest_caps[dest_i].cap, &temp_cap);
-            if (err_is_fail(err)) {
-                break;
-            }
-        }
-        break;
-
     case ObjType_L1CNode:
         for (dest_i = 0; dest_i < count; dest_i++) {
             assert(objsize >= OBJSIZE_L2CNODE);
@@ -1096,186 +1044,10 @@ static errval_t caps_create(enum objtype type, lpaddr_t lpaddr, gensize_t size,
 }
 
 /**
- * Look up a capability.
- *
- * Starting from #cnode_cap, recursively lookup the capability at #cptr
- * with #vbits.
- *
- * \bug Handle rights
- */
-static errval_t caps_lookup_slot_internal(struct capability *cnode_cap,
-                                          capaddr_t cptr, uint8_t vbits,
-                                          struct cte **ret, CapRights rights,
-                                          int level)
-{
-    TRACE(KERNEL, CAP_LOOKUP_SLOT, 0);
-    /* parameter checking */
-    assert(cnode_cap != NULL);
-
-    if (level > 2) {
-        // doing -1 here as we do not want the actual return address
-        uintptr_t called_from = kernel_virt_to_elf_addr(__builtin_return_address(0));
-        char *dispname = ((struct dispatcher_shared_generic*)dcb_current->disp)->name;
-        printk(LOG_NOTE, "%.*s: WARNING caps_lookup_slot: level=%d, cptr=%"PRIxCADDR
-                " called from %p\n", DISP_NAME_LEN, dispname,
-                level, cptr, (void*)called_from);
-        return SYS_ERR_DEPTH_EXCEEDED;
-    }
-
-    /* Can only resolve CNode type */
-    /* XXX: this is not very clean */
-    if (cnode_cap->type != ObjType_CNode &&
-        cnode_cap->type != ObjType_L1CNode &&
-        cnode_cap->type != ObjType_L2CNode)
-    {
-        debug(SUBSYS_CAPS, "caps_lookup_slot: Cap to lookup not of type CNode\n"
-              "cnode_cap->type = %u\n", cnode_cap->type);
-        TRACE(KERNEL, CAP_LOOKUP_SLOT, 1);
-        return SYS_ERR_CNODE_TYPE;
-    }
-
-    /* Apply rights to this CNode */
-    if ((cnode_cap->rights & rights) != rights) {
-        debug(SUBSYS_CAPS, "caps_lookup_slot: Rights mismatch\n"
-              "Passed rights = %u, cnode_cap->rights = %u\n",
-              rights, cnode_cap->rights);
-        TRACE(KERNEL, CAP_LOOKUP_SLOT, 1);
-        return SYS_ERR_CNODE_RIGHTS;
-    }
-
-    /* Number of bits resolved by this cnode (guard and bits) */
-    uint8_t bits_resolved = 0;
-    switch(cnode_cap->type) {
-        case ObjType_CNode:
-            bits_resolved = cnode_cap->u.cnode.bits +
-            cnode_cap->u.cnode.guard_size;
-            break;
-        case ObjType_L1CNode:
-            {
-            printk(LOG_NOTE, "L1CNode: size = %"PRIuGENSIZE"\n", cnode_cap->u.l1cnode.allocated_bytes);
-            cslot_t slots = cnode_cap->u.l1cnode.allocated_bytes / sizeof(struct cte);
-            printk(LOG_NOTE, "L1CNode: slots = %"PRIuCSLOT"\n", slots);
-            bits_resolved = log2cl(slots);
-            assert(bits_resolved >= L2_CNODE_BITS);
-            }
-            break;
-        case ObjType_L2CNode:
-            bits_resolved = L2_CNODE_BITS;
-            break;
-        default:
-            panic("caps_lookup_slot: trying to lookup cap in a non-cnode cap");
-    }
-    // All CNodes must resolve at least one bit
-    assert(bits_resolved > 0);
-    // If lookup exceeded expected depth then table is malformed
-    if (bits_resolved > vbits) {
-        debug(SUBSYS_CAPS, "caps_lookup_slot: Lookup exceeded valid bits\n"
-              "Cnode bits = %u, guard size = %u, valid bits = %u, bits_resolved = %u\n",
-              cnode_cap->u.cnode.bits, cnode_cap->u.cnode.guard_size,
-              vbits, bits_resolved);
-        TRACE(KERNEL, CAP_LOOKUP_SLOT, 1);
-        return SYS_ERR_DEPTH_EXCEEDED;
-    }
-
-    /* Guard-check (bit-mask of guard in cptr must match guard in cnode cap) */
-    if (cnode_cap->type == ObjType_CNode) {
-        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"
-                  "Computed guard = %"PRIuCADDR", "
-                  "Cnode guard = %"PRIxCADDR", bits = %u\n",
-                  cptr_guard, cnode_cap->u.cnode.guard,
-                  cnode_cap->u.cnode.guard_size);
-            TRACE(KERNEL, CAP_LOOKUP_SLOT, 1);
-            return SYS_ERR_GUARD_MISMATCH;
-        }
-    }
-
-    /* Locate capability in this cnode */
-    // Offset into the cnode
-    size_t offset = (cptr >> (vbits - bits_resolved)) &
-        MASK(log2cl(cnode_get_slots(cnode_cap)));
-    // The capability at the offset
-    struct cte *next_slot = caps_locate_slot(get_address(cnode_cap), offset);
-    printk(LOG_NOTE, "%s: level=%d, cntype=%d, caddr=%#"PRIxCADDR", vbits=%hhu, bits_resolved=%hhu,"
-            " slot=%zu: next_slot->type = %d\n",
-            __FUNCTION__, level, cnode_cap->type, cptr, vbits, bits_resolved, offset,
-            next_slot->cap.type);
-
-    // Do not return NULL type capability
-    if (next_slot->cap.type == ObjType_Null) {
-        TRACE(KERNEL, CAP_LOOKUP_SLOT, 1);
-        return SYS_ERR_CAP_NOT_FOUND;
-    }
-
-    /* Number of bits left to resolve */
-    int bitsleft = vbits - bits_resolved;
-    // If all bits have been resolved, return the capability
-    if(bitsleft == 0) {
-        *ret = next_slot;
-        TRACE(KERNEL, CAP_LOOKUP_SLOT, 1);
-        printk(LOG_NOTE, "return successfully\n");
-        return SYS_ERR_OK;
-    }
-
-    if (next_slot->cap.type == ObjType_L1CNode)
-    {
-        printk(LOG_NOTE, "found L1 CNode: restarting lookup with cptr=%#"PRIxCADDR
-                ", vbits=%hhu\n", cptr, bitsleft);
-        // restart lookup if we find L1 CNode
-        return caps_lookup_slot(&next_slot->cap, cptr, bitsleft, ret, rights);
-    }
-    /* If next capability is not of type cnode, return it */
-    // XXX: Is this consistent?
-    if (next_slot->cap.type != ObjType_CNode &&
-        next_slot->cap.type != ObjType_L2CNode)
-    {
-        *ret = next_slot;
-        TRACE(KERNEL, CAP_LOOKUP_SLOT, 1);
-        printk(LOG_NOTE, "return successfully\n");
-        return SYS_ERR_OK;
-    }
-
-    /* Descend to next level */
-    return caps_lookup_slot_internal(&next_slot->cap, cptr, bitsleft, ret,
-                                     rights, level+1);
-}
-
-errval_t caps_lookup_slot(struct capability *cnode_cap, capaddr_t cptr,
-                          uint8_t vbits, struct cte **ret, CapRights rights)
-{
-    panic("%s called from %#"PRIxPTR"\n", __FUNCTION__,
-        kernel_virt_to_elf_addr(__builtin_return_address(0)));
-
-    return caps_lookup_slot_internal(cnode_cap, cptr, vbits, ret, rights, 1);
-}
-
-/**
- * Wrapper for caps_lookup_slot returning capability instead of cte.
- */
-errval_t caps_lookup_cap(struct capability *cnode_cap, capaddr_t cptr,
-                         uint8_t vbits, struct capability **ret, CapRights rights)
-{
-    panic("%s called from %#"PRIxPTR"\n", __FUNCTION__,
-        kernel_virt_to_elf_addr(__builtin_return_address(0)));
-
-    TRACE(KERNEL, CAP_LOOKUP_CAP, 0);
-    struct cte *ret_cte;
-    errval_t err = caps_lookup_slot(cnode_cap, cptr, vbits, &ret_cte, rights);
-    if (err_is_fail(err)) {
-        return err;
-    }
-    *ret = &ret_cte->cap;
-    TRACE(KERNEL, CAP_LOOKUP_CAP, 1);
-    return SYS_ERR_OK;
-}
-
-/**
  * Look up a capability in two-level cspace rooted at `rootcn`.
  */
-errval_t caps_lookup_slot_2(struct capability *rootcn, capaddr_t cptr,
-                            uint8_t level, struct cte **ret, CapRights rights)
+errval_t caps_lookup_slot(struct capability *rootcn, capaddr_t cptr,
+                          uint8_t level, struct cte **ret, CapRights rights)
 {
     TRACE(KERNEL, CAP_LOOKUP_SLOT, 0);
 
@@ -1373,15 +1145,15 @@ errval_t caps_lookup_slot_2(struct capability *rootcn, capaddr_t cptr,
 }
 
 /**
- * Wrapper for caps_lookup_slot_2 returning capability instead of cte.
+ * Wrapper for caps_lookup_slot returning capability instead of cte.
  */
-errval_t caps_lookup_cap_2(struct capability *cnode_cap, capaddr_t cptr,
-                           uint8_t level, struct capability **ret, CapRights rights)
+errval_t caps_lookup_cap(struct capability *cnode_cap, capaddr_t cptr,
+                         uint8_t level, struct capability **ret, CapRights rights)
 {
     TRACE(KERNEL, CAP_LOOKUP_CAP, 0);
 
     struct cte *ret_cte;
-    errval_t err = caps_lookup_slot_2(cnode_cap, cptr, level, &ret_cte, rights);
+    errval_t err = caps_lookup_slot(cnode_cap, cptr, level, &ret_cte, rights);
     if (err_is_fail(err)) {
         return err;
     }
@@ -1405,8 +1177,8 @@ errval_t caps_create_from_existing(struct capability *root, capaddr_t cnode_cptr
     TRACE(KERNEL, CAP_CREATE_FROM_EXISTING, 0);
     errval_t err;
     struct capability *cnode;
-    err = caps_lookup_cap_2(root, cnode_cptr, cnode_level, &cnode,
-                            CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_cap(root, cnode_cptr, cnode_level, &cnode,
+                          CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return err_push(err, SYS_ERR_SLOT_LOOKUP_FAIL);
     }
@@ -1489,18 +1261,13 @@ errval_t caps_create_from_existing(struct capability *root, capaddr_t cnode_cptr
 //{{{1 Capability creation
 
 /// check arguments, return true iff ok
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 static bool check_caps_create_arguments(enum objtype type,
                                         size_t bytes, size_t objsize,
                                         bool exact)
 {
     /* mappable types need to be at least BASE_PAGE_SIZEd */
-    if (type_is_mappable(type) || type == ObjType_CNode) {
-        /* Adjust objsize to be in bytes for CNodes */
-        if (type == ObjType_CNode) {
-            objsize *= sizeof(struct cte);
-        }
-
+    if (type_is_mappable(type)) {
         /* source size not multiple of BASE_PAGE_SIZE */
         if (bytes & BASE_PAGE_MASK) {
             debug(SUBSYS_CAPS, "source size not multiple of BASE_PAGE_SIZE\n");
@@ -1610,11 +1377,10 @@ errval_t caps_create_new(enum objtype type, lpaddr_t addr, size_t bytes,
     return SYS_ERR_OK;
 }
 
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 /// Retype caps
 /// Create `count` new caps of `type` from `offset` in src, and put them in
 /// `dest_cnode` starting at `dest_slot`.
-/// Note: currently objsize is in slots for type == ObjType_CNode
 errval_t caps_retype(enum objtype type, gensize_t objsize, size_t count,
                      struct capability *dest_cnode, cslot_t dest_slot,
                      struct cte *src_cte, gensize_t offset,
@@ -1650,12 +1416,6 @@ errval_t caps_retype(enum objtype type, gensize_t objsize, size_t count,
     }
     // CNode is special for now, as we still specify CNode size in #slots
     // expressed as 2^bits
-    else if (type == ObjType_CNode &&
-            ((objsize * sizeof(struct cte)) % BASE_PAGE_SIZE != 0))
-    {
-        debug(SUBSYS_CAPS, "%s: CNode: objsize = %zu\n", __FUNCTION__, objsize);
-        return SYS_ERR_INVALID_SIZE;
-    }
     else if (type == ObjType_L1CNode && objsize % OBJSIZE_L2CNODE != 0)
     {
         printk(LOG_WARN, "%s: L1CNode: objsize = %zu\n", __FUNCTION__, objsize);
@@ -1666,14 +1426,11 @@ errval_t caps_retype(enum objtype type, gensize_t objsize, size_t count,
         printk(LOG_WARN, "%s: L2CNode: objsize = %zu\n", __FUNCTION__, objsize);
         return SYS_ERR_INVALID_SIZE;
     }
-    // TODO: clean up semantics for type == ObjType_CNode
-    assert((type == ObjType_CNode
-            && ((objsize * sizeof(struct cte)) % BASE_PAGE_SIZE == 0)) ||
-           (type_is_mappable(type) && objsize % BASE_PAGE_SIZE == 0) ||
+    assert((type_is_mappable(type) && objsize % BASE_PAGE_SIZE == 0) ||
            (type == ObjType_L1CNode && objsize % OBJSIZE_L2CNODE == 0 &&
             objsize >= OBJSIZE_L2CNODE) ||
            (type == ObjType_L2CNode && objsize == OBJSIZE_L2CNODE) ||
-           !(type_is_mappable(type) || type == ObjType_CNode));
+           !type_is_mappable(type));
 
     /* No explicit retypes to Mapping allowed */
     if (type_is_mapping(type)) {
@@ -1893,7 +1650,7 @@ errval_t caps_copy_to_cnode(struct cte *dest_cnode_cte, cslot_t dest_slot,
 }
 
 /// Create copies to a cte
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 errval_t caps_copy_to_cte(struct cte *dest_cte, struct cte *src_cte, bool mint,
                           uintptr_t param1, uintptr_t param2)
 {
@@ -1949,14 +1706,6 @@ errval_t caps_copy_to_cte(struct cte *dest_cte, struct cte *src_cte, bool mint,
     // Process source-specific parameters for minting
     // XXX: If failure, revert the insertion
     switch(src_cap->type) {
-    case ObjType_CNode:
-        if (param2 > CPTR_BITS) {
-            return SYS_ERR_GUARD_SIZE_OVERFLOW;
-        }
-        dest_cap->u.cnode.guard      = param1;
-        dest_cap->u.cnode.guard_size = param2;
-        break;
-
     case ObjType_EndPoint:
         // XXX: FIXME: check that buffer offset lies wholly within the disp frame
         // can't easily enforce this here, because the dispatcher frame may not
index ae6d122..cd2c412 100644 (file)
@@ -253,8 +253,8 @@ static errval_t lmp_transfer_cap(struct capability *ep, struct dcb *send,
     struct capability *recv_cspace_cap;
     // XXX: do we want a level into receiver's cspace here?
     // printk(LOG_NOTE, "recv_cspace_ptr = %"PRIxCADDR"\n", recv_ep->recv_cspc);
-    err = caps_lookup_cap_2(&recv->cspace.cap, recv_ep->recv_cspc, 2,
-                            &recv_cspace_cap, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_cap(&recv->cspace.cap, recv_ep->recv_cspc, 2,
+                          &recv_cspace_cap, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err) || recv_cspace_cap->type != ObjType_L1CNode) {
         return SYS_ERR_LMP_CAPTRANSFER_DST_CNODE_INVALID;
     }
@@ -273,13 +273,13 @@ static errval_t lmp_transfer_cap(struct capability *ep, struct dcb *send,
     }
     // The slot within the cnode
     struct cte *recv_cte;
-    recv_cte = caps_locate_slot(recv_cnode_cap->u.cnode.cnode,
+    recv_cte = caps_locate_slot(get_address(recv_cnode_cap),
                                 recv_ep->recv_cptr & MASK(L2_CNODE_BITS));
 
     /* Look up source slot in sender */
     struct cte *send_cte;
-    err = caps_lookup_slot_2(&send->cspace.cap, send_cptr, send_level,
-                             &send_cte, CAPRIGHTS_READ);
+    err = caps_lookup_slot(&send->cspace.cap, send_cptr, send_level,
+                           &send_cte, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return err_push(err, SYS_ERR_LMP_CAPTRANSFER_SRC_LOOKUP);
     }
index ff1eb18..1246d70 100644 (file)
@@ -112,14 +112,9 @@ errval_t is_retypeable(struct cte *src_cte,
                        bool from_monitor);
 
 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, capaddr_t cptr,
-                          uint8_t vbits, struct cte **ret, CapRights rights);
-errval_t caps_lookup_cap_2(struct capability *cnode_cap, capaddr_t cptr,
-                           uint8_t level, struct capability **ret, CapRights rights);
-errval_t caps_lookup_slot_2(struct capability *rootcn, capaddr_t cptr,
-                            uint8_t level, struct cte **ret, CapRights rights);
+                         uint8_t level, struct capability **ret, CapRights rights);
+errval_t caps_lookup_slot(struct capability *rootcn, capaddr_t cptr,
+                          uint8_t level, struct cte **ret, CapRights rights);
 
 /*
  * Delete and revoke
@@ -159,7 +154,6 @@ STATIC_ASSERT(64 >= ObjType_Num, "cap types fit in uint64_t bitfield");
     ((1ull<<ObjType_RAM) | \
      (1ull<<ObjType_Frame) | \
      (1ull<<ObjType_DevFrame) | \
-     (1ull<<ObjType_CNode) | \
      (1ull<<ObjType_L1CNode) | \
      (1ull<<ObjType_L2CNode) | \
      (1ull<<ObjType_FCNode) | \
index d993dd7..267dac0 100644 (file)
@@ -31,8 +31,8 @@ struct sysret sys_monitor_register(capaddr_t ep_caddr)
 {
     errval_t err;
     struct capability *ep;
-    err = caps_lookup_cap_2(&dcb_current->cspace.cap, ep_caddr, 2, &ep,
-                            CAPRIGHTS_READ);
+    err = caps_lookup_cap(&dcb_current->cspace.cap, ep_caddr, 2, &ep,
+                          CAPRIGHTS_READ);
 
     if(err_is_fail(err)) {
         printf("Failure looking up endpoint!\n");
@@ -50,8 +50,8 @@ struct sysret sys_cap_has_relations(capaddr_t caddr, uint8_t level,
     errval_t err;
 
     struct cte *cap;
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, caddr, level, &cap,
-                             CAPRIGHTS_READ);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, caddr, level, &cap,
+                           CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -121,7 +121,7 @@ struct sysret sys_monitor_identify_cap(struct capability *root,
                                        struct capability *retbuf)
 {
     struct capability *cap;
-    errval_t err = caps_lookup_cap_2(root, cptr, level, &cap, CAPRIGHTS_READ);
+    errval_t err = caps_lookup_cap(root, cptr, level, &cap, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_IDENTIFY_LOOKUP));
     }
@@ -138,8 +138,8 @@ struct sysret sys_monitor_nullify_cap(capaddr_t cptr, uint8_t level)
 {
     struct capability *root = &dcb_current->cspace.cap;
     struct cte *cte;
-    errval_t err = caps_lookup_slot_2(root, cptr, level, &cte,
-                                      CAPRIGHTS_READ_WRITE);
+    errval_t err = caps_lookup_slot(root, cptr, level, &cte,
+                                    CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -159,8 +159,8 @@ struct sysret sys_monitor_domain_id(capaddr_t cptr, domainid_t domain_id)
     struct capability *root = &dcb_current->cspace.cap;
     struct capability *disp;
 
-    errval_t err = caps_lookup_cap_2(root, cptr, CPTR_BITS, &disp,
-                                     CAPRIGHTS_READ_WRITE);
+    errval_t err = caps_lookup_cap(root, cptr, CPTR_BITS, &disp,
+                                   CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -177,13 +177,13 @@ static errval_t sys_double_lookup(capaddr_t rptr, uint8_t rlevel,
     errval_t err;
 
     struct capability *root;
-    err = caps_lookup_cap_2(&dcb_current->cspace.cap, rptr, rlevel,
-                            &root, CAPRIGHTS_READ);
+    err = caps_lookup_cap(&dcb_current->cspace.cap, rptr, rlevel,
+                          &root, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return err_push(err, SYS_ERR_ROOT_CAP_LOOKUP);
     }
 
-    err = caps_lookup_slot_2(root, tptr, tlevel, cte, CAPRIGHTS_READ);
+    err = caps_lookup_slot(root, tptr, tlevel, cte, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return err_push(err, SYS_ERR_IDENTIFY_LOOKUP);
     }
@@ -302,14 +302,14 @@ struct sysret sys_monitor_copy_existing(struct capability *src,
 
     /* lookup cspace for cnode_cptr */
     struct capability *root;
-    errval_t err = caps_lookup_cap_2(&dcb_current->cspace.cap, croot_cptr, 2,
-                                     &root, CAPRIGHTS_READ_WRITE);
+    errval_t err = caps_lookup_cap(&dcb_current->cspace.cap, croot_cptr, 2,
+                                   &root, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_ROOTCN_LOOKUP));
     }
     struct cte *cnode;
-    err = caps_lookup_slot_2(root, cnode_cptr, cnode_level, &cnode,
-                             CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(root, cnode_cptr, cnode_level, &cnode,
+                           CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_CNODE_LOOKUP));
     }
@@ -393,8 +393,8 @@ struct sysret sys_monitor_delete_last(capaddr_t root_addr, uint8_t root_level,
     }
 
     struct capability *retcn;
-    err = caps_lookup_cap_2(&dcb_current->cspace.cap, ret_cn_addr,
-                            ret_cn_level, &retcn, CAPRIGHTS_WRITE);
+    err = caps_lookup_cap(&dcb_current->cspace.cap, ret_cn_addr,
+                          ret_cn_level, &retcn, CAPRIGHTS_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_CNODE_LOOKUP));
     }
@@ -407,7 +407,7 @@ struct sysret sys_monitor_delete_last(capaddr_t root_addr, uint8_t root_level,
         return SYSRET(SYS_ERR_SLOTS_INVALID);
     }
 
-    struct cte *retslot = caps_locate_slot(retcn->u.cnode.cnode, ret_slot);
+    struct cte *retslot = caps_locate_slot(get_address(retcn), ret_slot);
 
     return SYSRET(caps_delete_last(target, retslot));
 }
@@ -417,7 +417,7 @@ struct sysret sys_monitor_delete_foreigns(capaddr_t cptr, uint8_t level)
     errval_t err;
 
     struct cte *cte;
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, cptr, level, &cte, CAPRIGHTS_READ);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, cptr, level, &cte, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -451,8 +451,8 @@ static errval_t sys_retslot_lookup(capaddr_t cnptr, uint8_t cnlevel,
     errval_t err;
 
     struct capability *retcn;
-    err = caps_lookup_cap_2(&dcb_current->cspace.cap, cnptr, cnlevel,
-                            &retcn, CAPRIGHTS_WRITE);
+    err = caps_lookup_cap(&dcb_current->cspace.cap, cnptr, cnlevel,
+                          &retcn, CAPRIGHTS_WRITE);
     if (err_is_fail(err)) {
         return err_push(err, SYS_ERR_DEST_CNODE_LOOKUP);
     }
@@ -466,7 +466,7 @@ static errval_t sys_retslot_lookup(capaddr_t cnptr, uint8_t cnlevel,
     }
 
     struct cte *retslot;
-    retslot = caps_locate_slot(retcn->u.cnode.cnode, slot);
+    retslot = caps_locate_slot(get_address(retcn), slot);
 
     if (retslot->cap.type != ObjType_Null) {
         return SYS_ERR_SLOT_IN_USE;
index 7aaadfc..bdecf4b 100644 (file)
@@ -57,14 +57,14 @@ sys_debug_print_capabilities_check_cnode(struct cte *cte, struct cte **dispatche
 
     struct cte *cn = (struct cte*) local_phys_to_mem(get_address(&cte->cap));
 
-    if (type == ObjType_CNode) {
+    if (type == ObjType_L2CNode) {
         // are we task cnode?
         if (cn[TASKCN_SLOT_DISPATCHER].cap.type == ObjType_Dispatcher) {
             *dispatcher = &cn[TASKCN_SLOT_DISPATCHER];
             return true;
         }
-
-        if (cn[ROOTCN_SLOT_TASKCN].cap.type == ObjType_CNode) {
+    } else if (type == ObjType_L1CNode) {
+        if (cn[ROOTCN_SLOT_TASKCN].cap.type == ObjType_L2CNode) {
             struct cte *cn_task = (struct cte*) local_phys_to_mem(get_address(&cn[ROOTCN_SLOT_TASKCN].cap));
 
             if (cn_task[TASKCN_SLOT_DISPATCHER].cap.type == ObjType_Dispatcher) {
@@ -93,7 +93,8 @@ sys_debug_print_capabilities_cb(struct cte *cte, void *data) {
         return err;
     }
 
-    assert(result->cap.type == ObjType_CNode ||
+    assert(result->cap.type == ObjType_L1CNode ||
+           result->cap.type == ObjType_L2CNode ||
            result->cap.type == ObjType_Dispatcher ||
            result->cap.type == ObjType_KernelControlBlock);
 
index 2e16acd..9094540 100644 (file)
@@ -84,8 +84,8 @@ sys_dispatcher_setup(struct capability *to, capaddr_t cptr, uint8_t level,
 
     /* 1. set cspace root */
     struct cte *root;
-    err = caps_lookup_slot_2(&dcb_current->cspace.cap, cptr, level,
-                             &root, CAPRIGHTS_READ);
+    err = caps_lookup_slot(&dcb_current->cspace.cap, cptr, level,
+                           &root, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         debug(SUBSYS_CAPS, "caps_lookup_cap for croot=%"PRIxCADDR", level=%d: %"PRIuERRV"\n", cptr, level, err);
         return SYSRET(err_push(err, SYS_ERR_DISP_CSPACE_ROOT));
@@ -101,7 +101,7 @@ sys_dispatcher_setup(struct capability *to, capaddr_t cptr, uint8_t level,
 
     /* 2. set vspace root */
     struct capability *vroot;
-    err = caps_lookup_cap_2(&root->cap, vptr, CNODE_TYPE_COUNT, &vroot, CAPRIGHTS_WRITE);
+    err = caps_lookup_cap(&root->cap, vptr, CNODE_TYPE_COUNT, &vroot, CAPRIGHTS_WRITE);
     if (err_is_fail(err)) {
         debug(SUBSYS_CAPS, "caps_lookup_cap for vroot=%"PRIxCADDR": %"PRIuERRV"\n", vptr, err);
         return SYSRET(err_push(err, SYS_ERR_DISP_VSPACE_ROOT));
@@ -115,8 +115,8 @@ sys_dispatcher_setup(struct capability *to, capaddr_t cptr, uint8_t level,
 
     /* 3. set dispatcher frame pointer */
     struct cte *dispcte;
-    err = caps_lookup_slot_2(&root->cap, dptr, CNODE_TYPE_COUNT, &dispcte,
-                             CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(&root->cap, dptr, CNODE_TYPE_COUNT, &dispcte,
+                           CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DISP_FRAME));
     }
@@ -154,8 +154,8 @@ sys_dispatcher_setup(struct capability *to, capaddr_t cptr, uint8_t level,
     // the same domain id as the domain doing the spawning. cf. T271
     // -SG, 2016-07-21.
     struct capability *odisp;
-    err = caps_lookup_cap_2(&dcb_current->cspace.cap, odptr, CNODE_TYPE_COUNT,
-                            &odisp, CAPRIGHTS_READ);
+    err = caps_lookup_cap(&dcb_current->cspace.cap, odptr, CNODE_TYPE_COUNT,
+                          &odisp, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DISP_OCAP_LOOKUP));
     }
@@ -243,15 +243,15 @@ sys_retype(struct capability *root, capaddr_t source_croot, capaddr_t source_cpt
 
     /* Lookup source cspace root cnode */
     struct capability *source_root;
-    err = caps_lookup_cap_2(root, source_croot, 2, &source_root, CAPRIGHTS_READ);
+    err = caps_lookup_cap(root, source_croot, 2, &source_root, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_SOURCE_ROOTCN_LOOKUP));
     }
     /* Source capability */
     struct cte *source_cte;
     // XXX: level from where
-    err = caps_lookup_slot_2(source_root, source_cptr, 2, &source_cte,
-                             CAPRIGHTS_READ);
+    err = caps_lookup_slot(source_root, source_cptr, 2, &source_cte,
+                           CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_SOURCE_CAP_LOOKUP));
     }
@@ -260,8 +260,8 @@ sys_retype(struct capability *root, capaddr_t source_croot, capaddr_t source_cpt
     /* Destination cspace root cnode in source cspace */
     struct capability *dest_cspace_root;
     // XXX: level from where?
-    err = caps_lookup_cap_2(root, dest_cspace_cptr, 2,
-                            &dest_cspace_root, CAPRIGHTS_READ);
+    err = caps_lookup_cap(root, dest_cspace_cptr, 2,
+                          &dest_cspace_root, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_ROOTCN_LOOKUP));
     }
@@ -272,8 +272,8 @@ sys_retype(struct capability *root, capaddr_t source_croot, capaddr_t source_cpt
 
     /* Destination cnode in destination cspace */
     struct capability *dest_cnode_cap;
-    err = caps_lookup_cap_2(dest_cspace_root, dest_cnode_cptr, dest_cnode_level,
-                            &dest_cnode_cap, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_cap(dest_cspace_root, dest_cnode_cptr, dest_cnode_level,
+                          &dest_cnode_cap, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_CNODE_LOOKUP));
     }
@@ -304,8 +304,8 @@ struct sysret sys_create(struct capability *root, enum objtype type,
 
     /* Destination CNode */
     struct capability *dest_cnode_cap;
-    err = caps_lookup_cap_2(root, dest_cnode_cptr, dest_level,
-                            &dest_cnode_cap, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_cap(root, dest_cnode_cptr, dest_level,
+                          &dest_cnode_cap, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_CNODE_LOOKUP));
     }
@@ -366,8 +366,8 @@ sys_copy_or_mint(struct capability *root, capaddr_t dest_cspace_cptr,
 
     /* Lookup source cspace in our cspace */
     struct capability *src_croot;
-    err = caps_lookup_cap_2(root, source_croot_ptr, 2, &src_croot,
-                            CAPRIGHTS_READ);
+    err = caps_lookup_cap(root, source_croot_ptr, 2, &src_croot,
+                          CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_SOURCE_ROOTCN_LOOKUP));
     }
@@ -377,8 +377,8 @@ sys_copy_or_mint(struct capability *root, capaddr_t dest_cspace_cptr,
     }
     /* Lookup source cap in source cspace */
     struct cte *src_cap;
-    err = caps_lookup_slot_2(src_croot, source_cptr, source_level, &src_cap,
-                             CAPRIGHTS_READ);
+    err = caps_lookup_slot(src_croot, source_cptr, source_level, &src_cap,
+                           CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_SOURCE_CAP_LOOKUP));
     }
@@ -386,7 +386,7 @@ sys_copy_or_mint(struct capability *root, capaddr_t dest_cspace_cptr,
     /* Destination cspace root cnode in source cspace */
     struct capability *dest_cspace_root;
     // XXX: level from where?
-    err = caps_lookup_cap_2(root, dest_cspace_cptr, 2, &dest_cspace_root, CAPRIGHTS_READ);
+    err = caps_lookup_cap(root, dest_cspace_cptr, 2, &dest_cspace_root, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_ROOTCN_LOOKUP));
     }
@@ -398,8 +398,8 @@ sys_copy_or_mint(struct capability *root, capaddr_t dest_cspace_cptr,
 
     /* Destination cnode in destination cspace */
     struct cte *dest_cnode_cap;
-    err = caps_lookup_slot_2(dest_cspace_root, destcn_cptr, destcn_level,
-                             &dest_cnode_cap, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(dest_cspace_root, destcn_cptr, destcn_level,
+                           &dest_cnode_cap, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_CNODE_LOOKUP));
     }
@@ -430,8 +430,8 @@ sys_map(struct capability *ptable, cslot_t slot, capaddr_t source_root_cptr,
 
     /* Lookup source root cn cap in own cspace */
     struct capability *src_root;
-    err = caps_lookup_cap_2(root, source_root_cptr, source_level, &src_root,
-                            CAPRIGHTS_READ);
+    err = caps_lookup_cap(root, source_root_cptr, source_level, &src_root,
+                          CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_SOURCE_ROOTCN_LOOKUP));
     }
@@ -440,24 +440,24 @@ sys_map(struct capability *ptable, cslot_t slot, capaddr_t source_root_cptr,
     }
     /* Lookup source cap in source cspace */
     struct cte *src_cte;
-    err = caps_lookup_slot_2(src_root, source_cptr, source_level, &src_cte,
-                             CAPRIGHTS_READ);
+    err = caps_lookup_slot(src_root, source_cptr, source_level, &src_cte,
+                           CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_SOURCE_CAP_LOOKUP));
     }
 
     /* Lookup mapping cspace root in our cspace */
     struct capability *mapping_croot;
-    err = caps_lookup_cap_2(root, mapping_crootptr, 2, &mapping_croot,
-                            CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_cap(root, mapping_crootptr, 2, &mapping_croot,
+                          CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_ROOTCN_LOOKUP));
     }
 
     /* Lookup mapping slot in dest cspace */
     struct cte *mapping_cnode_cte;
-    err = caps_lookup_slot_2(mapping_croot, mapping_cnptr, mapping_cn_level,
-                             &mapping_cnode_cte, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(mapping_croot, mapping_cnptr, mapping_cn_level,
+                           &mapping_cnode_cte, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err_push(err, SYS_ERR_DEST_CNODE_LOOKUP));
     }
@@ -483,7 +483,7 @@ struct sysret sys_delete(struct capability *root, capaddr_t cptr, uint8_t level)
 {
     errval_t err;
     struct cte *slot;
-    err = caps_lookup_slot_2(root, cptr, level, &slot, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(root, cptr, level, &slot, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -496,7 +496,7 @@ struct sysret sys_revoke(struct capability *root, capaddr_t cptr, uint8_t level)
 {
     errval_t err;
     struct cte *slot;
-    err = caps_lookup_slot_2(root, cptr, level, &slot, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_slot(root, cptr, level, &slot, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -509,7 +509,7 @@ struct sysret sys_get_state(struct capability *root, capaddr_t cptr, uint8_t lev
 {
     errval_t err;
     struct cte *slot;
-    err = caps_lookup_slot_2(root, cptr, level, &slot, CAPRIGHTS_READ);
+    err = caps_lookup_slot(root, cptr, level, &slot, CAPRIGHTS_READ);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -530,7 +530,7 @@ struct sysret sys_resize_l1cnode(struct capability *root, capaddr_t newroot_cptr
 
     // Lookup new L1 CNode cap
     struct cte *newroot;
-    err = caps_lookup_slot_2(root, newroot_cptr, 2, &newroot, CAPRIGHTS_ALLRIGHTS);
+    err = caps_lookup_slot(root, newroot_cptr, 2, &newroot, CAPRIGHTS_ALLRIGHTS);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -541,7 +541,7 @@ struct sysret sys_resize_l1cnode(struct capability *root, capaddr_t newroot_cptr
 
     // Lookup slot for returning RAM of old CNode
     struct capability *retcn;
-    err = caps_lookup_cap_2(root, retcn_cptr, 1, &retcn, CAPRIGHTS_READ_WRITE);
+    err = caps_lookup_cap(root, retcn_cptr, 1, &retcn, CAPRIGHTS_READ_WRITE);
     if (err_is_fail(err)) {
         return SYSRET(err);
     }
@@ -628,8 +628,8 @@ struct sysret sys_yield(capaddr_t target)
         errval_t err;
 
         /* directed yield */
-        err = caps_lookup_cap_2(&dcb_current->cspace.cap, target, 2,
-                                &yield_to, CAPRIGHTS_READ);
+        err = caps_lookup_cap(&dcb_current->cspace.cap, target, 2,
+                              &yield_to, CAPRIGHTS_READ);
         if (err_is_fail(err)) {
             return SYSRET(err);
         } else if (yield_to == NULL ||
index facad9f..4a4f3b2 100644 (file)
@@ -24,9 +24,8 @@ let common_srcs = [ "capabilities.c", "init.c", "dispatch.c", "threads.c",
                     "vspace/memobj_one_frame_lazy.c",
                     "vspace/utils.c", "vspace/memobj_fixed.c", "vspace/memobj_numa.c",
                     "vspace/memobj_one_frame_one_map.c", "vspace/mmu_aware.c",
-                    "slot_alloc/single_slot_alloc.c", "slot_alloc/multi_slot_alloc.c",
-                    "slot_alloc/slot_alloc.c", "slot_alloc/range_slot_alloc.c",
-                    "slot_alloc/slot_alloc_2.c", "slot_alloc/twolevel_slot_alloc.c",
+                    "slot_alloc/single_slot_alloc.c", "slot_alloc/slot_alloc.c",
+                    "slot_alloc/range_slot_alloc.c", "slot_alloc/twolevel_slot_alloc.c",
                     "bulk_transfer.c", "trace.c", "resource_ctrl.c", "coreset.c",
                     "inthandler.c", "deferred.c", "syscalls.c", "sys_debug.c"
                   ]
index 99d8a96..780037f 100644 (file)
@@ -25,6 +25,7 @@
 #include <string.h>
 #include <inttypes.h>
 #include <barrelfish_kpi/dispatcher_shared.h>
+#include "../newlib/newlib/libc/include/stdio.h"
 
 #define DISP_MEMORY_SIZE            1024 // size of memory dump in bytes
 
@@ -54,12 +55,17 @@ void user_panic_fn(const char *file, const char *func, int line,
     abort();
 }
 
+/*
+ * Have this invocation here to make debug_cap_identify work for domains that
+ * have no monitor connection but hold Kernel cap (e.g. init)
+ */
 static inline errval_t
-invoke_monitor_identify_cap(capaddr_t cap, int level, struct capability *out)
+invoke_kernel_identify_cap(capaddr_t cap, int level, struct capability *out)
 {
     return cap_invoke4(cap_kernel, KernelCmd_Identify_cap, cap, level,
                        (uintptr_t)out).error;
 }
+
 errval_t debug_cap_identify(struct capref cap, struct capability *ret)
 {
     errval_t err, msgerr;
@@ -70,7 +76,7 @@ errval_t debug_cap_identify(struct capref cap, struct capability *ret)
 
     uint8_t level = get_cap_level(cap);
     capaddr_t caddr = get_cap_addr(cap);
-    err = invoke_monitor_identify_cap(caddr, level, ret);
+    err = invoke_kernel_identify_cap(caddr, level, ret);
     if (err_is_ok(err)) {
         // we have kernel cap, return result;
         return SYS_ERR_OK;
@@ -143,7 +149,7 @@ void debug_printf(const char *fmt, ...)
 /**
  * \brief Function to do the actual printing based on the type of capability
  */
-STATIC_ASSERT(48 == ObjType_Num, "Knowledge of all cap types");
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 int debug_print_cap(char *buf, size_t len, struct capability *cap)
 {
     switch (cap->type) {
@@ -156,17 +162,6 @@ int debug_print_cap(char *buf, size_t len, struct capability *cap)
         return snprintf(buf, len, "RAM cap (0x%" PRIxGENPADDR ":0x%zx)",
                         cap->u.ram.base, cap->u.ram.bytes);
 
-    case ObjType_CNode: {
-        int ret = snprintf(buf, len, "CNode cap "
-                           "(bits %u, rights mask 0x%" PRIxCAPRIGHTS ")",
-                           cap->u.cnode.bits, cap->u.cnode.rightsmask);
-        if (cap->u.cnode.guard_size != 0 && ret < len) {
-            ret += snprintf(&buf[ret], len - ret, " (guard 0x%" PRIxCADDR ":%u)",
-                            cap->u.cnode.guard, cap->u.cnode.guard_size);
-        }
-        return ret;
-    }
-
     case ObjType_L1CNode: {
         int ret = snprintf(buf, len, "L1 CNode cap "
                            "(allocated bytes %#"PRIxGENSIZE
index 13e5a15..0072656 100644 (file)
@@ -221,7 +221,7 @@ errval_t barrelfish_init_onthread(struct spawn_domain_params *params)
         return err_push(err, LIB_ERR_VSPACE_INIT);
     }
 
-    err = slot_alloc_init_2();
+    err = slot_alloc_init();
     if (err_is_fail(err)) {
         return err_push(err, LIB_ERR_SLOT_ALLOC_INIT);
     }
diff --git a/lib/barrelfish/slot_alloc/multi_slot_alloc.c b/lib/barrelfish/slot_alloc/multi_slot_alloc.c
deleted file mode 100644 (file)
index 7973839..0000000
+++ /dev/null
@@ -1,303 +0,0 @@
-/**
- * \file
- * \brief Slot allocator for two layers of cnodes
- *
- * Warning: This code is coupled with vspace/pinned.c and vspace/pmap_*.
- *
- * The allocator maintains a list of single cnode allocators
- * and one single cnode allocator in reserve.
- * When the last slot in the list is allocated,
- * reserve is added to the list and a new reserve is created.
- *
- * Creating a new reserve requires additional slots and virtual address space.
- * 1 slot for the cnode, and more if the slab space needs to be grown.
- * If the slab has to be grown, then 1 slot for the frame.
- * Mapping in the frame can require additional slots.
- * Refer to code in vspace/pmap_* and vspace/util.c for more detail.
- *
- * Growing requires 2 slots from this file.
- *
- * \warning Due to lack of multithread support,
- * the thread safefy and locking is not properly test.
- */
-
-/*
- * Copyright (c) 2010, ETH Zurich.
- * Copyright (c) 2014, HP Labs.
- * 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, Universitaetstr. 6, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/barrelfish.h>
-#include "internal.h"
-
-/**
- * \brief slot allocator
- *
- * \param ca   Instance of the allocator
- * \param ret  Pointer to return the allocated slot
- */
-errval_t multi_alloc(struct slot_allocator *ca, struct capref *ret)
-{
-    errval_t err = SYS_ERR_OK;
-    struct multi_slot_allocator *mca = (struct multi_slot_allocator*)ca;
-
-    thread_mutex_lock(&ca->mutex);
-    assert(ca->space != 0);
-    ca->space--;
-
-    /* Try allocating from the list of single slot allocators */
-    struct slot_allocator_list *walk = mca->head;
-    //struct slot_allocator_list *prev = NULL;
-    while(walk != NULL) {
-        err = walk->a.a.alloc(&walk->a.a, ret);
-        if (err_no(err) != LIB_ERR_SLOT_ALLOC_NO_SPACE) {
-            break;
-        }
-        //prev = walk;
-        walk = walk->next;
-    }
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC);
-    }
-
-    /* If no more slots left, grow */
-    if (ca->space == 0) {
-        ca->space = ca->nslots;
-        /* Pull in the reserve */
-        mca->reserve->next = mca->head;
-        mca->head = mca->reserve;
-
-        /* Setup a new reserve */
-        // Cnode
-        struct capref cap;
-        struct cnoderef cnode;
-        err = mca->top->alloc(mca->top, &cap);
-        if (err_is_fail(err)) {
-            thread_mutex_unlock(&ca->mutex);
-            debug_printf("top allocator out of slots; can't refill\n");
-            return err_push(err, LIB_ERR_SLOT_ALLOC);
-        }
-        thread_mutex_unlock(&ca->mutex); // cnode_create_raw uses ram_alloc
-                                         // which may call slot_alloc
-        err = cnode_create_raw(cap, &cnode, ObjType_CNode, ca->nslots, NULL);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_CNODE_CREATE);
-        }
-        thread_mutex_lock(&ca->mutex);
-
-        // Buffers
-        void *buf = slab_alloc(&mca->slab);
-        if (!buf) { /* Grow slab */
-            // Allocate slot out of the list
-            mca->a.space--;
-            // ensure we have the right allocator
-            vspace_mmu_aware_set_slot_alloc(&mca->mmu_state, &mca->head->a.a);
-
-            thread_mutex_unlock(&ca->mutex); // following functions may call
-                                             // slot_alloc
-            void *slab_buf;
-            size_t size;
-            err = vspace_mmu_aware_map(&mca->mmu_state, mca->slab.blocksize,
-                                       &slab_buf, &size);
-            if (err_is_fail(err)) {
-                return err_push(err, LIB_ERR_VSPACE_MMU_AWARE_MAP);
-            }
-
-            thread_mutex_lock(&ca->mutex);
-
-            // Grow slab
-            slab_grow(&mca->slab, slab_buf, size);
-
-            // Try allocating again
-            buf = slab_alloc(&mca->slab);
-            if (err_is_fail(err)) {
-                thread_mutex_unlock(&ca->mutex);
-                return err_push(err, LIB_ERR_SLAB_ALLOC_FAIL);
-            }
-        }
-
-        mca->reserve = buf;
-        buf = (char *)buf + sizeof(struct slot_allocator_list);
-        size_t bufsize = mca->slab.blocksize - sizeof(struct slot_allocator_list);
-
-        // Allocator
-        err = single_slot_alloc_init_raw(&mca->reserve->a, cap, cnode,
-                                         mca->a.nslots, buf, bufsize);
-        if (err_is_fail(err)) {
-            thread_mutex_unlock(&ca->mutex);
-            return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT_RAW);
-        }
-    }
-
-    thread_mutex_unlock(&ca->mutex);
-    return SYS_ERR_OK;
-}
-
-/**
- * \brief Free an allocated slot
- *
- * \param ca  Instance of the allocator
- * \param cap The slot to free
- *
- * Walks the list of single slot allocators trying to free the slot.
- */
-errval_t multi_free(struct slot_allocator *ca, struct capref cap)
-{
-    errval_t err;
-    thread_mutex_lock(&ca->mutex);
-    struct multi_slot_allocator *mca = (struct multi_slot_allocator*)ca;
-    struct slot_allocator_list *walk = mca->head;
-
-    while(walk != NULL) {
-        err = walk->a.a.free(&walk->a.a, cap);
-        if (err_is_ok(err)) {
-            mca->a.space++;
-        }
-        if (err_no(err) != LIB_ERR_SLOT_ALLOC_WRONG_CNODE) {
-            thread_mutex_unlock(&ca->mutex);
-            return err;
-        }
-        walk = walk->next;
-    }
-
-    thread_mutex_unlock(&ca->mutex);
-    return LIB_ERR_SLOT_ALLOC_WRONG_CNODE;
-}
-
-/**
- * \brief Initializer that does not allocate any space
- *
- * #slot_alloc_init duplicates some of the code below,
- * modify it if making changes here.
- *
- * XXX: top_buf head_buf and reserve_buf each point to a separate buffer of
- * size bufsize bytes which can be used for backing storage. bufsize evidently
- * needs to be >= sizeof(struct cnode_meta) * nslots / 2. Don't ask me why! -AB
- */
-errval_t multi_slot_alloc_init_raw(struct multi_slot_allocator *ret,
-                                   cslot_t nslots, struct capref top_cap,
-                                   struct cnoderef top_cnode,
-                                   void *top_buf, void *head_buf,
-                                   void *reserve_buf, size_t bufsize)
-{
-    errval_t err;
-    struct capref cap;
-    struct cnoderef cnode;
-
-    /* Generic part */
-    ret->a.alloc = multi_alloc;
-    ret->a.free  = multi_free;
-    ret->a.space = nslots;
-    ret->a.nslots = nslots;
-    thread_mutex_init(&ret->a.mutex);
-
-    ret->head->next = NULL;
-    ret->reserve->next = NULL;
-
-    /* Top */
-    err = single_slot_alloc_init_raw((struct single_slot_allocator*)ret->top,
-                                     top_cap, top_cnode, nslots, top_buf, bufsize);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT);
-    }
-
-    /* Head */
-    err = ret->top->alloc(ret->top, &cap);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SLOT_ALLOC);
-    }
-    err = cnode_create_raw(cap, &cnode, ObjType_CNode, nslots, NULL);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_CNODE_CREATE);
-    }
-    err = single_slot_alloc_init_raw(&ret->head->a, cap, cnode, nslots,
-                                     head_buf, bufsize);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT);
-    }
-
-    /* Reserve */
-    err = ret->top->alloc(ret->top, &cap);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SLOT_ALLOC);
-    }
-    err = cnode_create_raw(cap, &cnode, ObjType_CNode, nslots, NULL);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_CNODE_CREATE);
-    }
-    err = single_slot_alloc_init_raw(&ret->reserve->a, cap, cnode, nslots,
-                                     reserve_buf, bufsize);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT);
-    }
-
-    /* Slab */
-    size_t allocation_unit = sizeof(struct slot_allocator_list) +
-                             SINGLE_SLOT_ALLOC_BUFLEN(nslots);
-    slab_init(&ret->slab, allocation_unit, NULL);
-
-    return SYS_ERR_OK;
-}
-
-/**
- * \brief Initializer that uses memory
- */
-errval_t multi_slot_alloc_init(struct multi_slot_allocator *ret,
-                               cslot_t nslots, cslot_t *retslots)
-{
-    errval_t err;
-    nslots = ROUND_UP(nslots, DEFAULT_CNODE_SLOTS);
-    size_t bufsize = SINGLE_SLOT_ALLOC_BUFLEN(nslots); // XXX?
-
-    ret->top = malloc(sizeof(struct single_slot_allocator));
-    if (!ret->top) {
-        return LIB_ERR_MALLOC_FAIL;
-    }
-    void *top_buf = malloc(bufsize);
-    if (!top_buf) {
-        return LIB_ERR_MALLOC_FAIL;
-    }
-
-    ret->head = malloc(sizeof(struct slot_allocator_list));
-    if (!ret->head) {
-        return LIB_ERR_MALLOC_FAIL;
-    }
-    ret->head->next = NULL;
-    void *head_buf = malloc(bufsize);
-    if (!head_buf) {
-        return LIB_ERR_MALLOC_FAIL;
-    }
-
-    ret->reserve = malloc(sizeof(struct slot_allocator_list));
-    if (!ret->reserve) {
-        return LIB_ERR_MALLOC_FAIL;
-    }
-    void *reserve_buf = malloc(bufsize);
-    if (!reserve_buf) {
-        return LIB_ERR_MALLOC_FAIL;
-    }
-
-    size_t allocation_unit = sizeof(struct slot_allocator_list) + bufsize;
-    err = vspace_mmu_aware_init(&ret->mmu_state, allocation_unit * nslots * 2);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_VSPACE_MMU_AWARE_INIT);
-    }
-
-    struct capref cap;
-    struct cnoderef cnode;
-    err = cnode_create(&cap, &cnode, nslots, NULL);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_CNODE_CREATE);
-    }
-    err = multi_slot_alloc_init_raw(ret, nslots, cap, cnode, top_buf,
-                                    head_buf, reserve_buf, bufsize);
-
-    if (retslots) {
-        *retslots = nslots;
-    }
-    return SYS_ERR_OK;
-}
index ed92250..aa652c3 100644 (file)
@@ -149,11 +149,6 @@ errval_t slot_free(struct capref ret)
     return err;
 }
 
-/**
- * \brief Initialize the slot_allocator
- *
- * Initializes the default and root slot_allocator.
- */
 errval_t slot_alloc_init(void)
 {
     errval_t err;
@@ -169,33 +164,20 @@ errval_t slot_alloc_init(void)
     // Generic
     thread_mutex_init(&def->a.mutex);
 
-    def->a.alloc = multi_alloc;
-    def->a.free  = multi_free;
+    def->a.alloc = two_level_alloc;
+    def->a.free  = two_level_free;
     def->a.space = SLOT_ALLOC_CNODE_SLOTS;
     def->a.nslots = SLOT_ALLOC_CNODE_SLOTS;
 
-    def->top = (struct slot_allocator*)&state->top;
     def->head = &state->head;
     def->head->next = NULL;
     def->reserve = &state->reserve;
     def->reserve->next = NULL;
 
-    // Top
-    cap.cnode = cnode_root;
-    cap.slot  = ROOTCN_SLOT_SLOT_ALLOC0;
-    cnode = build_cnoderef(cap, SLOT_ALLOC_CNODE_BITS);
-    err = single_slot_alloc_init_raw((struct single_slot_allocator*)def->top,
-                                     cap, cnode,
-                                     SLOT_ALLOC_CNODE_SLOTS, state->top_buf,
-                                     sizeof(state->top_buf));
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT_RAW);
-    }
-
     // Head
     cap.cnode = cnode_root;
     cap.slot  = ROOTCN_SLOT_SLOT_ALLOC1;
-    cnode = build_cnoderef(cap, SLOT_ALLOC_CNODE_BITS);
+    cnode = build_cnoderef(cap, CNODE_TYPE_OTHER);
     err = single_slot_alloc_init_raw(&def->head->a, cap, cnode,
                                      SLOT_ALLOC_CNODE_SLOTS, state->head_buf,
                                      sizeof(state->head_buf));
@@ -206,7 +188,7 @@ errval_t slot_alloc_init(void)
     // Reserve
     cap.cnode = cnode_root;
     cap.slot  = ROOTCN_SLOT_SLOT_ALLOC2;
-    cnode = build_cnoderef(cap, SLOT_ALLOC_CNODE_BITS);
+    cnode = build_cnoderef(cap, CNODE_TYPE_OTHER);
     err = single_slot_alloc_init_raw(&def->reserve->a, cap, cnode,
                                      SLOT_ALLOC_CNODE_SLOTS, state->reserve_buf,
                                      sizeof(state->reserve_buf));
@@ -222,15 +204,16 @@ errval_t slot_alloc_init(void)
     // Vspace mgmt
     // Warning: necessary to do this in the end as during initialization,
     // libraries can call into slot_alloc.
+    // XXX: this should be resizable
     err = vspace_mmu_aware_init(&def->mmu_state,
-                                allocation_unit * SLOT_ALLOC_CNODE_SLOTS * 2);
+                                allocation_unit * SLOT_ALLOC_CNODE_SLOTS * 20);
     if (err_is_fail(err)) {
         return err_push(err, LIB_ERR_VSPACE_MMU_AWARE_INIT);
     }
 
     /* Root allocator */
     err = single_slot_alloc_init_raw(&state->rootca, cap_root, cnode_root,
-                                     DEFAULT_CNODE_SLOTS, state->root_buf,
+                                     L2_CNODE_SLOTS, state->root_buf,
                                      sizeof(state->root_buf));
     if (err_is_fail(err)) {
         return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT_RAW);
diff --git a/lib/barrelfish/slot_alloc/slot_alloc_2.c b/lib/barrelfish/slot_alloc/slot_alloc_2.c
deleted file mode 100644 (file)
index 6aa24f7..0000000
+++ /dev/null
@@ -1,101 +0,0 @@
-/**
- * \file
- * \brief Slot allocator for two-level CSpace
- */
-
-/*
- * Copyright (c) 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, Universitaetstr. 6, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/barrelfish.h>
-#include <barrelfish/core_state.h>
-#include <barrelfish/caddr.h>
-#include "internal.h"
-
-
-/**
- * \brief Initialize the slot_allocator for two-level CSpace
- *
- * Initializes the default and root slot_allocator.
- */
-errval_t slot_alloc_init_2(void)
-{
-    errval_t err;
-
-    struct slot_alloc_state *state = get_slot_alloc_state();
-
-    /* Default allocator */
-    // While initializing, other domains will call into it. Be careful
-    struct capref cap;
-    struct cnoderef cnode;
-    struct multi_slot_allocator *def = &state->defca;
-
-    // Generic
-    thread_mutex_init(&def->a.mutex);
-
-    def->a.alloc = two_level_alloc;
-    def->a.free  = two_level_free;
-    def->a.space = SLOT_ALLOC_CNODE_SLOTS;
-    def->a.nslots = SLOT_ALLOC_CNODE_SLOTS;
-
-    def->top = NULL;
-    def->head = &state->head;
-    def->head->next = NULL;
-    def->reserve = &state->reserve;
-    def->reserve->next = NULL;
-
-    // Head
-    cap.cnode = cnode_root;
-    cap.slot  = ROOTCN_SLOT_SLOT_ALLOC1;
-    cnode = build_cnoderef(cap, CNODE_TYPE_OTHER);
-    err = single_slot_alloc_init_raw(&def->head->a, cap, cnode,
-                                     SLOT_ALLOC_CNODE_SLOTS, state->head_buf,
-                                     sizeof(state->head_buf));
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT_RAW);
-    }
-
-    // Reserve
-    cap.cnode = cnode_root;
-    cap.slot  = ROOTCN_SLOT_SLOT_ALLOC2;
-    cnode = build_cnoderef(cap, CNODE_TYPE_OTHER);
-    err = single_slot_alloc_init_raw(&def->reserve->a, cap, cnode,
-                                     SLOT_ALLOC_CNODE_SLOTS, state->reserve_buf,
-                                     sizeof(state->reserve_buf));
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT_RAW);
-    }
-
-    // Slab
-    size_t allocation_unit = sizeof(struct slot_allocator_list) +
-                             SINGLE_SLOT_ALLOC_BUFLEN(SLOT_ALLOC_CNODE_SLOTS);
-    slab_init(&def->slab, allocation_unit, NULL);
-
-    // Vspace mgmt
-    // Warning: necessary to do this in the end as during initialization,
-    // libraries can call into slot_alloc.
-    // XXX: this should be resizable
-    err = vspace_mmu_aware_init(&def->mmu_state,
-                                allocation_unit * SLOT_ALLOC_CNODE_SLOTS * 20);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_VSPACE_MMU_AWARE_INIT);
-    }
-
-    /* Root allocator */
-    err = single_slot_alloc_init_raw(&state->rootca, cap_root, cnode_root,
-                                     L2_CNODE_SLOTS, state->root_buf,
-                                     sizeof(state->root_buf));
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SINGLE_SLOT_ALLOC_INIT_RAW);
-    }
-    state->rootca.a.space     = DEFAULT_CNODE_SLOTS - ROOTCN_FREE_SLOTS;
-    state->rootca.head->space = DEFAULT_CNODE_SLOTS - ROOTCN_FREE_SLOTS;
-    state->rootca.head->slot  = ROOTCN_FREE_SLOTS;
-
-    return SYS_ERR_OK;
-}
index 2088c8a..aed709d 100644 (file)
@@ -183,14 +183,13 @@ errval_t two_level_slot_alloc_init_raw(struct multi_slot_allocator *ret,
     errval_t err;
 
     /* Generic part */
-    ret->a.alloc = multi_alloc;
-    ret->a.free  = multi_free;
+    ret->a.alloc = two_level_alloc;
+    ret->a.free  = two_level_free;
     ret->a.space = L2_CNODE_SLOTS;
     ret->a.nslots = L2_CNODE_SLOTS;
     thread_mutex_init(&ret->a.mutex);
 
     // Top unused in two-level allocator
-    ret->top = NULL;
 
     ret->head->next = NULL;
     ret->reserve->next = NULL;
@@ -227,10 +226,6 @@ errval_t two_level_slot_alloc_init(struct multi_slot_allocator *ret)
     errval_t err;
     size_t bufsize = SINGLE_SLOT_ALLOC_BUFLEN(L2_CNODE_SLOTS); // XXX?
 
-    ret->top = malloc(sizeof(struct single_slot_allocator));
-    if (!ret->top) {
-        return LIB_ERR_MALLOC_FAIL;
-    }
     void *top_buf = malloc(bufsize);
     if (!top_buf) {
         return LIB_ERR_MALLOC_FAIL;
index d373a58..24f999f 100644 (file)
@@ -170,17 +170,20 @@ mdb_dump_all_the_things(void)
     mdb_dump(mdb_root, 0);
 }
 
+STATIC_ASSERT(47 == ObjType_Num, "Knowledge of all cap types");
 static void print_cte(struct cte *cte, char *indent_buff)
 {
     struct mdbnode *node = N(cte);
     char extra[255] = { 0 };
     struct capability *cap = C(cte);
     switch (cap->type) {
-        case ObjType_CNode:
+        case ObjType_L1CNode:
             snprintf(extra, 255,
-                    "[guard=0x%08"PRIxCADDR",guard_size=%"PRIu8",rightsmask=%"PRIu8"]",
-                    cap->u.cnode.guard, cap->u.cnode.guard_size,
-                    cap->u.cnode.rightsmask);
+                    "[allocated_bytes=%"PRIxGENSIZE",rightsmask=%"PRIu8"]",
+                    cap->u.l1cnode.allocated_bytes, cap->u.l1cnode.rightsmask);
+            break;
+        case ObjType_L2CNode:
+            snprintf(extra, 255, "[rightsmask=%"PRIu8"]", cap->u.l2cnode.rightsmask);
             break;
         case ObjType_EndPoint:
             snprintf(extra, 255,
index ecc1e58..efd8091 100644 (file)
@@ -1,14 +1,14 @@
 --------------------------------------------------------------------------
--- Copyright (c) 2007-2009, ETH Zurich.
+-- Copyright (c) 2007-2009, 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.
 --
 -- Hakefile for lib/mm
 -- 
 --------------------------------------------------------------------------
 
-[ build library { target = "mm", cFiles = [ "mm.c", "slot_alloc.c", "slot_alloc_2.c" ] } ]
+[ build library { target = "mm", cFiles = [ "mm.c", "slot_alloc.c" ] } ]
 
index f8babd9..1a102b4 100644 (file)
@@ -4,12 +4,12 @@
  */
 
 /*
- * Copyright (c) 2007, 2008, ETH Zurich.
+ * Copyright (c) 2007, 2008, 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.
  */
 
 #include <barrelfish/barrelfish.h>
 #include <mm/slot_alloc.h>
 #include <stdio.h>
 
+static errval_t rootcn_alloc(void *st, uint8_t reqbits, struct capref *ret)
+{
+    return mm_alloc(st, reqbits, ret, NULL);
+}
+
 /// Allocate a new cnode if needed
 errval_t slot_prealloc_refill(struct slot_prealloc *this)
 {
     uint8_t refill = !this->current;
     errval_t err;
 
-    if (this->meta[refill].free == (1UL << this->cnode_size_bits)) {
+    if (this->meta[refill].free == L2_CNODE_SLOTS) {
         return SYS_ERR_OK; // Nop
     }
 
-    /* Check for initialize case */
-    // When initializing, the cnode on the other point should be NULL
-    if (this->top_used == -1UL) {
-        // Allocate a ram cap
-        struct capref ram_cap;
-        err = mm_alloc(this->mm, this->cnode_size_bits + OBJBITS_CTE, &ram_cap,
-                       NULL);
-        if (err_is_fail(err)) {
-            return err_push(err, MM_ERR_SLOT_MM_ALLOC);
-        }
-
-        // Retype to and build the top level cnode
-        err = cnode_create_from_mem(this->top_cnode_slot, ram_cap, ObjType_CNode,
-                                    &this->top_cnode, this->cnode_size_bits);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_CNODE_CREATE);
-        }
-
-        this->top_used = 0;
-    }
-
-    // Still enough slots in the top cnode
-    assert(this->top_used < (1UL << this->cnode_size_bits));
-
     // Allocate a ram cap
     struct capref ram_cap;
-    err = mm_alloc(this->mm, this->cnode_size_bits + OBJBITS_CTE, &ram_cap, NULL);
+    err = mm_alloc(this->mm, L2_CNODE_BITS + OBJBITS_CTE, &ram_cap, NULL);
     if (err_is_fail(err)) {
         return err_push(err, MM_ERR_SLOT_MM_ALLOC);
     }
 
     // Retype to and build the next cnode
-    struct capref cnode_cap = {
-        .cnode = this->top_cnode,
-        .slot  = this->top_used++
-    };
-    err = cnode_create_from_mem(cnode_cap, ram_cap, ObjType_CNode,
-                                &this->meta[refill].cap.cnode,
-                                this->cnode_size_bits);
+    struct capref cnode_cap;
+    err = slot_alloc_root(&cnode_cap);
+    if (err_no(err) == LIB_ERR_SLOT_ALLOC_NO_SPACE) {
+        // resize root slot allocator (and rootcn)
+        err = root_slot_allocator_refill(rootcn_alloc, this->mm);
+        if (err_is_fail(err)) {
+            return err_push(err, LIB_ERR_ROOTSA_RESIZE);
+        }
+        // retry slot_alloc_root
+        err = slot_alloc_root(&cnode_cap);
+    }
+    if (err_is_fail(err)) {
+        return err_push(err, LIB_ERR_SLOT_ALLOC);
+    }
+
+    err = cnode_create_from_mem(cnode_cap, ram_cap, ObjType_L2CNode,
+            &this->meta[refill].cap.cnode, L2_CNODE_SLOTS);
     if (err_is_fail(err)) {
         return err_push(err, LIB_ERR_CNODE_CREATE);
     }
 
     // Set the metadata
     this->meta[refill].cap.slot  = 0;
-    this->meta[refill].free      = (1UL << this->cnode_size_bits);
+    this->meta[refill].free      = L2_CNODE_SLOTS;
 
     return SYS_ERR_OK;
 }
@@ -104,25 +95,23 @@ errval_t slot_alloc_prealloc(void *inst, uint64_t nslots, struct capref *ret)
  * \brief Initialise preallocating slot allocator instance
  *
  * \param this Pointer to area for instance data
- * \param top Location to place top-level CNode
  * \param maxslotbits Maximum size of each allocation (in bits)
- * \param cnode_size_bits Size of CNodes (in bits) to create (>= maxslotbits)
  * \param initial_cnode First cap in an empty cnode to start allocating from
  * \param initial_space Number of slots free in initial cnode
  * \param ram_mm Memory allocator to use for RAM caps when creating new CNodes
  */
-errval_t slot_prealloc_init(struct slot_prealloc *this, struct capref top,
-                            uint8_t maxslotbits, uint8_t cnode_size_bits,
+errval_t slot_prealloc_init(struct slot_prealloc *this, uint8_t maxslotbits,
                             struct capref initial_cnode, uint64_t initial_space,
                             struct mm *ram_mm)
 {
-    assert(cnode_size_bits >= maxslotbits);
     this->maxslotbits = maxslotbits;
-    this->cnode_size_bits = cnode_size_bits;
     this->mm = ram_mm;
 
-    this->top_cnode_slot = top;
-    this->top_used = -1UL; /* flag */
+    assert(initial_space == L2_CNODE_SLOTS);
+    if (initial_space != L2_CNODE_SLOTS) {
+        debug_printf("Initial CNode for 2 level preallocating slot allocator needs to be 16kB");
+        return LIB_ERR_SLOT_ALLOC_INIT;
+    }
 
     this->current = 0;
     this->meta[0].cap       = initial_cnode;
diff --git a/lib/mm/slot_alloc_2.c b/lib/mm/slot_alloc_2.c
deleted file mode 100644 (file)
index b7fe816..0000000
+++ /dev/null
@@ -1,122 +0,0 @@
-/**
- * \file
- * \brief Slot management for the memory allocator.
- */
-
-/*
- * Copyright (c) 2007, 2008, 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, Universitaetstr. 6, CH-8092 Zurich. Attn: Systems Group.
- */
-
-#include <barrelfish/barrelfish.h>
-#include <mm/mm.h>
-#include <mm/slot_alloc.h>
-#include <stdio.h>
-
-static errval_t rootcn_alloc(void *st, uint8_t reqbits, struct capref *ret)
-{
-    return mm_alloc(st, reqbits, ret, NULL);
-}
-
-/// Allocate a new cnode if needed
-errval_t slot_prealloc_refill_2(struct slot_prealloc_2 *this)
-{
-    uint8_t refill = !this->current;
-    errval_t err;
-
-    if (this->meta[refill].free == L2_CNODE_SLOTS) {
-        return SYS_ERR_OK; // Nop
-    }
-
-    // Allocate a ram cap
-    struct capref ram_cap;
-    err = mm_alloc(this->mm, L2_CNODE_BITS + OBJBITS_CTE, &ram_cap, NULL);
-    if (err_is_fail(err)) {
-        return err_push(err, MM_ERR_SLOT_MM_ALLOC);
-    }
-
-    // Retype to and build the next cnode
-    struct capref cnode_cap;
-    err = slot_alloc_root(&cnode_cap);
-    if (err_no(err) == LIB_ERR_SLOT_ALLOC_NO_SPACE) {
-        // resize root slot allocator (and rootcn)
-        err = root_slot_allocator_refill(rootcn_alloc, this->mm);
-        if (err_is_fail(err)) {
-            return err_push(err, LIB_ERR_ROOTSA_RESIZE);
-        }
-        // retry slot_alloc_root
-        err = slot_alloc_root(&cnode_cap);
-    }
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SLOT_ALLOC);
-    }
-
-    err = cnode_create_from_mem(cnode_cap, ram_cap, ObjType_L2CNode,
-            &this->meta[refill].cap.cnode, L2_CNODE_SLOTS);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_CNODE_CREATE);
-    }
-
-    // Set the metadata
-    this->meta[refill].cap.slot  = 0;
-    this->meta[refill].free      = L2_CNODE_SLOTS;
-
-    return SYS_ERR_OK;
-}
-
-errval_t slot_alloc_prealloc_2(void *inst, uint64_t nslots, struct capref *ret)
-{
-    struct slot_prealloc_2 *this = inst;
-    assert(nslots <= (1UL << this->maxslotbits));
-
-    /* Check if enough space */
-    if (this->meta[this->current].free < nslots) {
-        // Allocate from next cnode
-        this->current = !this->current;
-    }
-
-    if (this->meta[this->current].free < nslots) {
-        return MM_ERR_SLOT_NOSLOTS;
-    }
-
-    /* Return next slot and update */
-    *ret = this->meta[this->current].cap;
-    this->meta[this->current].cap.slot += nslots;
-    this->meta[this->current].free -= nslots;
-
-    return SYS_ERR_OK;
-}
-
-/**
- * \brief Initialise preallocating slot allocator instance
- *
- * \param this Pointer to area for instance data
- * \param maxslotbits Maximum size of each allocation (in bits)
- * \param initial_cnode First cap in an empty cnode to start allocating from
- * \param initial_space Number of slots free in initial cnode
- * \param ram_mm Memory allocator to use for RAM caps when creating new CNodes
- */
-errval_t slot_prealloc_init_2(struct slot_prealloc_2 *this, uint8_t maxslotbits,
-                              struct capref initial_cnode, uint64_t initial_space,
-                              struct mm *ram_mm)
-{
-    this->maxslotbits = maxslotbits;
-    this->mm = ram_mm;
-
-    assert(initial_space == L2_CNODE_SLOTS);
-    if (initial_space != L2_CNODE_SLOTS) {
-        debug_printf("Initial CNode for 2 level preallocating slot allocator needs to be 16kB");
-        return LIB_ERR_SLOT_ALLOC_INIT;
-    }
-
-    this->current = 0;
-    this->meta[0].cap       = initial_cnode;
-    this->meta[0].free      = initial_space;
-    this->meta[1].free      = 0;
-
-    return SYS_ERR_OK;
-}
index 79cc0a6..c597bac 100644 (file)
@@ -89,8 +89,6 @@ void dummy(void)
     DECL(DCB_RR_PREV, struct dcb, prev);
     DECL(DCB_RBED_NEXT, struct dcb, next);
 
-    DECL(CAP_CNODE_BITS, struct capability, u.cnode.bits);
-    DECL(CAP_CNODE_CNODE, struct capability, u.cnode.cnode);
     DECL(CAP_TYPE, struct capability, type);
     DECL(CAP_ENDPOINT_EPOFFSET, struct capability, u.endpoint.epoffset);
     DECL(CAP_ENDPOINT_EPBUFLEN, struct capability, u.endpoint.epbuflen);
index 0f53b0b..76cf537 100644 (file)
@@ -32,7 +32,7 @@ enum task_type {
 };
 
 enum objtype {
-    ObjType_CNode,
+    ObjType_L1CNode,
     ObjType_EndPoint
 };
 
@@ -112,7 +112,7 @@ static struct dcb *sched, **allptrs;
 static void init_dcb(struct dcb *dcb, int id)
 {
     dcb->disp = (uintptr_t)&dcb->dsg;
-    dcb->cspace.cap.type = ObjType_CNode;
+    dcb->cspace.cap.type = ObjType_L1CNode;
     dcb->ep.cap.type = ObjType_EndPoint;
     dcb->vspace = 1;
     dcb->next = NULL;
index 61411dd..e3a95f2 100644 (file)
@@ -78,7 +78,7 @@ static struct bootinfo *bi;
 static struct mm mm_ram;
 
 /// Slot allocator for MM
-static struct slot_prealloc_2 ram_slot_alloc;
+static struct slot_prealloc ram_slot_alloc;
 
 static errval_t mymm_alloc(struct capref *ret, uint8_t bits, genpaddr_t minbase,
                            genpaddr_t maxlimit)
@@ -253,7 +253,7 @@ static void mem_allocate_handler(struct mem_binding *b, uint8_t bits,
     trace_event(TRACE_SUBSYS_MEMSERV, TRACE_EVENT_MEMSERV_ALLOC, bits);
 
     /* refill slot allocator if needed */
-    err = slot_prealloc_refill_2(mm_ram.slot_alloc_inst);
+    err = slot_prealloc_refill(mm_ram.slot_alloc_inst);
     if (err_is_fail(err)) {
         DEBUG_ERR(err, "slot_prealloc_refill in mem_allocate_handler");
     }
@@ -401,14 +401,14 @@ initialize_ram_alloc(void)
     };
 
     /* init slot allocator */
-    err = slot_prealloc_init_2(&ram_slot_alloc, MAXCHILDBITS,
-                               cnode_start_cap, L2_CNODE_SLOTS,
-                               &mm_ram);
+    err = slot_prealloc_init(&ram_slot_alloc, MAXCHILDBITS,
+                             cnode_start_cap, L2_CNODE_SLOTS,
+                             &mm_ram);
     assert(err_is_ok(err));
 
     err = mm_init(&mm_ram, ObjType_RAM, guess_physical_addr_start(),
-                MAXSIZEBITS, MAXCHILDBITS, NULL,
-                slot_alloc_prealloc_2, NULL, &ram_slot_alloc, true);
+                  MAXSIZEBITS, MAXCHILDBITS, NULL,
+                  slot_alloc_prealloc, NULL, &ram_slot_alloc, true);
     assert(err_is_ok(err));
 
     /* give MM allocator static storage to get it started */
@@ -443,9 +443,9 @@ initialize_ram_alloc(void)
             }
 
             /* try to refill slot allocator (may fail if the mem allocator is empty) */
-            err = slot_prealloc_refill_2(mm_ram.slot_alloc_inst);
+            err = slot_prealloc_refill(mm_ram.slot_alloc_inst);
             if (err_is_fail(err) && err_no(err) != MM_ERR_SLOT_MM_ALLOC) {
-                DEBUG_ERR(err, "in slot_prealloc_refill_2() while initialising"
+                DEBUG_ERR(err, "in slot_prealloc_refill() while initialising"
                         " memory allocator");
                 abort();
             }
@@ -461,7 +461,7 @@ initialize_ram_alloc(void)
         }
     }
 
-    err = slot_prealloc_refill_2(mm_ram.slot_alloc_inst);
+    err = slot_prealloc_refill(mm_ram.slot_alloc_inst);
     if (err_is_fail(err)) {
         printf("Fatal internal error in RAM allocator: failed to initialise "
                "slot allocator\n");
index ee7c7f3..9fa2f46 100644 (file)
@@ -515,48 +515,28 @@ static errval_t init_mm(struct mm *mm, char nodebuf[], memsize_t nodebuf_size,
     return SYS_ERR_OK;
 }
 
-static errval_t init_slot_allocator(struct slot_prealloc *slot_alloc_inst, 
+static errval_t init_slot_allocator(struct slot_prealloc *slot_alloc_inst,
                                 struct mm *mm)
 {
     errval_t err;
 
-    // Initialize slot allocator by passing a cnode cap for it to start with 
-    struct capref cnode_cap;
-    err = slot_alloc(&cnode_cap);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_SLOT_ALLOC);
-    }
-
-    struct capref cnode_start_cap = { .slot  = 0 };
-    struct capref ram;
-
-    err = ram_alloc(&ram, BASE_PAGE_BITS);
-    if (err_is_fail(err)) {
-        DEBUG_ERR(err, "failed to allocate RAM cap for cnode");
-        return err_push(err, LIB_ERR_RAM_ALLOC);
-    }
-
-    err = cnode_create_from_mem(cnode_cap, ram, ObjType_CNode,
-                                &cnode_start_cap.cnode, DEFAULT_CNODE_BITS);
-    if (err_is_fail(err)) {
-        return err_push(err, LIB_ERR_CNODE_CREATE_FROM_MEM);
-    }
-
-    // location where slot allocator will place its top-level cnode 
-    struct capref top_slot_cap = {
-        .cnode = cnode_root,
-        .slot = ROOTCN_SLOT_MODULECN, // XXX: we don't have the module CNode
+    // Use ROOTCN_SLOT_SLOT_ALLOC0 as initial cnode for mm slot allocator
+    struct capref cnode_start_cap = {
+        .cnode = {
+            .croot = CPTR_ROOTCN,
+            .cnode = ROOTCN_SLOT_ADDR(ROOTCN_SLOT_SLOT_ALLOC0),
+            .level = CNODE_TYPE_OTHER,
+        },
+        .slot = 0,
     };
 
     // init slot allocator 
-    err = slot_prealloc_init(slot_alloc_inst, top_slot_cap,
-                             MAXCHILDBITS,
-                             CNODE_BITS, cnode_start_cap,
-                             1UL << DEFAULT_CNODE_BITS, mm);
+    err = slot_prealloc_init(slot_alloc_inst, MAXCHILDBITS,
+                             cnode_start_cap, L2_CNODE_SLOTS, mm);
     if (err_is_fail(err)) {
         return err_push(err, MM_ERR_SLOT_ALLOC_INIT);
-    } 
-      
+    }
+
     return SYS_ERR_OK;
 }