feature: boot.mgr replace hardcoded init sequence with dependency-driven boot manager

Introduce boot.mgr - a self-registering, dependency-ordered boot
initialization framework with barrier-based phasing and glob pattern
matching. Units now declare their own init procedures and dependencies
via registerBoot()/registerBarrier() in their initialization sections,
boot.mgr.run() topologically sorts and executes them.

- Add src/boot/boot.mgr.pas with topoSort, glob matching, barrier
  two-pass algorithm, and boot tree printer
- Gut src/asuro.pas (kmain): now just stores multiboot info, calls
  System.init(), boot.mgr.run, and yield()
- Add initialization sections with registerBoot() to 53 existing units
- Add new units: core.pas, test.pas, driver.storage.boot.pas,
  app.wasm.pas, app.bsod.pas (factored out of asuro.pas)
- Define 9 barrier phases: immediate -> early -> middle -> storage ->
  bus -> device -> bus.late -> late -> final
- Fix xHCI ISR: exclude PRC/WRC from PORTSC change bit clearing to
  prevent race with port reset busy-wait
- Fix driver.bus.usb.core fire_completion_hooks: guard against uint32
  underflow when CompletionHookCount = 0
- Move auto_mount_volumes from device barrier to late barrier so it
  runs after PCI scan discovers storage controllers
- Add toolchain/compile_initcalls.sh for boot entry extraction
- Add Boot Registration sections to all 51 doc files; create 4 new
  doc files; rewrite boot.mgr.md; update mkdocs.yml nav

.gitignore

@@ -15,9 +15,8 @@ localenv.json
 dockerout.txt
 AGENTS.md
 lessons_learnt.md
