651899220c
1449 lines of boot/bios/, tools/sign.pl and tools/padstage2.pl, plus the build rules, the disk image and the ISO entry that existed to carry them. Everything since roughly 2012 boots UEFI, and CSM -- the firmware-side BIOS emulation that lets a legacy loader run on such a machine at all -- has been going away since Intel dropped support for it in 2020. So this is not a path being retired early; it is one whose remaining hardware is already the exception. The cost was never the code, it was the tax on everything near it. Stage 2 had a 65-sector ceiling it overflowed silently -- 25440 bytes against 24576 -- and because the kernel is written at sector 1 + STAGE2_SECTORS, an overflowing loader was overwritten by the very kernel it was loading. The resolution list could not be shared with UEFI either: VBE mode setting is INT 10h, so matching it needed unreal mode, which is the riskiest code in the tree for a feature that already worked elsewhere. What replaces schos.img is the staged ESP, handed to QEMU as a virtual FAT volume. That is a development arrangement and not an installable disk; a real GPT image with a real FAT partition is the installer's job, and until it exists nothing here writes a disk a machine boots unaided. Secure Boot is untouched too -- the loader is unsigned. The ISO keeps one El Torito entry, the FAT image holding loader and kernel. It never booted from a USB stick via BIOS anyway: the firmware presents the stick as a hard disk while stage2main.c read the kernel back over ATAPI. The 32-bit multiboot entry in entry.S now has no caller and is left in place. Deleting kernel entry code is its own change with its own way of failing silently, and it should not ride along with this one. Ported with it: run.ps1, the six screenshot tools, and schcom_test.sh, each with its own OVMF varstore copy so no run inherits another's UEFI variables. Two things this shook out. OVMF now belongs in `all`: nothing boots without firmware, `make clean` wipes build/ including the copy fetched from the host, and a clean followed by a build left every run script throwing. And it cannot be listed as a prerequisite at the top of the file -- make expands prerequisites when it reads the line, and $(OVMF_CODE) is defined further down, so naming it there appends nothing and says nothing. Verified from a clean tree: 110 [ok] and no failures on the full suite, the ISO boots with no hard disk attached, schfs-check passes, schcom's end-to-end pixel test passes, and fbshot captures a real 1280x800 frame.
8.4 KiB
Repository layout
One rule holds the whole thing together:
A directory contains either hand-written source or generated output. Never both.
Everything generated lives under build/. Delete build/ and you lose nothing
that can't be rebuilt (except upstream tarballs, which live in dist/ and are
deliberately kept out of clean).
schos/
├─ boot/ Stage 1 MBR + stage 2 loader (splash, F8 menu, kernel load)
├─ kernel/ The kernel, by subsystem: arch/ core/ dev/ fs/ proc/ sys/
├─ include/ Headers shared by kernel, userland, and tools/mkfs
├─ lib/ First-party userland runtime: _start glue, syscall stubs,
│ the initcode blob embedded in the kernel, user.ld
├─ cmd/ First-party programs — one directory per program:
│ cmd/<name>/main.c → sysroot/bin/<name>
├─ ports/ Third-party software — one directory per port.
│ Contains ONLY a Makefile and optional patches/.
├─ projects/ Things that run ON SchOS rather than things that ARE it:
│ the compositor, window manager, desktop, and installer.
│ Not part of the kernel build. See projects/README.md.
├─ tools/ Host-side helpers, SOURCE ONLY: mkfs.c, the SchFS test
│ suites, sign.pl, vectors.pl, and the PowerShell harnesses.
│ Their binaries build into build/tools/ -- this directory
│ used to hold both, which is the one rule this layout has.
│ tools/windows/loc.ps1 counts how much of the tree is first-party.
├─ sysroot/ Staging for the disk image. etc/ is hand-maintained;
│ bin/ lib/ sbin/ are populated by `make sysroot-install`.
├─ dist/ Upstream tarball cache. Survives `make clean`.
├─ Refrence/ A FreeBSD checkout (Refrence/freebsd-src), kept as reference
│ material and a parts bin. Never built, never in an image.
│ Read it when a specification is ambiguous; copy from it only
│ after the per-file licence check in docs/licensing.md.
│ A full clone is 2.1 GB and a previous NetBSD one was deleted
│ for that reason. Only sys/dev, sys/net and sys/netinet have
│ ever been read, so a sparse checkout is ~100 MB:
│ git clone --filter=blob:none --sparse <url> Refrence/freebsd-src
│ git -C Refrence/freebsd-src sparse-checkout set │ sys/dev sys/net sys/netinet
├─ src-trunk/ A NetBSD checkout, kept as reference material and a parts
│ bin. NOT built, NOT installed, and it must never reach an
│ image. Copying from it is governed by the per-file licence
│ check in docs/architecture/schapi.md §5 — NetBSD is not
│ uniformly licensed.
├─ docs/ Design docs
└─ build/ ALL generated output (see below)
build/
build/
├─ boot/ uefi/ loader, common/ UI
├─ kernel/ object files, the linked kernel, kernel.asm
├─ lib/ libc glue objects, initcode blob
├─ cmd/ linked first-party programs
├─ fs.img the filesystem image
└─ ports/<name>/
├─ src/ extracted upstream tarball
├─ obj/ out-of-tree build directory
└─ prefix/ install prefix (musl's headers and libs land here)
Adding your own program
mkdir cmd/hello
$EDITOR cmd/hello/main.c # include "types.h", "user.h", ...
Then add hello to CMDS in the root Makefile. It gets linked against
lib/ and installed to sysroot/bin/hello by make sysroot-install.
Adding a third-party port
mkdir ports/foo
$EDITOR ports/foo/Makefile # start with `include ../mk/port.mk`
port.mk derives everything from the directory name — it gives you $(SRCDIR),
$(BUILDDIR), $(PREFIX), $(DISTDIR), $(SYSROOT), and $(MUSL) (the
musl install prefix that every port links against). Follow the pattern in
ports/mksh/Makefile: fetch tarball to $(DISTDIR), extract to $(SRCDIR),
build into $(BUILDDIR), install into $(SYSROOT). clean removes
$(PORTDIR) and nothing else.
ports/Makefile picks up the new directory automatically. If it links against
musl, add foo: musl there so ordering is right.
Local modifications to upstream go in ports/foo/patches/*.patch and are
applied after extraction — never by editing files under build/, which are
wiped on every clean.
Ramdisk root
make # normal: root on the IDE disk (build/fs.img as hdb)
make ramroot # root from a SCHFS image linked into the kernel
make ramroot builds build/fs-ram.img (default 6000 blocks, override with
RAMDISK_BLOCKS=) and links it into the kernel, so the system boots to a shell
with no data disk attached at all. That is what makes destructive work on
the real disk survivable — reformatting it, or bringing up a new on-disk format
— and it is the first piece of the installer.
Use make ramroot, not make RAMROOT=1: the flag changes CFLAGS, which make
cannot see, so objects compiled for one setting would be silently reused for
the other and ROOTDEV would point at the wrong device. The target drops the
compiled objects first. Switching back is the same — plain make after a
ramroot build reuses stale objects, so run rm -rf build/kernel build/lib build/cmd first (or just make clean).
The image costs boot time: the loader reads the kernel through the firmware's file protocol, so a 6 MB ramroot kernel is visibly slower to start than the 350 KB default.
What may go in it is a licensing question, not only a size one. The image is
linked into the kernel binary, so anything in sysroot/ when it is built becomes
part of a distributable artifact. A file staged there under a licence that
cannot be combined with Apache-2.0 does not merely ride along — it makes the
kernel itself undistributable. RAMDISK_EXCLUDE in the Makefile is the list of
paths kept out, and enforcing it in the build rather than relying on someone
remembering to unstage something first is deliberate. It has been needed once
already: a 33 MB test payload landed in sysroot/ and both overflowed the image
and would have gone into the kernel binary.
Three knobs, all in the Makefile, none of them FSSIZE:
RAMDISK_BLOCKS |
image size, 6000 (× 1 KiB BSIZE) |
RAMDISK_NINODES |
inode table size, 2000 |
RAMDISK_EXCLUDE |
sysroot-relative paths to omit, with their subtrees |
RAMDISK_NINODES is worth knowing about because the inode table is
preallocated: mkfs's default of 12000 inodes cost 1501 of the 6000 blocks — a
quarter of the image — to describe about 260 files. At 2000 it costs 251, and
metadata overall fell from 1596 blocks to 345.
If mkfs reports the image is full, read its message: it now prints the
metadata breakdown and names the right knob for whichever image overflowed. It
used to say only "increase FSSIZE in param.h", which is a constant that has
nothing to do with the ramdisk root and sends you to the wrong file.
Two things that will bite you
ld -r -b binary derives symbol names from the input file's path. The
kernel embeds two blobs this way (initcode, entryother), and the root
Makefile has --redefine-sym lines mapping e.g.
_binary_build_lib_initcode_start → _binary_initcode_start. Move either
blob's build location and those symbol names change; update the Makefile to
match or the kernel fails to link.
STAGE2_SECTORS is gone, with the BIOS loader it sized. It is recorded here
because the shape of the bug outlived it: one number that four files each
believed independently — boot/bios/bootasm.S, stage2main.c's readseg(),
the dd ... seek= offset, and twice inside mkiso.sh. Raising it from 24 to 48
for the boot logo left the dd seek=25 offset behind, so the kernel was written
directly over stage 2's own tail, and nothing said so.
The fix was to derive all five from one Makefile variable. The lesson worth
keeping is the other half: tools/padstage2.pl failed the build when stage 2
overflowed its budget rather than truncating it, which is why the overflow to
25440 bytes against a 24576 limit was found at all. A layout constant that
several artifacts must agree on wants a check that stops the build, not a
comment asking people to remember.