| CL4::Ipc::Array_ref< char const, unsigned long > | |
| CL4::Ipc::Array_ref< ELEM_TYPE, Array_len_default > | |
| Ccxx::Bits::Base_avl_set< ITEM_TYPE, Lt_functor< ITEM_TYPE >, New_allocator, Bits::Avl_set_get_key< ITEM_TYPE > > | |
| Ccxx::Bits::Base_avl_set< Pair< KEY_TYPE, DATA_TYPE >, Lt_functor< KEY_TYPE >, New_allocator, Bits::Avl_map_get_key< KEY_TYPE > > | |
| Ccxx::Bits::Base_avl_set< Pair< Region, Hdlr >, cxx::Lt_functor< Region >, Alloc, Bits::Avl_map_get_key< Region > > | |
| Ccxx::Base_slab< Obj_size, Slab_size, Max_free, Alloc > | |
| Ccxx::Base_slab< sizeof(Type), L4_PAGESIZE, 2, New_allocator > | |
| Ccxx::Base_slab_static< sizeof(Type), L4_PAGESIZE, 2, New_allocator > | |
| Ccxx::Bits::Basic_list< Bits::Basic_list_policy< cxx::Base_slab::Slab_i, H_list_item > > | |
| Ccxx::Bits::Basic_list< Bits::Basic_list_policy< Observer, H_list_item > > | |
| Ccxx::Bits::Basic_list< Bits::Basic_list_policy< T, H_list_item > > | |
| Ccxx::Bits::Basic_list< Bits::Basic_list_policy< T, H_list_item_t< T > > > | |
| Ccxx::Bits::Basic_list< Bits::Basic_list_policy< T, S_list_item > > | |
| Ccxx::Bits::Basic_list< Bits::Basic_list_policy< Timeout, H_list_item > > | |
| Ccxx::Bits::Basic_list< Bits::Basic_list_policy< Weak_ref_base, H_list_item_t< Weak_ref_base > > > | |
| CBlock_device::Device_discard_feature | Partial interface for devices that offer discard functionality |
| CBlock_device::Device_mgr< DEV, FACTORY, SCHEDULER > | Basic class that scans devices and handles client connections |
| CBlock_device::Device_with_notification_domain< DEV > | Device with a per-device notification domain |
| CBlock_device::Dma_region_info | Base class used by the driver implementation to derive its own DMA mapping tracking structure |
| ►CBlock_device::Impl::Partitioned_device_discard_mixin< PART_DEV, BASE_DEV, bool > | Dummy class used when the device class is not derived from Device_discard_feature |
| CBlock_device::Partitioned_device< BASE_DEV > | A partition device for the given device interface |
| CBlock_device::Impl::Partitioned_device_discard_mixin< PART_DEV, BASE_DEV, true > | Mixin implementing discard for partition devices |
| CBlock_device::Inout_block | Description of an inout block to be sent to the device |
| CBlock_device::Inout_memory< DEV > | Helper class that temporarily allocates memory that can be used for in/out operations with the device |
| CBlock_device::Mem_region_info | Additional info stored in each L4virtio::Svr::Driver_mem_region_t used for tracking dataspace-wide DMA mappings |
| CBlock_device::Notification_domain | Opaque type for representing a notification domain |
| CBlock_device::Partition_info | Information about a single partition |
| CBlock_device::Partition_reader< DEV > | Partition table reader for block devices |
| CBlock_device::Pending_request | Interface for pending requests |
| ►CBlock_device::Scheduler_base< DEV > | Scheduler base class |
| CBlock_device::Rr_scheduler< DEV > | Round Robin scheduler class |
| CL4::Types::Bool< __Iface_conflict< I, I2 >::value||_Iface_conflict< I, LIST::type >::value > | |
| ►CL4::Types::Bool< false > | |
| ►CL4::Types::False | False meta value |
| CL4::Types::Same< A, B > | Compare two data types for equality |
| CL4::Types::Bool< I1::Proto !=PROTO_EMPTY &&I1::Proto==I2::Proto > | |
| CL4::Types::Bool< Iface_conflict< I, L2::type >::value||_Conflict< L1::type, L2::type >::value > | |
| ►CL4::Types::Bool< true > | |
| ►CL4::Types::True | True meta value |
| CL4::Ipc::Msg::Is_valid_rpc_type< A * > | |
| CL4::Ipc::Msg::Is_valid_rpc_type< T > | Type trait defining a valid RPC parameter type |
| CL4::Types::Bool< Typeid::Conflict< L1::type, L2::type >::value||Conflict< L1, LIST... >::value||Conflict< L2, LIST... >::value > | |
| CL4::Types::Bool< Typeid::Iface_conflict< I::type, L::type >::value||Iface_conflict< I, LIST... >::value > | |
| Ccxx::Bits::Bst< _Node, Bits::Avl_map_get_key< KEY_TYPE >, Lt_functor< KEY_TYPE > > | |
| Ccxx::Bits::Bst< _Node, Bits::Avl_map_get_key< Region >, cxx::Lt_functor< Region > > | |
| Ccxx::Bits::Bst< _Node, Bits::Avl_set_get_key< ITEM_TYPE >, Lt_functor< ITEM_TYPE > > | |
| Ccxx::Bits::Bst< _Node, GET_KEY, COMPARE > | |
| Ccxx::Bits::Bst< Entry, Names_get_key, Lt_functor< typename Get_key::Key_type > > | |
| Ccxx::Bits::Bst< Node, Get_key, Lt_functor< typename Get_key::Key_type > > | |
| CL4::Ipc::Msg::Clnt_val_ops< Detail::_Plain< T >::type, DIR, CLASS > | |
| CL4::Ipc::Msg::Clnt_val_ops< Detail::_Plain< typename ELEM::arg_type >::type, typename Direction< A * >::type, typename Class< typename Detail::_Plain< A * >::type >::type > | |
| CL4::Ipc::Msg::Clnt_val_ops< Detail::_Plain< typename ELEM::arg_type >::type, typename Direction< A const * >::type, typename Class< typename Detail::_Plain< A const * >::type >::type > | |
| CL4::Ipc::Msg::Clnt_val_ops< Detail::_Plain< typename ELEM::arg_type >::type, typename Direction< Array< A, LEN > & >::type, typename Class< typename Detail::_Plain< Array< A, LEN > & >::type >::type > | |
| CL4::Ipc::Msg::Clnt_val_ops< Detail::_Plain< typename ELEM::arg_type >::type, typename Direction< Array< A, LEN > >::type, typename Class< typename Detail::_Plain< Array< A, LEN > >::type >::type > | |
| CL4::Ipc::Msg::Clnt_val_ops< Detail::_Plain< typename ELEM::arg_type >::type, typename Direction< String< A, LEN > & >::type, typename Class< typename Detail::_Plain< String< A, LEN > & >::type >::type > | |
| CL4::Ipc::Msg::Clnt_val_ops< Detail::_Plain< typename ELEM::arg_type >::type, typename Direction< T >::type, typename Class< typename Detail::_Plain< T >::type >::type > | |
| ►Ccxx::Base_slab< Obj_size, Slab_size, Max_free, Alloc > | Basic slab allocator |
| Ccxx::Slab< Type, Slab_size, Max_free, Alloc > | Slab allocator for object of type Type |
| ►Ccxx::Base_slab_static< Obj_size, Slab_size, Max_free, Alloc > | Merged slab allocator (allocators for objects of the same size are merged together) |
| Ccxx::Slab_static< Type, Slab_size, Max_free, Alloc > | Merged slab allocator (allocators for objects of the same size are merged together) |
| Ccxx::Bitfield< T, LSB, MSB > | Definition for a member (part) of a bit field |
| ►Ccxx::Bitfield< T, LSB, MSB >::Value_base< TT > | Internal helper type |
| Ccxx::Bitfield< T, LSB, MSB >::Value< TT > | Internal helper type |
| Ccxx::Bitfield< T, LSB, MSB >::Value_unshifted< TT > | Internal helper type |
| ►Ccxx::Bitmap_base | Basic bitmap abstraction |
| Ccxx::Bitmap< BITS > | A static bitmap |
| Ccxx::Bitmap_base::Bit | A writable bit in a bitmap |
| Ccxx::Bitmap_base::Char< BITS > | Helper abstraction for a byte contained in the bitmap |
| Ccxx::Bitmap_base::Word< BITS > | Helper abstraction for a word contained in the bitmap |
| Ccxx::Bits::Avl_map_get_key< KEY_TYPE > | Key-getter for Avl_map |
| Ccxx::Bits::Avl_set_get_key< KEY_TYPE > | Internal, key-getter for Avl_set nodes |
| ►Ccxx::Bits::Base_avl_set< ITEM_TYPE, COMPARE, ALLOC, GET_KEY > | Internal: AVL set with internally managed nodes |
| Ccxx::Avl_map< Region, Hdlr, cxx::Lt_functor, Alloc > | |
| Ccxx::Avl_map< KEY_TYPE, DATA_TYPE, COMPARE, ALLOC > | AVL tree based associative container |
| Ccxx::Avl_set< ITEM_TYPE, COMPARE, ALLOC > | AVL set for simple comparable items |
| Ccxx::Bits::Base_avl_set< ITEM_TYPE, COMPARE, ALLOC, GET_KEY >::Node | A smart pointer to a tree item |
| ►Ccxx::Bits::Basic_list< POLICY > | Internal: Common functions for all head-based list implementations |
| ►Ccxx::H_list< T, Bits::Basic_list_policy< T, H_list_item_t< T > > > | |
| Ccxx::H_list_t< T > | Double-linked list of typed H_list_item_t elements |
| Ccxx::H_list< Observer > | |
| Ccxx::H_list< cxx::Base_slab::Slab_i > | |
| Ccxx::H_list< Weak_ref_base, Bits::Basic_list_policy< Weak_ref_base, H_list_item_t< Weak_ref_base > > > | |
| Ccxx::H_list< Timeout > | |
| Ccxx::S_list< T, Bits::Basic_list_policy< T, S_list_item > > | |
| ►Ccxx::H_list< T, POLICY > | General double-linked list of unspecified cxx::H_list_item elements |
| ►Ccxx::H_list_t< Weak_ref_base > | |
| Ccxx::Weak_ref_base::List | The list type for keeping all weak references to an object |
| Ccxx::S_list< T, POLICY > | Simple single-linked list |
| ►Ccxx::Bits::Bst< Node, Get_key, Compare > | Basic binary search tree (BST) |
| Ccxx::Avl_tree< _Node, Bits::Avl_map_get_key< KEY_TYPE >, Lt_functor< KEY_TYPE > > | |
| Ccxx::Avl_tree< _Node, Bits::Avl_set_get_key< ITEM_TYPE >, Lt_functor< ITEM_TYPE > > | |
| Ccxx::Avl_tree< Entry, Names_get_key > | |
| Ccxx::Avl_tree< _Node, Bits::Avl_map_get_key< Region >, cxx::Lt_functor< Region > > | |
| Ccxx::Avl_tree< _Node, GET_KEY, COMPARE > | |
| Ccxx::Avl_tree< Node, Get_key, Compare > | A generic AVL tree |
| ►Ccxx::Bits::Bst_node | Basic type of a node in a binary search tree (BST) |
| Ccxx::Avl_tree_node | Node of an AVL tree |
| Ccxx::Bits::Direction | The direction to go in a binary search tree |
| Ccxx::Bits::Smart_ptr_list< ITEM > | List of smart-pointer-managed objects |
| ►Ccxx::Bits::Smart_ptr_list_item< T, STORE_T > | List item for an arbitrary item in a Smart_ptr_list |
| Ccxx::Ref_obj_list_item< Connection > | |
| Ccxx::Ref_obj_list_item< T > | Item for list linked via cxx::Ref_ptr with default refence counting |
| ►Ccxx::H_list_item_t< ELEM_TYPE > | Basic element type for a double-linked H_list |
| ►CL4::Ipc_svr::Timeout | Callback interface for Timeout_queue |
| CBlock_device::Errand::Errand | Wrapper for a small task executed asynchronously in the server loop |
| CBlock_device::Errand::Poll_errand | Wrapper for a regularly repeated task |
| Ccxx::List< D, Alloc > | Doubly linked list, with internal allocation |
| Ccxx::List< D, Alloc >::Iter | Iterator |
| Ccxx::List_alloc | Standard list-based allocator |
| Ccxx::List_item | Basic list item |
| ►Ccxx::List_item::Iter | Iterator for a list of ListItem-s |
| Ccxx::List_item::T_iter< E > | |
| Ccxx::List_item::T_iter< T, Poly > | Iterator for derived classes from ListItem |
| Ccxx::Lt_functor< Obj > | Generic comparator class that defaults to the less-than operator |
| Ccxx::New_allocator< _Type > | Standard allocator based on operator new () |
| Ccxx::Nothrow | Helper type to distinguish the operator new version that does not throw exceptions |
| Ccxx::Pair< First, Second > | Pair of two values |
| Ccxx::Pair_first_compare< Cmp, Typ > | Comparison functor for Pair |
| Ccxx::Ref_ptr< T, CNT > | A reference-counting pointer with automatic cleanup |
| Ccxx::static_vector< T, IDX > | Simple encapsulation for a dynamically allocated array |
| ►Ccxx::String | Allocation free string class with explicit length field |
| CL4Re::Util::Names::Name | Name class |
| ►CL4virtio::Svr::Device_t< Ds_data > | |
| CL4virtio::Svr::Block_dev_base< Ds_data > | Base class for virtio block devices |
| CL4virtio::Svr::Device_t< Mem_region_info > | |
| CL4virtio::Svr::Driver_mem_list_t< Ds_data > | |
| CL4virtio::Svr::Driver_mem_list_t< Mem_region_info > | |
| CL4virtio::Svr::Driver_mem_region_t< Ds_data > | |
| 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 |
| CL4::Epiface_t0< IFACE, BASE > | |
| CL4::Epiface_t0< void, BASE > | |
| ►CL4Re::Event_buffer_t< PAYLOAD > | |
| ►CL4Re::Util::Event_buffer_t< PAYLOAD > | Event_buffer utility class |
| CL4Re::Util::Event_buffer_consumer_t< PAYLOAD > | An event buffer consumer |
| CL4::Types::Flags_ops_t< Flags > | |
| ►CL4::Types::Flags_ops_t< Flags_t< DT, T > > | |
| CL4::Types::Flags_t< DT, T > | Template type to define a flags type with bitwise operations |
| Cgfxbitmap_offset | Offsets in pmap[] and bmap[] |
| ►Ccxx::H_list_item_t< Weak_ref_base > | |
| ►Ccxx::Weak_ref_base | Generic (base) weak reference to some object |
| Ccxx::Weak_ref< T > | Typed weak reference to an object of type T |
| CBlock_device::Inout_memory< Device_type > | |
| ►CL4::Kobject_2t< Console, Video::Goos, Event, L4::PROTO_EMPTY > | |
| CL4Re::Console | Console class |
| CL4::Kobject_2t< Debug_obj_t< BASE >, BASE, Debug_obj, L4::PROTO_EMPTY > | |
| ►CL4::Kobject_x< Iommu, Proto_t< L4_PROTO_IOMMU >, Type_info::Demand_t< 1 > > | |
| CL4::Iommu | Interface for IO-MMUs used for DMA remapping |
| CL4::Alloc_list | A simple list-based allocator |
| ►CL4::Basic_registry | This registry returns the corresponding server object based on the label of an Ipc_gate |
| CL4Re::Util::Object_registry | A registry that manages server objects and their attached IPC gates for a single server loop for a specific thread |
| ►CL4::Cap_base | Base class for all kinds of capabilities |
| CL4::Cap< void > | |
| CL4::Cap< L4::Rcv_endpoint > | |
| CL4::Cap< L4Re::Rm > | |
| CL4::Cap< L4::Irq > | |
| CL4::Cap< L4Re::Namespace > | |
| CL4::Cap< L4Re::Dataspace > | |
| CL4::Cap< L4::Vcon > | |
| CL4::Cap< L4::Semaphore > | |
| CL4::Cap< L4::Thread > | |
| CL4::Cap< L4::Factory > | |
| CL4::Cap< L4Re::Video::Goos > | |
| CL4::Cap< L4vbus::Vbus > | |
| CL4::Cap< L4virtio::Device > | |
| CL4::Cap< T > | C++ interface for capabilities |
| CL4::Smart_cap< T, SMART > | Smart capability class |
| ►CL4::Epiface | Base class for interface implementations |
| CL4::Epiface_t0< void, Epiface > | |
| CL4::Epiface_t0< L4virtio::Device, L4::Epiface > | |
| CL4::Epiface_t0< IFACE, L4::Epiface > | |
| CL4::Epiface_t0< L4::Kobject, L4::Epiface > | |
| CL4::Epiface_t0< L4::Factory, L4::Epiface > | |
| ►CL4::Epiface_t0< RPC_IFACE, BASE > | Epiface mixin for generic Kobject-based interfaces |
| CL4::Epiface_t< Virtio_client< DEV >, L4virtio::Device > | |
| CL4::Epiface_t< Null_handler, L4::Kobject > | |
| CL4::Epiface_t< Block_dev< Ds_data >, L4virtio::Device > | |
| CL4::Epiface_t< Virtio_i2c< Request_handler, L4virtio::Device >, L4virtio::Device > | |
| CL4::Epiface_t< Virtio_rng< Rnd_state >, L4virtio::Device > | |
| ►CL4::Epiface_t< Switch_factory, L4::Factory > | |
| CSwitch_factory | The IPC interface for creating ports |
| ►CL4::Epiface_t< Virtio_net, L4virtio::Device > | |
| ►CVirtio_net | The Base class of a Port |
| CVirtio_port | A Port on the Virtio Net Switch |
| CL4::Irqep_t< Irq_object > | |
| ►CL4::Irqep_t< Host_irq > | |
| CL4virtio::Svr::Virtio_i2c< Request_handler, Epiface >::Host_irq | Handler for the host irq |
| CL4virtio::Svr::Virtio_rng< Rnd_state, Epiface >::Host_irq | Handler for the host irq |
| CL4::Irqep_t< Del_cap_irq > | |
| CL4::Irqep_t< Kick_irq > | |
| ►CL4::Epiface_t< Derived, IFACE, BASE, bool > | Epiface implementation for Kobject-based interface implementations |
| CL4virtio::Svr::Virtio_i2c< Request_handler, Epiface > | A server implementation of the virtio-i2c protocol |
| CL4virtio::Svr::Virtio_rng< Rnd_state, Epiface > | A server implementation of the virtio-rng protocol |
| CL4::Irqep_t< Derived, BASE, bool > | Epiface implementation for interrupt handlers |
| ►CL4::Server_object | Abstract server object to be used with L4::Server and L4::Basic_registry |
| ►CL4::Server_object_t< Kobject > | |
| CL4::Irq_handler_object | Server object base class for handling IRQ messages |
| CL4::Server_object_t< IFACE, L4::Server_object > | |
| ►CL4::Server_object_t< IFACE, BASE > | Base class (template) for server implementing server objects |
| CL4::Server_object_x< Derived, IFACE, BASE > | Helper class to implement p_dispatch based server objects |
| CL4::Server_object_x< Derived, IFACE, BASE > | Helper class to implement p_dispatch based server objects |
| ►CL4::Exception_tracer | Back-trace support for exceptions |
| ►CL4::Base_exception | Base class for all exceptions, thrown by the L4Re framework |
| CL4::Invalid_capability | Indicates that an invalid object was invoked |
| ►CL4::Runtime_error | Exception for an abstract runtime error |
| CL4::Bounds_error | Access out of bounds |
| CL4::Com_error | Error conditions during IPC |
| CL4::Element_already_exists | Exception for duplicate element insertions |
| CL4::Element_not_found | Exception for a failed lookup (element not found) |
| CL4::Out_of_memory | Exception signalling insufficient memory |
| CL4::Unknown_error | Exception for an unknown condition |
| CL4::Factory::Lstr | Special type to add a pascal string into the factory create stream |
| CL4::Factory::Nil | Special type to add a void argument into the factory create stream |
| CL4::Factory::S | Stream class for the create() argument stream |
| CL4::IOModifier | Modifier class for the IO stream |
| CL4::Ipc::Array_in_buf< ELEM_TYPE, LEN_TYPE, MAX > | Server-side copy in buffer for Array |
| ►CL4::Ipc::Array_ref< ELEM_TYPE, LEN_TYPE > | Array reference data type for arrays located in the message |
| CL4::Ipc::Array< char const, unsigned long > | |
| CL4::Ipc::Array< ELEM_TYPE, LEN_TYPE > | Array data type for dynamically sized arrays in RPCs |
| CL4::Ipc::As_value< T > | Pass the argument as plain data value |
| ►CL4::Ipc::Call | RPC attribute for a standard RPC call |
| CL4::Ipc::Call_t< RIGHTS > | RPC attribute for an RPC call with required rights |
| CL4::Ipc::Call_zero_send_timeout | RPC attribute for an RPC call, with zero send timeout |
| CL4::Ipc::Cap< T > | Capability type for RPC interfaces (see L4::Cap<T>) |
| ►CL4::Ipc::Gen_fpage | Generic RPC base for typed message items |
| CL4::Ipc::Rcv_fpage | Non-small receive item |
| CL4::Ipc::Snd_fpage | Send item or return item |
| CL4::Ipc::In_out< T > | Mark an argument as in-out argument |
| ►CL4::Ipc::Istream | Input stream for IPC unmarshalling |
| CL4::Ipc::Iostream | Input/Output stream for IPC [un]marshalling |
| CL4::Ipc::Msg::Clnt_val_ops< MTYPE, DIR, CLASS > | Defines client-side handling of ‘MTYPE’ as RPC argument |
| ►CL4::Ipc::Msg::Cls_buffer | Marker type for receive buffer values |
| CL4::Ipc::Msg::Do_rcv_buffers | Marker for receive buffers |
| ►CL4::Ipc::Msg::Cls_data | Marker type for data values |
| CL4::Ipc::Msg::Do_in_data | Marker for Input data |
| CL4::Ipc::Msg::Do_out_data | Marker for Output data |
| ►CL4::Ipc::Msg::Cls_item | Marker type for item values |
| CL4::Ipc::Msg::Do_in_items | Marker for Input items |
| CL4::Ipc::Msg::Do_out_items | Marker for Output items |
| ►CL4::Ipc::Msg::Dir_in | Marker type for input values |
| CL4::Ipc::Msg::Do_in_data | Marker for Input data |
| CL4::Ipc::Msg::Do_in_items | Marker for Input items |
| CL4::Ipc::Msg::Do_rcv_buffers | Marker for receive buffers |
| ►CL4::Ipc::Msg::Dir_out | Marker type for output values |
| CL4::Ipc::Msg::Do_out_data | Marker for Output data |
| CL4::Ipc::Msg::Do_out_items | Marker for Output items |
| CL4::Ipc::Msg::Elem< Array< A, LEN > & > | Array as output argument |
| CL4::Ipc::Msg::Elem< Array< A, LEN > > | Array as input arguments |
| CL4::Ipc::Msg::Elem< Array_ref< A, LEN > & > | Array_ref as output argument |
| CL4::Ipc::Msg::Svr_arg_pack< IPC_TYPE > | Server-side RPC arguments data structure used to provide arguments to the server-side implementation of an RPC function |
| CL4::Ipc::Msg::Svr_val_ops< MTYPE, DIR, CLASS > | Defines server-side handling for MTYPE server arguments |
| CL4::Ipc::Msg_ptr< T > | Pointer to an element of type T in an Ipc::Istream |
| CL4::Ipc::Opt< T > | Attribute for defining an optional RPC argument |
| ►CL4::Ipc::Ostream | Output stream for IPC marshalling |
| CL4::Ipc::Iostream | Input/Output stream for IPC [un]marshalling |
| CL4::Ipc::Out< T > | Mark an argument as a output value in an RPC signature |
| CL4::Ipc::Ret_array< T > | Dynamically sized output array of type T |
| CL4::Ipc::Send_only | RPC attribute for a send-only RPC |
| CL4::Ipc::Small_buf | A receive item for receiving a single object capability |
| CL4::Ipc::Str_cp_in< T > | Abstraction for extracting a zero-terminated string from an Ipc::Istream |
| CL4::Ipc::Varg | Variably sized RPC argument |
| ►CL4::Ipc::Varg_list_ref | List of variable-sized RPC parameters as received by the server |
| CL4::Ipc::Varg_list< MAX > | Self-contained list of variable-sized RPC parameters |
| CL4::Ipc::Varg_list_ref::Iterator | Iterator for Valists |
| ►CL4::Ipc_svr::Compound_reply | Mix in for LOOP_HOOKS to always use compound reply and wait |
| ►CL4::Ipc_svr::Default_loop_hooks | Default LOOP_HOOKS |
| CL4::Server< L4::Ipc_svr::Default_loop_hooks > | |
| ►CL4::Server< LOOP_HOOKS > | Basic server loop for handling client requests |
| CL4Re::Util::Registry_server< LOOP_HOOKS > | A server loop object which has a Object_registry included |
| CL4Re::Util::Br_manager_hooks | Predefined server-loop hooks for a server loop using the Br_manager |
| CL4::Ipc_svr::Default_setup_wait | Mix in for LOOP_HOOKS for setup_wait no op |
| ►CL4::Ipc_svr::Default_timeout | Mix in for LOOP_HOOKS to use a 0 send and a infinite receive timeout |
| CL4::Ipc_svr::Default_loop_hooks | Default LOOP_HOOKS |
| CL4Re::Util::Br_manager_hooks | Predefined server-loop hooks for a server loop using the Br_manager |
| ►CL4::Ipc_svr::Direct_dispatch< R > | Direct dispatch helper, for forwarding dispatch calls to a registry R |
| CL4::Ipc_svr::Dbg_dispatch< R, Exc, Printer > | Dispatch helper that, in addition to what Exc_dispatch does, prints exception messages |
| CL4::Ipc_svr::Exc_dispatch< R, Exc > | Dispatch helper wrapping try {} catch {} around the dispatch call |
| CL4::Ipc_svr::Direct_dispatch< R * > | Direct dispatch helper, for forwarding dispatch calls via a pointer to a registry R |
| ►CL4::Ipc_svr::Ignore_errors | Mix in for LOOP_HOOKS to ignore IPC errors |
| CL4::Ipc_svr::Default_loop_hooks | Default LOOP_HOOKS |
| CL4Re::Util::Br_manager_hooks | Predefined server-loop hooks for a server loop using the Br_manager |
| CL4Re::Util::Br_manager_timeout_hooks | Predefined server-loop hooks for a server with using the Br_manager and a timeout queue |
| ►CL4::Ipc_svr::Server_iface | Interface for server-loop related functions |
| CL4::Ipc_svr::Timeout_queue_hooks< Loop_hooks, L4Re::Util::Br_manager > | |
| ►CL4::Ipc_svr::Timeout_queue_hooks< Br_manager_timeout_hooks, Br_manager > | |
| CL4Re::Util::Br_manager_timeout_hooks | Predefined server-loop hooks for a server with using the Br_manager and a timeout queue |
| ►CL4::Ipc_svr::Br_manager_no_buffers | Empty implementation of Server_iface |
| CL4::Ipc_svr::Default_loop_hooks | Default LOOP_HOOKS |
| CL4::Ipc_svr::Timeout_queue_hooks< HOOKS, BR_MAN > | Loop hooks mixin for integrating a timeout queue into the server loop |
| CL4::Ipc_svr::Timeout_queue_hooks< HOOKS, BR_MAN > | Loop hooks mixin for integrating a timeout queue into the server loop |
| ►CL4Re::Util::Br_manager | Buffer-register (BR) manager for L4::Server |
| CL4::Ipc_svr::Timeout_queue_hooks< Loop_hooks, L4Re::Util::Br_manager > | |
| CL4Re::Util::Br_manager_hooks | Predefined server-loop hooks for a server loop using the Br_manager |
| CL4::Ipc_svr::Timeout_queue | Timeout queue to be used in l4re server loop |
| CL4::Kip::Mem_desc | Memory descriptors stored in the kernel interface page |
| ►CL4::Kobject | Base class for all kinds of kernel objects and remote objects, referenced by capabilities |
| CL4::Kobject_t< Arm_smccc, L4::Kobject, PROTO, Type_info::Demand_t<> > | |
| ►CL4::Kobject_t< Debugger, Kobject, L4_PROTO_DEBUGGER > | |
| CL4::Debugger | C++ kernel debugger API |
| CL4::Kobject_t< Exception, L4::Kobject, PROTO, Type_info::Demand_t<> > | |
| ►CL4::Kobject_t< Factory, Kobject, L4_PROTO_FACTORY > | |
| ►CL4::Factory | C++ Factory interface, see Factory for the C interface |
| ►CL4::Kobject_t< Mem_alloc, L4::Factory, L4::PROTO_EMPTY > | |
| CL4Re::Mem_alloc | Memory allocation interface |
| CL4::Kobject_t< Io_pager, L4::Kobject, PROTO, Type_info::Demand_t<> > | |
| CL4::Kobject_t< Irq_eoi, L4::Kobject, PROTO, Type_info::Demand_t<> > | |
| CL4::Kobject_t< Derived, L4::Kobject, L4::PROTO_ANY, Type_info::Demand_t<> > | |
| ►CL4::Kobject_t< Meta, Kobject, L4_PROTO_META > | |
| CL4::Meta | Meta interface that shall be implemented by each L4Re object and gives access to the dynamic type information for L4Re objects |
| ►CL4::Kobject_t< Platform_control, Kobject, L4_PROTO_PLATFORM_CTL > | |
| CL4::Platform_control | L4 C++ interface for controlling platform-wide properties, see Platform Control C API for the C interface |
| ►CL4::Kobject_t< Rcv_endpoint, Kobject, L4_PROTO_KOBJECT, Type_info::Demand_t< 1 > > | |
| ►CL4::Rcv_endpoint | Interface for kernel objects that allow to receive IPC from them |
| ►CL4::Kobject_2t< Irq, Triggerable, Rcv_endpoint, L4_PROTO_IRQ_SENDER > | |
| CL4::Irq | C++ Irq interface, see IRQs for the C interface |
| ►CL4::Kobject_t< Ipc_gate, Rcv_endpoint, L4_PROTO_KOBJECT, Type_info::Demand_t< 1 > > | |
| CL4::Ipc_gate | The C++ IPC gate interface, see IPC-Gate API for the C interface |
| ►CL4::Kobject_t< Task, Kobject, L4_PROTO_TASK, Type_info::Demand_t< 2 > > | |
| ►CL4::Task | C++ interface of the Task kernel object, see Task for the C interface |
| ►CL4::Kobject_t< Vm, Task, L4_PROTO_VM > | |
| CL4::Vm | Virtual machine host address space |
| CL4::Vm | Virtual machine host address space |
| ►CL4::Kobject_t< Thread, Kobject, L4_PROTO_THREAD, Type_info::Demand_t< 1 > > | |
| CL4::Thread | C++ L4 kernel thread interface, see Thread for the C interface |
| CL4::Kobject_t< Vcpu_context, Kobject, L4_PROTO_VCPU_CONTEXT > | |
| ►CL4::Kobject_t< Dataspace, L4::Kobject, L4RE_PROTO_DATASPACE, L4::Type_info::Demand_t< 1 > > | |
| ►CL4Re::Dataspace | Interface for memory-like objects |
| ►CL4::Kobject_3t< Vbus, L4Re::Dataspace, L4Re::Inhibitor, L4Re::Event > | |
| CL4vbus::Vbus | The virtual bus (Vbus) interface |
| ►CL4::Kobject_t< Debug_obj, L4::Kobject, L4RE_PROTO_DEBUG > | |
| CL4Re::Debug_obj | Debug interface |
| CL4::Kobject_t< Dma_space, L4::Kobject, PROTO, L4::Type_info::Demand_t< 1 > > | |
| ►CL4::Kobject_t< Inhibitor, L4::Kobject, L4RE_PROTO_INHIBITOR > | |
| ►CL4Re::Inhibitor | Set of inhibitor locks, which inhibit specific actions when held |
| CL4::Kobject_3t< Vbus, L4Re::Dataspace, L4Re::Inhibitor, L4Re::Event > | |
| ►CL4::Kobject_t< Itas, L4::Kobject, L4RE_PROTO_ITAS, L4::Type_info::Demand_t< 2 > > | |
| CL4Re::Itas | Interface to the ITAS |
| ►CL4::Kobject_t< Mmio_space, L4::Kobject, L4RE_PROTO_MMIO_SPACE > | |
| CL4Re::Mmio_space | Interface for memory-like address space accessible via IPC |
| ►CL4::Kobject_t< Namespace, L4::Kobject, L4RE_PROTO_NAMESPACE, L4::Type_info::Demand_t< 1 > > | |
| CL4Re::Namespace | Name-space interface |
| CL4::Kobject_t< Cmd_control, L4::Kobject, L4::PROTO_ANY, Type_info::Demand_t<> > | |
| ►CL4::Kobject_t< Parent, L4::Kobject, L4RE_PROTO_PARENT > | |
| CL4Re::Parent | Parent interface |
| ►CL4::Kobject_t< Goos, L4::Kobject, L4RE_PROTO_GOOS > | |
| CL4Re::Video::Goos | Class that abstracts framebuffers |
| CL4::Kobject_2t< Derived, Base1, Base2, PROTO, S_DEMAND > | Helper class to create an L4Re interface class that is derived from two base classes (see L4::Kobject_t) |
| CL4::Kobject_3t< Derived, Base1, Base2, Base3, PROTO, S_DEMAND > | Helper class to create an L4Re interface class that is derived from three base classes (see L4::Kobject_t) |
| CL4::Kobject_demand< T > | Get the combined server-side resource requirements for all type T.. |
| CL4::Kobject_t< Derived, Base, PROTO, S_DEMAND > | Helper class to create an L4Re interface class that is derived from a single base class |
| CL4::Kobject_typeid< T > | Meta object for handling access to type information of Kobjects |
| CL4::Kobject_typeid< void > | Minimalistic ID for void interface |
| CL4::Kobject_x< Derived, ARGS > | Generic Kobject inheritance template |
| CL4::Lock_guard | Basic lock guard implementation that prevents forgotten unlocks on exit paths from a method or a block of code |
| CL4::Poll_timeout_counter | Evaluate an expression for a maximum number of times |
| CL4::Poll_timeout_kipclock | A polling timeout based on the L4Re clock |
| CL4::Proto_t< P > | Data type for defining protocol numbers |
| ►CL4::Registry_iface | Abstract interface for object registries |
| CL4Re::Util::Object_registry | A registry that manages server objects and their attached IPC gates for a single server loop for a specific thread |
| CL4::String | A null-terminated string container class |
| CL4::Thread::Attr | Thread attributes used for control() |
| CL4::Thread::Modify_senders | Class wrapping a list of rules which modify the sender label of IPC messages inbound to this thread |
| CL4::Type_info | Dynamic Type Information for L4Re Interfaces |
| ►CL4::Type_info::Demand | Data type for expressing the needed receive buffers at the server-side of an interface |
| ►CL4::Type_info::Demand_t< __I::Max< D1::Caps, D2::Caps >::Res, D1::Flags|D2::Flags, __I::Max< D1::Mem, D2::Mem >::Res, __I::Max< D1::Ports, D2::Ports >::Res > | |
| CL4::Type_info::Demand_union_t< Kobject_typeid< T1 >::Demand, Kobject_demand< T2... > > | |
| CL4::Type_info::Demand_union_t< D1, D2 > | Template type statically describing the combination of two Demand object |
| CL4::Type_info::Demand_t< CAPS, FLAGS, MEM, PORTS > | Template type statically describing demand of receive buffers |
| CL4::Typeid::Detail::_Rpcs< OPCODE, O, Default_op< R > >::Rpc< Y > | Find the given RPC in the list |
| CL4::Typeid::Detail::_Rpcs< OPCODE, O, R, X... > | Non-empty list of RPCs |
| CL4::Typeid::Detail::_Rpcs< OPCODE, O, R, X... >::Rpc< Y > | Find the given RPC in the list |
| ►CL4::Typeid::Detail::Rpcs_end | Internal end-of-list marker |
| ►CL4::Typeid::Detail::_Rpcs< void, 0, OPERATION > | |
| CL4::Typeid::Rpc_nocode< OPERATION > | List of RPCs of an interface using a single operation without an opcode |
| ►CL4::Typeid::Detail::_Rpcs< L4::Opcode, 0, RPCS... > | |
| CL4::Typeid::Rpcs< RPCS > | Standard list of RPCs of an interface |
| ►CL4::Typeid::Detail::_Rpcs< OPCODE_TYPE, 0, RPCS... > | |
| CL4::Typeid::Rpcs_code< OPCODE_TYPE >::F< RPCS > | |
| ►CL4::Typeid::Detail::_Rpcs< l4_umword_t, 0, ARG... > | |
| CL4::Typeid::Rpcs_sys< ARG > | List of RPCs typically used for kernel interfaces |
| CL4::Typeid::Detail::_Rpcs< OPCODE, O, X > | Empty list of RPCs |
| CL4::Typeid::P_dispatch< LIST > | Use for protocol based dispatch stage |
| CL4::Typeid::Raw_ipc< CLASS > | RPCs list for passing raw incoming IPC to the server object |
| CL4::Typeid::Rpcs_code< OPCODE_TYPE > | List of RPCs of an interface using a special opcode type |
| CL4::Types::Bool< V > | Boolean meta type |
| CL4::Types::Flags< BITS_ENUM, UNDERLYING > | Template for defining typical Flags bitmaps |
| CL4::Types::Flags_ops_t< DT > | Mixin class to define a set of friend bitwise operators on DT |
| CL4::Types::Int_for_size< SIZE, bool > | Metafunction to get an unsigned integral type for the given size |
| CL4::Types::Int_for_type< T > | Metafunction to get an integral type of the same size as T |
| ►CL4::Uart | Uart driver abstraction |
| CL4::Uart_apb | Driver for the Advanced Peripheral Bus (APB) UART from the Cortex-M System Design Kit (CMSDK) |
| 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::Info | This class encapsulates information about 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 |
| CL4vcpu::Vcpu | C++ implementation of the vCPU save state area |
| 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 |
| CL4drivers::Register_block< MAX_BITS, BLOCK > | Handles a reference to a register block of the given maximum access width |
| CL4drivers::Register_block_base< MAX_BITS > | Abstract register block interface |
| ►CL4drivers::Register_block_impl< BASE, MAX_BITS > | Implementation helper for register blocks |
| CL4drivers::Mmio_register_block< MAX_BITS > | An MMIO block with up to 64-bit register access (32-bit default) and little endian byte order |
| CL4drivers::Register_block_tmpl< BLOCK > | Helper template that translates to the Register_block_base interface |
| CL4drivers::Ro_register_block< MAX_BITS, BLOCK > | Handles a reference to a read only register block of the given maximum access width |
| ►CL4drivers::Ro_register_tmpl< BITS, BLOCK > | Single read only register inside a Register_block_base interface |
| CL4drivers::Register_tmpl< BITS, BLOCK > | Single hardware register inside a Register_block_base interface |
| ►CL4Re::Cap_alloc | Capability allocator interface |
| CL4Re::Util::_Cap_alloc | Adapter to expose the cap allocator implementation as L4Re::Cap_alloc compatible class |
| CL4Re::Dataspace::F | Dataspace flags definitions |
| CL4Re::Dataspace::Stats | Information about the dataspace |
| CL4Re::Default_event_payload | Default event stream payload |
| CL4Re::Env | C++ interface of the initial environment that is provided to an L4 task |
| CL4Re::Event_buffer_t< PAYLOAD > | Event buffer class |
| CL4Re::Event_buffer_t< PAYLOAD >::Event | Event structure used in buffer |
| CL4Re::Rm::F | Rm flags definitions |
| CL4Re::Rm::Range | A range of virtual addresses |
| CL4Re::Rm::Unique_region< T > | Unique region |
| CL4Re::Smart_cap_auto< Unmap_flags > | Helper for Unique_cap and Unique_del_cap |
| CL4Re::Smart_count_cap< Unmap_flags > | Helper for Ref_cap and Ref_del_cap |
| CL4Re::Util::Cap_alloc_base | Capability allocator |
| CL4Re::Util::Counter< COUNTER > | Counter for Counting_cap_alloc with variable data width |
| CL4Re::Util::Counter_atomic< COUNTER > | Thread safe version of counter for Counting_cap_alloc |
| CL4Re::Util::Counting_cap_alloc< COUNTERTYPE, Dbg > | Internal reference-counting cap allocator |
| CL4Re::Util::Dataspace_svr | Dataspace server class |
| CL4Re::Util::Event_svr< SVR > | Convenience wrapper for implementing an event server |
| CL4Re::Util::Event_t< PAYLOAD > | Convenience wrapper for getting access to an event object |
| CL4Re::Util::Item_alloc_base | Item allocator |
| CL4Re::Util::Names::Name_space | Abstract server-side implementation of the L4::Namespace interface |
| CL4Re::Util::Ref_cap< T > | Automatic capability that implements automatic free and unmap of the capability selector |
| CL4Re::Util::Ref_del_cap< T > | Automatic capability that implements automatic free and unmap+delete of the capability selector |
| CL4Re::Util::Smart_cap_auto< Unmap_flags > | Helper for Unique_cap and Unique_del_cap |
| CL4Re::Util::Smart_count_cap< Unmap_flags > | Helper for Ref_cap and Ref_del_cap |
| CL4Re::Util::Vcon_svr< SVR > | Console server template class |
| CL4Re::Util::Video::Goos_svr | Goos server class |
| ►CL4Re::Vfs::Directory | Interface for a POSIX file that is a directory |
| ►CL4Re::Vfs::File | The basic interface for an open POSIX file |
| CL4Re::Vfs::Be_file | Boiler plate class for implementing an open file for L4Re::Vfs |
| ►CL4Re::Vfs::File_system | Basic interface for an L4Re::Vfs file system |
| CL4Re::Vfs::Be_file_system | Boilerplate class for implementing a L4Re::Vfs::File_system |
| ►CL4Re::Vfs::Fs | POSIX File-system related functionality |
| CL4Re::Vfs::Ops | Interface for the POSIX backends of an application |
| ►CL4Re::Vfs::Generic_file | The common interface for an open POSIX file |
| CL4Re::Vfs::File | The basic interface for an open POSIX file |
| ►CL4Re::Vfs::Mman | Interface for POSIX memory management |
| CL4Re::Vfs::Ops | Interface for the POSIX backends of an application |
| ►CL4Re::Vfs::Regular_file | Interface for a POSIX file that provides regular file semantics |
| CL4Re::Vfs::File | The basic interface for an open POSIX file |
| ►CL4Re::Vfs::Special_file | Interface for a POSIX file that provides special file semantics |
| CL4Re::Vfs::File | The basic interface for an open POSIX file |
| CL4Re::Video::Color_component | A color component |
| CL4Re::Video::Goos::Info | Information structure of a Goos |
| CL4Re::Video::Pixel_info | Pixel information |
| CL4Re::Video::View | View of a framebuffer |
| CL4Re::Video::View::Info | Information structure of a view |
| 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 inital 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::Gpio_module::Pin_slice | A slice of the pins provided by this module |
| CL4vbus::Pm< DEC > | Power-management API mixin |
| Cl4vbus_device_t | Detailed information about a vbus device |
| Cl4vbus_resource_t | Description of a single vbus resource |
| CL4vcpu::State | C++ implementation of state word in the vCPU area |
| CL4virtio::Driver::Block_device::Handle | Handle to an ongoing request |
| ►CL4virtio::Driver::Device | Client-side implementation for a general virtio device |
| CL4virtio::Driver::Block_device | Simple class for accessing a virtio block device synchronously |
| CL4virtio::Driver::Virtio_net_device | Simple class for accessing a virtio net device |
| CL4virtio::Driver::Virtio_net_device::Packet | Structure for a network packet (header including data) with maximum size, assuming that no extra features have been negotiated |
| CL4virtio::Ptr< T > | Pointer used in virtio descriptors |
| CL4virtio::Svr::Bad_descriptor | Exception used by Queue to indicate descriptor errors |
| CL4virtio::Svr::Block_request< Ds_data > | A request to read or write data |
| CL4virtio::Svr::Console::Control_message | Virtio console control message |
| CL4virtio::Svr::Console::Control_request | Specialised Virtqueue::Request providing access to control message payload |
| ►CL4virtio::Svr::Console::Port | Representation of a Virtio console port |
| CL4virtio::Svr::Console::Device_port | A console port with associated read/write state |
| CL4virtio::Svr::Console::Port::Transition | State transition from last report state to current state |
| ►CL4virtio::Svr::Data_buffer | Abstract data buffer |
| CBuffer | Data buffer used to transfer packets |
| CL4virtio::Svr::Dev_config | Abstraction for L4-Virtio device config memory |
| ►CL4virtio::Svr::Dev_features | Type for device feature bitmap |
| CL4virtio::Svr::Console::Features | Virtio console specific feature bits |
| CL4virtio::Svr::Dev_status | Type of the device status register |
| ►CL4virtio::Svr::Device_t< DATA > | Server-side L4-VIRTIO device stub |
| CL4virtio::Svr::Block_dev_base< Mem_region_info > | |
| ►CL4virtio::Svr::Console::Virtio_con | Base class implementing a virtio console functionality |
| CL4virtio::Svr::Console::Device | Base class implementing a virtio console device with L4Re-based notification handling |
| CL4virtio::Svr::Scmi::Scmi_dev | A server implementation of the virtio-scmi protocol |
| CL4virtio::Svr::Virtio_i2c< Request_handler, Epiface > | A server implementation of the virtio-i2c protocol |
| CL4virtio::Svr::Virtio_rng< Rnd_state, Epiface > | A server implementation of the virtio-rng protocol |
| CVirtio_net | The Base class of a Port |
| CL4virtio::Svr::Driver_mem_list_t< DATA > | List of driver memory regions assigned to a single L4-VIRTIO transport instance |
| CL4virtio::Svr::Driver_mem_region_t< DATA > | Region of driver memory, that shall be managed locally |
| ►CL4virtio::Svr::Request_processor | Encapsulate the state for processing a VIRTIO request |
| CL4virtio::Svr::Virtio_i2c< Request_handler, Epiface >::Request_processor | Handler for the Virtio requests |
| CL4virtio::Svr::Virtio_rng< Rnd_state, Epiface >::Request_processor | Handler for the Virtio requests |
| CL4virtio::Svr::Scmi::Base_attr_t | SCMI base protocol attributes |
| CL4virtio::Svr::Scmi::Performance_attr_t | SCMI performance protocol attributes |
| CL4virtio::Svr::Scmi::Performance_describe_level_t | SCMI performance describe level |
| CL4virtio::Svr::Scmi::Performance_describe_levels_n_t | SCMI performance describe levels numbers |
| CL4virtio::Svr::Scmi::Performance_domain_attr_t | SCMI performance domain protocol attributes |
| CL4virtio::Svr::Scmi::Proto< OBSERV > | Base class for all protocols |
| CL4virtio::Svr::Scmi::Scmi_hdr_t | SCMI header |
| CL4virtio::Svr::Virtqueue::Head_desc | VIRTIO request, essentially a descriptor from the available ring |
| ►CL4virtio::Virtqueue | Low-level Virtqueue |
| CL4virtio::Driver::Virtqueue | Driver-side implementation of a Virtqueue |
| CL4virtio::Svr::Virtqueue | Virtqueue implementation for the device |
| CL4virtio::Virtqueue::Avail | Type of available ring, this is read-only for the host |
| CL4virtio::Virtqueue::Avail::Flags | Flags of the available ring |
| CL4virtio::Virtqueue::Desc | Descriptor in the descriptor table |
| CL4virtio::Virtqueue::Desc::Flags | Type for descriptor flags |
| CL4virtio::Virtqueue::Used | Used ring |
| CL4virtio::Virtqueue::Used::Flags | Flags for the used ring |
| CL4virtio::Virtqueue::Used_elem | Type of an element of the used ring |
| 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 |
| CMac_addr | A wrapper class around the value of a MAC address |
| CMac_table< Size > | Mac_table manages a 1:n association between ports and MAC addresses |
| Ccxx::New_allocator< _Node > | |
| Ccxx::New_allocator< Node > | |
| Ccxx::New_allocator< Slab_i > | |
| CBlock_device::Impl::Partitioned_device_discard_mixin< Partitioned_device< Device >, Device > | |
| ►CL4vbus::Pm< Device > | |
| ►CL4vbus::Device | Device on a L4vbus::Vbus |
| CL4vbus::Gpio_module | A Gpio_module groups multiple GPIO pins together |
| CL4vbus::Gpio_pin | A GPIO pin |
| CL4vbus::Icu | Vbus Interrupt controller API |
| CL4vbus::Pci_dev | A PCI device |
| CL4vbus::Pci_host_bridge | A Pci host bridge |
| ►CL4virtio::Svr::Scmi::Proto< Scmi_dev > | |
| CL4virtio::Svr::Scmi::Base_proto | Base class for the SCMI base protocol |
| CL4virtio::Svr::Scmi::Perf_proto | Base class for the SCMI performance protocol |
| CL4virtio::Ptr< void > | |
| Ccxx::Ref_ptr< Device_type > | |
| Ccxx::Ref_ptr< L4Re::Vfs::File > | |
| Ccxx::Ref_ptr< Mount_tree > | |
| CL4drivers::Register_block_base< 16 > | |
| CL4drivers::Register_block_base< 32 > | |
| CL4drivers::Register_block_base< 64 > | |
| CL4drivers::Register_block_base< 8 > | |
| CL4drivers::Register_block_base< MAX_BITS > | |
| CL4drivers::Register_block_impl< Mmio_register_block< 32 >, 32 > | |
| CL4drivers::Register_block_tmpl< Register_block_base< MAX_BITS > > | |
| CL4drivers::Register_block_tmpl< Register_block_base< MAX_BITS > const > | |
| Ccxx::Bits::Smart_ptr_list< Connection > | |
| CL4::Ipc::Msg::Svr_val_ops< Array_ref< A, LEN >, Dir_in, CLASS > | |
| CL4::Ipc::Msg::Svr_val_ops< Array_ref< A, LEN >, Dir_out, CLASS > | |
| CL4::Ipc::Msg::Svr_val_ops< L4::Ipc::Snd_fpage, Dir_in, CLASS > | |
| CL4::Ipc::Msg::Svr_val_ops< typename ELEM::svr_type, typename Direction< A * >::type, typename Class< typename Detail::_Plain< A * >::type >::type > | |
| CL4::Ipc::Msg::Svr_val_ops< typename ELEM::svr_type, typename Direction< A >::type, typename Class< typename Detail::_Plain< A >::type >::type > | |
| CL4::Ipc::Msg::Svr_val_ops< typename ELEM::svr_type, typename Direction< A const * >::type, typename Class< typename Detail::_Plain< A const * >::type >::type > | |
| CL4::Ipc::Msg::Svr_val_ops< typename ELEM::svr_type, typename Direction< Array_ref< A, LEN > & >::type, typename Class< typename Detail::_Plain< Array_ref< A, LEN > & >::type >::type > | |
| CL4::Ipc::Msg::Svr_val_ops< typename ELEM::svr_type, typename Direction< Array_ref< A, LEN > >::type, typename Class< typename Detail::_Plain< Array_ref< A, LEN > >::type >::type > | |
| CL4::Ipc::Msg::Svr_val_ops< typename ELEM::svr_type, typename Direction< T >::type, typename Class< typename Detail::_Plain< T >::type >::type > | |
| CL4Re::Rm::Unique_region< char * > | |
| CL4Re::Rm::Unique_region< l4_addr_t > | |
| CL4Re::Rm::Unique_region< l4_uint8_t * > | |
| CL4Re::Rm::Unique_region< L4virtio::Device::Config_hdr * > | |
| CL4Re::Rm::Unique_region< l4virtio_config_hdr_t * > | |
| CL4Re::Rm::Unique_region< unsigned char * > | |
| CL4Re::Rm::Unique_region< void * > | |
| CVirtio_net_request | Abstraction for a network request |
| CVirtio_net_transfer | A network request to only a single destination |
| CVirtio_switch | The Virtio switch contains all ports and processes network requests |
| CVirtio_vlan_mangle | Class for VLAN packet rewriting |
| Ccxx::Bitmap_base::Word< Bits > | |
| Ccxx::Bitmap_base::Word< COUNT > | |
| Ccxx::Bitmap_base::Word< Size > | |
1.9.8 