-/plan.md
 *.log
 wasuro
 src/core/core.version.pas
 site/*
-!site/.gitkeep
+!site/.gitkeep

Dockerfile

@@ -6,7 +6,7 @@ ENV DEBIAN_FRONTEND=noninteractive
 RUN dpkg --add-architecture i386
 RUN apt-get update && apt-get install -y \
 	curl dos2unix wget git make nasm binutils xorriso grub-pc-bin gcc gcc-multilib \
-	python3 python3-pip python3-pil && \
+	python3 python3-pip && \
 	apt-get clean my room
 
 RUN pip3 install --no-cache-dir --break-system-packages "mkdocs>=1.6,<2" mkdocs-material

doc/src/driver/storage/ctl/driver.storage.ctl.usb.md

@@ -1,85 +1,49 @@
-<!--
-Copyright 2026 Aaron Hance
-Author: Aaron Hance <[email protected]>
+# driver.storage.ctl.usb
 
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
+USB Mass Storage Class driver stub.
 
-http://www.apache.org/licenses/LICENSE-2.0
+## Overview
 
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
+This unit registers a USB class driver with the driver manager (`driver.mgr`) to claim USB Mass Storage Class interfaces (class `$08`, subclass `$06` SCSI, protocol `$50` Bulk-Only). When the USB stack enumerates a matching interface, the `load` callback is invoked. Currently the callback only logs a detection message; no I/O infrastructure is established.
 
-# USB mass storage
+Full Bulk-Only Transport (BOT) support — including Max LUN query, endpoint setup, CBW/CSW command exchange, and `driver.storage.mgr` device registration — is planned but not yet implemented.
 
-`driver.storage.ctl.usb` implements SCSI transparent commands over USB Mass
-Storage Bulk-Only Transport (interface class/subclass/protocol `08/06/50`).
+## Boot Registration
 
-It probes INQUIRY, TEST UNIT READY and READ CAPACITY(10), registers LUN 0 with
-the storage manager, and exposes READ(10), WRITE(10), REQUEST SENSE and
-SYNCHRONIZE CACHE(10). Existing partition discovery and filesystem mounting
-apply to the resulting USB disk. Writes complete only after cache synchronization.
+Registered with `boot.mgr` as `driver.storage.ctl.usb` at the `device` barrier. The barrier order places `device` after `bus`, ensuring `driver.bus.usb.core.init` has run before the storage class driver registers with the driver manager.
 
-## Execution and ownership
+## Dependencies
 
-An attachment task probes and registers each disk after scheduling starts; boot
-initialization never waits on a worker that cannot run yet.
+- `boot.mgr`
 
-Storage dispatch only publishes a request. One persistent `usb.storage` worker
-performs I/O in task context, with one command active per device and a reusable,
-page-aligned 4 KiB bounce buffer. Caller buffers are never submitted for DMA.
-Commands are split at the bounce-buffer boundary; all LBA/count and buffer-end
-arithmetic is checked before submission. CBW/CSW wire sizes, tags, status,
-residue, and actual transfer lengths are validated.
+- `driver.mgr`
+- `memory.heap`
+- `driver.storage.types`
+- `io.syslog`
+- `debug.tracer`
+- `driver.bus.usb.core`
+- `driver.bus.usb.types`
+- `core.util`, `arch.x86.util`
 
-OHCI batches bulk data into spans of at most 4 KiB per transfer descriptor,
-using the endpoint's hardware toggle carry across packets. A 4 KiB full-speed
-read uses one data descriptor instead of 64. Short packets still halt the chain
-and report the actual byte count; interrupt endpoint packet sizing is unchanged.
+## Constants
 
-The worker performs reset recovery (class reset, clear bulk-IN halt, clear
-bulk-OUT halt) after malformed status or phase errors. Failed SCSI commands
-request sense and return storage errors, including write protection.
+| Constant | Value | Description |
+|---|---|---|
+| `USB_CLASS_MASS_STORAGE` | `$08` | USB interface class for mass storage |
+| `USB_SC_SCSI` | `$06` | SCSI transparent command set subclass |
+| `USB_PROTO_BBB` | `$50` | Bulk-Only (BOT) transport protocol |
 
-On disconnect the disk is marked removed immediately. Accepted requests are
-completed with errors, and idle volumes are invalidated/unmounted by the worker;
-busy volumes are retried. Storage-manager records remain stable tombstones.
-Class-driver buffers and context are freed after pending hardware work drains.
+## Functions and Procedures
 
-Host controllers currently have no cancellation API. A timed-out transfer is
-therefore quarantined with its private device snapshot and DMA memory. No further
-commands are issued to that device. If hardware never completes, those allocations
-remain retained until reboot; freeing them would permit DMA into reused memory.
-The timeout uses the PIT's actual frequency and a bounded polling fallback.
+### init
 
-## Supported scope
+```pascal
+procedure init;
+```
 
-- LUN 0 on a single-interface device with one bulk-IN and one bulk-OUT endpoint.
-- Direct-access disks with power-of-two sectors from 512 through 4096 bytes.
-- Capacity representable by the existing 32-bit storage-sector API; the
-  READ CAPACITY(16) sentinel is rejected.
-- OHCI, EHCI and xHCI bulk transfers. OHCI/EHCI report actual data lengths and
-  terminate bulk reads on short packets.
+Constructs a `TDeviceIdentifier` matching any USB device with `bInterfaceClass = $08`, `bInterfaceSubClass = $06`, `bInterfaceProtocol = $50`, and registers the `load` callback with `driver.mgr`.
 
-UAS, additional LUNs, composite/alternate-setting interfaces, UHCI storage,
-optical devices, and media replacement without USB reconnect are not supported.
-The current xHCI driver lacks endpoint-ring reset support: a halted bulk endpoint
-fails the device closed rather than attempting an unsafe ring reuse.
+## Notes
 
-## Validation
-
-`UnitTest` is called by the boot test suite and is available as `USBMSCTEST`.
-Tests use a memory-only mock host controller: wire layout, byte order, capacity
-limits, reads, writes, sense errors, short transfers, status stalls, reset ordering,
-and request bounds. They perform no disk I/O.
-
-For hardware/VM checks, boot with a disposable USB disk, confirm `USBMSC` discovery
-and filesystem mounting, test file read/write/read-back, then unplug while idle
-and during I/O. Do not run destructive disk tests against a disk containing data.
-
-Protocol: [USB-IF Bulk-Only Transport 1.0](https://www.usb.org/sites/default/files/usbmassbulk_10.pdf).
+- The `load` callback currently returns true unconditionally after logging a detection message.
+- Once full BOT support is implemented, `load` should query the Max LUN, allocate endpoint structures, and call `driver.storage.mgr.register_device` for each logical unit.

doc/src/driver/storage/driver.storage.mgr.md

@@ -1,20 +1,3 @@
-<!--
-Copyright 2026 Aaron Hance
-Author: Aaron Hance <[email protected]>
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
--->
-
 # driver.storage.mgr
 
 Physical storage device registry and I/O dispatch manager.
@@ -31,7 +14,7 @@ The I/O model operates as follows:
 - `storage_read` / `storage_write` are convenience wrappers that build a stack-local `TIORequest` and call `submit_io_wait`.
 - `storage_read_async` / `storage_write_async` build and submit a request with a caller-supplied callback, returning immediately.
 
-Blocking callers use `storage_read` / `storage_write` and check the returned `TError`.
+Legacy `storage_read_legacy` / `storage_write_legacy` procedure wrappers are retained for callers not yet migrated to the function-returning API.
 
 ## Dependencies
 
@@ -222,42 +205,17 @@ function storage_write_async(device : PStorage_Device; addr : uint32; sectors :
 
 Non-blocking write. Analogous to `storage_read_async`.
 
+### storage_read_legacy / storage_write_legacy
+
+```pascal
+procedure storage_read_legacy(device : PStorage_Device; addr : uint32; sectors : uint32; buffer : puint32);
+procedure storage_write_legacy(device : PStorage_Device; addr : uint32; sectors : uint32; buffer : puint32);
+```
+
+Drop-in procedure replacements for callers using the old void-returning API. Forward to `storage_read` / `storage_write` and discard the error code. Marked for removal once all callers are migrated.
+
 ## Notes
 
 - `dispatch_next` is an internal procedure called with interrupts disabled. It dequeues the head of the CFIFO, allocates a heap copy via `ioreq_copy` (for ISR safety), and invokes the appropriate `dispatchRead` or `dispatchWrite` on the device. If neither dispatch pointer is set, the request is failed with `eDeviceNotFound`.
 - The blocking path relies on pointer-dereferenced spin (`puint32(@wait.Done)^`) to prevent FPC from caching the `Done` flag in a register across the `hlt` instruction.
 - Devices without `dispatchRead`/`dispatchWrite` set (i.e., drivers not yet migrated to Phase 2) will have `submit_io` return `eDeviceNotFound`. Legacy drivers must be migrated before they can use the new I/O path.
-
-
-## Bounded performance path
-
-The manager merges up to 32 consecutive queued requests when operation, device,
-LBA range, and virtual buffer range are contiguous. It never searches past the
-queue head or delays a lone request to create a merge. Drivers opt in through
-`mergeMaxSectors`; SATA AHCI advertises 65,536 sectors, while other drivers default
-to zero (disabled). A merged command delivers one completion to each original
-request, in FIFO order. A command error fails every member conservatively.
-
-`storage_get_stats` takes an interrupt-protected snapshot of the device counters.
-`DISK info <index>` displays accepted/completed/failed logical requests, hardware
-commands, merged requests, queue-full rejections, queue and active high-water
-marks, successful read/write sectors, request-size buckets, queue/service ticks,
-and FAT metadata cache hits/misses. Queue ticks are accumulated per logical
-request; service ticks are accumulated per hardware command. Tick values use
-`Counters.c32`, not milliseconds. Counters are unsigned 32-bit values, start at
-device registration, and wrap; use snapshot differences over bounded benchmark
-intervals. Size buckets are <=8, 9..256, and >256 sectors.
-
-FAT32 blocking and async reads share a pooled transfer engine with batches of up
-to four outstanding reads, capped by device queue depth. Destination slices are
-disjoint. On any error, the engine drains every accepted request before releasing
-its context and reports only the contiguous successful byte prefix. Unaligned
-edges and odd DMA addresses use the context's private scratch sector. Writes
-remain sequential. Run maps store cumulative file-cluster offsets; an open-file
-cursor handles sequential locality and binary search handles random seeks.
-
-`STORPERF` runs memory-backed regression checks (also included in boot unit tests)
-for reverse completion order, failures, unaligned reads, run lookup, queue
-rejection, merging limits, and callback accounting. It does not access real disks
-or measure hardware throughput. Compare counters alongside `STORBENCH` and file
-benchmarks on contiguous and fragmented files for actual performance validation.

doc/src/driver/storage/driver.storage.test.md

@@ -58,111 +58,3 @@ Registers the `STORTEST` and `DISKTEST` shell commands with `io.stdio`. Must be
 - `run_tests` exercises `makeAbsolutePathFrom`, `resolvePathFrom`, `changeDirectoryFrom`, `GetDirectoryListingFrom`, `newVirtualDirectory`, and `PathValid` including `.` and `..` traversal.
 - `run_disk_tests` is destructive and will irreversibly wipe the partition table of disk 0. It is never called automatically.
 - The `Assert` helper used in both procedures increments `passed` or `failed` counters and logs the test name on failure; passing tests produce no output to avoid noise.
-
-
-## Raw read benchmark
-
-`STORBENCH` is implemented and registered by `driver.storage.bench`. It performs
-read-only raw-device I/O; it does not invoke the destructive `DISKTEST` path.
-
-```text
-STORBENCH [disk] [MiB]
-STORBENCH list
-STORBENCH run [disk] [MiB] [KiB/request] [depth] [seq|random] [start_lba]
-STORBENCH compare [disk] [MiB]
-STORBENCH help
-```
-
-Manual (`run`) defaults are disk 0, 128 MiB, 1024 KiB/request, sequential reads, and a depth of
-`min(4, hardware depth)` (at least one). Examples:
-
-```text
-STORBENCH 0 128 64 4
-STORBENCH 0 128 4 16 random
-STORBENCH 0 256 1024 1 seq 2048
-STORBENCH compare 0 128
-```
-
-The comparison runs sequential reads at 4, 64, and 1024 KiB/request, each at depths
-1, 4, 16, and 32. The MiB argument applies to each of the twelve cases. Queue depth
-may exceed hardware depth to expose software queuing and request merging.
-
-Limits are 1..16384 MiB, 1..1024 KiB/request, and depth 1..32. Request size must be
-an exact number of device sectors. Buffers are allocated once per case, with a
-separate slice for every outstanding request and a maximum total size of 32 MiB.
-The transfer range is clamped to the device. Without an explicit LBA, reads start
-at sector 2048 when the full requested range fits there; otherwise they start at
-zero. Random mode uses a fixed xorshift seed and samples that range with replacement,
-so total bytes read are bounded but unique coverage is not guaranteed.
-
-Reports include successful bytes, elapsed microseconds, MiB/s, IOPS, accepted and
-completed request counts, peak outstanding requests, average/p95/max completion
-latency, and per-run storage-counter deltas. Latencies are measured from submission
-to callback. The p95 is an upper bound from logarithmic microsecond buckets, not an exact
-microsecond percentile. Runs shorter than 10 ms are excluded from suite speed comparisons.
-No console output occurs inside the measured loop. Any failure stops new work;
-already accepted DMA is drained before buffers are freed, and failed requests
-contribute no bytes or successful IOPS.
-
-Timing prefers the Hyper-V-compatible VM reference counter (100 ns ticks), detected
-through its Hv#1 interface and reference-counter privilege. It needs no calibration.
-Other platforms use an invariant TSC calibrated against two complete RTC seconds,
-with up to three attempts to tolerate transient RTC updates or scheduling delays.
-Calibration requires agreement within 1%; failures include the specific reason.
-Unlike delivered timer interrupts, this clock advances while interrupts are masked.
-Queue submission restores interrupts between requests. Filesystem caches are
-bypassed, but drive and virtual-machine/host caches may still affect results.
-Virtual or sparse disks can report throughput above physical-media speed.
-Device counter deltas may include concurrent I/O from other processes;
-benchmark-owned byte, request, and latency counters do not.
-
-`driver.storage.bench.UnitTest` runs memory-only parser, arithmetic, range,
-queue-depth, completion-order, and error-accounting tests at boot. It never reads
-or writes a real disk. The clock tests also verify that an advertised VM reference
-counter advances with interrupts masked; they never calibrate the RTC at boot.
-
-
-### Automatic suite and table output
-
-`STORBENCH` without arguments, or `STORBENCH auto [disk] [MiB]`, runs six
-read-only profiles. Auto defaults to disk 0 and **32 MiB per profile** (up to
-192 MiB total before device-size clamping). One or two numeric arguments select the auto suite: `STORBENCH 2 512` tests
-disk 2 with 512 MiB per profile. `STORBENCH list` lists disk indices, capacities,
-controllers, sector sizes, and hardware queue depths. Three or more numeric
-arguments retain the legacy manual syntax; `run` selects manual mode explicitly.
-
-| Profile | Request size | Queue depth |
-| --- | --- | --- |
-| Seq large | 1024 KiB | 1 |
-| Seq queued | 1024 KiB | queued |
-| Seq medium | 64 KiB | queued |
-| Random small | 4 KiB | 1 |
-| Random queued | 4 KiB | queued |
-| Random medium | 64 KiB | queued |
-
-Queued depth is the device hardware depth clamped to 4..16, allowing software
-queue testing even on serial devices. A request smaller than a device sector is
-increased to one sector. Each profile samples the same byte-span size, with the
-existing fixed random seed and range clamping rules.
-
-Auto and compare modes print an aligned ASCII table with request KiB, queue
-depth, MiB/s, IOPS, average latency, p95 latency upper bound, and status. Rows are
-printed outside the measured loop. Successful runs shorter than 10 ms show `-` metrics and
-`SHORT`, and are excluded from best-result and queue-gain summaries. Errors show
-`FAILED`, stop the suite after accepted DMA has drained, and leave remaining
-profiles unrun. The summary includes successful profiles, bytes actually read,
-measured time, best sequential throughput, peak random IOPS, and (in auto mode)
-queued/QD1 throughput ratios. These ratios describe the measured cases, including
-any controller-cache effects; they are not a hardware rating.
-
-```text
-STORBENCH
-STORBENCH list
-STORBENCH 2 512
-STORBENCH auto 0 64
-STORBENCH compare 0 32
-```
-
-Profiles reuse the same raw device range. Host/drive caches are not flushed, so
-later profiles may read warm data. These results are observed raw read throughput,
-not a claim of uncached physical-media performance.

lvglh/lv_conf.h

@@ -30,8 +30,8 @@
 #define LV_LIMITS_INCLUDE       <limits.h>
 #define LV_STDARG_INCLUDE       <stdarg.h>
 
-/* Built-in memory pool: 1 MB for complex UI (file browser etc.) */
-#define LV_MEM_SIZE (1024 * 1024U)
+/* Built-in memory pool: 256 KB should be plenty for our UI */
+#define LV_MEM_SIZE (256 * 1024U)
 #define LV_MEM_POOL_EXPAND_SIZE 0
 #define LV_MEM_ADR 0
 

