### Install Configuration

Source: https://genode.org/documentation/developer-resources/porting_dosbox

Installs a configuration file used by the init program to start scenario components, including DosBox.

```Genode Script
install_config $config
```

--------------------------------

### Genode Configuration for DosBox Scenario

Source: https://genode.org/documentation/developer-resources/porting_dosbox

Provides the XML configuration for the DosBox application within Genode. It defines parent-provided services, default routing, and starts essential drivers (audio, framebuffer, input, timer) and the DosBox application itself with specific resource allocations and internal configurations.

```xml
<config>
  <parent-provides>
    <service name="ROM"/>
    <service name="RAM"/>
    <service name="IRQ"/>
    <service name="IO_MEM"/>
    <service name="IO_PORT"/>
    <service name="CAP"/>
    <service name="PD"/>
    <service name="RM"/>
    <service name="CPU"/>
    <service name="LOG"/>
    <service name="SIGNAL"/>
  </parent-provides>
  <default-route>
    <any-service> <parent/> <any-child/> </any-service>
  </default-route>
  <start name="audio_drv">
    <resource name="RAM" quantum="6M"/>
    <provides><service name="Audio_out"/></provides>
  </start>
  <start name="fb_drv">
    <resource name="RAM" quantum="4M"/>
    <provides><service name="Framebuffer"/></provides>
  </start>
  <start name="ps2_drv">
    <resource name="RAM" quantum="1M"/>
    <provides><service name="Input"/></provides>
  </start>
  <start name="timer">
    <resource name="RAM" quantum="1M"/>
    <provides><service name="Timer"/></provides>
  </start>
  <start name="dosbox">
    <resource name="RAM" quantum="128M"/>
    <config>
      <sdl_audio_volume value="100"/>
      <libc stdout="/dev/log" stderr="/dev/log">
        <vfs>
          <tar name="dosbox.tar"/>
          <dir name="dev"> <log/> </dir>
        </vfs>
      </libc>
    </config>
  </start>
</config>
```

--------------------------------

### Initialize Software Depot

Source: https://genode.org/documentation/articles/sculpt-ea

Initialize the depot for hosting installed software by copying the example configuration, which includes public keys and download URLs, using the `cp -r` command.

```shell
noux:/> cp -r /config/examples/depot /rw/
```

--------------------------------

### Building the init component

Source: https://genode.org/documentation/articles/sel4_part_3

Example output from attempting to build the 'init' binary, indicating a missing library description file required for the build process.

```shell
sel4_x86_32> make init
checking library dependencies...
Library-description file base.mk is missing
```

--------------------------------

### Define and Build Boot Image

Source: https://genode.org/documentation/developer-resources/porting_dosbox

Declares the necessary boot modules, including binaries and configuration files like dosbox.conf, and then builds the boot image for the scenario.

```Genode Script
set boot_modules {
    core init timer audio_drv fb_drv ps2_drv ld.lib.so
    libc.lib.so libm.lib.so
    lwip.lib.so libpng.lib.so stdcxx.lib.so sdl.lib.so
    pthread.lib.so zlib.lib.so dosbox dosbox.tar
}

build_boot_image $boot_modules
```

--------------------------------

### Genode SSH Helper Component Example

Source: https://genode.org/documentation/release-notes/19

Illustrative example of a helper component's script for setting up an environment to run commands via SSH. It typically starts a sub-init process to execute the command.

```Shell
# Example script for ssh_exec_channel.run
# Starts noux in a sub init and executes the provided command inside of it.
```

--------------------------------

### Configure QEMU and Run Genode

Source: https://genode.org/documentation/developer-resources/porting_dosbox

Appends specific arguments for QEMU execution and instructs the Genode run script to keep the scenario executing until manually stopped.

```Genode Script
append qemu_args " -m 256 -soundhw ac97 "
run_genode_until forever
```

--------------------------------

### Genode System Configuration and Execution Script

Source: https://genode.org/documentation/genode-foundations/19.05/getting_started/Hello_world

Configures and builds a Genode system, including a timer driver and a 'hello' component. It specifies resource allocation, service dependencies, and execution arguments for QEMU. This script integrates the timer service required by the example component.

```shell
build "core init drivers/timer app/hello"
create_boot_directory
install_config {
 <config>
   <parent-provides>
     <service name="LOG"/>
     <service name="PD"/>
     <service name="CPU"/>
     <service name="ROM"/>
   </parent-provides>
   <default-route>
     <any-service> <parent/> <any-child/> </any-service>
   </default-route>
   <default caps="100"/>
   <start name="timer">
     <resource name="RAM" quantum="1M"/>
     <provides> <service name="Timer"/> </provides>
   </start>
   <start name="hello">
     <resource name="RAM" quantum="10M"/>
   </start>
 </config>
}
build_boot_image "core ld.lib.so init timer hello"
append qemu_args "-nographic -m 64"
run_genode_until forever

```

--------------------------------

### Sculpt OS Initial Setup Steps

Source: https://genode.org/documentation/articles/sculpt-22-04

A guide to performing initial setup tasks in Sculpt OS, including selecting a storage location, enabling networking, and installing new components.

