doc: tn13: update capability type section
[barrelfish] / usr / monitor / include / monitor_invocations.h
1 /*
2  * Copyright (c) 2007, 2008, 2009, 2010, 2011, 2012, 2016, ETH Zurich.
3  * All rights reserved.
4  *
5  * This file is distributed under the terms in the attached LICENSE file.
6  * If you do not find this file, copies can be found by writing to:
7  * ETH Zurich D-INFK, Universitaetstr. 6, CH-8092 Zurich. Attn: Systems Group.
8  */
9
10 #ifndef MONITOR_INVOCATIONS_H
11 #define MONITOR_INVOCATIONS_H
12
13 #include <stdbool.h>
14 #include <barrelfish/caddr.h>
15 #include <barrelfish/types.h>
16 #include <barrelfish_kpi/capabilities.h>
17 #include <barrelfish_kpi/distcaps.h>
18 #include <domcap.h>
19
20 #include <monitor_invocations_arch.h>
21
22 //{{{1 Cap identification and relation checking
23 static inline errval_t
24 invoke_monitor_remote_relations(capaddr_t root_cap, int root_level,
25                                 capaddr_t cap, int level,
26                                 uint8_t relations, uint8_t mask,
27                                 uint8_t *ret_remote_relations)
28 {
29     struct sysret r = cap_invoke6(cap_kernel, KernelCmd_Remote_relations,
30                                   root_cap, root_level, cap, level,
31                                   ((uint16_t)relations) | (((uint16_t)mask)<<8));
32     if (err_is_ok(r.error) && ret_remote_relations) {
33         *ret_remote_relations = r.value;
34     }
35     return r.error;
36 }
37
38 static inline errval_t
39 invoke_monitor_cap_has_relations(capaddr_t caddr, uint8_t level, uint8_t mask,
40                                  uint8_t *res)
41 {
42     assert(res);
43     struct sysret ret = cap_invoke4(cap_kernel, KernelCmd_Cap_has_relations,
44                                     caddr, level, mask);
45     if (err_is_ok(ret.error)) {
46         *res = ret.value;
47     }
48     return ret.error;
49 }
50
51 static inline errval_t
52 invoke_monitor_identify_cap(capaddr_t cap, int level, struct capability *out)
53 {
54     return cap_invoke4(cap_kernel, KernelCmd_Identify_cap, cap, level,
55                        (uintptr_t)out).error;
56 }
57
58 static inline errval_t
59 invoke_monitor_identify_domains_cap(capaddr_t root_cap, int root_level,
60                                     capaddr_t cap, int level,
61                                     struct capability *out)
62 {
63     return cap_invoke6(cap_kernel, KernelCmd_Identify_domains_cap,
64                        root_cap, root_level, cap, level, (uintptr_t)out).error;
65 }
66
67 //{{{1 Cap zeroing
68 static inline errval_t
69 invoke_monitor_nullify_cap(capaddr_t cap, int level)
70 {
71     return cap_invoke3(cap_kernel, KernelCmd_Nullify_cap, cap, level).error;
72 }
73
74 //{{{1 Cap ownership manipulation
75 static inline errval_t
76 invoke_monitor_get_cap_owner(capaddr_t root, int rlevel, capaddr_t cap, int clevel, coreid_t *ret_owner)
77 {
78     assert(ret_owner);
79     struct sysret sysret = cap_invoke5(cap_kernel, KernelCmd_Get_cap_owner, root, rlevel, cap, clevel);
80     if (err_is_ok(sysret.error)) {
81         *ret_owner = sysret.value;
82     }
83     return sysret.error;
84 }
85
86 static inline errval_t
87 invoke_monitor_set_cap_owner(capaddr_t root, int rlevel, capaddr_t cap, int clevel, coreid_t owner)
88 {
89     return cap_invoke6(cap_kernel, KernelCmd_Set_cap_owner, root, rlevel, cap, clevel, owner).error;
90 }
91
92 //{{{1 Cap locking
93 static inline errval_t
94 invoke_monitor_lock_cap(capaddr_t root, int rlevel, capaddr_t cap, int clevel)
95 {
96     return cap_invoke5(cap_kernel, KernelCmd_Lock_cap, root, rlevel, cap, clevel).error;
97 }
98
99 static inline errval_t
100 invoke_monitor_unlock_cap(capaddr_t root, int rlevel, capaddr_t cap, int clevel)
101 {
102     return cap_invoke5(cap_kernel, KernelCmd_Unlock_cap, root, rlevel, cap, clevel).error;
103 }
104
105 //{{{1 Delete and revoke state machine stepping
106 static inline errval_t
107 invoke_monitor_delete_last(capaddr_t root, int rlevel, capaddr_t cap, int clevel,
108                            capaddr_t retcn, int retcnlevel, cslot_t retslot)
109 {
110     return cap_invoke8(cap_kernel, KernelCmd_Delete_last, root, rlevel, cap,
111                        clevel, retcn, retcnlevel, retslot).error;
112 }
113
114 static inline errval_t
115 invoke_monitor_delete_foreigns(capaddr_t cap, int level)
116 {
117     return cap_invoke3(cap_kernel, KernelCmd_Delete_foreigns, cap, level).error;
118 }
119
120 static inline errval_t
121 invoke_monitor_revoke_mark_target(capaddr_t root, int rlevel,
122                                   capaddr_t cap, int clevel)
123 {
124     return cap_invoke5(cap_kernel, KernelCmd_Revoke_mark_target,
125                        root, rlevel, cap, clevel).error;
126 }
127
128 static inline errval_t
129 invoke_monitor_delete_step(capaddr_t retcn, int retcnlevel, cslot_t retslot)
130 {
131     return cap_invoke4(cap_kernel, KernelCmd_Delete_step,
132                        retcn, retcnlevel, retslot).error;
133 }
134
135 static inline errval_t
136 invoke_monitor_clear_step(capaddr_t retcn, int retcnlevel, cslot_t retslot)
137 {
138     return cap_invoke4(cap_kernel, KernelCmd_Clear_step,
139                        retcn, retcnlevel, retslot).error;
140 }
141
142 //{{{1 Register EP
143 static inline errval_t
144 invoke_monitor_register(struct capref ep)
145 {
146     return cap_invoke2(cap_kernel, KernelCmd_Register, get_cap_addr(ep)).error;
147 }
148
149 //{{{1 IPI operations
150 static inline errval_t
151 invoke_monitor_ipi_register(struct capref ep, int chanid)
152 {
153     return cap_invoke3(cap_kernel, KernelCmd_IPI_Register, get_cap_addr(ep),
154                        chanid).error;
155 }
156
157 static inline errval_t
158 invoke_monitor_ipi_delete(int chanid)
159 {
160     return cap_invoke2(cap_kernel, KernelCmd_IPI_Delete, chanid).error;
161 }
162
163 //{{{1 KCB operations
164 static inline errval_t
165 invoke_monitor_add_kcb(uintptr_t kcb_base)
166 {
167     assert(kcb_base);
168
169     return cap_invoke2(cap_kernel, KernelCmd_Add_kcb, kcb_base).error;
170 }
171
172 static inline errval_t
173 invoke_monitor_remove_kcb(uintptr_t kcb_base)
174 {
175     assert(kcb_base);
176
177     return cap_invoke2(cap_kernel, KernelCmd_Remove_kcb, kcb_base).error;
178 }
179
180 static inline errval_t
181 invoke_monitor_suspend_kcb_scheduler(bool suspend)
182 {
183     return cap_invoke2(cap_kernel, KernelCmd_Suspend_kcb_sched, suspend).error;
184 }
185
186 //{{{1 Get information about HW
187 static inline errval_t
188 invoke_monitor_get_arch_id(uintptr_t *arch_id)
189 {
190     assert(arch_id != NULL);
191
192     struct sysret sysret = cap_invoke1(cap_kernel, KernelCmd_Get_arch_id);
193     if (sysret.error == SYS_ERR_OK) {
194         *arch_id = sysret.value;
195     }
196     return sysret.error;
197 }
198
199 static inline errval_t invoke_get_platform_info(uintptr_t pi)
200 {
201     return cap_invoke2(cap_kernel, KernelCmd_Get_platform, pi).error;
202 }
203
204
205 struct capability;
206
207 bool monitor_can_send_cap(struct capability *cap);
208 errval_t monitor_cap_identify(struct capref cap, struct capability *out);
209 errval_t monitor_domains_cap_identify(struct capref croot, capaddr_t cap,
210                                       int vlevel, struct capability *out);
211 errval_t monitor_domcap_remote_relations(struct capref croot, capaddr_t cptr,
212                                          int level, uint8_t relations, uint8_t
213                                          mask, uint8_t *ret_relations);
214 errval_t monitor_remote_relations(struct capref cap, uint8_t relations, uint8_t
215                                   mask, uint8_t *ret_relations);
216 errval_t monitor_cap_has_relations(struct capref cap, uint8_t mask,
217                                    uint8_t *res);
218 errval_t monitor_cap_create(struct capref dest, struct capability *cap,
219                             coreid_t owner);
220 errval_t monitor_nullify_cap(struct capref cap);
221 errval_t monitor_retype_remote_cap(struct capref croot, capaddr_t src, gensize_t offset,
222                                    enum objtype newtype, gensize_t objsize,
223                                    gensize_t count, capaddr_t to,
224                                    capaddr_t slot, int level);
225 errval_t monitor_create_caps(struct capref src_root, struct capref dest_root,
226                              enum objtype newtype, gensize_t objsize,
227                              size_t count, capaddr_t src,
228                              int src_level, size_t offset, capaddr_t dest_cn,
229                              int dest_level, cslot_t dest_slot);
230 errval_t monitor_copy_if_exists(struct capability* cap, struct capref dest);
231 errval_t monitor_delete_remote_cap(struct capref croot, capaddr_t src, int level);
232 errval_t monitor_revoke_remote_cap(struct capref croot, capaddr_t src, int level);
233 errval_t monitor_get_cap_owner(struct capref croot, capaddr_t cptr, int level, coreid_t *ret_owner);
234 errval_t monitor_set_cap_owner(struct capref croot, capaddr_t cptr, int level, coreid_t owner);
235 errval_t monitor_lock_cap(struct capref croot, capaddr_t cptr, int level);
236 errval_t monitor_unlock_cap(struct capref croot, capaddr_t cptr, int level);
237 errval_t monitor_has_descendants(struct capability *cap, bool *res);
238 errval_t monitor_is_retypeable(struct capability *cap, gensize_t offset,
239                                gensize_t objsize, size_t count);
240
241 static inline errval_t
242 monitor_get_domcap_owner(struct domcapref cap, coreid_t *ret_owner)
243 {
244
245     return monitor_get_cap_owner(cap.croot, cap.cptr, cap.level, ret_owner);
246 }
247
248 static inline errval_t
249 monitor_set_domcap_owner(struct domcapref cap, coreid_t owner)
250 {
251     return monitor_set_cap_owner(cap.croot, cap.cptr, cap.level, owner);
252 }
253
254 /*
255  * Delete- and revoke-related operations
256  */
257
258 errval_t monitor_delete_last(struct capref croot, capaddr_t cptr, int level,
259                              struct capref ret_cap);
260 errval_t monitor_delete_foreigns(struct capref cap);
261 errval_t monitor_revoke_mark_target(struct capref croot,
262                                     capaddr_t cptr,
263                                     int level);
264 errval_t monitor_revoke_mark_relations(struct capability *cap);
265 errval_t monitor_delete_step(struct capref ret_cap);
266 errval_t monitor_clear_step(struct capref ret_cap);
267
268 #endif