T187: x86_64: squash capability size to 64 bytes
authorSimon Gerber <simon.gerber@inf.ethz.ch>
Tue, 17 Nov 2015 19:11:55 +0000 (20:11 +0100)
committerSimon Gerber <simon.gerber@inf.ethz.ch>
Tue, 17 Nov 2015 19:11:55 +0000 (20:11 +0100)
Signed-off-by: Simon Gerber <simon.gerber@inf.ethz.ch>

capabilities/caps.hl
include/barrelfish_kpi/capabilities.h
include/barrelfish_kpi/init.h
kernel/arch/x86_64/entry.S
kernel/arch/x86_64/syscall.c
kernel/include/capabilities.h
kernel/syscall.c
tools/hamlet/HamletBackend.lhs
tools/hamlet/Main.lhs
usr/monitor/include/arch/x86_64/monitor_invocations_arch.h

index d9ef938..602bda0 100644 (file)
@@ -23,7 +23,7 @@
  * barrelfish_kpi/capabilities.h */
 
 /* Size of CNode entry: */
-define cte_size 7;
+define cte_size 6;
 /* Size of DCB: */
 define dispatcher_size 10;
 /* Size of (x86_64) VNode: */
index 6be1bbf..8c9f33b 100644 (file)
@@ -19,7 +19,7 @@
 /* FIXME: OBJBITS defines must match sizes in Hamlet's capabilities/caps.hl */
 
 // Size of CNode entry
-#define OBJBITS_CTE             7
+#define OBJBITS_CTE             6
 
 // Size of dispatcher
 #define OBJBITS_DISPATCHER     10
index 5ee12bd..bfec78d 100644 (file)
@@ -65,7 +65,7 @@
 #define DEFAULT_CNODE_SLOTS      (1UL << DEFAULT_CNODE_BITS)
 
 /// Number of entries in page cnode (in bits)
-#define PAGE_CNODE_BITS         (DEFAULT_CNODE_BITS + 3)
+#define PAGE_CNODE_BITS         (DEFAULT_CNODE_BITS + 2)
 
 /// Number of entries in page cnode
 #define PAGE_CNODE_SLOTS        (1UL << PAGE_CNODE_BITS)
index c8b124e..d0f92d8 100644 (file)
@@ -75,7 +75,7 @@ syscall_entry:
        add     %rsi, %rcx
 
        /* Check that it's an endpoint */
-       cmpl    $OBJTYPE_ENDPOINT, OFFSETOF_CAP_TYPE(%rcx)
+       cmpb    $OBJTYPE_ENDPOINT, OFFSETOF_CAP_TYPE(%rcx)
        jne     err_endpoint
 
        /* TODO: Check rights on the endpoint */
