T191: Implement prototype for new retype
[barrelfish] / include / barrelfish / capabilities.h
1 /**
2  * \file
3  * \brief Base capability/cnode handling functions.
4  */
5
6 /*
7  * Copyright (c) 2007, 2008, 2009, 2010, 2012, ETH Zurich.
8  * All rights reserved.
9  *
10  * This file is distributed under the terms in the attached LICENSE file.
11  * If you do not find this file, copies can be found by writing to:
12  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
13  */
14
15 #ifndef INCLUDEBARRELFISH_CAPABILITIES_H
16 #define INCLUDEBARRELFISH_CAPABILITIES_H
17
18 #include <stdint.h>
19 #include <sys/cdefs.h>
20
21 #include <barrelfish_kpi/types.h>
22 #include <barrelfish_kpi/capabilities.h>
23 #include <barrelfish_kpi/dispatcher_shared.h>
24 #include <barrelfish_kpi/distcaps.h>
25 #include <barrelfish/invocations_arch.h>
26
27 __BEGIN_DECLS
28
29 errval_t cnode_create(struct capref *ret_dest, struct cnoderef *cnoderef,
30                  cslot_t slots, cslot_t *retslots);
31 errval_t cnode_create_raw(struct capref dest, struct cnoderef *cnoderef,
32                      cslot_t slots, cslot_t *retslots);
33 errval_t cnode_create_with_guard(struct capref dest, struct cnoderef *cnoderef,
34                             cslot_t slots, cslot_t *retslots,
35                             uint64_t guard, uint8_t guard_size);
36 errval_t cnode_create_from_mem(struct capref dest, struct capref src,
37                           struct cnoderef *cnoderef, uint8_t slot_bits);
38
39 errval_t cap_retype(struct capref dest_start, struct capref src,
40                enum objtype new_type, uint8_t size_bits);
41 errval_t cap_retype2(struct capref dest_start, struct capref src, gensize_t offset,
42                      enum objtype new_type, gensize_t objsize, size_t count);
43 errval_t cap_create(struct capref dest, enum objtype type, uint8_t size_bits);
44 errval_t cap_delete(struct capref cap);
45 errval_t cap_revoke(struct capref cap);
46 struct cspace_allocator;
47 errval_t cap_destroy(struct capref cap);
48
49 errval_t vnode_create(struct capref dest, enum objtype type);
50 errval_t frame_create(struct capref dest, size_t bytes, size_t *retbytes);
51 errval_t frame_alloc(struct capref *dest, size_t bytes, size_t *retbytes);
52 errval_t devframe_type(struct capref *dest, struct capref src, uint8_t bits);
53 errval_t dispatcher_create(struct capref dest);
54
55 typedef void (*handler_func_t)(void *);
56 struct lmp_endpoint;
57
58 errval_t endpoint_create(size_t buflen, struct capref *retcap,
59                          struct lmp_endpoint **retep);
60
61 errval_t idcap_alloc(struct capref *dest);
62 errval_t idcap_create(struct capref dest);
63
64 errval_t cnode_build_cnoderef(struct cnoderef *cnoder, struct capref capr);
65
66 /**
67  * \brief Mint (Copy changing type-specific parameters) a capability
68  *
69  * \param dest    Location of destination slot, which must be empty
70  * \param src     Location of source slot
71  * \param param1  Type-specific parameter 1
72  * \param param2  Type-specific parameter 2
73  *
74  * Consult the Barrelfish Kernel API Specification for the meaning of the
75  * type-specific parameters.
76  */
77 static inline errval_t
78 cap_mint(struct capref dest, struct capref src, uint64_t param1,
79          uint64_t param2)
80 {
81     uint8_t dcn_vbits = get_cnode_valid_bits(dest);
82     capaddr_t dcn_addr = get_cnode_addr(dest);
83     uint8_t scp_vbits = get_cap_valid_bits(src);
84     capaddr_t scp_addr = get_cap_addr(src) >> (CPTR_BITS - scp_vbits);
85
86     return invoke_cnode_mint(cap_root, dcn_addr, dest.slot, scp_addr, dcn_vbits,
87                              scp_vbits, param1, param2);
88 }
89
90 /**
91  * \brief Perform mapping operation in kernel by minting a cap to a VNode
92  *
93  * \param dest destination VNode cap
94  * \param src  source Frame cap
95  * \param slot slot in destination VNode
96  * \param attr Architecture-specific page (table) attributes
97  * \param off Offset from source frame to map (must be page-aligned)
98  */
99 static inline errval_t
100 vnode_map(struct capref dest, struct capref src, capaddr_t slot,
101           uint64_t attr, uint64_t off, uint64_t pte_count,
102           struct capref mapping)
103 {
104     uint8_t svbits = get_cap_valid_bits(src);
105     capaddr_t saddr = get_cap_addr(src) >> (CPTR_BITS - svbits);
106
107     uint8_t mcn_vbits = get_cnode_valid_bits(mapping);
108     capaddr_t mcn_addr = get_cnode_addr(mapping);
109
110     return invoke_vnode_map(dest, slot, saddr, svbits, attr, off, pte_count,
111                             mcn_addr, mcn_vbits, mapping.slot);
112 }
113
114 static inline errval_t vnode_unmap(struct capref pgtl, struct capref mapping)
115 {
116     uint8_t bits = get_cap_valid_bits(mapping);
117     capaddr_t mapping_addr = get_cap_addr(mapping) >> (CPTR_BITS - bits);
118
119     return invoke_vnode_unmap(pgtl, mapping_addr, bits);
120 }
121
122 /**
123  * \brief Copy a capability between slots in CSpace
124  *
125  * \param dest    Location of destination slot, which must be empty
126  * \param src     Location of source capability
127  */
128 static inline errval_t cap_copy(struct capref dest, struct capref src)
129 {
130     errval_t err;
131     uint8_t dcn_vbits = get_cnode_valid_bits(dest);
132     capaddr_t dcn_addr = get_cnode_addr(dest);
133     uint8_t scp_vbits = get_cap_valid_bits(src);
134     capaddr_t scp_addr = get_cap_addr(src) >> (CPTR_BITS - scp_vbits);
135
136     err = invoke_cnode_copy(cap_root, dcn_addr, dest.slot, scp_addr, dcn_vbits,
137                             scp_vbits);
138     return err;
139 }
140
141 static inline errval_t cap_get_state(struct capref cap, distcap_state_t *state)
142 {
143     uint8_t vbits = get_cap_valid_bits(cap);
144     capaddr_t caddr = get_cap_addr(cap) >> (CPTR_BITS - vbits);
145
146     return invoke_cnode_get_state(cap_root, caddr, vbits, state);
147 }
148
149 __END_DECLS
150
151 #endif //INCLUDEBARRELFISH_CAPABILITIES_H