Create "ProcessManager" and "Domain" capabilities.
[barrelfish] / 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