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
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
142//{{{1 Register EP
143static inline errval_t
144invoke_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
150static inline errval_t
151invoke_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
157static inline errval_t
158invoke_monitor_ipi_delete(int chanid)
159{
160    return cap_invoke2(cap_kernel, KernelCmd_IPI_Delete, chanid).error;
161}
162
163//{{{1 KCB operations
164static inline errval_t
165invoke_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
172static inline errval_t
173invoke_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
180static inline errval_t
181invoke_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
187static inline errval_t
188invoke_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
199static 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
205struct capability;
206
207bool monitor_can_send_cap(struct capability *cap);
208errval_t monitor_cap_identify(struct capref cap, struct capability *out);
209errval_t monitor_domains_cap_identify(struct capref croot, capaddr_t cap,
210                                      int vlevel, struct capability *out);
211errval_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);
214errval_t monitor_remote_relations(struct capref cap, uint8_t relations, uint8_t
215                                  mask, uint8_t *ret_relations);
216errval_t monitor_cap_has_relations(struct capref cap, uint8_t mask,
217                                   uint8_t *res);
218errval_t monitor_cap_create(struct capref dest, struct capability *cap,
219                            coreid_t owner);
220errval_t monitor_nullify_cap(struct capref cap);
221errval_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);
225errval_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);
230errval_t monitor_copy_if_exists(struct capability* cap, struct capref dest);
231errval_t monitor_delete_remote_cap(struct capref croot, capaddr_t src, int level);
232errval_t monitor_revoke_remote_cap(struct capref croot, capaddr_t src, int level);
233errval_t monitor_get_cap_owner(struct capref croot, capaddr_t cptr, int level, coreid_t *ret_owner);
234errval_t monitor_set_cap_owner(struct capref croot, capaddr_t cptr, int level, coreid_t owner);
235errval_t monitor_lock_cap(struct capref croot, capaddr_t cptr, int level);
236errval_t monitor_unlock_cap(struct capref croot, capaddr_t cptr, int level);
237errval_t monitor_has_descendants(struct capability *cap, bool *res);
238errval_t monitor_is_retypeable(struct capability *cap, gensize_t offset,
239                               gensize_t objsize, size_t count);
240
241static inline errval_t
242monitor_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
248static inline errval_t
249monitor_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
258errval_t monitor_delete_last(struct capref croot, capaddr_t cptr, int level,
259                             struct capref ret_cap);
260errval_t monitor_delete_foreigns(struct capref cap);
261errval_t monitor_revoke_mark_target(struct capref croot,
262                                    capaddr_t cptr,
263                                    int level);
264errval_t monitor_revoke_mark_relations(struct capability *cap);
265errval_t monitor_delete_step(struct capref ret_cap);
266errval_t monitor_clear_step(struct capref ret_cap);
267
268#endif
269