Purpose

This Specification defines Initialization, the process by which axisd establishes the minimum runtime environment required for the Base OS after Boot transfers execution to /sbin/axisd.

Initialization begins with axisd executing as PID 1 and ends when the minimum Base OS runtime environment has been established.

Scope

This Specification defines the entry conditions for axisd, the minimum runtime filesystems established during Initialization, the handling of compatible state inherited from the Platform boot environment, the conditions under which Initialization completes, and the behavior required when Initialization cannot complete.

This Specification does not define Platform boot behavior, persistent system state, user state, service management, Platform runtime support, system transactions, system APIs, application processes, device-management policy, or the initialization of higher-level Operating System components.

Entry Conditions

Initialization begins when the Platform boot environment transfers execution to /sbin/axisd according to the Base OS Boot contract.

At the beginning of Initialization, the selected OS Artifact MUST already be established as the read-only root filesystem and axisd MUST be executing as PID 1.

axisd MUST verify that it is executing as PID 1 before proceeding with Initialization.

A Platform boot environment MAY leave compatible runtime filesystems mounted when it transfers execution to axisd. If a required runtime filesystem is already mounted with the required filesystem type and behavior, axisd MUST keep and use it instead of mounting it again.

Initialization Model

axisd initializes the Base OS by ensuring that the minimum kernel interfaces, device interfaces, and ephemeral runtime filesystems required by the running system are available at their defined locations.

Initialization MUST NOT modify the OS Artifact.


flowchart TD
    Boot["Boot"]
    Axisd["axisd"]
    Kernel["Kernel interfaces"]
    Devices["Device interfaces"]
    Ephemeral["Ephemeral runtime state"]
    Runtime["Base OS runtime"]

    Boot -->|transfers execution| Axisd
    Axisd -->|establishes| Kernel
    Axisd -->|establishes| Devices
    Axisd -->|establishes| Ephemeral
    Kernel --> Runtime
    Devices --> Runtime
    Ephemeral --> Runtime

    class Axisd program

Runtime Filesystems

During Initialization, axisd MUST ensure that the runtime filesystems defined by this section are mounted with the required filesystem types and semantics.

/proc MUST be a proc filesystem exposing the Linux process and kernel interfaces provided by procfs.
/sys MUST be a sysfs filesystem exposing the Linux kernel object, device, and driver interfaces provided by sysfs.
/dev MUST be a devtmpfs filesystem exposing device nodes maintained by the Linux kernel.
/dev/pts MUST be a devpts filesystem providing pseudoterminal slave devices.
/dev/shm MUST be a tmpfs filesystem providing volatile shared-memory storage.
/run MUST be a tmpfs filesystem providing volatile writable storage for runtime state.
/tmp MUST be a tmpfs filesystem providing volatile writable storage for temporary data.

The contents of /dev/shm, /run, and /tmp MUST NOT persist across system boots.

Device Filesystem

The kernel-maintained device nodes exposed through devtmpfs form the fundamental device namespace of the Base OS.

axisd MUST NOT require a userspace device manager to create the fundamental device nodes required for Initialization.

Device-management policy performed after device nodes exist, including permissions, ownership, stable names, symbolic links, reactions to device events, and other higher-level device behavior, is outside the scope of this Specification.

The use of devtmpfs does not preclude the Base OS from providing additional device-management behavior through axisd or another component defined by a later Specification.

Inherited Runtime State

A Platform boot environment MAY leave runtime filesystems mounted when execution is transferred to axisd.

axisd MUST reuse an inherited mount when that mount already satisfies the filesystem type and semantics required by this Specification for its location.

If an inherited mount does not satisfy the applicable requirement, axisd MUST establish a conforming runtime filesystem before Initialization can complete.

Whether a runtime filesystem was established by the Platform boot environment or by axisd MUST NOT change its semantics during the Base OS runtime.

Completion

Initialization completes when axisd is executing as PID 1 and all runtime filesystems required by this Specification have been successfully established.

Completion of Initialization marks the beginning of normal Base OS runtime management by axisd.

Initialization completion does not imply that persistent state, Platform runtime support, users, services, networking, device-management policy, applications, or other higher-level system facilities have been initialized unless required by another applicable Specification.


flowchart LR
    Entry["axisd"]
    Kernel["Kernel interfaces"]
    Devices["Device interfaces"]
    Ephemeral["Ephemeral state"]
    Initialized["Initialization complete"]
    Runtime["Runtime management"]

    Entry --> Kernel
    Kernel --> Devices
    Devices --> Ephemeral
    Ephemeral --> Initialized
    Initialized --> Runtime

    class Entry program

Failure

Initialization MUST fail if axisd is not executing as PID 1.

Initialization MUST fail if a runtime filesystem required by this Specification cannot be established with the required filesystem type and semantics.

axisd MUST NOT report Initialization as complete while any mandatory Initialization requirement remains unsatisfied.

The behavior of the system after Initialization failure, including diagnostics, recovery, shutdown, or restart, is outside the scope of this Specification.

Fundamental Invariants

Initialization begins with axisd as PID 1. The OS Artifact is already the root filesystem when Initialization begins.
Initialization does not modify the OS Artifact. Writable runtime state MUST be established outside the immutable root filesystem.
Kernel interfaces use the standard Linux virtual filesystems. /proc uses proc and /sys uses sysfs.
The kernel maintains the fundamental device namespace. /dev uses devtmpfs.
Pseudoterminals use devpts. /dev/pts MUST provide the pseudoterminal slave namespace through devpts.
Ephemeral writable filesystems use tmpfs. /dev/shm, /run, and /tmp MUST use tmpfs and MUST NOT preserve their contents across system boots.
Compatible inherited state may be reused. axisd MUST NOT require runtime filesystems to be recreated solely because they were established by the Platform boot environment.
Initialization has an explicit completion boundary. axisd MUST NOT consider Initialization complete until every requirement defined by this Specification has been satisfied.

Conformance

An implementation conforms to this Specification when axisd begins Initialization as PID 1 with the OS Artifact established as the root filesystem, establishes or validates all required runtime filesystems with the required filesystem types and semantics without modifying the OS Artifact, and enters normal runtime management only after all Initialization requirements have been satisfied.