30#include <l4/sys/l4int.h>
35#include <l4/sys/cxx/ipc_ret_array>
87 L4::Type_info::Demand_t<1> >
90 typedef L4Re::Dataspace::Offset Offset;
98 Detach_result_mask = 3,
108 Caching_shift = Dataspace::F::Caching_shift,
118 Search_addr = 0x20000,
124 Attach_mask = 0xf0000,
140 RW = Dataspace::F::RW,
142 RX = Dataspace::F::RX,
144 RWX = Dataspace::F::RWX,
155 Caching_mask = Dataspace::F::Caching_mask,
157 Cache_normal = Dataspace::F::Normal,
159 Cache_buffered = Dataspace::F::Bufferable,
161 Cache_uncached = Dataspace::F::Uncacheable,
167 Region_flags_mask = 0xffff,
172 friend constexpr Dataspace::Flags map_flags(
Region_flags rf)
174 return Dataspace::Flags((
l4_uint16_t)rf & Ds_map_mask);
181 explicit constexpr Flags(
l4_uint32_t f) : raw(f) {}
182 constexpr Flags(Attach_flags rf) : raw((
l4_uint32_t)rf) {}
183 constexpr Flags(Region_flags rf) : raw((
l4_uint32_t)rf) {}
185 friend constexpr Dataspace::Flags map_flags(Flags f)
187 return Dataspace::Flags(f.raw & Ds_map_mask);
190 constexpr Region_flags region_flags()
const
192 return Region_flags(raw & Region_flags_mask);
195 constexpr Attach_flags attach_flags()
const
197 return Attach_flags(raw & Attach_mask);
200 constexpr bool r()
const {
return raw &
L4_FPAGE_RO; }
201 constexpr bool w()
const {
return raw &
L4_FPAGE_W; }
202 constexpr bool x()
const {
return raw &
L4_FPAGE_X; }
203 constexpr unsigned cap_rights()
const
207 friend constexpr Flags operator | (Region_flags l, Attach_flags r)
208 {
return Flags(l) | Flags(r); }
210 friend constexpr Flags operator | (Attach_flags l, Region_flags r)
211 {
return Flags(l) | Flags(r); }
214 using Attach_flags = F::Attach_flags;
215 using Region_flags = F::Region_flags;
216 using Flags = F::Flags;
279 Flags flags = Flags(0),
281 {
return reserve_area_t::call(c(), start, size, flags, align); }
286 unsigned char align));
303 template<
typename T >
305 Flags flags = Flags(0),
307 {
return reserve_area_t::call(c(), (
l4_addr_t*)start, size, flags, align); }
324 unsigned long size, Flags flags,
326 Offset offs,
unsigned char align,
383 long attach(
l4_addr_t *start,
unsigned long size, Flags flags,
390 template<
typename T >
391 long attach(T **start,
unsigned long size, Flags flags,
396 X *x =
reinterpret_cast<X*
>(start);
397 return attach(&x->a, size, flags, mem, offs, align);
400#if __cplusplus >= 201103L
411 template<
typename T >
426 : _addr(0), _rm(
L4::Cap<
Rm>::Invalid) {}
443 : _addr(addr), _rm(rm) {}
530 T operator * () const noexcept {
return _addr; }
533 T operator -> () const noexcept {
return _addr; }
536 template<
typename T >
537 long attach(Unique_region<T> *start,
unsigned long size, Flags flags,
543 long res = attach(&addr, size, flags, mem, offs, align);
646 {
return find_t::call(c(), addr, size, flags, offset, m); }
650 L4Re::Rm::Flags *flags, Offset *offset,
716 reserve_area_t, free_area_t,
717 get_regions_t, get_areas_t>
Rpcs;
724{
return detach(addr, 1, mem, task, Detach_overlap); }
729{
return detach((
l4_addr_t)addr, 1, mem, task, Detach_overlap); }
734{
return detach(addr, size, mem, task, Detach_exact); }
L4::Cap related definitions.
Unique_region(T addr) noexcept
Construct a Unique_region from an address.
Unique_region(Unique_region &&o) noexcept
Move-Construct a Unique_region
T get() const noexcept
Return the address.
void reset() noexcept
Make the Unique_region invalid.
bool is_valid() const noexcept
Check if the Unique_region is valid.
void reset(T addr, L4::Cap< Rm > const &rm) noexcept
Set new address and region manager.
Unique_region() noexcept
Construct an invalid Unique_region
~Unique_region() noexcept
Destructor.
Unique_region(T addr, L4::Cap< Rm > const &rm) noexcept
Construct a valid Unique_region from an address and a region manager.
T release() noexcept
Return the address and invalidate the Unique_region
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.
Region_flag_shifts
Region flag shifts.
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.
long 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.
int detach(l4_addr_t addr, L4::Cap< Dataspace > *mem, L4::Cap< L4::Task > const &task=This_task) const noexcept
Detach and unmap 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
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.
#define L4_PAGESHIFT
Size of a page, log2-based.
#define L4_EXPORT
Attribute to mark functions, variables, and data types as being exported from a library.
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)
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.
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.