30 #include <l4/sys/l4int.h>
35 #include <l4/sys/cxx/ipc_ret_array>
75 L4::Type_info::Demand_t<1> >
78 typedef L4Re::Dataspace::Offset Offset;
86 Detach_result_mask = 3,
105 Search_addr = 0x20000,
111 Attach_mask = 0xf0000,
124 RX = Dataspace::F::RX,
125 RWX = Dataspace::F::RWX,
148 Region_flags_mask = 0xffff,
153 friend constexpr Dataspace::Flags map_flags(
Region_flags rf)
155 return Dataspace::Flags((
l4_uint16_t)rf & Ds_map_mask);
162 explicit constexpr Flags(
l4_uint32_t f) : raw(f) {}
163 constexpr Flags(Attach_flags rf) : raw((
l4_uint32_t)rf) {}
164 constexpr Flags(Region_flags rf) : raw((
l4_uint32_t)rf) {}
166 friend constexpr Dataspace::Flags map_flags(Flags f)
168 return Dataspace::Flags(f.raw & Ds_map_mask);
171 constexpr Region_flags region_flags()
const
173 return Region_flags(raw & Region_flags_mask);
176 constexpr Attach_flags attach_flags()
const
178 return Attach_flags(raw & Attach_mask);
181 constexpr
bool r()
const {
return raw &
L4_FPAGE_RO; }
182 constexpr
bool w()
const {
return raw &
L4_FPAGE_W; }
183 constexpr
bool x()
const {
return raw &
L4_FPAGE_X; }
184 constexpr
unsigned cap_rights()
const
188 friend constexpr Flags operator | (Region_flags l, Attach_flags r)
189 {
return Flags(l) | Flags(r); }
191 friend constexpr Flags operator | (Attach_flags l, Region_flags r)
192 {
return Flags(l) | Flags(r); }
195 using Attach_flags = F::Attach_flags;
196 using Region_flags = F::Region_flags;
197 using Flags = F::Flags;
259 Flags flags = Flags(0),
261 {
return reserve_area_t::call(c(), start, size, flags, align); }
266 unsigned char align));
283 template<
typename T >
285 Flags flags = Flags(0),
287 {
return reserve_area_t::call(c(), (
l4_addr_t*)start, size, flags, align); }
304 unsigned long size, Flags flags,
306 Offset offs,
unsigned char align,
361 long attach(
l4_addr_t *start,
unsigned long size, Flags flags,
368 template<
typename T >
369 long attach(T **start,
unsigned long size, Flags flags,
374 X *x =
reinterpret_cast<X*
>(start);
375 return attach(&x->a, size, flags, mem, offs, align);
378 #if __cplusplus >= 201103L
379 template<
typename T >
387 Unique_region(Unique_region
const &) =
delete;
388 Unique_region &operator = (Unique_region
const &) =
delete;
390 Unique_region() noexcept
391 : _addr(0), _rm(
L4::Cap<
Rm>::Invalid) {}
393 explicit Unique_region(T addr) noexcept
396 Unique_region(T addr,
L4::Cap<Rm> const &rm) noexcept
397 : _addr(addr), _rm(rm) {}
399 Unique_region(Unique_region &&o) noexcept : _addr(o.get()), _rm(o._rm)
402 Unique_region &operator = (Unique_region &&o) noexcept
414 ~Unique_region() noexcept
420 T get() const noexcept
438 void reset() noexcept
441 bool is_valid() const noexcept
445 T operator * () const noexcept {
return _addr; }
448 T operator -> () const noexcept {
return _addr; }
451 template<
typename T >
452 long attach(Unique_region<T> *start,
unsigned long size, Flags flags,
458 long res = attach(&addr, size, flags, mem, offs, align);
561 {
return find_t::call(c(), addr, size, flags, offset, m); }
565 L4Re::Rm::Flags *flags, Offset *offset,
631 reserve_area_t, free_area_t,
632 get_regions_t, get_areas_t>
Rpcs;
639 {
return detach(addr, 1, mem, task, Detach_overlap); }
644 {
return detach((
l4_addr_t)addr, 1, mem, task, Detach_overlap); }
649 {
return detach(addr, size, mem, task, Detach_exact); }
#define L4_PAGESHIFT
Size of a page, log2-based.
L4::Cap related definitions.
int find(l4_addr_t *addr, unsigned long *size, Offset *offset, L4Re::Rm::Flags *flags, L4::Cap< Dataspace > *m) noexcept
Find a region given an address and size.
Detach_result
Result values for detach operation.
long reserve_area(T **start, unsigned long size, Flags flags=Flags(0), unsigned char align=L4_PAGESHIFT) const noexcept
Reserve the given area in the region map.
long attach(T **start, unsigned long size, Flags flags, L4::Ipc::Cap< Dataspace > mem, Offset offs=0, unsigned char align=L4_PAGESHIFT) const noexcept
Attach a data space to a region.
Detach_flags
Flags for detach operation.
long reserve_area(l4_addr_t *start, unsigned long size, Flags flags=Flags(0), unsigned char align=L4_PAGESHIFT) const noexcept
Reserve the given area in the region map.
int detach(l4_addr_t addr, L4::Cap< Dataspace > *mem, L4::Cap< L4::Task > const &task=This_task) const noexcept
Detach a region from the address space.
bool is_valid() const noexcept
Test whether the capability is a valid capability index (i.e., not L4_INVALID_CAP).
C++ interface for capabilities.
Capability type for RPC interfaces (see L4::Cap<T>).
Helper class to create an L4Re interface class that is derived from a single base class.
unsigned long l4_addr_t
Address type.
unsigned int l4_uint32_t
Unsigned 32bit value.
unsigned short int l4_uint16_t
Unsigned 16bit value.
unsigned long l4_cap_idx_t
L4 Capability selector Type.
@ L4_FPAGE_X
Executable flex page.
@ L4_FPAGE_RO
Read-only flex page
@ L4_FPAGE_W
Writable flex page.
@ L4_CAP_FPAGE_RO
Read right for capability flex-pages.
@ L4_CAP_FPAGE_RW
Read and interface specific 'W' right for capability flex-pages.
Interface Definition Language.
#define L4_RPC(res, name, args, attr...)
Define an RPC call (type and callable).
#define L4_RPC_NF(res, name, args...)
Define an RPC call type (the type only, no callable).
Common L4 ABI Data Types.
L4 low-level kernel interface.
L4Re Protocol Constants (C version)
@ Caching_shift
shift value for caching flags
@ Uncacheable
request uncacheable memory mappings
@ RW
Request writable mapping (R + W)
@ Normal
request normal memory mapping
@ Caching_mask
mask for caching flags
@ R
Request read-only mapping.
@ W
Request write-only memory.
@ Bufferable
request bufferable (write buffered) mappings
Attach_flags
Flags for attach operation.
A range of virtual addresses.
l4_addr_t start
First address of the range.
l4_addr_t end
Last address of the range.
Pass the argument as plain data value.
Mark an argument as in-out argument.
Attribute for defining an optional RPC argument.
Dynamically sized output array of type T.
List of RPCs of an interface using a single operation without an opcode.
Standard list of RPCs of an interface.
Mixin class to define a set of friend bitwise operators on DT.
#define L4_TYPES_FLAGS_OPS_DEF(T)
Helper macro to define a set of bitwise operators on an enum type.