```APIDOC
Sculpt OS Initial Setup:

1.  **Select Default Storage Location**:
    - Action: Click the 'ram fs' component in the graph and press the 'Use' button.
    - Purpose: Installs software solely into memory, avoiding interaction with physical storage devices.

2.  **Enable Networking**:
    - Action: Navigate to the 'Network' dialog.
    - Options: Select 'Wired' or 'Wifi'. For Wifi, choose an access point and enter the passphrase if required.
    - Verification: A successful connection is indicated by an IP address displayed at the bottom of the network dialog.

3.  **Install and Start Components**:
    - Action: Click the '+' button in the components view.
    - Menu Option: Select 'Depot ...' from the menu.
    - Purpose: Access the software depot to download and install packages from various providers.
    - Provider Selection: The choice of software providers can be configured in the 'Selection ...' sub-menu.
```

--------------------------------

### Genode Hello World Run Script Configuration

Source: https://genode.org/documentation/genode-foundations/19.05/getting_started/Hello_world

Defines a basic Genode system scenario for a 'Hello world' application. It specifies build targets, component configuration, boot image assembly, and QEMU arguments.

```genode-run
build "core init app/hello"
create_boot_directory
install_config {
 <config>
   <parent-provides>
     <service name="LOG"/>
     <service name="PD"/>
     <service name="CPU"/>
     <service name="ROM"/>
   </parent-provides>
   <default-route>
     <any-service> <parent/> </any-service>
   </default-route>
   <default caps="100"/>
   <start name="hello">
     <resource name="RAM" quantum="10M"/>
   </start>
 </config>
}
build_boot_image "core ld.lib.so init hello"
append qemu_args "-nographic -m 64"
run_genode_until {Hello world.*\n} 10
```

--------------------------------

### Genode Hello Client Run Script

Source: https://genode.org/documentation/developer-resources/client_server_tutorial

A script to automate the build, configuration, and execution of the hello client-server scenario. It defines build steps, installation, and execution parameters for QEMU, including system configuration and run conditions.

```shell
build { core lib/ld init hello }

create_boot_directory

install_config {
<config>
  <parent-provides>
    <service name="LOG"/>
    <service name="PD"/>
    <service name="CPU"/>
    <service name="ROM"/>
  </parent-provides>
  <default-route>
    <any-service> <parent/> <any-child/> </any-service>
  </default-route>
  <default caps="60"/>
  <start name="hello_server">
    <resource name="RAM" quantum="1M"/>
    <provides> <service name="Hello"/> </provides>
  </start>
  <start name="hello_client">
    <resource name="RAM" quantum="1M"/>
  </start>
</config>}

build_boot_image [build_artifacts]

append qemu_args " -nographic "

run_genode_until "hello test completed.*\n" 10

```

--------------------------------

### Sculpt OS Initial Setup and Component Installation

Source: https://genode.org/documentation/articles/sculpt-vc

Step-by-step guide to configure Sculpt OS after booting, including setting default storage, enabling network connectivity, and installing the first components.

```APIDOC
Sculpt OS Initial Setup:

1.  **Select Default Storage**:
    - Action: Click 'ram' in the 'Storage' dialog and enable the 'Use' button.
    - Purpose: Configures the in-memory file system as the default storage location, meaning installed software is stored in RAM.

2.  **Enable Networking**:
    - Action: Navigate to the 'Network' dialog and select 'Wired' or 'Wifi'. For Wifi, choose an access point and enter the passphrase.
    - Indication: A successful connection is shown by an IP address displayed in the dialog.

3.  **Install and Start Components**:
    - Action: Click the '+' button in the runtime view and select a component from the context menu (e.g., 'backdrop').
    - Process: On first run, selected subsystem ingredients are downloaded to the 'used' storage location and then started.
    - Observation: A slight visual change indicates successful installation.

4.  **Toggle View**:
    - Action: Press F12.
    - Purpose: Switches between the 'Leitzentrale' (system management UI) and the actual runtime view.

5.  **Add More Components**:
    - Action: Select items from the '+' context menu in the runtime view. Most components require a window manager.
    - Recommendation: First select 'wm' (window manager).
    - Monitoring: Pay attention to diagnostic messages in the runtime dialog for dependency information.

6.  **Inspect Components**:
    - Action: Click on any component in the runtime view.
    - Information: Displays details like memory usage. A 'remove' button is available for manually started components.
```

--------------------------------

### Integrate Muen Kernel with Genode

Source: https://genode.org/documentation/platforms/muen

This snippet shows how to download the Muen kernel and integrate it with your Genode installation. It requires the Genode tool-chain to be set up.

```shell
cd <genode_dir>
./tool/ports/prepare_port muen
```

--------------------------------

### Genode run script for hello component

Source: https://genode.org/documentation/genode-foundations/23.05/getting_started/Hello_world

Defines a system scenario for the 'hello' component. It specifies build targets, configuration for the init component (including service dependencies and resource allocation), boot image assembly, QEMU arguments, and execution monitoring with a timeout.

