QEMU Full OS Core Workdown

QEMU Full OS Core Workdown

Purpose

This page tracks the work required to move OSAI from a QEMU readiness gate to a real QEMU full OS core.

The QEMU hardware-readiness gate is useful, but it is not the same as a complete OS. Intel hardware work should not start until the QEMU core has stable process, userspace control-plane, persistence, networking, CPU-AI runtime, security, telemetry, and filesystem contracts.

Contents

• Completion Rule
• Phase Q1: Real Process Lifecycle
• Phase Q2: Real Userspace Control Plane
• Phase Q3: Real Filesystem and Persistence
• Phase Q4: Networking Depth
• Phase Q5: CPU-Only AI Runtime Depth
• Phase Q6: Security Enforcement
• Phase Q7: QEMU Release Candidate

Completion Rule

Do not start Intel hardware code until this QEMU workdown has a release candidate gate with stable ABI, telemetry, filesystem, process, security, and control-plane contracts.

Phase Q1: Real Process Lifecycle

Goal: stop treating /init as a one-way kernel-hosted test and make EL0 process execution return cleanly to kernel supervision.

Current status:

• Done: process states: empty, loaded, running, exited, failed.
• Done: process lifecycle transition counters.
• Done: sys_exit marks the current process exited or failed.
• Done: EL0 exit returns to a kernel continuation.
• Done: process lifecycle telemetry.
• Done: child service descriptor parsing from /etc/osai-init.conf.
• Done: /init defines, starts, and reports the child /svc/source-index service record through osctl.
• Done: invalid-transition and failed-exit lifecycle tests.

Definition of done: QEMU boot proves /init loads, runs, exits, and the kernel resumes after EL0. Telemetry includes loaded, running, exited, failed, transition counters, child service descriptor count, and service transition count.

Verification:

• make qemu-smoke
• make qemu-readiness-gate

Phase Q2: Real Userspace Control Plane

Goal: move policy decisions out of kernel fixtures and into userland service management.

Required work:

• Split userland into /init and a service-manager payload.
• Add a service descriptor format in the read-only filesystem.
• Add syscalls for status, start, stop, restart, rollback, and update.
• Keep kernel APIs as capability-checked primitives.
• Add denied-operation tests for missing capabilities.
• Emit userspace control-plane state telemetry.

Phase Q3: Real Filesystem and Persistence

Goal: replace metadata-only persistence with serialized state records and mutable VirtIO-backed state.

Required work:

• Add a mutable state region to the VirtIO test block image.
• Serialize boot, service, workspace, sandbox, and update records.
• Add checksums and versioning for persistence records.
• Reload persisted records after a QEMU reboot.
• Prove rollback restores prior service and workspace state.
• Keep read-only system image and mutable state boundaries explicit.

Phase Q4: Networking Depth

Goal: move beyond parser smoke paths into queue-backed packet flow.

Required work:

• Add queue-backed RX/TX packet ownership.
• Add UDP flow table with per-core ownership.
• Add minimal TCP state machine and timeouts.
• Add packet lifetime/drop counters.
• Preserve malformed packet tests.
• Emit p50/p95/p99/p999 correctness telemetry.

Phase Q5: CPU-Only AI Runtime Depth

Goal: turn the deterministic CPU-AI stub into real boundaries that can later host actual CPU-only model code.

Required work:

• Add model-loader interface and manifest format.
• Add tokenizer/runtime boundary.
• Keep shared read-only model weights.
• Keep private KV/cache arenas per AI Cell.
• Add multi-cell shared-weight tests.
• Add model load failure tests.
• Keep GPU acceleration out of the runtime contract.

Phase Q6: Security Enforcement

Goal: make capability policy enforce service, filesystem, Git/workspace, update, rollback, and build/test permissions.

Required work:

• Extend capability checks across service operations.
• Enforce filesystem read/write boundaries.
• Enforce Git workspace write and patch permissions.
• Enforce build/test sandbox permissions.
• Strengthen signed update validation beyond the current stub.
• Add rollback authorization tests.
• Ensure secrets are rejected from logs, updates, and benchmark records.

Phase Q7: QEMU Release Candidate

Goal: freeze the QEMU full OS core contract.

Required work:

• Expand make qemu-readiness-gate to include CPU matrix tiers.
• Freeze syscall ABI.
• Freeze telemetry schema.
• Freeze filesystem format.
• Freeze persistence record format.
• Freeze service descriptor format.
• Document what remains out of scope for Intel bring-up.

Definition of done: a single QEMU release-candidate gate proves process, userspace control, persistence, networking, CPU-AI runtime, security, and documentation contracts are stable enough to start Intel Desktop work.

Related Pages

• QEMU on macOS
• QEMU CPU Test Matrix
• Hardware Readiness Gate
• Implementation Plan
• Roadmap