Loading...
Searching...
No Matches
Data Structures
Here are the data structures with brief descriptions:

cxx | Our C++ library
arith |
Ld | Computes the binary logarithm of the given number at compile time
Bits | Internal helpers for the cxx package
Avl_map_get_key | Key-getter for Avl_map
Avl_set_get_key | Internal, key-getter for Avl_set nodes
Base_avl_set | Internal: AVL set with internally managed nodes
Node | A smart pointer to a tree item
Bst | Basic binary search tree (BST)
Direction | The direction to go in a binary search tree
Bst_node | Basic type of a node in a binary search tree (BST)
Basic_list | Internal: Common functions for all head-based list implementations
Smart_ptr_list_item | List item for an arbitrary item in a Smart_ptr_list
Smart_ptr_list | List of smart-pointer-managed objects
Avl_map | AVL tree based associative container
Avl_set | AVL set for simple comparable items
Avl_tree_node | Node of an AVL tree
Avl_tree | A generic AVL tree
Bitfield | Definition for a member (part) of a bit field
Value_base | Internal helper type
Value | Internal helper type
Value_unshifted | Internal helper type
Bitmap_base | Basic bitmap abstraction
Bit | A writable bit in a bitmap
Word | Helper abstraction for a word contained in the bitmap
Char | Helper abstraction for a byte contained in the bitmap
Bitmap | A static bitmap
H_list_item_t | Basic element type for a double-linked H_list
H_list | General double-linked list of unspecified cxx::H_list_item elements
H_list_t | Double-linked list of typed H_list_item_t elements
List_item | Basic list item
Iter | Iterator for a list of ListItem-s
T_iter | Iterator for derived classes from ListItem
List | Doubly linked list, with internal allocation
Iter | Iterator
List_alloc | Standard list-based allocator
Pair | Pair of two values
Pair_first_compare | Comparison functor for Pair
Ref_ptr | A reference-counting pointer with automatic cleanup
Ref_obj_list_item | Item for list linked via cxx::Ref_ptr with default refence counting
Base_slab | Basic slab allocator
Slab_i | Type of a slab
Slab | Slab allocator for object of type Type
Base_slab_static | Merged slab allocator (allocators for objects of the same size are merged together)
Slab_static | Merged slab allocator (allocators for objects of the same size are merged together)
S_list | Simple single-linked list
static_vector | Simple encapsulation for a dynamically allocated array
Nothrow | Helper type to distinguish the `operator new` version that does not throw exceptions
New_allocator | Standard allocator based on `operator new ()`
Lt_functor | Generic comparator class that defaults to the less-than operator
String | Allocation free string class with explicit length field
Weak_ref_base | Generic (base) weak reference to some object
List | The list type for keeping all weak references to an object
Weak_ref | Typed weak reference to an object of type T
L4 | L4 low-level kernel interface
Typeid | Definition of interface data-type helpers
Detail |
Rpcs_end | Internal end-of-list marker
_Rpcs | Empty list of RPCs
_Rpcs< OPCODE, O, R, X... > | Non-empty list of RPCs
Rpc | Find the given RPC in the list
P_dispatch | Use for protocol based dispatch stage
Raw_ipc | RPCs list for passing raw incoming IPC to the server object
Rpcs | Standard list of RPCs of an interface
Rpcs_code | List of RPCs of an interface using a special opcode type
F |
Rpc_nocode | List of RPCs of an interface using a single operation without an opcode
Rpcs_sys | List of RPCs typically used for kernel interfaces
Ipc | IPC related functionality
Msg | IPC Message related functionality
Elem< Array< A, LEN > > | Array as input arguments
Elem< Array< A, LEN > & > | Array as output argument
Elem< Array_ref< A, LEN > & > | Array_ref as output argument
Dir_in | Marker type for input values
Dir_out | Marker type for output values
Cls_data | Marker type for data values
Cls_item | Marker type for item values
Cls_buffer | Marker type for receive buffer values
Do_in_data | Marker for Input data
Do_out_data | Marker for Output data
Do_in_items | Marker for Input items
Do_out_items | Marker for Output items
Do_rcv_buffers | Marker for receive buffers
Svr_val_ops | Defines client-side handling of `MTYPE' as RPC argument
Is_valid_rpc_type | Type trait defining a valid RPC parameter type
Svr_arg_pack | Server-side RPC arguments data structure used to provide arguments to the server-side implementation of an RPC function
True | True meta value
False | False meta value
Array_ref | Array reference data type for arrays located in the message
Array | Array data type for dynamically sized arrays in RPCs
Array_in_buf | Server-side copy in buffer for Array
Call | RPC attribute for a standard RPC call
Call_zero_send_timeout | RPC attribute for an RPC call, with zero send timeout
Call_t | RPC attribute for an RPC call with required rights
Send_only | RPC attribute for a send-only RPC
Ret_array | Dynamically sized output array of type T
Out | Mark an argument as a output value in an RPC signature
In_out | Mark an argument as in-out argument
As_value | Pass the argument as plain data value
Opt | Attribute for defining an optional RPC argument
Small_buf | A receive item for receiving a single object capability
Gen_fpage | Generic RPC base for typed message items
Snd_fpage | Send item or return item
Rcv_fpage | Non-small receive item
Cap | Capability type for RPC interfaces (see L4::Cap<T>)
Varg | Variably sized RPC argument
Varg_list | Self-contained list of variable-sized RPC parameters
Varg_list_ref | List of variable-sized RPC parameters as received by the server
Iterator | Iterator for Valists
Str_cp_in | Abstraction for extracting a zero-terminated string from an Ipc::Istream
Msg_ptr | Pointer to an element of type T in an Ipc::Istream
Istream | Input stream for IPC unmarshalling
Ostream | Output stream for IPC marshalling
Iostream | Input/Output stream for IPC [un]marshalling
Ipc_svr | Helper classes for L4::Server instantiation
Server_iface | Interface for server-loop related functions
Ignore_errors | Mix in for LOOP_HOOKS to ignore IPC errors
Default_timeout | Mix in for LOOP_HOOKS to use a 0 send and a infinite receive timeout
Compound_reply | Mix in for LOOP_HOOKS to always use compound reply and wait
Default_setup_wait | Mix in for LOOP_HOOKS for setup_wait no op
Direct_dispatch | Direct dispatch helper, for forwarding dispatch calls to a registry R
Direct_dispatch< R * > | Direct dispatch helper, for forwarding dispatch calls via a pointer to a registry R
Exc_dispatch | Dispatch helper wrapping try {} catch {} around the dispatch call
Dbg_dispatch | Dispatch helper that, in addition to what Exc_dispatch does, prints exception messages
Br_manager_no_buffers | Empty implementation of Server_iface
Default_loop_hooks | Default LOOP_HOOKS
Timeout | Callback interface for Timeout_queue
Timeout_queue | Timeout queue to be used in l4re server loop
Timeout_queue_hooks | Loop hooks mixin for integrating a timeout queue into the server loop
Types | L4 basic type helpers for C++
Flags | Template for defining typical Flags bitmaps
Int_for_size | Metafunction to get an unsigned integral type for the given size
Int_for_type | Metafunction to get an integral type of the same size as T
Flags_ops_t | Mixin class to define a set of friend bitwise operators on DT
Flags_t | Template type to define a flags type with bitwise operations
Bool | Boolean meta type
False | False meta value
True | True meta value
Same | Compare two data types for equality
Kip |
Mem_desc | Memory descriptors stored in the kernel interface page
Type_info | Dynamic Type Information for L4Re Interfaces
Demand | Data type for expressing the needed receive buffers at the server-side of an interface
Demand_t | Template type statically describing demand of receive buffers
Demand_union_t | Template type statically describing the combination of two Demand object
Kobject_typeid | Meta object for handling access to type information of Kobjects
Kobject_typeid< void > | Minimalistic ID for void interface
Kobject_t | Helper class to create an L4Re interface class that is derived from a single base class
Kobject_2t | Helper class to create an L4Re interface class that is derived from two base classes (see L4::Kobject_t)
Kobject_3t | Helper class to create an L4Re interface class that is derived from three base classes (see L4::Kobject_t)
Kobject_demand | Get the combined server-side resource requirements for all type T..
Proto_t | Data type for defining protocol numbers
Kobject_x | Generic Kobject inheritance template
Vm | Virtual machine host address space
Arm_smccc | Wrapper for function calls that follow the ARM SMC/HVC calling convention
Cap | C++ interface for capabilities
Cap_base | Base class for all kinds of capabilities
Epiface | Base class for interface implementations
Epiface_t0 | Epiface mixin for generic Kobject-based interfaces
Irqep_t | Epiface implementation for interrupt handlers
Registry_iface | Abstract interface for object registries
Epiface_t | Epiface implementation for Kobject-based interface implementations
Basic_registry | This registry returns the corresponding server object based on the label of an Ipc_gate
Server | Basic server loop for handling client requests
Debugger | C++ kernel debugger API
Exception | Exception interface
Factory | C++ Factory interface, see Factory for the C interface
Nil | Special type to add a void argument into the factory create stream
Lstr | Special type to add a pascal string into the factory create stream
S | Stream class for the create() argument stream
Iommu | Interface for IO-MMUs used for DMA remapping
Ipc_gate | The C++ IPC gate interface, see IPC-Gate API for the C interface
Irq_eoi | Interface for sending an unmask message to an object
Triggerable | Interface that allows an object to be triggered by some source
Irq | C++ Irq interface, see IRQs for the C interface
Icu | C++ Icu interface, see Interrupt controller for the C interface
Info | This class encapsulates information about an ICU
Kobject | Base class for all kinds of kernel objects and remote objects, referenced by capabilities
Meta | Meta interface that shall be implemented by each L4Re object and gives access to the dynamic type information for L4Re objects
Io_pager | Io_pager interface
Pager | Pager interface including the Io_pager interface
Platform_control | L4 C++ interface for controlling platform-wide properties, see Platform Control C API for the C interface
Rcv_endpoint | Interface for kernel objects that allow to receive IPC from them
Scheduler | C++ interface of the Scheduler kernel object, see Scheduler for the C interface
Semaphore | C++ Kernel-provided semaphore interface, see Kernel-provided semaphore for the C interface
Smart_cap | Smart capability class
Task | C++ interface of the Task kernel object, see Task for the C interface
Thread | C++ L4 kernel thread interface, see Thread for the C interface
Attr | Thread attributes used for control()
Modify_senders | Class wrapping a list of rules which modify the sender label of IPC messages inbound to this thread
Thread_group | C++ L4 kernel thread group interface, see Thread groups for the C interface
Vcon | C++ L4 Vcon interface, see Virtual Console for the C interface
Poll_timeout_kipclock | A polling timeout based on the L4Re clock
Alloc_list | A simple list-based allocator
IOModifier | Modifier class for the IO stream
Exception_tracer | Back-trace support for exceptions
Base_exception | Base class for all exceptions, thrown by the L4Re framework
Runtime_error | Exception for an abstract runtime error
Out_of_memory | Exception signalling insufficient memory
Element_already_exists | Exception for duplicate element insertions
Unknown_error | Exception for an unknown condition
Element_not_found | Exception for a failed lookup (element not found)
Invalid_capability | Indicates that an invalid object was invoked
Com_error | Error conditions during IPC
Bounds_error | Access out of bounds
Server_object | Abstract server object to be used with L4::Server and L4::Basic_registry
Server_object_t | Base class (template) for server implementing server objects
Server_object_x | Helper class to implement p_dispatch based server objects
Irq_handler_object | Server object base class for handling IRQ messages
Lock_guard | Basic lock guard implementation that prevents forgotten unlocks on exit paths from a method or a block of code
String | A null-terminated string container class
Poll_timeout_counter | Evaluate an expression for a maximum number of times
Uart_apb | Driver for the Advanced Peripheral Bus (APB) UART from the Cortex-M System Design Kit (CMSDK)
Uart | Uart driver abstraction
L4drivers |
Mmio_register_block | An MMIO block with up to 64-bit register access (32-bit default) and little endian byte order
Register_block_base | Abstract register block interface
Register_block_tmpl | Helper template that translates to the Register_block_base interface
Ro_register_tmpl | Single read only register inside a Register_block_base interface
Register_tmpl | Single hardware register inside a Register_block_base interface
Register_block | Handles a reference to a register block of the given maximum access width
Ro_register_block | Handles a reference to a read only register block of the given maximum access width
Register_block_impl | Implementation helper for register blocks
L4Re | L4Re C++ Interfaces
Ned |
Cmd_control | Direct control interface for Ned
Vfs | Virtual file system for interfaces in POSIX libc
Be_file | Boiler plate class for implementing an open file for L4Re::Vfs
Be_file_system | Boilerplate class for implementing a L4Re::Vfs::File_system
Generic_file | The common interface for an open POSIX file
Directory | Interface for a POSIX file that is a directory
Regular_file | Interface for a POSIX file that provides regular file semantics
Special_file | Interface for a POSIX file that provides special file semantics
File | The basic interface for an open POSIX file
Mman | Interface for POSIX memory management
File_system | Basic interface for an L4Re::Vfs file system
Fs | POSIX File-system related functionality
Ops | Interface for the POSIX backends of an application
Core |
Ref_ptr | A reference-counting pointer with automatic cleanup
Util | Documentation of the L4 Runtime Environment utility functionality in C++
Names |
Name | Name class
Name_space | Abstract server-side implementation of the L4::Namespace interface
Video |
Goos_svr | Goos server class
Cap_alloc_base | Capability allocator
Br_manager | Buffer-register (BR) manager for L4::Server
Br_manager_hooks | Predefined server-loop hooks for a server loop using the Br_manager
Br_manager_timeout_hooks | Predefined server-loop hooks for a server with using the Br_manager and a timeout queue
Smart_cap_auto | Helper for Unique_cap and Unique_del_cap
Smart_count_cap | Helper for Ref_cap and Ref_del_cap
Ref_cap | Automatic capability that implements automatic free and unmap of the capability selector
Ref_del_cap | Automatic capability that implements automatic free and unmap+delete of the capability selector
_Cap_alloc | Adapter to expose the cap allocator implementation as L4Re::Cap_alloc compatible class
Counter | Counter for Counting_cap_alloc with variable data width
Counter_atomic | Thread safe version of counter for Counting_cap_alloc
Counting_cap_alloc | Internal reference-counting cap allocator
Dataspace_svr | Dataspace server class
Event_t | Convenience wrapper for getting access to an event object
Event_buffer_t | Event_buffer utility class
Event_buffer_consumer_t | An event buffer consumer
Event_svr | Convenience wrapper for implementing an event server
Item_alloc_base | Item allocator
Object_registry | A registry that manages server objects and their attached IPC gates for a single server loop for a specific thread
Registry_server | A server loop object which has a Object_registry included
Vcon_svr | Console server template class
Bitmap_base | Basic bitmap abstraction
Bit | A writable bit in a bitmap
Word | Helper abstraction for a word contained in the bitmap
Char | Helper abstraction for a byte contained in the bitmap
Bitmap | A static bitmap
Video |
Color_component | A color component
Pixel_info | Pixel information
View | View of a framebuffer
Info | Information structure of a view
Goos | Class that abstracts framebuffers
Info | Information structure of a Goos
Cap_alloc | Capability allocator interface
Smart_cap_auto | Helper for Unique_cap and Unique_del_cap
Smart_count_cap | Helper for Ref_cap and Ref_del_cap
Console | Console class
Dataspace | Interface for memory-like objects
F | Dataspace flags definitions
Stats | Information about the dataspace
Debug_obj | Debug interface
Dma_space | Managed DMA Address Space
Env | C++ interface of the initial environment that is provided to an L4 task
Event | Event class
Default_event_payload | Default event stream payload
Event_buffer_t | Event buffer class
Event | Event structure used in buffer
Inhibitor | Set of inhibitor locks, which inhibit specific actions when held
Itas | Interface to the ITAS
Log | Log interface class
Mem_alloc | Memory allocation interface
Stats | Statistics about memory-allocator
Mmio_space | Interface for memory-like address space accessible via IPC
Namespace | Name-space interface
Parent | Parent interface
Random | Low-bandwidth interface for random number generators
Rm | Region map
F | Rm flags definitions
Unique_region | Unique region
Region | A region is a range of virtual addresses which is backed by content
Area | An area is a range of virtual addresses which is reserved, see L4Re::Rm::reserve_area()
L4vbus | C++ interface of the Vbus API.
Pm | Power-management API mixin
Device | Device on a L4vbus::Vbus
Icu | Vbus Interrupt controller API
Vbus | The virtual bus (Vbus) interface
Gpio_pin | A GPIO pin
Gpio_module | A Gpio_module groups multiple GPIO pins together
Pin_slice | A slice of the pins provided by this module
Pci_host_bridge | A Pci host bridge
Pci_dev | A PCI device
L4vcpu |
State | C++ implementation of state word in the vCPU area
Vcpu | C++ implementation of the vCPU save state area
L4virtio | L4-VIRTIO Transport C++ API
Driver |
Device | Client-side implementation for a general virtio device
Block_device | Simple class for accessing a virtio block device synchronously
Handle | Handle to an ongoing request
Virtio_net_device | Simple class for accessing a virtio net device
Packet | Structure for a network packet (header including data) with maximum size, assuming that no extra features have been negotiated
Virtqueue | Driver-side implementation of a Virtqueue
Svr |
Console |
Features | Virtio console specific feature bits
Control_message | Virtio console control message
Control_request | Specialised Virtqueue::Request providing access to control message payload
Port | Representation of a Virtio console port
Transition | State transition from last report state to current state
Virtio_con | Base class implementing a virtio console functionality
Device_port | A console port with associated read/write state
Device | Base class implementing a virtio console device with L4Re-based notification handling
Scmi |
Scmi_hdr_t | SCMI header
Base_attr_t | SCMI base protocol attributes
Performance_attr_t | SCMI performance protocol attributes
Performance_domain_attr_t | SCMI performance domain protocol attributes
Performance_describe_levels_n_t | SCMI performance describe levels numbers
Performance_describe_level_t | SCMI performance describe level
Proto | Base class for all protocols
Scmi_dev | A server implementation of the virtio-scmi protocol
Base_proto | Base class for the SCMI base protocol
Perf_proto | Base class for the SCMI performance protocol
Dev_config | Abstraction for L4-Virtio device config memory
Driver_mem_region_t | Region of driver memory, that shall be managed locally
Driver_mem_list_t | List of driver memory regions assigned to a single L4-VIRTIO transport instance
Device_t | Server-side L4-VIRTIO device stub
Dev_status | Type of the device status register
Dev_features | Type for device feature bitmap
Virtqueue | Virtqueue implementation for the device
Head_desc | VIRTIO request, essentially a descriptor from the available ring
Data_buffer | Abstract data buffer
Bad_descriptor | Exception used by Queue to indicate descriptor errors
Request_processor | Encapsulate the state for processing a VIRTIO request
Block_dev_base | Base class for virtio block devices
Block_request | A request to read or write data
Virtio_gpio | A server implementation of the virtio-gpio protocol
Irq_handler | Handler for an gpio pin irq
Host_irq | Handler for the host irq
Request_processor | Generic handler for the Virtio requests
Virtio_i2c | A server implementation of the virtio-i2c protocol
Host_irq | Handler for the host irq
Request_processor | Handler for the Virtio requests
Virtio_rng | A server implementation of the virtio-rng protocol
Host_irq | Handler for the host irq
Request_processor | Handler for the Virtio requests
Device | IPC interface for virtio over L4 IPC
Ptr | Pointer used in virtio descriptors
Virtqueue | Low-level Virtqueue
Desc | Descriptor in the descriptor table
Flags | Type for descriptor flags
Avail | Type of available ring, this is read-only for the host
Flags | Flags of the available ring
Used_elem | Type of an element of the used ring
Used | Used ring
Flags | Flags for the used ring
Buffer | Data buffer used to transfer packets
Elf32_Auxv | Auxiliary vector (32-bit)
Elf32_Dyn | ELF32 dynamic entry
Elf32_Ehdr | ELF32 header
Elf32_Phdr | ELF32 program header
Elf32_Rel | ELF32 relocation entry w/o addend
Elf32_Rela | ELF32 relocation entry w/ addend
Elf32_Shdr | ELF32 section header
Elf32_Sym | ELF32 symbol table entry
Elf64_Auxv | Auxiliary vector (64-bit)
Elf64_Dyn | ELF64 dynamic entry
Elf64_Ehdr | ELF64 header
Elf64_Phdr | ELF64 program header
Elf64_Rel | ELF64 relocation entry w/o addend
Elf64_Rela | ELF64 relocation entry w/ addend
Elf64_Shdr | ELF64 section header
Elf64_Sym | ELF64 symbol table entry
l4_buf_regs_t | Encapsulation of the buffer-registers block in the UTCB
l4_exc_regs_t | UTCB structure for exceptions
l4_fpage_t | L4 flexpage type
l4_icu_info_t | Info structure for an ICU
l4_icu_msi_info_t | Info to use for a specific MSI
l4_kernel_info_mem_desc_t | Memory descriptor data structure
l4_kernel_info_t | L4 Kernel Interface Page
l4_msg_regs_t | Encapsulation of the message-register block in the UTCB
l4_msgtag_t | Message tag data structure
l4_sched_cpu_set_t | CPU sets
l4_sched_param_t | Scheduler parameter set
l4_snd_fpage_t | Send-flexpage types
l4_thread_regs_t | Encapsulation of the thread-control-register block of the UTCB
l4_timeout_s | Basic timeout specification
l4_timeout_t | Timeout pair
l4_vcon_attr_t | Vcon attribute structure
l4_vcpu_arch_state_t | Architecture-specific vCPU state
l4_vcpu_ipc_regs_t | VCPU message registers
l4_vcpu_regs_t | VCPU registers
l4_vcpu_state_t | State of a vCPU
l4_vm_svm_vmcb_control_area | VMCB structure for SVM VMs
l4_vm_svm_vmcb_state_save_area | State save area structure for SVM VMs
l4_vm_svm_vmcb_state_save_area_seg | State save area segment selector struct
l4_vm_svm_vmcb_t | Control structure for SVM VMs
l4_vm_tz_state | State structure for TrustZone VMs
l4_vm_vmx_vcpu_infos_t | VMX information members
l4_vm_vmx_vcpu_state_t | VMX vCPU state
l4_vm_vmx_vcpu_vmcs_t | VMX software VMCS
l4_vmx_offset_table_t | Software VMCS field offset table
l4re_aux_t | Auxiliary descriptor
l4re_ds_stats_t | Information about the data space
l4re_elf_aux_mword_t | Auxiliary vector element for a single unsigned data word
l4re_elf_aux_t | Generic header for each auxiliary vector element
l4re_elf_aux_vma_t | Auxiliary vector element for a reserved virtual memory area
l4re_env_cap_entry_t | Entry in the L4Re environment array for the named initial objects
l4re_env_t | Initial environment data structure
l4re_event_t | Event structure used in buffer
l4re_video_color_component_t | Color component structure
l4re_video_goos_info_t | Goos information structure
l4re_video_pixel_info_t | Pixel_info structure
l4re_video_view_info_t | View information structure
l4re_video_view_t | C representation of a goos view
l4shmc_ringbuf_head_t | Head field of a ring buffer
l4shmc_ringbuf_t | Ring buffer
l4util_l4mod_info | Base module structure
l4util_l4mod_mod | A single module
l4util_mb_addr_range_t | INT-15, AX=E820 style "AddressRangeDescriptor" ...with a "size" parameter on the front which is the structure size - 4, pointing to the next one, up until the full buffer length of the memory map has been reached
l4util_mb_apm_t | APM BIOS info
l4util_mb_drive_t | Drive Info structure
l4util_mb_info_t | MultiBoot Info description
l4util_mb_mod_t | The structure type "mod_list" is used by the multiboot_info structure
l4util_mb_vbe_ctrl_t | VBE controller information
l4util_mb_vbe_mode_t | VBE mode information
l4vbus_device_t | Detailed information about a vbus device
l4vbus_resource_t | Description of a single vbus resource
l4virtio_block_config_t | Device configuration for block devices
l4virtio_block_discard_t | Structure used for the write zeroes and discard commands
l4virtio_block_header_t | Header structure of a request for a block device
l4virtio_config_hdr_t | L4-VIRTIO config header, provided in shared data space
l4virtio_config_queue_t | Queue configuration entry
l4virtio_input_absinfo_t | Information about the absolute axis in the underlying evdev implementation
l4virtio_input_config_t | Device configuration for input devices
l4virtio_input_devids_t | Device ID information for the device
l4virtio_input_event_t | Single event in event or status queue
l4virtio_net_config_t | Device configuration for network devices
l4virtio_net_header_t | Header structure of a request for a network device
L4virtio_port | A Port on the Virtio Net Switch
Mac_addr | A wrapper class around the value of a MAC address
Mac_table | Mac_table manages a 1:n association between ports and MAC addresses
Net_transfer | A network request to only a single destination
Rm | Region map
F | Rm flags definitions
Unique_region | Unique region
Region | A region is a range of virtual addresses which is backed by content
Area | An area is a range of virtual addresses which is reserved, see L4Re::Rm::reserve_area()
Switch_factory | The IPC interface for creating ports
Virtio_net | The Base class of a Port
Virtio_net_request | Abstraction for a network request
Virtio_switch | The Virtio switch contains all ports and processes network requests
Virtio_vlan_mangle | Class for VLAN packet rewriting