```genode-script
build "core init app/hello"
create_boot_directory
install_config {
 <config>
   <parent-provides>
     <service name="LOG"/>
     <service name="PD"/>
     <service name="CPU"/>
     <service name="ROM"/>
   </parent-provides>
   <default-route>
     <any-service> <parent/> </any-service>
   </default-route>
   <default caps="100"/>
   <start name="hello">
     <resource name="RAM" quantum="10M"/>
   </start>
 </config>
}
build_boot_image "core ld.lib.so init hello"
append qemu_args "-nographic -m 64"
run_genode_until {Hello world.нула\n} 10
```

--------------------------------

### Genode Run Script Examples

Source: https://genode.org/documentation/release-notes/11

A collection of Genode run scripts demonstrating various use cases, from basic demos to complex application integration and debugging setups. These scripts guide users through building, configuring, and integrating specific features.

```shell
os/run/demo.run
  Builds and executes Genode's default demo scenario.
```

```shell
libports/run/lwip.run
  Runs the lwip_httpsrv example on Qemu, downloads a website, and validates the response.
  Requires: libc, libports repositories enabled, lwip prepared (make prepare PKG=lwip), and a network driver (nic_drv).
```

```shell
ports/run/gdb_monitor.run
  Runs a test program as a child of the GDB monitor in Qemu, then attaches a GDB session.
  Requires: lwip.run dependencies plus the gdb package from the ports repository.
```

```shell
qt4/run/qt4.run
  Runs the qt_launchpad application to start the Qt4 textedit program.
  Requires: prepared qt4 repository, zlib, libpng, and freetype from libports.
```

```shell
ports/run/noux.run
  Compiles GNU coreutils, wraps them in a tar archive, and runs the Noux environment executing 'ls -Rla'.
  Requires: libc, ports repositories, and coreutils package prepared in ports.
```

```shell
ports-okl4/run/lx_block.run
  Starts the OKLinux kernel on top of OKL4.
  Requires: Custom disk image (tinycore.img) and initrd (initrd.gz) in <build-dir>/bin/.
```

```shell
ports-foc/run/l4linux.run
  Starts the L4Linux kernel on top of Fiasco.OC.
```

--------------------------------

### Genode Core Build and Run Script

Source: https://genode.org/documentation/articles/sel4_part_3

This script demonstrates the process of building the Genode core component, creating a boot directory, building the boot image, configuring QEMU arguments, and running the Genode system until completion. It's a practical example for executing the core functionality.

```bash
build { core }
create_boot_directory
build_boot_image "core"
append qemu_args " -nographic -m 64 "
run_genode_until forever
```

--------------------------------

### Automated Deployment Configuration (AMT/iPXE)

Source: https://genode.org/documentation/platforms/muen

Example configuration for automated deployment and execution of a Muen/Genode system on real hardware. It uses Intel AMT for system resets and iPXE for loading the kernel image.

```bash
RUN_OPT += --include power_on/amt
RUN_OPT += --power-on-amt-host 192.168.254.2
RUN_OPT += --power-on-amt-password 'foo!'
RUN_OPT += --include load/ipxe
RUN_OPT += --load-ipxe-base-dir /srv/www
RUN_OPT += --load-ipxe-boot-dir boot
RUN_OPT += --include log/amt
RUN_OPT += --log-amt-host 192.168.254.2
RUN_OPT += --log-amt-password 'foo!'
```

--------------------------------

### Genode Porting Guide Sections

Source: https://genode.org/documentation/developer-resources/porting

Details the different sections covered in the Genode Porting Guide, outlining specific porting tasks and examples.

```APIDOC
Porting third-party code to Genode:
  Description: Overview of general steps for using 3rd-party code on Genode.

Porting a program to natively run on Genode:
  Example: DosBox
  Description: Step-by-step guide applying general steps to port an application.

Native Genode port of a library:
  Example: SDL_net (dependency for DosBox)
  Description: Demonstrates porting a library with application dependencies.

Porting an application to Genode's Noux runtime:
  Example: tar program
  Description: Shows how to port and execute command-line Unix software within the Noux runtime.

Porting devices drivers:
  Description: Explains the concepts and requirements for porting device drivers to the Genode framework.
```

--------------------------------

### Genode Build Configuration Example

Source: https://genode.org/documentation/articles/sculpt-24-04

Illustrative configuration settings for Genode's build.conf, focusing on enabling repositories and QEMU run options.

```text
# Enable the gems source-code repository
# ...

# Change default QEMU_RUN_OPT to image/disk
# QEMU_RUN_OPT = image/disk

# Enable parallel build
# ... (uncomment corresponding line)
```

--------------------------------

### Build Configuration Example

Source: https://genode.org/documentation/articles/sculpt-20-02

Example configuration snippet for build.conf to change the default QEMU_RUN_OPT and enable specific repositories. Also shows how to set a custom depot user.

```configuration
QEMU_RUN_OPT += --run-opt image/disk
RUN_OPT += --depot-user <YOU>
```

--------------------------------

### Sculpt OS Initial Setup Steps

Source: https://genode.org/documentation/articles/sculpt-23-10

A guide to performing initial setup tasks in Sculpt OS, including selecting storage, enabling networking, and loading system presets.

