git.barrelfish.org Git - barrelfish/blob - include/barrelfish/caddr.h

   1 /**
   2  * \file
   3  * \brief Inline functions to allow manipulation of raw capability addresses
   4  *
   5  * This file is not part of the standard includes, because most user code should
   6  * treat #capref as an opaque value.
   7  */
   8
   9 /*
  10  * Copyright (c) 2007, 2008, 2009, 2010, 2012, ETH Zurich.
  11  * All rights reserved.
  12  *
  13  * This file is distributed under the terms in the attached LICENSE file.
  14  * If you do not find this file, copies can be found by writing to:
  15  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
  16  */
  17
  18 #ifndef INCLUDEBARRELFISH_CADDR_H
  19 #define INCLUDEBARRELFISH_CADDR_H
  20
  21 #include <stdbool.h>
  22 #include <sys/cdefs.h>
  23
  24 #include <barrelfish_kpi/types.h>
  25 #include <barrelfish_kpi/init.h>
  26 #include <barrelfish_kpi/capabilities.h>
  27
  28 #include <barrelfish/cspace.h>
  29
  30 #include <stdint.h>
  31 #include <stdbool.h>
  32
  33 #include <bitmacros.h>
  34
  35 __BEGIN_DECLS
  36
  37 /**
  38  * \brief extract slot (L2 index) from capability address `addr`
  39  * \param addr the capability address
  40  * \return The slot number (L2 index) component of the address, i.e. the low
  41  *         bits.
  42  */
  43 static inline cslot_t get_capaddr_slot(capaddr_t addr)
  44 {
  45     return (cslot_t)(addr & MASK_T(capaddr_t, L2_CNODE_BITS));
  46 }
  47
  48 /**
  49  * \brief extract CNode address component from capability address `addr`
  50  * \param addr the capability address
  51  * \return the cnode component of the address, i.e. the address with the slot
  52  *         (L2 index) bits set to zero.
  53  */
  54 static inline capaddr_t get_capaddr_cnode_addr(capaddr_t addr)
  55 {
  56     return addr & ~MASK_T(capaddr_t, L2_CNODE_BITS);
  57 }
  58
  59 enum cnode_type {
  60     CNODE_TYPE_ROOT = 0,
  61     CNODE_TYPE_OTHER,
  62     CNODE_TYPE_COUNT,
  63 } __attribute__((packed));
  64
  65 /**
  66  * \brief User-level representation of a CNode, this is essentially a capref
  67  * to a CNode.
  68  */
  69 struct cnoderef {
  70     capaddr_t croot;
  71     capaddr_t cnode;
  72     enum cnode_type level;
  73 } __attribute__((packed));
  74
  75 #define NULL_CNODE (struct cnoderef){ \
  76     /*croot*/ 0, /*cnode*/ 0, \
  77     /*level*/ CNODE_TYPE_ROOT  }
  78
  79 /**
  80  * \brief User-level representation of a capability and its CSpace address
  81  */
  82
  83 struct capref {
  84     struct cnoderef cnode;
  85     cslot_t slot;
  86 };
  87
  88 #define NULL_CAP (struct capref){ /*cnode*/ NULL_CNODE, /*slot*/ 0 }
  89
  90 static inline bool cnoderef_is_null(struct cnoderef cnoderef)
  91 {
  92     return cnoderef.croot == 0 && cnoderef.cnode == 0;
  93 }
  94
  95 static inline bool capref_is_null(struct capref capref)
  96 {
  97     return cnoderef_is_null(capref.cnode) && capref.slot == 0;
  98 }
  99
 100 /* well-known cnodes */
 101 extern struct cnoderef cnode_root, cnode_task, cnode_base, cnode_super,
 102                        cnode_page, cnode_module;
 103
 104 /* well-known capabilities */
 105 extern struct capref cap_root, cap_monitorep, cap_irq, cap_io, cap_dispatcher,
 106                      cap_selfep, cap_kernel, cap_initep, cap_perfmon, cap_dispframe,
 107                      cap_sessionid, cap_ipi, cap_vroot, cap_argcn, cap_procmng;
 108
 109 /**
 110  * \brief Returns the depth in the CSpace address of a cap
 111  */
 112 static inline uint8_t get_cap_level(struct capref cap)
 113 {
 114     if (capref_is_null(cap)) {
 115         return 0;
 116     } else {
 117         return cap.cnode.level + 1;
 118     }
 119 }
 120
 121 /**
 122  * \brief Returns the CSpace address of a cap
 123  */
 124 static inline capaddr_t get_cap_addr(struct capref cap)
 125 {
 126     if (!capref_is_null(cap)) {
 127         switch (cap.cnode.level) {
 128             case CNODE_TYPE_ROOT:
 129                 return cap.slot << L2_CNODE_BITS;
 130             // capref is in L2 CNode
 131             case CNODE_TYPE_OTHER:
 132                 return cap.cnode.cnode | cap.slot;
 133             default:
 134                 assert(!"invalid level");
 135                 return 0x0;
 136         }
 137     }
 138     return 0;
 139 }
 140
 141 /**
 142  * \brief Returns the depth in the CSpace address of the CNode
 143  *        containing the given cap
 144  */
 145 static inline uint8_t get_cnode_level(struct capref cap)
 146 {
 147     return cap.cnode.level;
 148 }
 149
 150 /**
 151  * \brief Returns the CSpace address of the CNode containing the given cap
 152  */
 153 static inline capaddr_t get_cnode_addr(struct capref cap)
 154 {
 155     switch (cap.cnode.level) {
 156         case CNODE_TYPE_ROOT:
 157             return cap.cnode.croot;
 158         case CNODE_TYPE_OTHER:
 159             return cap.cnode.cnode;
 160         default:
 161             assert(!"unknown cnoderef type");
 162             return 0x0;
 163     }
 164 }
 165
 166
 167 /**
 168  * \brief Returns the CSpace address of the cspace root cap of the given cap
 169  */
 170 static inline capaddr_t get_croot_addr(struct capref cap)
 171 {
 172     return cap.cnode.croot;
 173 }
 174
 175 static inline struct capref get_croot_capref(struct capref cap)
 176 {
 177     capaddr_t croot = get_croot_addr(cap);
 178     struct capref ref = {
 179         .cnode = {
 180             .croot = CPTR_ROOTCN,
 181             .cnode = get_capaddr_cnode_addr(croot),
 182             .level = CNODE_TYPE_OTHER,
 183         },
 184         .slot = get_capaddr_slot(croot),
 185     };
 186     return ref;
 187 }
 188
 189 /**
 190  * \brief Compare two cnoderefs
 191  *
 192  * Two cnoderefs are equal if they have the same base address,
 193  * same number of valid bits and the same guard_size.
 194  */
 195 static inline bool cnodecmp(struct cnoderef c1, struct cnoderef c2)
 196 {
 197     return (c1.cnode == c2.cnode && c1.croot == c2.croot && c1.level == c2.level);
 198 }
 199
 200 /**
 201  * \brief Compare two caprefs
 202  *
 203  * Two caprefs are equal if they have the same cnoderef and the same
 204  * slot.
 205  */
 206 static inline bool capcmp(struct capref c1, struct capref c2)
 207 {
 208     return c1.slot == c2.slot && cnodecmp(c1.cnode, c2.cnode);
 209 }
 210
 211 /**
 212  * \brief Creates a new #cnoderef struct, performing address calculations.
 213  * XXX: TODO remove size_bits from signature
 214  */
 215 static inline struct cnoderef build_cnoderef(struct capref cap,
 216                                              enum cnode_type cntype)
 217 {
 218     assert(cntype < CNODE_TYPE_COUNT);
 219
 220     struct cnoderef cnode = NULL_CNODE;
 221     switch(get_cnode_level(cap)) {
 222         // L2 cnode in our root cnode
 223         case CNODE_TYPE_ROOT:
 224             // cannot make cnoderef from non-invokable capref.
 225             assert(cap.cnode.croot == CPTR_ROOTCN);
 226             cnode.croot = CPTR_ROOTCN;
 227             cnode.cnode = get_cap_addr(cap);
 228             cnode.level = cntype;
 229             break;
 230         // CNode for another cspace
 231         case CNODE_TYPE_OTHER:
 232             cnode.level = cntype;
 233             switch (cntype) {
 234                 // creating a cnoderef to a root cnode for another cspace
 235                 case CNODE_TYPE_ROOT:
 236                     cnode.croot = get_cap_addr(cap);
 237                     cnode.cnode = 0;
 238                     break;
 239                 case CNODE_TYPE_OTHER:
 240                     cnode.croot = get_croot_addr(cap);
 241                     cnode.cnode = get_cap_addr(cap);
 242                     break;
 243                 default:
 244                     assert(!"build_cnoderef: provided cntype invalid");
 245                     return NULL_CNODE;
 246             }
 247             break;
 248         default:
 249             assert(!"cap level not valid");
 250             return NULL_CNODE;
 251     }
 252     return cnode;
 253 }
 254
 255 __END_DECLS
 256
 257 #endif