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, Universitaetstrasse 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
23static inline errval_t
24invoke_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
38static inline errval_t
39invoke_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
51static inline errval_t
52invoke_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
58static inline errval_t
59invoke_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
68static inline errval_t
69invoke_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
75static inline errval_t
76invoke_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
86static inline errval_t
87invoke_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
93static inline errval_t
94invoke_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
99static inline errval_t
100invoke_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
106static inline errval_t
107invoke_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
114static inline errval_t
115invoke_monitor_delete_foreigns(capaddr_t cap, int level)
116{
117    return cap_invoke3(cap_kernel, KernelCmd_Delete_foreigns, cap, level).error;
118}
119
120static inline errval_t
121invoke_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
128static inline errval_t
129invoke_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
135static inline errval_t
136invoke_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
142static inline errval_t
143invoke_monitor_reclaim_ram(capaddr_t retcn, int retcnlevel, cslot_t retslot)
144{
145    return cap_invoke4(cap_kernel, KernelCmd_ReclaimRAM,
146                       retcn, retcnlevel, retslot).error;
147}
148
149//{{{1 Register EP
150static inline errval_t
151invoke_monitor_register(struct capref ep)
152{
153    return cap_invoke2(cap_kernel, KernelCmd_Register, get_cap_addr(ep)).error;
154}
155
156//{{{1 IPI operations
157static inline errval_t
158invoke_monitor_ipi_register(struct capref ep, int chanid)
159{
160    return cap_invoke3(cap_kernel, KernelCmd_IPI_Register, get_cap_addr(ep),
161                       chanid).error;
162}
163
164static inline errval_t
165invoke_monitor_ipi_delete(int chanid)
166{
167    return cap_invoke2(cap_kernel, KernelCmd_IPI_Delete, chanid).error;
168}
169
170//{{{1 KCB operations
171static inline errval_t
172invoke_monitor_add_kcb(uintptr_t kcb_base)
173{
174    assert(kcb_base);
175
176    return cap_invoke2(cap_kernel, KernelCmd_Add_kcb, kcb_base).error;
177}
178
179static inline errval_t
180invoke_monitor_remove_kcb(uintptr_t kcb_base)
181{
182    assert(kcb_base);
183
184    return cap_invoke2(cap_kernel, KernelCmd_Remove_kcb, kcb_base).error;
185}
186
187static inline errval_t
188invoke_monitor_suspend_kcb_scheduler(bool suspend)
189{
190    return cap_invoke2(cap_kernel, KernelCmd_Suspend_kcb_sched, suspend).error;
191}
192
193//{{{1 Get information about HW
194static inline errval_t
195invoke_monitor_get_arch_id(uintptr_t *arch_id)
196{
197    assert(arch_id != NULL);
198
199    struct sysret sysret = cap_invoke1(cap_kernel, KernelCmd_Get_arch_id);
200    if (sysret.error == SYS_ERR_OK) {
201        *arch_id = sysret.value;
202    }
203    return sysret.error;
204}
205
206static inline errval_t invoke_get_platform_info(uintptr_t pi)
207{
208    return cap_invoke2(cap_kernel, KernelCmd_Get_platform, pi).error;
209}
210
211
212struct capability;
213
214bool monitor_can_send_cap(struct capability *cap);
215errval_t monitor_cap_identify(struct capref cap, struct capability *out);
216errval_t monitor_domains_cap_identify(struct capref croot, capaddr_t cap,
217                                      int vlevel, struct capability *out);
218errval_t monitor_domcap_remote_relations(struct capref croot, capaddr_t cptr,
219                                         int level, uint8_t relations, uint8_t
220                                         mask, uint8_t *ret_relations);
221errval_t monitor_remote_relations(struct capref cap, uint8_t relations, uint8_t
222                                  mask, uint8_t *ret_relations);
223errval_t monitor_cap_has_relations(struct capref cap, uint8_t mask,
224                                   uint8_t *res);
225errval_t monitor_cap_create(struct capref dest, struct capability *cap,
226                            coreid_t owner);
227errval_t monitor_nullify_cap(struct capref cap);
228errval_t monitor_retype_remote_cap(struct capref croot, capaddr_t src, gensize_t offset,
229                                   enum objtype newtype, gensize_t objsize,
230                                   gensize_t count, capaddr_t to,
231                                   capaddr_t slot, int level);
232errval_t monitor_create_caps(struct capref src_root, struct capref dest_root,
233                             enum objtype newtype, gensize_t objsize,
234                             size_t count, capaddr_t src,
235                             int src_level, size_t offset, capaddr_t dest_cn,
236                             int dest_level, cslot_t dest_slot);
237errval_t monitor_copy_if_exists(struct capability* cap, struct capref dest);
238errval_t monitor_delete_remote_cap(struct capref croot, capaddr_t src, int level);
239errval_t monitor_revoke_remote_cap(struct capref croot, capaddr_t src, int level);
240errval_t monitor_get_cap_owner(struct capref croot, capaddr_t cptr, int level, coreid_t *ret_owner);
241errval_t monitor_set_cap_owner(struct capref croot, capaddr_t cptr, int level, coreid_t owner);
242errval_t monitor_lock_cap(struct capref croot, capaddr_t cptr, int level);
243errval_t monitor_unlock_cap(struct capref croot, capaddr_t cptr, int level);
244errval_t monitor_has_descendants(struct capability *cap, bool *res);
245errval_t monitor_is_retypeable(struct capability *cap, gensize_t offset,
246                               gensize_t objsize, size_t count);
247
248static inline errval_t
249monitor_get_domcap_owner(struct domcapref cap, coreid_t *ret_owner)
250{
251
252    return monitor_get_cap_owner(cap.croot, cap.cptr, cap.level, ret_owner);
253}
254
255static inline errval_t
256monitor_set_domcap_owner(struct domcapref cap, coreid_t owner)
257{
258    return monitor_set_cap_owner(cap.croot, cap.cptr, cap.level, owner);
259}
260
261/*
262 * Delete- and revoke-related operations
263 */
264
265errval_t monitor_delete_last(struct capref croot, capaddr_t cptr, int level,
266                             struct capref ret_cap);
267errval_t monitor_delete_foreigns(struct capref cap);
268errval_t monitor_revoke_mark_target(struct capref croot,
269                                    capaddr_t cptr,
270                                    int level);
271errval_t monitor_revoke_mark_relations(struct capability *cap);
272errval_t monitor_delete_step(struct capref ret_cap);
273errval_t monitor_clear_step(struct capref ret_cap);
274errval_t monitor_reclaim_ram(struct capref ret_cap);
275
276#endif
277