```APIDOC
Sculpt OS Initial Setup:

1. Select Default Storage Location:
   - Action: Click the 'ram fs' component in the graph and press the 'Use' button.
   - Purpose: Installs software solely into memory, without accessing real storage devices.

2. Enable Networking:
   - Action: Navigate to the 'Network' dialog. Select 'Wired' or 'Wifi'. For Wifi, choose an access point and enter the passphrase if required.
   - Indicator: A successful connection is shown by the IP address displayed at the bottom of the network dialog.

3. Try a Preset Scenario:
   - Action: Access the system menu (upper-left screen corner) and select a preset, e.g., 'nano3d'.
   - Purpose: Downloads and configures all necessary components for the selected scenario.
```

--------------------------------

### Genode/seL4 Boot Output Example

Source: https://genode.org/documentation/articles/sel4_part_3

This output demonstrates a successful Genode scenario on seL4, showing the boot process of core components (init, test-printf, config), initialization messages, and the final successful execution of a test scenario involving inter-component communication via RPC.

```console
boot module 'init' (371556 bytes)
boot module 'test-printf' (249776 bytes)
boot module 'config' (272 bytes)
Genode 15.02-360-gb3cb2ca <local changes>
int main(): --- create local services ---
int main(): --- start init ---
int main(): transferred 43 MB to init
int main(): --- init created, waiting for exit condition ---
[init] Could not open ROM session for module "ld.lib.so"
[init -> test-printf] -1 = -1 = -1Test succeeded
```

--------------------------------

### Install Clang and Setup Scan-Build

Source: https://genode.org/documentation/genode-foundations/25.05/development/Static_code_analysis

Steps to install the required Clang tools (version 6.0) on Ubuntu 16.04 and create a symbolic link for the `scan-build` command.

```shell
sudo apt install clang-tools-6.0
cd $HOME/bin
ln -s $(which scan-build-6.0) scan-build
```

--------------------------------

### Configure Genode Init Component to Start Hello Server

Source: https://genode.org/documentation/developer-resources/client_server_tutorial

Defines the necessary configuration for the Genode init component to start the hello_server program. It specifies required services and the start command.

```xml
<config>
   <parent-provides>
     <service name="LOG"/>
     <service name="PD"/>
     <service name="CPU"/>
     <service name="ROM"/>
   </parent-provides>
   <default-route>
     <any-service> <parent/> <any-child/> </any-service>
   </default-route>
   <default caps="60"/>
   <start name="hello_s
```

--------------------------------

### Install Clang and Setup Scan-Build

Source: https://genode.org/documentation/genode-foundations/24.05/development/Static_code_analysis

Steps to install the required Clang tools (version 6.0) on Ubuntu 16.04 and create a symbolic link for the `scan-build` command.

```shell
sudo apt install clang-tools-6.0
cd $HOME/bin
ln -s $(which scan-build-6.0) scan-build
```

--------------------------------

### Genode Run Script Configuration

Source: https://genode.org/documentation/genode-foundations/24.05/getting_started/Hello_world

This shell script snippet outlines the configuration for building and running a Genode system scenario. It specifies the components to build, installs configuration files, defines default routing, and configures the 'timer' and 'hello' components with their resource requirements. It also sets up QEMU arguments for execution.

```shell
build { core init lib/ld timer app/hello }
create_boot_directory
install_config {
 <config>
   <parent-provides>
     <service name="LOG"/>
     <service name="PD"/>
     <service name="CPU"/>
     <service name="ROM"/>
   </parent-provides>
   <default-route>
     <any-service> <parent/> <any-child/> </any-service>
   </default-route>
   <default caps="100"/>
   <start name="timer">
     <resource name="RAM" quantum="1M"/>
     <provides> <service name="Timer"/> </provides>
   </start>
   <start name="hello">
     <resource name="RAM" quantum="10M"/>
   </start>
 </config>
}
build_boot_image [build_artifacts]
append qemu_args "-nographic -m 64"
run_genode_until forever

```

--------------------------------

### Install Clang and Setup Scan-Build

Source: https://genode.org/documentation/genode-foundations/23.05/development/Static_code_analysis

Steps to install the required Clang tools (version 6.0) on Ubuntu 16.04 and create a symbolic link for the `scan-build` command.

```shell
sudo apt install clang-tools-6.0
cd $HOME/bin
ln -s $(which scan-build-6.0) scan-build
```

--------------------------------

### Genode Configuration Example Scenario

Source: https://genode.org/documentation/release-notes/15

Describes a visual example of the configuration flow, showing how the backdrop component receives its background composition description, how the init component routes the request to the FS-ROM server, and how saving a file in an editor triggers updates.

```APIDOC
Scenario: Interactive Desktop Background Update
  1. Backdrop Component: Obtains background composition description via its "config" ROM module.
  2. Init Component: Routes the ROM session request from the backdrop.
  3. FS-ROM Server: Provides the ROM service by reading ROM modules from a file system.
  4. File System Access: Other clients (e.g., noux instance with Vim) can access the same file system.
  5. Editor Interaction: User edits files (e.g., background configuration) using an editor like Vim.
  6. File Save Notification: When the file is saved, the editor notifies the FS-ROM server.
  7. Configuration Update: FS-ROM server notifies the backdrop component of the new configuration.
  8. Dynamic Update: Backdrop component updates its display based on the edited configuration.
```

