L4Re Operating System Framework
Interface and Usage Documentation
Loading...
Searching...
No Matches
region_mapping_svr_2
1// vi:set ft=cpp: -*- Mode: C++ -*-
7/*
8 * (c) 2014 Alexander Warg <alexander.warg@kernkonzept.com>
9 *
10 * License: see LICENSE.spdx (in this directory or the directories above)
11 */
12#pragma once
13
14#include <l4/sys/types.h>
15#include <l4/re/rm>
17
18namespace L4Re { namespace Util {
19
20template<typename DERIVED, typename Dbg>
21struct Rm_server
22{
23private:
24 DERIVED *rm() { return static_cast<DERIVED*>(this); }
25 DERIVED const *rm() const { return static_cast<DERIVED const *>(this); }
26
27public:
28
32 long op_attach(L4Re::Rm::Rights, l4_addr_t &_start,
33 unsigned long size, Rm::Flags flags,
34 L4::Ipc::Snd_fpage ds_cap, L4Re::Rm::Offset offs,
35 unsigned char align, l4_cap_idx_t client_cap_idx,
36 L4::Ipc::String<> name, L4Re::Rm::Offset backing_offset)
37 {
38 typename DERIVED::Dataspace ds;
39
40 if (!(flags & (Rm::F::Reserved | Rm::F::Kernel)))
41 {
42 if (long r = rm()->validate_ds
43 (static_cast<DERIVED*>(this)->server_iface(), ds_cap,
44 flags.region_flags(), &ds))
45 return r;
46 }
47
48 size = l4_round_page(size);
49 l4_addr_t start = l4_trunc_page(_start);
50
51 if (size < L4_PAGESIZE)
52 return -L4_EINVAL;
53
54 Rm::Region_flags r_flags = flags.region_flags();
55 Rm::Attach_flags a_flags = flags.attach_flags();
56
57 typename DERIVED::Region_handler handler(ds, client_cap_idx, offs, r_flags);
58 start = l4_addr_t(rm()->attach(reinterpret_cast<void*>(start), size,
59 handler, a_flags, align,
60 name.data, name.length, backing_offset));
61
62 if (start == L4_INVALID_ADDR)
63 return -L4_EADDRNOTAVAIL;
64
65 _start = start;
66 return L4_EOK;
67 }
68
72 long op_free_area(L4Re::Rm::Rights, l4_addr_t start)
73 {
74 if (!rm()->detach_area(start))
75 return -L4_ENOENT;
76
77 return L4_EOK;
78 }
79
83 long op_find(L4Re::Rm::Rights, l4_addr_t &addr, unsigned long &size,
84 L4Re::Rm::Flags &flags, L4Re::Rm::Offset &offset,
85 L4::Cap<L4Re::Dataspace> &m)
86 {
87 if (!DERIVED::Have_find)
88 return -L4_EPERM;
89
90 Rm::Flags flag_area { 0 };
91
92 typename DERIVED::Node r = rm()->find(Region(addr, addr + size -1));
93 if (!r)
94 {
95 r = rm()->area_find(Region(addr, addr + size - 1));
96 if (!r)
97 return -L4_ENOENT;
98 flag_area = Rm::F::In_area;
99 }
100
101 addr = r->first.start();
102 size = r->first.end() + 1 - addr;
103
104 flags = r->second.flags() | flag_area;
105 offset = r->second.offset();
106 m = L4::Cap<L4Re::Dataspace>(DERIVED::find_res(r->second.memory()));
107 return L4_EOK;
108 }
109
113 long op_detach(L4Re::Rm::Rights, l4_addr_t addr,
114 unsigned long size, unsigned flags,
115 l4_addr_t &start, l4_addr_t &rsize,
116 l4_cap_idx_t &mem_cap)
117 {
118 Region r;
119 typename DERIVED::Region_handler h;
120 int err = rm()->detach(reinterpret_cast<void*>(addr), size, flags, &r, &h);
121 if (err < 0)
122 {
123 start = rsize = 0;
124 mem_cap = L4_INVALID_CAP;
125 return err;
126 }
127
128 if (r.invalid())
129 {
130 start = rsize = 0;
131 mem_cap = L4_INVALID_CAP;
132 return -L4_ENOENT;
133 }
134
135 start = r.start();
136 rsize = r.size();
137 mem_cap = h.client_cap_idx();
138 return err;
139 }
140
144 long op_reserve_area(L4Re::Rm::Rights, l4_addr_t &start, unsigned long size,
145 L4Re::Rm::Flags flags, unsigned char align)
146 {
147 start = rm()->attach_area(start, size, flags, align);
148 if (start == L4_INVALID_ADDR)
149 return -L4_EADDRNOTAVAIL;
150 return L4_EOK;
151 }
152
156 long op_get_regions(L4Re::Rm::Rights, l4_addr_t addr,
157 L4::Ipc::Ret_array<L4Re::Rm::Region> regions)
158 {
159 typename DERIVED::Node r;
160 unsigned num = 0;
161 while ((r = rm()->lower_bound(Region(addr))))
162 {
163 Rm::Region &x = regions.value[num];
164 x.start = r->first.start();
165 x.end = r->first.end();
166 x.flags = r->second.flags();
167
168 if (++num >= regions.max)
169 break;
170
171 if (x.end >= rm()->max_addr())
172 break;
173 addr = x.end + 1;
174 }
175 return num;
176 }
177
181 long op_get_areas(L4Re::Rm::Rights, l4_addr_t addr,
182 L4::Ipc::Ret_array<L4Re::Rm::Area> areas)
183 {
184 typename DERIVED::Node r;
185 unsigned num = 0;
186 while ((r = rm()->lower_bound_area(Region(addr))))
187 {
188 Rm::Area &x = areas.value[num];
189 x.start = r->first.start();
190 x.end = r->first.end();
191
192 if (++num >= areas.max)
193 break;
194
195 if (x.end >= rm()->max_addr())
196 break;
197
198 addr = x.end + 1;
199 }
200 return num;
201 }
202
203private:
204 static void pager_set_result(L4::Ipc::Opt<L4::Ipc::Snd_fpage> *fp,
205 L4::Ipc::Snd_fpage const &f)
206 { *fp = f; }
207
208 static void pager_set_result(L4::Ipc::Opt<L4::Ipc::Snd_fpage> *, ...)
209 {}
210public:
211
215 long op_io_page_fault(L4::Io_pager::Rights, l4_fpage_t, l4_umword_t,
216 L4::Ipc::Opt<L4::Ipc::Snd_fpage> &)
217 {
218 // generate exception
219 return -L4_ENOMEM;
220 }
221
222 long op_page_fault(L4::Pager::Rights, l4_umword_t addr, l4_umword_t pc,
223 L4::Ipc::Opt<L4::Ipc::Snd_fpage> &fp)
224 {
225 Dbg(Dbg::Server).printf("page fault: %lx pc=%lx\n", addr, pc);
226
227 bool need_w = addr & 2;
228 bool need_x = addr & 4;
229
230 typename DERIVED::Node n = rm()->find(addr);
231
232 if (!n || !n->second.memory())
233 {
234 Dbg(Dbg::Warn, "rm").printf("unhandled %s page fault at 0x%lx pc=0x%lx\n",
235 need_w ? "write" :
236 need_x ? "instruction" : "read", addr, pc);
237 // generate exception
238 return -L4_ENOMEM;
239 }
240
241 if (!(n->second.flags() & L4Re::Rm::F::W) && need_w)
242 {
243 Dbg(Dbg::Warn, "rm").printf("write page fault in readonly region at 0x%lx pc=0x%lx\n",
244 addr, pc);
245 // generate exception
246 return -L4_EACCESS;
247 }
248
249 if (!(n->second.flags() & L4Re::Rm::F::X) && need_x)
250 {
251 Dbg(Dbg::Warn, "rm").printf("instruction page fault in non-exec region at 0x%lx pc=0x%lx\n",
252 addr, pc);
253 // generate exception
254 return -L4_EACCESS;
255 }
256
257 // This check is optional but avoids doing a map operation that will not
258 // work. We shall never get here from a page-fault but only from
259 // artificial page handling.
260 if (n->second.flags() & (L4Re::Rm::F::Kernel | L4Re::Rm::F::Reserved))
261 {
262 Dbg(Dbg::Warn, "rm").printf("page fault handling in kernel-memory provided region or reserved region at 0x%lx pc=0x%lx\n",
263 addr, pc);
264 // generate exception
265 return -L4_ENODEV;
266 }
267
268 typename DERIVED::Region_handler::Ops::Map_result map_res;
269 if (int err = n->second.map(addr, n->first, need_w, &map_res))
270 {
271 Dbg(Dbg::Warn, "rm").printf("mapping for page fault failed with error %d at 0x%lx pc=0x%lx\n",
272 err, addr, pc);
273 // generate exception
274 return -L4_ENOMEM;
275 }
276
277 pager_set_result(&fp, map_res);
278 return L4_EOK;
279 }
280
281 long op_get_info(L4Re::Rm::Rights, l4_addr_t addr,
282 L4::Ipc::String<char> &name, L4Re::Rm::Offset &backing_offset)
283 {
284#ifdef CONFIG_L4RE_REGION_INFO
285 typename DERIVED::Node r = rm()->find(Region(addr));
286 if (!r)
287 return -L4_ENOENT;
288 backing_offset = r->first.backing_offset();
289 unsigned long i;
290 char const *src = r->first.name();
291 unsigned src_len = r->first.name_len();
292 for (i = 0; i < src_len && i < name.length - 1; ++i)
293 name.data[i] = src[i];
294 name.length = i + 1;
295 name.data[i] = '\0';
296 return L4_EOK;
297#else
298 (void)addr;
299 (void)name;
300 (void)backing_offset;
301 return -L4_ENOSYS;
302#endif
303 }
304};
305
306}}
unsigned long l4_umword_t
Unsigned machine word.
Definition l4int.h:40
unsigned long l4_addr_t
Address type.
Definition l4int.h:34
unsigned long l4_cap_idx_t
Capability selector type.
Definition types.h:336
@ L4_INVALID_CAP
Invalid capability selector.
Definition consts.h:153
@ L4_ENOENT
No such entity.
Definition err.h:34
@ L4_ENOSYS
No sys.
Definition err.h:50
@ L4_EACCESS
Permission denied.
Definition err.h:40
@ L4_EINVAL
Invalid argument.
Definition err.h:46
@ L4_ENODEV
No such thing.
Definition err.h:44
@ L4_EOK
Ok.
Definition err.h:32
@ L4_EADDRNOTAVAIL
Address not available.
Definition err.h:52
@ L4_EPERM
No permission.
Definition err.h:33
@ L4_ENOMEM
No memory.
Definition err.h:39
l4_addr_t l4_trunc_page(l4_addr_t address) L4_NOTHROW
Round an address down to the next lower page boundary.
Definition consts.h:448
l4_addr_t l4_round_page(l4_addr_t address) L4_NOTHROW
Round address up to the next page.
Definition consts.h:473
#define L4_PAGESIZE
Minimal page size (in bytes).
Definition consts.h:391
@ L4_INVALID_ADDR
Invalid address.
Definition consts.h:505
Common L4 ABI Data Types.
Documentation of the L4 Runtime Environment utility functionality in C++.
Definition l4re.dox:21
L4Re C++ Interfaces.
Definition cmd_control:14
Region handling.
Region mapper interface.
@ Reserved
Region is reserved (blocked).
Definition rm:152
@ X
Executable region.
Definition rm:137
@ W
Writable region.
Definition rm:135
@ Kernel
Kernel-provided memory (KUMEM).
Definition rm:146
@ In_area
Search only in area, or map into area.
Definition rm:116