Genode OS Framework Foundations

1. Introduction
   1. Operating-system framework
   2. Licensing and commercial support
   3. About this document
2. Getting started
   1. Obtaining the source code
   2. Source-tree structure
   3. Using the build system
   4. A simple system scenario
   5. Hello world
      1. Using a custom source-code repository
      2. Source code and build description
      3. Building the component
      4. Defining a system scenario
      5. Responding to external events
   6. Next steps
3. Architecture
   1. Capability-based security
      1. Capability spaces, object identities, and RPC objects
      2. Delegation of authority and ownership
      3. Capability invocation
      4. Capability delegation through capability invocation
   2. Recursive system structure
      1. Component ownership
      2. Tree of components
      3. Services and sessions
      4. Client-server relationship
   3. Resource trading
      1. Resource assignment
      2. Trading memory between clients and servers
      3. Component-local heap partitioning
      4. Dynamic resource balancing
   4. Core - the root of the component tree
      1. Dataspaces
      2. Region maps
      3. Access to boot modules (ROM)
      4. Protection domains (PD)
      5. Region-map management (RM)
      6. Processing-time allocation (CPU)
      7. Access to device resources (IO_MEM, IO_PORT, IRQ)
      8. Logging (LOG)
      9. Event tracing (TRACE)
   5. Component creation
      1. Obtaining the child's ROM and PD sessions
      2. Constructing the child's address space
      3. Creating the initial thread
   6. Inter-component communication
      1. Synchronous remote procedure calls (RPC)
      2. Asynchronous notifications
      3. Shared memory
      4. Asynchronous state propagation
      5. Synchronous bulk transfer
      6. Asynchronous bulk transfer - packet streams
4. Components
   1. Device drivers
      1. Platform driver
      2. Interrupt handling
      3. Direct memory access (DMA) transactions
   2. Protocol stacks
   3. Resource multiplexers
   4. Runtime environments and applications
   5. Common session interfaces
      1. Read-only memory (ROM)
      2. Report
      3. Terminal and UART
      4. Event
      5. Capture
      6. GUI
      7. Platform
      8. Pin state and control
      9. Block
      10. Timer
      11. NIC
      12. Uplink
      13. Audio recording and playing
      14. File system
   6. Component configuration
      1. Configuration format
      2. Server-side policy selection
      3. Dynamic component reconfiguration at runtime
   7. Component composition
      1. Sandboxing
      2. Component-level and OS-level virtualization
      3. Interposing individual services
      4. Ceding the parenthood
      5. Publishing and subscribing
      6. Feedback control system
5. Development
   1. Source-code repositories
   2. Integration of 3rd-party software
   3. Build system
      1. Build directories
      2. Target descriptions
      3. Library descriptions
      4. Platform specifications
      5. Building tools to be executed on the host platform
      6. Building 3rd-party software
   4. System integration and automated testing
      1. Run tool
      2. Run-tool configuration examples
      3. Meaningful default behaviour
      4. Run scripts
      5. The run mechanism explained
      6. Using run scripts to implement integration tests
      7. Automated testing across base platforms
   5. Package management
      1. Nomenclature
      2. Depot structure
      3. Depot management
      4. Automated extraction of archives from the source tree
      5. Convenience front-end to the extract, build tools
      6. Accessing depot content from run scripts
   6. Static code analysis
   7. Git flow
      1. Master and staging
      2. Development practice
6. System configuration
   1. Nested configuration concept
   2. The init component
      1. Session routing
      2. Resource assignment
      3. Multiple instantiation of a single ELF binary
      4. Session-label rewriting
      5. Nested configuration
      6. Configuring components from distinct ROM modules
      7. Assigning subsystems to CPUs
      8. Priority support
      9. Propagation of exit events
      10. State reporting
      11. Init verbosity
      12. Service forwarding
      13. Component health monitoring
7. Under the hood
   1. Component-local startup code and linker scripts
      1. Linker scripts
      2. Startup code
   2. C++ runtime
      1. Rationale behind using exceptions
      2. Bare-metal C++ runtime
   3. Interaction of core with the underlying kernel
      1. System-image assembly
      2. Bootstrapping and allocator setup
      3. Kernel-object creation
      4. Page-fault handling
   4. Asynchronous notification mechanism
   5. Parent-child interaction in detail
   6. Dynamic linker
      1. Building dynamically-linked programs
      2. Startup of dynamically-linked programs
      3. Address-space management
   7. Execution on bare hardware (base-hw)
      1. Bootstrapping of base-hw
      2. Kernel entry and exit
      3. Interrupt handling and preemptive multi-threading
      4. Split kernel interface
      5. Public part of the kernel interface
      6. Core-private part of the kernel interface
      7. Scheduler of the base-hw kernel
      8. Sparsely populated core address space
      9. Multi-processor support of base-hw
      10. Asynchronous notifications on base-hw
   8. Execution on the NOVA microhypervisor (base-nova)
      1. Integration of NOVA with Genode
      2. Bootstrapping of a NOVA-based system
      3. Log output on modern PC hardware
      4. Relation of NOVA's kernel objects to Genode's core services
      5. Page-fault handling on NOVA
      6. Asynchronous notifications on NOVA
      7. IOMMU support
      8. Genode-specific modifications of the NOVA kernel
      9. Known limitations of NOVA
8. API
   1. API primitives
      1. Capability types
      2. Sessions and connections
      3. Dataspace interface
   2. Component execution environment
      1. Interface to the component's environment
      2. Parent interface
   3. Entrypoint
   4. Region-map interface
   5. Session interfaces of the base API
      1. PD session interface
      2. ROM session interface
      3. RM session interface
      4. CPU session interface
      5. IO_MEM session interface
      6. IO_PORT session interface
      7. IRQ session interface
      8. LOG session interface
   6. OS-level session interfaces
      1. Report session interface
      2. Terminal and UART session interfaces
      3. Event session interface
      4. Capture session interface
      5. GUI session interface
      6. Capture session interface
      7. Platform session interface
      8. Block session interface
      9. Timer session interface
      10. NIC and uplink session interfaces
      11. Record and play session interfaces
      12. File-system session interface
      13. Pin state and control session interfaces
   7. Fundamental types
      1. Integer types
      2. Exception types
      3. Exception-less error handling
      4. C++ supplements
   8. Data structures
      1. List and registry
      2. Fifo queue
      3. AVL tree
      4. Dictionary
      5. ID space
      6. Bit array
   9. Object lifetime management
      1. Thread-safe weak pointers
      2. Late and repeated object construction
   10. Physical memory allocation
   11. Component-local allocators
       1. Slab allocator
       2. AVL-tree-based best-fit allocator
       3. Heap and sliced heap
       4. Bit allocator
   12. String processing
       1. Basic string operations
       2. Tokenizing
       3. Diagnostic output
       4. Obtaining backtraces
       5. Unicode handling
   13. Multi-threading and synchronization
       1. Threads
       2. Inter-thread synchronization
   14. Signalling
   15. Remote procedure calls
       1. RPC mechanism
       2. Transferable argument types
       3. Throwing C++ exceptions across RPC boundaries
       4. RPC interface inheritance
       5. Casting capability types
       6. Non-virtual RPC interface functions
       7. Limitations of the RPC mechanism
       8. Root interface
       9. Server-side policy handling
       10. Packet stream
   16. XML processing
       1. XML parsing
       2. XML generation
       3. XML-based data models
   17. Component management
       1. Shared objects
       2. Child management
       3. Composition of subsystems
   18. Utilities for user-level device drivers
       1. Register declarations
       2. Memory-mapped I/O