--------------------------------

### Install Clang and Setup Scan-Build

Source: https://genode.org/documentation/genode-foundations/19.05/development/Static_code_analysis

Steps to install the required Clang tools (version 6.0) on Ubuntu 16.04 and create a symbolic link for the `scan-build` command.

```shell
sudo apt install clang-tools-6.0
cd $HOME/bin
ln -s $(which scan-build-6.0) scan-build
```

--------------------------------

### Libc VFS Configuration Example

Source: https://genode.org/documentation/release-notes/14

Example configuration for libc, demonstrating how to set up a program-local virtual file system, including pseudo devices and inline file content.

```xml
<config>
    ...
    <libc stdin="/dev/null" stdout="/dev/log" stderr="/dev/log">
      <vfs>
        <dir name="dev">
          <log/>
          <null/>
        </dir>
        <dir name="etc">
          <dir name="lighttpd">
            <inline name="lighttpd.conf">
              ...
            </inline>
          </dir>
        </dir>
        <dir name="website">
          <tar name="website.tar"/>
        </dir>
      </vfs>
    </libc>
  </config>
```

--------------------------------

### Example Sculpt OS Subsystems

Source: https://genode.org/documentation/articles/sculpt-vc

Descriptions of sample subsystems available for installation in Sculpt OS, detailing their functionality and purpose within the system.

```APIDOC
Example Subsystems:

- **fonts_fs**:
  - Type: File-system server.
  - Functionality: Transforms TrueType fonts into glyph images, making them accessible as virtual files. Allows customization of font size and removes dependency on specific font-rendering libraries.
  - Configuration: Taken from */config/managed/fonts*.
  - Usage: Used by the graphical terminal of the noux subsystem and the top_view application.

- **wm**:
  - Type: Window manager.
  - Functionality: Displays client applications within windows that can be manipulated using the mouse.

- **backdrop**:
  - Type: Wallpaper.
  - Functionality: Displays a background image that automatically adjusts to fit any screen size.

- **nano3d**:
  - Type: Software-rendering demo.
  - Functionality: A basic 3D rendering demonstration that can be configured at runtime via its textual interface.
```

--------------------------------

### Genode Hello Client Application

Source: https://genode.org/documentation/developer-resources/client_server_tutorial

The main entry point for the client component. It instantiates the Hello::Connection object, invokes say_hello and add RPCs, and logs the results, demonstrating the client's interaction with the service.

```C++
#include <base/component.h>
#include <base/log.h>
#include <hello_session/connection.h>

Genode::size_t Component::stack_size() { return 64*1024; }

void Component::construct(Genode::Env &env) {
  Hello::Connection hello(env);

  hello.say_hello();

  int const sum = hello.add(2, 5);
  Genode::log("added 2 + 5 = ", sum);

  Genode::log("hello test completed");
}

```

--------------------------------

### Genode System Scenario Run Script

Source: https://genode.org/documentation/genode-foundations/25.05/getting_started/Hello_world

This is a sample run script for Genode, defining a system scenario. It specifies components to build, configuration for the init process, boot image creation, QEMU arguments, and execution monitoring criteria.

```genode-run-script
build { core init lib/ld app/hello }
create_boot_directory
install_config {
 <config>
   <parent-provides>
     <service name="LOG"/>
     <service name="PD"/>
     <service name="CPU"/>
     <service name="ROM"/>
   </parent-provides>
   <default-route>
     <any-service> <parent/> </any-service>
   </default-route>
   <default caps="100"/>
   <start name="hello" ram="10M"/>
 </config>
}
build_boot_image [build_artifacts]
append qemu_args "-nographic -m 64"
run_genode_until {Hello world.*\n} 10
```

--------------------------------

### Noux System Call Trace Example

Source: https://genode.org/documentation/developer-resources/porting_noux_packages

Example output of system calls traced from the Noux runtime when an application like 'tar' fails. This trace helps identify unimplemented functions, such as 'fstatat' in this case, which prevents the tar operation.

```genode-trace
[init -> noux] PID 0 -> SYSCALL FORK
[init -> noux] PID 0 -> SYSCALL WAIT4
[init -> noux] PID 5 -> SYSCALL STAT
[init -> noux] PID 5 -> SYSCALL EXECVE
[init -> noux] PID 5 -> SYSCALL STAT
[init -> noux] PID 5 -> SYSCALL GETTIMEOFDAY
[init -> noux] PID 5 -> SYSCALL STAT
[init -> noux] PID 5 -> SYSCALL OPEN
[init -> noux] PID 5 -> SYSCALL FTRUNCATE
[init -> noux] PID 5 -> SYSCALL FSTAT
[init -> noux] PID 5 -> SYSCALL GETTIMEOFDAY
[init -> noux] PID 5 -> SYSCALL FCNTL
[init -> noux] PID 5 -> SYSCALL WRITE
[init -> noux -> /bin/tar] DUMMY fstatat(): fstatat called, not implemented
[init -> noux] PID 5 -> SYSCALL FCNTL
[init -> noux] PID 5 -> SYSCALL FCNTL
[init -> noux] PID 5 -> SYSCALL WRITE
[init -> noux] PID 5 -> SYSCALL FC
```