index 4909fef..3baaa1a 100644 (file)
@@ -429,7 +429,7 @@ static struct sysret monitor_create_cap(struct capability *kernel_cap,
 {
     /* XXX: Get the raw metadata of the capability to create */
     struct capability *src = (struct capability *)args;
-    int pos = sizeof(struct capability) / sizeof(uint64_t);
+    int pos = ROUND_UP(sizeof(struct capability), sizeof(uint64_t)) / sizeof(uint64_t);
 
     /* Cannot create null caps */
     if (src->type == ObjType_Null) {
@@ -450,6 +450,7 @@ static struct sysret monitor_create_cap(struct capability *kernel_cap,
     capaddr_t cnode_cptr = args[pos];
     int cnode_vbits      = args[pos + 1];
     size_t slot          = args[pos + 2];
+    assert(cnode_vbits < CPTR_BITS);
 
     return SYSRET(caps_create_from_existing(&dcb_current->cspace.cap,
                                             cnode_cptr, cnode_vbits,
@@ -461,7 +462,7 @@ static struct sysret monitor_copy_existing(struct capability *kernel_cap,
 {
     /* XXX: Get the raw metadata of the capability to create */
     struct capability *src = (struct capability *)args;
-    int pos = sizeof(struct capability) / sizeof(uint64_t);
+    int pos = ROUND_UP(sizeof(struct capability), sizeof(uint64_t)) / sizeof(uint64_t);
 
     capaddr_t cnode_cptr = args[pos];
     int cnode_vbits    = args[pos + 1];
index 5f9b713..3f6ffa4 100644 (file)
@@ -31,11 +31,18 @@ struct delete_list {
     char padding[DELETE_LIST_SIZE - sizeof(struct cte*)];
 };
 
-STATIC_ASSERT((sizeof(struct capability) + sizeof(struct mdbnode)
-               + sizeof(struct delete_list) + sizeof(struct mapping_info))
+#ifndef ROUND_UP
+#define ROUND_UP(n, size)           ((((n) + (size) - 1)) & (~((size) - 1)))
+#endif
+
+STATIC_ASSERT((ROUND_UP(sizeof(struct capability), 8)
+               + ROUND_UP(sizeof(struct mdbnode), 8)
+               + sizeof(struct delete_list))
                <= (1UL << OBJBITS_CTE),
               "cap+mdbnode fit in cte");
 
+STATIC_ASSERT(sizeof(enum objtype) == 1, "short enums work");
+
 /**
  * \brief A CTE (Capability Table Entry).
  *
@@ -45,16 +52,16 @@ STATIC_ASSERT((sizeof(struct capability) + sizeof(struct mdbnode)
  */
 struct cte {
     struct capability   cap;            ///< The capability
+    char padding0[ROUND_UP(sizeof(struct capability), 8)- sizeof(struct capability)];
     struct mdbnode      mdbnode;        ///< MDB "root" node for the cap
+    char padding1[ROUND_UP(sizeof(struct mdbnode), 8) - sizeof(struct mdbnode)];
     struct delete_list  delete_node;    ///< State for in-progress delete cascades
-#if 0
-    struct mapping_info mapping_info;   ///< Mapping info for mapped pmem capabilities
-#endif
 
     /// Padding to fill the struct out to the size required by OBJBITS_CTE
     char padding[(1UL << OBJBITS_CTE)
-                 - sizeof(struct capability) - sizeof(struct mdbnode)
-                 - sizeof(struct delete_list)];
+                 - sizeof(struct delete_list)
+                 - ROUND_UP(sizeof(struct capability), 8)
+                 - ROUND_UP(sizeof(struct mdbnode), 8)];
 };
 
 STATIC_ASSERT_SIZEOF(struct cte, (1UL << OBJBITS_CTE));
index f52227c..313d249 100644 (file)
@@ -376,6 +376,7 @@ sys_map(struct capability *ptable, cslot_t slot, capaddr_t source_cptr,
     if (mapping_cnode_cte->cap.type != ObjType_CNode) {
         return SYSRET(SYS_ERR_DEST_TYPE_INVALID);
     }
+
     struct cte *mapping_cte = caps_locate_slot(get_address(&mapping_cnode_cte->cap),
                                                mapping_slot);
     if (mapping_cte->cap.type != ObjType_Null) {
index 4c80a71..186b56e 100644 (file)
 
 > mkCapsStruct :: Capabilities -> TFieldList
 > mkCapsStruct caps = strict
->     [("type", objtypeT),
->      ("rights", capRightsT),
->      ("u", capUnionT)]
+>     [("u", capUnionT),
+>      ("type", objtypeT),
+>      ("rights", capRightsT)]
 >     where capUnionT = unionST "capability_u" ((map (\cap -> (lower $ capNameOf cap, mkCapStructT cap))
 >                                                  (capabilities caps)) )
 >                      -- XXX: Why do I need to define types here when they are already
@@ -590,7 +590,7 @@ count).
 
 > backend :: Capabilities -> FoFCode PureExpr
 > backend caps =
->     do dummy <- newEnum "objtype" enums "ObjType_Num"
+>     do dummy <- newEnum "__attribute__((__packed__)) objtype" enums "ObjType_Num"
 >        getAddress <- get_address caps
 >        getSize <- get_size caps
 >        getTypeRoot <- get_type_root caps
index 7152e06..ae71d13 100644 (file)
 >                    hPutStrLn fileDefs "#ifndef CAPBITS_H"
 >                    hPutStrLn fileDefs "#define CAPBITS_H"
 >                    hPutStrLn fileDefs "#include <barrelfish_kpi/capabilities.h>"
+>                    hPutStrLn fileDefs "#pragma pack(1)"
 >                    hPutStrLn fileDefs $! show $ vcat' $ extractM $ types compiledCode
 >                    hPutStrLn fileDefs $! show $ vcat' $ extractL $ declarations compiledCode
+>                    hPutStrLn fileDefs "#pragma pack(0)"
 >                    hPutStrLn fileDefs "#endif // CAPBITS_H"
 >                    hClose fileDefs
 >
index a7cb063..15a2505 100644 (file)
@@ -73,10 +73,9 @@ invoke_monitor_nullify_cap(capaddr_t cap, int bits)
 static inline errval_t
 invoke_monitor_create_cap(uint64_t *raw, capaddr_t caddr, int bits, capaddr_t slot, coreid_t owner)
 {
-    assert(sizeof(struct capability) % sizeof(uint64_t) == 0);
-    assert(sizeof(struct capability) / sizeof(uint64_t) == 4);
-    return cap_invoke9(cap_kernel, KernelCmd_Create_cap,
-                       raw[0], raw[1], raw[2], raw[3],
+    assert(sizeof(struct capability) <= 3*sizeof(uint64_t));
+    return cap_invoke8(cap_kernel, KernelCmd_Create_cap,
+                       raw[0], raw[1], raw[2],
                        caddr, bits, slot, owner).error;
 }
 
@@ -99,9 +98,9 @@ invoke_monitor_remote_cap_retype(capaddr_t rootcap_addr, uint8_t rootcap_vbits,
 static inline errval_t
 invoke_monitor_copy_existing(uint64_t *raw, capaddr_t cn_addr, int cn_bits, cslot_t slot)
 {
-    assert(sizeof(struct capability) == 4*sizeof(uint64_t));
-    return cap_invoke8(cap_kernel, KernelCmd_Copy_existing,
-                       raw[0], raw[1], raw[2], raw[3],
+    assert(sizeof(struct capability) <= 3*sizeof(uint64_t));
+    return cap_invoke7(cap_kernel, KernelCmd_Copy_existing,
+                       raw[0], raw[1], raw[2],
                        cn_addr, cn_bits, slot).error;
 }
 
@@ -207,11 +206,9 @@ invoke_monitor_revoke_mark_target(capaddr_t root, int rbits,
 static inline errval_t
 invoke_monitor_revoke_mark_relations(uint64_t *raw_base)
 {
-    assert(sizeof(struct capability) % sizeof(uint64_t) == 0);
-    assert(sizeof(struct capability) / sizeof(uint64_t) == 4);
-    return cap_invoke5(cap_kernel, KernelCmd_Revoke_mark_relations,
-                       raw_base[0], raw_base[1],
-                       raw_base[2], raw_base[3]).error;
+    assert(sizeof(struct capability) <= 3*sizeof(uint64_t));
+    return cap_invoke4(cap_kernel, KernelCmd_Revoke_mark_relations,
+                       raw_base[0], raw_base[1], raw_base[2]).error;
 }
 
 static inline errval_t
@@ -231,11 +228,10 @@ invoke_monitor_clear_step(capaddr_t retcn, int retcnbits, cslot_t retslot)
 static inline errval_t
 invoke_monitor_has_descendants(uint64_t *raw, bool *res)
 {
-    assert(sizeof(struct capability) % sizeof(uint64_t) == 0);
-    assert(sizeof(struct capability) / sizeof(uint64_t) == 4);
+    assert(sizeof(struct capability) <= 3*sizeof(uint64_t));
     struct sysret sysret;
-    sysret = cap_invoke5(cap_kernel, KernelCmd_Has_descendants,
-                         raw[0], raw[1], raw[2], raw[3]);
+    sysret = cap_invoke4(cap_kernel, KernelCmd_Has_descendants,
+                         raw[0], raw[1], raw[2]);
     if (err_is_ok(sysret.error)) {
         *res = sysret.value;
     }