| NBlock_device | |
| NErrand | |
| CPoll_errand | Wrapper for a regularly repeated task |
| CErrand | Wrapper for a small task executed asynchronously in the server loop |
| NImpl | |
| CPartitioned_device_discard_mixin | Dummy class used when the device class is not derived from Device_discard_feature |
| CPartitioned_device_discard_mixin< PART_DEV, BASE_DEV, true > | Mixin implementing discard for partition devices |
| CDevice_mgr | Basic class that scans devices and handles client connections |
| CNotification_domain | Opaque type for representing a notification domain |
| CDevice_with_notification_domain | Device with a per-device notification domain |
| CDevice_discard_feature | Partial interface for devices that offer discard functionality |
| CInout_memory | Helper class that temporarily allocates memory that can be used for in/out operations with the device |
| CPartitioned_device | A partition device for the given device interface |
| CPartition_info | Information about a single partition |
| CPartition_reader | Partition table reader for block devices |
| CPending_request | Interface for pending requests |
| CScheduler_base | Scheduler base class |
| CRr_scheduler | Round Robin scheduler class |
| CDma_region_info | Base class used by the driver implementation to derive its own DMA mapping tracking structure |
| CMem_region_info | Additional info stored in each L4virtio::Svr::Driver_mem_region_t used for tracking dataspace-wide DMA mappings |
| CInout_block | Description of an inout block to be sent to the device |
| Ncxx | Our C++ library |
| Narith | |
| CLd | Computes the binary logarithm of the given number at compile time |
| NBits | Internal helpers for the cxx package |
| CAvl_map_get_key | Key-getter for Avl_map |
| CAvl_set_get_key | Internal, key-getter for Avl_set nodes |
| CBase_avl_set | Internal: AVL set with internally managed nodes |
| CNode | A smart pointer to a tree item |
| CBst | Basic binary search tree (BST) |
| CDirection | The direction to go in a binary search tree |
| CBst_node | Basic type of a node in a binary search tree (BST) |
| CBasic_list | Internal: Common functions for all head-based list implementations |
| CSmart_ptr_list_item | List item for an arbitrary item in a Smart_ptr_list |
| CSmart_ptr_list | List of smart-pointer-managed objects |
| CAvl_map | AVL tree based associative container |
| CAvl_set | AVL set for simple comparable items |
| CAvl_tree_node | Node of an AVL tree |
| CAvl_tree | A generic AVL tree |
| CBitfield | Definition for a member (part) of a bit field |
| CValue_base | Internal helper type |
| CValue | Internal helper type |
| CValue_unshifted | Internal helper type |
| CBitmap_base | Basic bitmap abstraction |
| CBit | A writable bit in a bitmap |
| CWord | Helper abstraction for a word contained in the bitmap |
| CChar | Helper abstraction for a byte contained in the bitmap |
| CBitmap | A static bitmap |
| CH_list_item_t | Basic element type for a double-linked H_list |
| CH_list | General double-linked list of unspecified cxx::H_list_item elements |
| CH_list_t | Double-linked list of typed H_list_item_t elements |
| CList_item | Basic list item |
| CIter | Iterator for a list of ListItem-s |
| CT_iter | Iterator for derived classes from ListItem |
| CList | Doubly linked list, with internal allocation |
| CIter | Iterator |
| CList_alloc | Standard list-based allocator |
| CPair | Pair of two values |
| CPair_first_compare | Comparison functor for Pair |
| CRef_ptr | A reference-counting pointer with automatic cleanup |
| CRef_obj_list_item | Item for list linked via cxx::Ref_ptr with default refence counting |
| CBase_slab | Basic slab allocator |
| CSlab_i | Type of a slab |
| CSlab | Slab allocator for object of type Type |
| CBase_slab_static | Merged slab allocator (allocators for objects of the same size are merged together) |
| CSlab_static | Merged slab allocator (allocators for objects of the same size are merged together) |
| CS_list | Simple single-linked list |
| Cstatic_vector | Simple encapsulation for a dynamically allocated array |
| CNothrow | Helper type to distinguish the operator new version that does not throw exceptions |
| CNew_allocator | Standard allocator based on operator new () |
| CLt_functor | Generic comparator class that defaults to the less-than operator |
| CString | Allocation free string class with explicit length field |
| CWeak_ref_base | Generic (base) weak reference to some object |
| CList | The list type for keeping all weak references to an object |
| CWeak_ref | Typed weak reference to an object of type T |
| NL4 | L4 low-level kernel interface |
| NTypeid | Definition of interface data-type helpers |
| NDetail | |
| CRpcs_end | Internal end-of-list marker |
| C_Rpcs | Empty list of RPCs |
| C_Rpcs< OPCODE, O, R, X... > | Non-empty list of RPCs |
| CRpc | Find the given RPC in the list |
| CP_dispatch | Use for protocol based dispatch stage |
| CRaw_ipc | RPCs list for passing raw incoming IPC to the server object |
| CRpcs | Standard list of RPCs of an interface |
| CRpcs_code | List of RPCs of an interface using a special opcode type |
| CF | |
| CRpc_nocode | List of RPCs of an interface using a single operation without an opcode |
| CRpcs_sys | List of RPCs typically used for kernel interfaces |
| NIpc | IPC related functionality |
| NMsg | IPC Message related functionality |
| CElem< Array< A, LEN > > | Array as input arguments |
| CElem< Array< A, LEN > & > | Array as output argument |
| CElem< Array_ref< A, LEN > & > | Array_ref as output argument |
| CDir_in | Marker type for input values |
| CDir_out | Marker type for output values |
| CCls_data | Marker type for data values |
| CCls_item | Marker type for item values |
| CCls_buffer | Marker type for receive buffer values |
| CDo_in_data | Marker for Input data |
| CDo_out_data | Marker for Output data |
| CDo_in_items | Marker for Input items |
| CDo_out_items | Marker for Output items |
| CDo_rcv_buffers | Marker for receive buffers |
| CSvr_val_ops | Defines client-side handling of `MTYPE' as RPC argument |
| CIs_valid_rpc_type | Type trait defining a valid RPC parameter type |
| CSvr_arg_pack | Server-side RPC arguments data structure used to provide arguments to the server-side implementation of an RPC function |
| CTrue | True meta value |
| CFalse | False meta value |
| CArray_ref | Array reference data type for arrays located in the message |
| CArray | Array data type for dynamically sized arrays in RPCs |
| CArray_in_buf | Server-side copy in buffer for Array |
| CCall | RPC attribute for a standard RPC call |
| CCall_zero_send_timeout | RPC attribute for an RPC call, with zero send timeout |
| CCall_t | RPC attribute for an RPC call with required rights |
| CSend_only | RPC attribute for a send-only RPC |
| CRet_array | Dynamically sized output array of type T |
| COut | Mark an argument as a output value in an RPC signature |
| CIn_out | Mark an argument as in-out argument |
| CAs_value | Pass the argument as plain data value |
| COpt | Attribute for defining an optional RPC argument |
| CSmall_buf | A receive item for receiving a single object capability |
| CGen_fpage | Generic RPC base for typed message items |
| CSnd_fpage | Send item or return item |
| CRcv_fpage | Non-small receive item |
| CCap | Capability type for RPC interfaces (see L4::Cap<T>) |
| CVarg | Variably sized RPC argument |
| CVarg_list | Self-contained list of variable-sized RPC parameters |
| CVarg_list_ref | List of variable-sized RPC parameters as received by the server |
| CIterator | Iterator for Valists |
| CStr_cp_in | Abstraction for extracting a zero-terminated string from an Ipc::Istream |
| CMsg_ptr | Pointer to an element of type T in an Ipc::Istream |
| CIstream | Input stream for IPC unmarshalling |
| COstream | Output stream for IPC marshalling |
| CIostream | Input/Output stream for IPC [un]marshalling |
| NIpc_svr | Helper classes for L4::Server instantiation |
| CServer_iface | Interface for server-loop related functions |
| CIgnore_errors | Mix in for LOOP_HOOKS to ignore IPC errors |
| CDefault_timeout | Mix in for LOOP_HOOKS to use a 0 send and a infinite receive timeout |
| CCompound_reply | Mix in for LOOP_HOOKS to always use compound reply and wait |
| CDefault_setup_wait | Mix in for LOOP_HOOKS for setup_wait no op |
| CDirect_dispatch | Direct dispatch helper, for forwarding dispatch calls to a registry R |
| CDirect_dispatch< R * > | Direct dispatch helper, for forwarding dispatch calls via a pointer to a registry R |
| CExc_dispatch | Dispatch helper wrapping try {} catch {} around the dispatch call |
| CDbg_dispatch | Dispatch helper that, in addition to what Exc_dispatch does, prints exception messages |
| CBr_manager_no_buffers | Empty implementation of Server_iface |
| CDefault_loop_hooks | Default LOOP_HOOKS |
| CTimeout | Callback interface for Timeout_queue |
| CTimeout_queue | Timeout queue to be used in l4re server loop |
| CTimeout_queue_hooks | Loop hooks mixin for integrating a timeout queue into the server loop |
| NTypes | L4 basic type helpers for C++ |
| CFlags | Template for defining typical Flags bitmaps |
| CInt_for_size | Metafunction to get an unsigned integral type for the given size |
| CInt_for_type | Metafunction to get an integral type of the same size as T |
| CFlags_ops_t | Mixin class to define a set of friend bitwise operators on DT |
| CFlags_t | Template type to define a flags type with bitwise operations |
| CBool | Boolean meta type |
| CFalse | False meta value |
| CTrue | True meta value |
| CSame | Compare two data types for equality |
| NKip | |
| CMem_desc | Memory descriptors stored in the kernel interface page |
| CType_info | Dynamic Type Information for L4Re Interfaces |
| CDemand | Data type for expressing the needed receive buffers at the server-side of an interface |
| CDemand_t | Template type statically describing demand of receive buffers |
| CDemand_union_t | Template type statically describing the combination of two Demand object |
| CKobject_typeid | Meta object for handling access to type information of Kobjects |
| CKobject_typeid< void > | Minimalistic ID for void interface |
| CKobject_t | Helper class to create an L4Re interface class that is derived from a single base class |
| CKobject_2t | Helper class to create an L4Re interface class that is derived from two base classes (see L4::Kobject_t) |
| CKobject_3t | Helper class to create an L4Re interface class that is derived from three base classes (see L4::Kobject_t) |
| CKobject_demand | Get the combined server-side resource requirements for all type T.. |
| CProto_t | Data type for defining protocol numbers |
| CKobject_x | Generic Kobject inheritance template |
| CVm | Virtual machine host address space |
| CArm_smccc | Wrapper for function calls that follow the ARM SMC/HVC calling convention |
| CCap | C++ interface for capabilities |
| CCap_base | Base class for all kinds of capabilities |
| CEpiface | Base class for interface implementations |
| CEpiface_t0 | Epiface mixin for generic Kobject-based interfaces |
| CIrqep_t | Epiface implementation for interrupt handlers |
| CRegistry_iface | Abstract interface for object registries |
| CEpiface_t | Epiface implementation for Kobject-based interface implementations |
| CBasic_registry | This registry returns the corresponding server object based on the label of an Ipc_gate |
| CServer | Basic server loop for handling client requests |
| CDebugger | C++ kernel debugger API |
| CException | Exception interface |
| CFactory | C++ Factory interface, see Factory for the C interface |
| CNil | Special type to add a void argument into the factory create stream |
| CLstr | Special type to add a pascal string into the factory create stream |
| CS | Stream class for the create() argument stream |
| CIommu | Interface for IO-MMUs used for DMA remapping |
| CIpc_gate | The C++ IPC gate interface, see IPC-Gate API for the C interface |
| CIrq_eoi | Interface for sending an unmask message to an object |
| CTriggerable | Interface that allows an object to be triggered by some source |
| CIrq | C++ Irq interface, see IRQs for the C interface |
| CIcu | C++ Icu interface, see Interrupt controller for the C interface |
| CInfo | This class encapsulates information about an ICU |
| CKobject | Base class for all kinds of kernel objects and remote objects, referenced by capabilities |
| CMeta | Meta interface that shall be implemented by each L4Re object and gives access to the dynamic type information for L4Re objects |
| CIo_pager | Io_pager interface |
| CPager | Pager interface including the Io_pager interface |
| CPlatform_control | L4 C++ interface for controlling platform-wide properties, see Platform Control C API for the C interface |
| CRcv_endpoint | Interface for kernel objects that allow to receive IPC from them |
| CScheduler | C++ interface of the Scheduler kernel object, see Scheduler for the C interface |
| CSemaphore | C++ Kernel-provided semaphore interface, see Kernel-provided semaphore for the C interface |
| CSmart_cap | Smart capability class |
| CTask | C++ interface of the Task kernel object, see Task for the C interface |
| CThread | C++ L4 kernel thread interface, see Thread for the C interface |
| CAttr | Thread attributes used for control() |
| CModify_senders | Class wrapping a list of rules which modify the sender label of IPC messages inbound to this thread |
| CThread_group | C++ L4 kernel thread group interface, see Thread groups for the C interface |
| CVcon | C++ L4 Vcon interface, see Virtual Console for the C interface |
| CPoll_timeout_kipclock | A polling timeout based on the L4Re clock |
| CAlloc_list | A simple list-based allocator |
| CIOModifier | Modifier class for the IO stream |
| CException_tracer | Back-trace support for exceptions |
| CBase_exception | Base class for all exceptions, thrown by the L4Re framework |
| CRuntime_error | Exception for an abstract runtime error |
| COut_of_memory | Exception signalling insufficient memory |
| CElement_already_exists | Exception for duplicate element insertions |
| CUnknown_error | Exception for an unknown condition |
| CElement_not_found | Exception for a failed lookup (element not found) |
| CInvalid_capability | Indicates that an invalid object was invoked |
| CCom_error | Error conditions during IPC |
| CBounds_error | Access out of bounds |
| CServer_object | Abstract server object to be used with L4::Server and L4::Basic_registry |
| CServer_object_t | Base class (template) for server implementing server objects |
| CServer_object_x | Helper class to implement p_dispatch based server objects |
| CIrq_handler_object | Server object base class for handling IRQ messages |
| CLock_guard | Basic lock guard implementation that prevents forgotten unlocks on exit paths from a method or a block of code |
| CString | A null-terminated string container class |
| CPoll_timeout_counter | Evaluate an expression for a maximum number of times |
| CUart_apb | Driver for the Advanced Peripheral Bus (APB) UART from the Cortex-M System Design Kit (CMSDK) |
| CUart | Uart driver abstraction |
| NL4drivers | |
| CMmio_register_block | An MMIO block with up to 64-bit register access (32-bit default) and little endian byte order |
| CRegister_block_base | Abstract register block interface |
| CRegister_block_tmpl | Helper template that translates to the Register_block_base interface |
| CRo_register_tmpl | Single read only register inside a Register_block_base interface |
| CRegister_tmpl | Single hardware register inside a Register_block_base interface |
| CRegister_block | Handles a reference to a register block of the given maximum access width |
| CRo_register_block | Handles a reference to a read only register block of the given maximum access width |
| CRegister_block_impl | Implementation helper for register blocks |
| NL4Re | L4Re C++ Interfaces |
| NNed | |
| CCmd_control | Direct control interface for Ned |
| NVfs | Virtual file system for interfaces in POSIX libc |
| CBe_file | Boiler plate class for implementing an open file for L4Re::Vfs |
| CBe_file_system | Boilerplate class for implementing a L4Re::Vfs::File_system |
| CGeneric_file | The common interface for an open POSIX file |
| CDirectory | Interface for a POSIX file that is a directory |
| CRegular_file | Interface for a POSIX file that provides regular file semantics |
| CSpecial_file | Interface for a POSIX file that provides special file semantics |
| CFile | The basic interface for an open POSIX file |
| CMman | Interface for POSIX memory management |
| CFile_system | Basic interface for an L4Re::Vfs file system |
| CFs | POSIX File-system related functionality |
| COps | Interface for the POSIX backends of an application |
| NCore | |
| CRef_ptr | A reference-counting pointer with automatic cleanup |
| NUtil | Documentation of the L4 Runtime Environment utility functionality in C++ |
| NNames | |
| CName | Name class |
| CName_space | Abstract server-side implementation of the L4::Namespace interface |
| NVideo | |
| CGoos_svr | Goos server class |
| CCap_alloc_base | Capability allocator |
| CBr_manager | Buffer-register (BR) manager for L4::Server |
| CBr_manager_hooks | Predefined server-loop hooks for a server loop using the Br_manager |
| CBr_manager_timeout_hooks | Predefined server-loop hooks for a server with using the Br_manager and a timeout queue |
| CSmart_cap_auto | Helper for Unique_cap and Unique_del_cap |
| CSmart_count_cap | Helper for Ref_cap and Ref_del_cap |
| CRef_cap | Automatic capability that implements automatic free and unmap of the capability selector |
| CRef_del_cap | Automatic capability that implements automatic free and unmap+delete of the capability selector |
| C_Cap_alloc | Adapter to expose the cap allocator implementation as L4Re::Cap_alloc compatible class |
| CCounter | Counter for Counting_cap_alloc with variable data width |
| CCounter_atomic | Thread safe version of counter for Counting_cap_alloc |
| CCounting_cap_alloc | Internal reference-counting cap allocator |
| CDataspace_svr | Dataspace server class |
| CEvent_t | Convenience wrapper for getting access to an event object |
| CEvent_buffer_t | Event_buffer utility class |
| CEvent_buffer_consumer_t | An event buffer consumer |
| CEvent_svr | Convenience wrapper for implementing an event server |
| CItem_alloc_base | Item allocator |
| CObject_registry | A registry that manages server objects and their attached IPC gates for a single server loop for a specific thread |
| CRegistry_server | A server loop object which has a Object_registry included |
| CVcon_svr | Console server template class |
| CBitmap_base | Basic bitmap abstraction |
| CBit | A writable bit in a bitmap |
| CWord | Helper abstraction for a word contained in the bitmap |
| CChar | Helper abstraction for a byte contained in the bitmap |
| CBitmap | A static bitmap |
| NVideo | |
| CColor_component | A color component |
| CPixel_info | Pixel information |
| CView | View of a framebuffer |
| CInfo | Information structure of a view |
| CGoos | Class that abstracts framebuffers |
| CInfo | Information structure of a Goos |
| CCap_alloc | Capability allocator interface |
| CSmart_cap_auto | Helper for Unique_cap and Unique_del_cap |
| CSmart_count_cap | Helper for Ref_cap and Ref_del_cap |
| CConsole | Console class |
| CDataspace | Interface for memory-like objects |
| CF | Dataspace flags definitions |
| CStats | Information about the dataspace |
| CDebug_obj | Debug interface |
| CDma_space | Managed DMA Address Space |
| CEnv | C++ interface of the initial environment that is provided to an L4 task |
| CEvent | Event class |
| CDefault_event_payload | Default event stream payload |
| CEvent_buffer_t | Event buffer class |
| CEvent | Event structure used in buffer |
| CInhibitor | Set of inhibitor locks, which inhibit specific actions when held |
| CItas | Interface to the ITAS |
| CLog | Log interface class |
| CMem_alloc | Memory allocation interface |
| CStats | Statistics about memory-allocator |
| CMmio_space | Interface for memory-like address space accessible via IPC |
| CNamespace | Name-space interface |
| CParent | Parent interface |
| CRandom | Low-bandwidth interface for random number generators |
| CRm | Region map |
| CF | Rm flags definitions |
| CUnique_region | Unique region |
| CRegion | A region is a range of virtual addresses which is backed by content |
| CArea | An area is a range of virtual addresses which is reserved, see L4Re::Rm::reserve_area() |
| NL4vbus | C++ interface of the Vbus API. |
| CPm | Power-management API mixin |
| CDevice | Device on a L4vbus::Vbus |
| CIcu | Vbus Interrupt controller API |
| CVbus | The virtual bus (Vbus) interface |
| CGpio_pin | A GPIO pin |
| CGpio_module | A Gpio_module groups multiple GPIO pins together |
| CPin_slice | A slice of the pins provided by this module |
| CPci_host_bridge | A Pci host bridge |
| CPci_dev | A PCI device |
| NL4vcpu | |
| CState | C++ implementation of state word in the vCPU area |
| CVcpu | C++ implementation of the vCPU save state area |
| NL4virtio | L4-VIRTIO Transport C++ API |
| NDriver | |
| CDevice | Client-side implementation for a general virtio device |
| CBlock_device | Simple class for accessing a virtio block device synchronously |
| CHandle | Handle to an ongoing request |
| CVirtio_net_device | Simple class for accessing a virtio net device |
| CPacket | Structure for a network packet (header including data) with maximum size, assuming that no extra features have been negotiated |
| CVirtqueue | Driver-side implementation of a Virtqueue |
| NSvr | |
| NConsole | |
| CFeatures | Virtio console specific feature bits |
| CControl_message | Virtio console control message |
| CControl_request | Specialised Virtqueue::Request providing access to control message payload |
| CPort | Representation of a Virtio console port |
| CTransition | State transition from last report state to current state |
| CVirtio_con | Base class implementing a virtio console functionality |
| CDevice_port | A console port with associated read/write state |
| CDevice | Base class implementing a virtio console device with L4Re-based notification handling |
| NScmi | |
| CScmi_hdr_t | SCMI header |
| CBase_attr_t | SCMI base protocol attributes |
| CPerformance_attr_t | SCMI performance protocol attributes |
| CPerformance_domain_attr_t | SCMI performance domain protocol attributes |
| CPerformance_describe_levels_n_t | SCMI performance describe levels numbers |
| CPerformance_describe_level_t | SCMI performance describe level |
| CProto | Base class for all protocols |
| CScmi_dev | A server implementation of the virtio-scmi protocol |
| CBase_proto | Base class for the SCMI base protocol |
| CPerf_proto | Base class for the SCMI performance protocol |
| CDev_config | Abstraction for L4-Virtio device config memory |
| CDriver_mem_region_t | Region of driver memory, that shall be managed locally |
| CDriver_mem_list_t | List of driver memory regions assigned to a single L4-VIRTIO transport instance |
| CDevice_t | Server-side L4-VIRTIO device stub |
| CDev_status | Type of the device status register |
| CDev_features | Type for device feature bitmap |
| CVirtqueue | Virtqueue implementation for the device |
| CHead_desc | VIRTIO request, essentially a descriptor from the available ring |
| CData_buffer | Abstract data buffer |
| CBad_descriptor | Exception used by Queue to indicate descriptor errors |
| CRequest_processor | Encapsulate the state for processing a VIRTIO request |
| CBlock_dev_base | Base class for virtio block devices |
| CBlock_request | A request to read or write data |
| CVirtio_gpio | A server implementation of the virtio-gpio protocol |
| CIrq_handler | Handler for an gpio pin irq |
| CHost_irq | Handler for the host irq |
| CRequest_processor | Generic handler for the Virtio requests |
| CVirtio_i2c | A server implementation of the virtio-i2c protocol |
| CHost_irq | Handler for the host irq |
| CRequest_processor | Handler for the Virtio requests |
| CVirtio_rng | A server implementation of the virtio-rng protocol |
| CHost_irq | Handler for the host irq |
| CRequest_processor | Handler for the Virtio requests |
| CDevice | IPC interface for virtio over L4 IPC |
| CPtr | Pointer used in virtio descriptors |
| CVirtqueue | Low-level Virtqueue |
| CDesc | Descriptor in the descriptor table |
| CFlags | Type for descriptor flags |
| CAvail | Type of available ring, this is read-only for the host |
| CFlags | Flags of the available ring |
| CUsed_elem | Type of an element of the used ring |
| CUsed | Used ring |
| CFlags | Flags for the used ring |
| CBuffer | Data buffer used to transfer packets |
| CElf32_Auxv | Auxiliary vector (32-bit) |
| CElf32_Dyn | ELF32 dynamic entry |
| CElf32_Ehdr | ELF32 header |
| CElf32_Phdr | ELF32 program header |
| CElf32_Rel | ELF32 relocation entry w/o addend |
| CElf32_Rela | ELF32 relocation entry w/ addend |
| CElf32_Shdr | ELF32 section header |
| CElf32_Sym | ELF32 symbol table entry |
| CElf64_Auxv | Auxiliary vector (64-bit) |
| CElf64_Dyn | ELF64 dynamic entry |
| CElf64_Ehdr | ELF64 header |
| CElf64_Phdr | ELF64 program header |
| CElf64_Rel | ELF64 relocation entry w/o addend |
| CElf64_Rela | ELF64 relocation entry w/ addend |
| CElf64_Shdr | ELF64 section header |
| CElf64_Sym | ELF64 symbol table entry |
| Cgfxbitmap_offset | Offsets in pmap[] and bmap[] |
| Cl4_buf_regs_t | Encapsulation of the buffer-registers block in the UTCB |
| Cl4_exc_regs_t | UTCB structure for exceptions |
| Cl4_fpage_t | L4 flexpage type |
| Cl4_icu_info_t | Info structure for an ICU |
| Cl4_icu_msi_info_t | Info to use for a specific MSI |
| Cl4_kernel_info_mem_desc_t | Memory descriptor data structure |
| Cl4_kernel_info_t | L4 Kernel Interface Page |
| Cl4_msg_regs_t | Encapsulation of the message-register block in the UTCB |
| Cl4_msgtag_t | Message tag data structure |
| Cl4_sched_cpu_set_t | CPU sets |
| Cl4_sched_param_t | Scheduler parameter set |
| Cl4_snd_fpage_t | Send-flexpage types |
| Cl4_thread_regs_t | Encapsulation of the thread-control-register block of the UTCB |
| Cl4_timeout_s | Basic timeout specification |
| Cl4_timeout_t | Timeout pair |
| Cl4_vcon_attr_t | Vcon attribute structure |
| Cl4_vcpu_arch_state_t | Architecture-specific vCPU state |
| Cl4_vcpu_ipc_regs_t | VCPU message registers |
| Cl4_vcpu_regs_t | VCPU registers |
| Cl4_vcpu_state_t | State of a vCPU |
| Cl4_vm_svm_vmcb_control_area | VMCB structure for SVM VMs |
| Cl4_vm_svm_vmcb_state_save_area | State save area structure for SVM VMs |
| Cl4_vm_svm_vmcb_state_save_area_seg | State save area segment selector struct |
| Cl4_vm_svm_vmcb_t | Control structure for SVM VMs |
| Cl4_vm_tz_state | State structure for TrustZone VMs |
| Cl4_vm_vmx_vcpu_infos_t | VMX information members |
| Cl4_vm_vmx_vcpu_state_t | VMX vCPU state |
| Cl4_vm_vmx_vcpu_vmcs_t | VMX software VMCS |
| Cl4_vmx_offset_table_t | Software VMCS field offset table |
| Cl4re_aux_t | Auxiliary descriptor |
| Cl4re_ds_stats_t | Information about the data space |
| Cl4re_elf_aux_mword_t | Auxiliary vector element for a single unsigned data word |
| Cl4re_elf_aux_t | Generic header for each auxiliary vector element |
| Cl4re_elf_aux_vma_t | Auxiliary vector element for a reserved virtual memory area |
| Cl4re_env_cap_entry_t | Entry in the L4Re environment array for the named initial objects |
| Cl4re_env_t | Initial environment data structure |
| Cl4re_event_t | Event structure used in buffer |
| Cl4re_video_color_component_t | Color component structure |
| Cl4re_video_goos_info_t | Goos information structure |
| Cl4re_video_pixel_info_t | Pixel_info structure |
| Cl4re_video_view_info_t | View information structure |
| Cl4re_video_view_t | C representation of a goos view |
| Cl4shmc_ringbuf_head_t | Head field of a ring buffer |
| Cl4shmc_ringbuf_t | Ring buffer |
| Cl4util_l4mod_info | Base module structure |
| Cl4util_l4mod_mod | A single module |
| Cl4util_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 |
| Cl4util_mb_apm_t | APM BIOS info |
| Cl4util_mb_drive_t | Drive Info structure |
| Cl4util_mb_info_t | MultiBoot Info description |
| Cl4util_mb_mod_t | The structure type "mod_list" is used by the multiboot_info structure |
| Cl4util_mb_vbe_ctrl_t | VBE controller information |
| Cl4util_mb_vbe_mode_t | VBE mode information |
| Cl4vbus_device_t | Detailed information about a vbus device |
| Cl4vbus_resource_t | Description of a single vbus resource |
| Cl4virtio_block_config_t | Device configuration for block devices |
| Cl4virtio_block_discard_t | Structure used for the write zeroes and discard commands |
| Cl4virtio_block_header_t | Header structure of a request for a block device |
| Cl4virtio_config_hdr_t | L4-VIRTIO config header, provided in shared data space |
| Cl4virtio_config_queue_t | Queue configuration entry |
| Cl4virtio_input_absinfo_t | Information about the absolute axis in the underlying evdev implementation |
| Cl4virtio_input_config_t | Device configuration for input devices |
| Cl4virtio_input_devids_t | Device ID information for the device |
| Cl4virtio_input_event_t | Single event in event or status queue |
| Cl4virtio_net_config_t | Device configuration for network devices |
| Cl4virtio_net_header_t | Header structure of a request for a network device |
| CL4virtio_port | A Port on the Virtio Net Switch |
| CMac_addr | A wrapper class around the value of a MAC address |
| CMac_table | Mac_table manages a 1:n association between ports and MAC addresses |
| CNet_transfer | A network request to only a single destination |
| CRm | Region map |
| CF | Rm flags definitions |
| CUnique_region | Unique region |
| CRegion | A region is a range of virtual addresses which is backed by content |
| CArea | An area is a range of virtual addresses which is reserved, see L4Re::Rm::reserve_area() |
| CSwitch_factory | The IPC interface for creating ports |
| CVirtio_net | The Base class of a Port |
| CVirtio_net_request | Abstraction for a network request |
| CVirtio_switch | The Virtio switch contains all ports and processes network requests |
| CVirtio_vlan_mangle | Class for VLAN packet rewriting |
1.15.0