--------------------------------

### Publish Tool Output Example

Source: https://genode.org/documentation/genode-foundations/19.05/development/Package_management

Example output from the `tool/depot/publish` tool, listing the paths of the compressed and signed archives that are placed in the public directory.

```shell
publish /.../public/<you>/api/base/2018-02-26.tar.xz
publish /.../public/<you>/api/framebuffer_session/2017-05-31.tar.xz
publish /.../public/<you>/api/gems/2018-01-28.tar.xz
publish /.../public/<you>/api/input_session/2018-01-05.tar.xz
publish /.../public/<you>/api/nitpicker_gfx/2018-01-05.tar.xz
publish /.../public/<you>/api/nitpicker_session/2018-01-05.tar.xz
publish /.../public/<you>/api/os/2018-02-13.tar.xz
publish /.../public/<you>/api/report_session/2018-01-05.tar.xz
publish /.../public/<you>/api/scout_gfx/2018-01-05.tar.xz
publish /.../public/<you>/bin/x86_64/decorator/2018-02-26.tar.xz
publish /.../public/<you>/bin/x86_64/floating_window_layouter/2018-02-26.tar.xz
publish /.../public/<you>/bin/x86_64/report_rom/2018-02-26.tar.xz
publish /.../public/<you>/bin/x86_64/wm/2018-02-26.tar.xz
publish /.../public/<you>/pkg/wm/2018-02-26.tar.xz
publish /.../public/<you>/raw/wm/2018-02-14.tar.xz
publish /.../public/<you>/src/decorator/2018-02-26.tar.xz
publish /.../public/<you>/src/floating_window_layouter/2018-02-26.tar.xz
publish /.../public/<you>/src/report_rom/2018-02-26.tar.xz
publish /.../public/<you>/src/wm/2018-02-26.tar.xz
```

--------------------------------

### Ada/Spark Runtime Integration Example

Source: https://genode.org/documentation/release-notes/9

Demonstrates executing freestanding Ada code on Genode. The example relies on the standard Genode startup procedure, starting execution from crt0 assembly. It showcases seamless integration of Ada and C code, including calling C functions from Ada.

```ada
-- Example Ada main procedure
procedure Ada_Main is
begin
  -- Ada code execution
  Put_Line ("Hello from Ada on Genode!");
end Ada_Main;

-- C function call from Ada (example)
-- external C_Function : C_Function_Signature;
-- begin
--   C_Function (some_value);

```

```shell
# To build the Ada test program, ensure GNU GNAT Ada compiler is installed.
# Add 'gnat' to the SPECS declaration in your <builddir>/etc/specs.conf:
# SPECS = [ ..., "gnat", ... ]
# This enables the Genode build system to compile Ada code.
```

--------------------------------

### Install and Configure System Shell with Font Server

Source: https://genode.org/documentation/articles/sculpt-20-08

Guide for setting up a Unix-like subsystem ('system shell') within a terminal window, requiring a font server for terminal fonts. It covers installing the font server and the system shell, and configuring file system mounts and permissions for the shell.

```APIDOC
Font Server Setup:

1. Install package: "genodelabs -> GUI -> fonts fs".
2. Assign "system font configuration" to its "ROM (config)" for read-only access to default font settings.

System Shell Installation:

1. Install package: "genodelabs -> Tools -> system shell".

System Shell Configuration:

- **GUI**: Select "themed wm" to host the terminal.
- **File system (config)**: Mounts at */config/*. Options include:
  - "writeable system configuration": Grants full control over the system (use with caution).
  - Recommended for trusted packages: "writeable system configuration".
- **File system (report)**: Mounts at */report/*. Assign "read-only system reports" to view system states.
- **File system (target)**: Mounts at */rw/*. Can be any file system.
```

--------------------------------

### Genode System Scenario Run Script

Source: https://genode.org/documentation/genode-foundations/24.05/getting_started/Hello_world

This is a sample Genode run script that defines a system scenario. It specifies components to build, configuration for the init process, boot image assembly, QEMU arguments, and execution monitoring.

```genode-runscript
build { core init lib/ld app/hello }
create_boot_directory
install_config {
 <config>
   <parent-provides>
     <service name="LOG"/>
     <service name="PD"/>
     <service name="CPU"/>
     <service name="ROM"/>
   </parent-provides>
   <default-route>
     <any-service> <parent/> </any-service>
   </default-route>
   <default caps="100"/>
   <start name="hello">
     <resource name="RAM" quantum="10M"/>
   </start>
 </config>
}
build_boot_image [build_artifacts]
append qemu_args "-nographic -m 64"
run_genode_until {Hello world.*\n} 10
```

--------------------------------

### Genode Rpc_entrypoint API Documentation

Source: https://genode.org/documentation/api/code/repos/base/include/base/rpc_server.h