src/app/app.diskcmd.pas

@@ -150,7 +150,6 @@ var
     device   : PStorage_Device;
     volCount : uint32;
     freeSec  : uint32;
-    stats : TStorageStats;
 begin
     if paramCount(params) < 2 then begin
         println('Usage: DISK info <disk>');
@@ -192,16 +191,6 @@ begin
     else
         volCount := 0;
     print('Partitions:      '); printint(volCount); println('');
-    storage_get_stats(device,stats);
-    print('I/O submitted/completed/failed: '); printint(stats.Submitted); print(' / '); printint(stats.Completed); print(' / '); printint(stats.Failed); println('');
-    print('Commands / merged requests: '); printint(stats.Commands); print(' / '); printint(stats.Merged); println('');
-    print('Queue peak / active peak / queue full: '); printint(stats.QueuePeak); print(' / '); printint(stats.ActivePeak); print(' / '); printint(stats.QueueFull); println('');
-    print('Read / written sectors: '); printint(stats.ReadSectors); print(' / '); printint(stats.WriteSectors); println('');
-    print('Requests <=8 / <=256 / >256 sectors: '); printint(stats.SmallRequests); print(' / '); printint(stats.MediumRequests); print(' / '); printint(stats.LargeRequests); println('');
-    print('Queue ticks total / max: '); printint(stats.QueueTicks); print(' / '); printint(stats.MaxQueueTicks); println('');
-    print('Service ticks total / max: '); printint(stats.ServiceTicks); print(' / '); printint(stats.MaxServiceTicks); println('');
-    print('FAT cache hits / misses: '); printint(stats.FatCacheHits); print(' / '); printint(stats.FatCacheMisses); println('');
-
 end;
 
 { ---------- DISK WIPE ---------- }