Provides API documentation for the `Rpc_entrypoint` class, covering its constructor, destructor, methods for managing RPC objects, activating the entry point, and handling replies. Includes details on parameters, return values, and usage notes.

```APIDOC
Rpc_entrypoint(Pd_session *pd_session, size_t stack_size, char const *name, bool start_on_construction = true, Affinity::Location location = Affinity::Location());
  - Constructor for the Rpc_entrypoint.
  - Parameters:
    - pd_session: `Cap_session` for creating capabilities for the RPC objects managed by this entry point.
    - stack_size: Stack size of the entrypoint thread.
    - name: Name of the entrypoint thread.
    - start_on_construction: If true, the entrypoint thread starts immediately upon construction.
    - location: CPU affinity for the entrypoint thread.

~Rpc_entrypoint();
  - Destructor for the Rpc_entrypoint.

manage(Rpc_object<RPC_INTERFACE, RPC_SERVER> *obj);
  - Associates an RPC object with the entry point.
  - Template Parameters:
    - RPC_INTERFACE: The interface type of the RPC object.
    - RPC_SERVER: The server type of the RPC object.
  - Parameters:
    - obj: Pointer to the RPC object to manage.
  - Returns: A capability for the managed RPC object.

dissolve(Rpc_object<RPC_INTERFACE, RPC_SERVER> *obj);
  - Dissolves an RPC object from the entry point.
  - Template Parameters:
    - RPC_INTERFACE: The interface type of the RPC object.
    - RPC_SERVER: The server type of the RPC object.
  - Parameters:
    - obj: Pointer to the RPC object to dissolve.

activate();
  - Activates the entrypoint, starting the processing of RPC requests.

reply_dst();
  - Requests the reply capability for the current call.
  - Note: This is a temporary API method and is subject to removal. It is typically used as an argument for `intermediate_reply`.
  - Returns: An `Untyped_capability` representing the destination for replies.

prevent_reply();
  - Prevents the reply of the current request.
  - Note: This is a temporary API method and is subject to removal. It can be used to keep the calling client blocked.
```

--------------------------------

### DDE Kit kmalloc Implementation Example

Source: https://genode.org/documentation/developer-resources/porting_device_drivers

An example of implementing the `kmalloc` function using the Genode DDE kit's simple memory allocation primitive. This showcases how to leverage DDE kit for essential memory management functions in drivers.

```c
void *kmalloc(size_t size, gfp_t flags) {
  return dde_kit_simple_malloc(size);
}
```

--------------------------------

### Configure Genode Server Entrypoint and Stack

Source: https://genode.org/documentation/developer-resources/client_server_tutorial

Sets the stack size for the Genode component and defines the entry point for the server application. It constructs the Hello::Main instance to start the service.

```C++
Genode::size_t Component::stack_size() {
  return 64*1024;
}

void Component::construct(Genode::Env &env) {
  static Hello::Main main(env);
}
```

--------------------------------

### Get Sculpt Installation Version

Source: https://genode.org/documentation/articles/sculpt-vc

Retrieves the current version and content hash of the sculpt-installation package. The first part of the output is the version, and the second is the content hash.

```shell
cat <genode-dir>/repos/gems/recipes/pkg/sculpt-installation/hash
```

--------------------------------

### Configure Software Deployment

Source: https://genode.org/documentation/articles/sculpt-tc

The \"/config/deploy\" file manages software installation and subsystem routing. Uncomment \"<start>\" entries to install packages and their dependencies. Pay attention to \"<route>\" definitions to control subsystem connections.

```APIDOC
File: /config/deploy

Purpose: Defines system composition, software installation, and inter-subsystem routing.

Key Elements:
  - <start> entries: Uncomment to trigger the download and installation of specified subsystems and their dependencies.
    Example: Uncommenting <start> for \"fonts_fs\", \"wm\", and \"backdrop\".
  - <route> definitions: Specify how subsystems connect to each other.
    - <parent/>: Connects to the base system (parent).
    - <child name=\"subsystem_name\"/>: Connects to a specified child subsystem.
      Example: Changing route from <parent/> to <child name=\"wm\"/> to connect backdrop to the window manager.

Dependencies: Sculpt manager, network connection for downloads.

Usage:
  Edit the \"/config/deploy\" file, uncomment desired subsystem \"<start>\" tags, and save. The Sculpt manager handles the rest.

Limitations:
  Requires understanding of subsystem dependencies and routing configurations.
```

--------------------------------

### Run-tool Configuration Example: Executing NOVA in Qemu

Source: https://genode.org/documentation/genode-foundations/24.05/development/System_integration_and_automated_testing

This example demonstrates the configuration of the Genode 'run' tool to execute a system scenario. It specifies modules for setting up the boot directory with the NOVA kernel, using QEMU for emulation (power-on and logging), and creating a bootable ISO image.

```buildconf
RUN_OPT = --include boot_dir/nova \
          --include power_on/qemu --include log/qemu --include image/iso
```

--------------------------------

### Build and Emulate Muen SK System with Genode Base-HW

Source: https://genode.org/documentation/platforms/muen

Builds a Muen SK system using a specific Genode base-HW configuration and starts it in the Bochs emulator. This step is part of the integration process and may initially fail if Genode components are not yet built.

```makefile
make SYSTEM=xml/genode-base_hw_simple.xml COMPONENTS="libdebuglog libmudm libmutime libxhcidbg dbgserver sm time" emulate
```

--------------------------------

### Run-tool Configuration Example: Executing NOVA in Qemu

Source: https://genode.org/documentation/genode-foundations/23.05/development/System_integration_and_automated_testing

This example demonstrates the configuration of the Genode 'run' tool to execute a system scenario. It specifies modules for setting up the boot directory with the NOVA kernel, using QEMU for emulation (power-on and logging), and creating a bootable ISO image.

```buildconf
RUN_OPT = --include boot_dir/nova \
          --include power_on/qemu --include log/qemu --include image/iso
```

--------------------------------

### Run-tool Configuration Example: Executing NOVA in Qemu

Source: https://genode.org/documentation/genode-foundations/25.05/development/System_integration_and_automated_testing

This example demonstrates the configuration of the Genode 'run' tool to execute a system scenario. It specifies modules for setting up the boot directory with the NOVA kernel, using QEMU for emulation (power-on and logging), and creating a bootable ISO image.

```buildconf
RUN_OPT = --include boot_dir/nova \
          --include power_on/qemu --include log/qemu --include image/iso
```

--------------------------------

### Genode Configuration for rump_cgd

Source: https://genode.org/documentation/release-notes/14

Example Genode configuration snippet to start and configure the `rump_cgd` server. It specifies the encryption key and routes block service requests to the AHCI driver.

```XML
<start name="rump_cgd">
  <resource name="RAM" quantum="8M"/>
  <provides><service name="Block"/></provides>
  <config action="configure">
    <params>
      <method>key</method>
      <key>AAABAJhpB2Y2UvVjkFdlP4m44449Pi3A/uW211mkanSulJo8</key>
    </params>
  </config>
  <route>
    <service name="Block"> <child name="ahci"/> </service>
    <any-service> <parent/> <any-child/> </any-service>
  </route>
</start>
```

--------------------------------

### Sculpt OS Initial Setup Steps

Source: https://genode.org/documentation/articles/sculpt-25-04

Guides for initial interaction with Sculpt OS after booting, focusing on setting up the in-memory file system for temporary storage and configuring network connectivity.

```APIDOC
Sculpt OS Initial Setup:

1.  **Select In-Memory File System as Default Storage**:
    - Action: Click on the "ram fs" component in the system graph.
    - Action: Press the "Use" button.
    - Purpose: This configures the system to install software solely into RAM, avoiding immediate interaction with physical storage devices.

2.  **Enable Networking**:
    - Action: Open the "Network" dialog.
    - Option: Select either "Wired" or "Wifi".
    - For Wifi: Select an access point and enter the passphrase if required.
    - Verification: A successful network connection is indicated by the display of an IP address.
```

--------------------------------

### Run Genode Demo Scenario with NOVA

Source: https://genode.org/documentation/genode-foundations/24.05/getting_started/A_simple_system_scenario

Executes the Genode demo scenario using the NOVA microkernel on a PC board. This command initiates the build process and starts Qemu to run the scenario. Adjustments to Qemu arguments might be needed based on your Qemu version.

```shell
make run/demo KERNEL=nova BOARD=pc
```

--------------------------------

### Run DosBox on Genode

Source: https://genode.org/documentation/developer-resources/porting_dosbox

Executes the compiled DosBox application on the Genode OS Framework. This command triggers the build of all necessary components for the scenario to run.

```Shell
$ make run/dosbox
```

--------------------------------

### Intel Display Connector Configuration

Source: https://genode.org/documentation/release-notes/25

Example configuration for the Intel display driver, specifying connector properties like name, resolution, rotation, and flip settings. This allows for detailed display setup.

```XML
<connector name="eDP-1" width="1920" height="1080" rotate="90" flip="false"/>
```

--------------------------------

### Genode Build Commands

Source: https://genode.org/documentation/developer-resources/client_server_tutorial

These commands are used to build components within the Genode OS Framework. 'make hello' builds both the client and server components for the 'hello_tutorial' project. 'make hello/server' and 'make hello/client' allow for building specific targets individually.

```bash
make hello
make hello/server
make hello/client
```

--------------------------------

### Acquire Muen Sources and Initialize Submodules

Source: https://genode.org/documentation/platforms/muen

Commands to clone the Muen repository and update its submodules, which are necessary components for building and running Muen.

```bash
git clone https://git.codelabs.ch/git/muen.git
cd muen
git submodule update --init tools/mugenschedcfg
git submodule update --init components/libxhcidbg
```

--------------------------------

### Genode Build System Manual Link

Source: https://genode.org/documentation/developer-resources/porting

Provides a link to the essential documentation for the Genode Build System, which is a prerequisite for porting guides.

```APIDOC
Build-system manual:
  URL: <http://genode.org/documentation/developer-resources/build_system>
  Description: Documentation detailing the Genode Build System, crucial for understanding porting workflows.
```