tools: group scripts by what runs them

tools/windows/   .ps1   (pwsh, so usable from Linux and macOS too)
  tools/posix/     .sh
  tools/python/    .py
  tools/           .c and .pl

The .c and .pl files stay at the top level because they are not
host-specific: the build compiles or invokes them on every platform.

Call sites updated in the Makefile, ports/mk/port.mk, docs and the
project memory. The one thing that does not survive a move on its own is
a script deriving the repo root from its own location -- all nine
PowerShell tools used Split-Path $PSScriptRoot -Parent, and memory-sync.sh
used dirname/.., both of which quietly become tools/ one level deeper.
Two levels now.

Two pre-existing Windows failures surfaced while verifying, both real and
neither caused by the move:

  - schfs_fsck.c did not compile under mingw at all: --extract uses
    POSIX mkdir(path,mode), symlink() and link(), none of which mingw
    has. That took the whole tool with it, and `make schfs-check` with
    it. mkdir maps to _mkdir; symlink and link fail loudly rather than
    writing a regular file in their place, because an extracted tree
    that differs from the image while reporting success defeats the
    point of --extract.
  - the round-trip test then failed at `ln -s`, since Git Bash cannot
    create symlinks without developer mode. It skips with a message now.
    Not a fudge: mkschfs's mingw build cannot see a symlink either, so
    the test would have compared a tree with none against an image with
    none and called it a pass -- coverage reporting itself as present
    while being absent.

Verified on Windows: build clean, all seven bootcheck suites green,
make schfs-check passes.
This commit is contained in:
Nexoniarz 2026-08-09 14:38:02 +02:00
commit 754d96ebc5
26 changed files with 127 additions and 39 deletions

177
tools/windows/makeiso.ps1 Normal file
View file

@ -0,0 +1,177 @@
# Build a bootable SchOS ISO, ready for VMware or a real machine.
#
# Wraps `make iso`, which builds the ramdisk-root variant and wraps it in an
# El Torito image. The ramdisk root is the point: the ISO carries a complete
# userland inside the kernel, so it boots with no hard disk attached at all.
#
# tools/makeiso.ps1 build it
# tools/makeiso.ps1 -Run build it, then boot it under QEMU to check
# tools/makeiso.ps1 -Clean force a full rebuild first
#
# Afterwards the ISO is schos.iso in the repository root; point a VM's optical
# drive at it and boot from CD.
param(
[switch]$Run,
[switch]$Clean,
[string]$Qemu = (Find-Qemu)
)
# QEMU, on whichever host this is.
#
# PowerShell 7 runs on Linux, macOS and the BSDs as well as Windows, so these
# scripts are usable from all of them -- but the old default was a hardcoded
# scoop path under $env:USERPROFILE, which exists on exactly one of those. PATH
# first, because a package-managed qemu is on it everywhere; the scoop location
# is only a fallback for the Windows install that does not add itself to PATH.
function Find-Qemu {
$exe = if ($IsWindows -or $env:OS -eq 'Windows_NT') { 'qemu-system-x86_64.exe' }
else { 'qemu-system-x86_64' }
$onPath = Get-Command $exe -ErrorAction SilentlyContinue
if ($onPath) { return $onPath.Source }
if ($env:USERPROFILE) {
$scoop = Join-Path (Join-Path $env:USERPROFILE 'scoop/apps/qemu/current') $exe
if (Test-Path $scoop) { return $scoop }
}
foreach ($p in @('/usr/bin', '/usr/local/bin', '/opt/homebrew/bin')) {
$c = Join-Path $p $exe
if (Test-Path $c) { return $c }
}
throw "qemu-system-x86_64 not found on PATH. Install QEMU, or pass -Qemu <path>."
}
$ErrorActionPreference = 'Stop'
# Repo root is two levels up: this script lives in tools/windows/.
$root = Split-Path (Split-Path $PSScriptRoot -Parent) -Parent
Push-Location $root
function Fail($msg) {
Write-Host "FAIL: $msg" -ForegroundColor Red
Pop-Location
exit 1
}
# Git Bash, found by full path and never as bare `bash`.
#
# From PowerShell, `bash` resolves to C:\...\WindowsApps\bash.exe -- the *WSL*
# launcher -- long before anything on PATH. On this machine WSL2 cannot start at
# all, because it needs the Hyper-V hypervisor underneath the whole system and
# that is deliberately off. So calling `bash` here does not run a different
# shell, it fails with a wall of virtualisation advice and an exit code that
# looks like the build broke.
$BashCandidates = @(
"$env:ProgramFiles\Git\bin\bash.exe"
"${env:ProgramFiles(x86)}\Git\bin\bash.exe"
"$env:USERPROFILE\scoop\apps\git\current\bin\bash.exe"
"$env:LOCALAPPDATA\Programs\Git\bin\bash.exe"
)
$Bash = $BashCandidates | Where-Object { Test-Path $_ } | Select-Object -First 1
if (-not $Bash) { Fail "Git Bash not found; looked in:`n $($BashCandidates -join "`n ")" }
function Invoke-Make([string]$cmd) {
# -c, not -lc: a login shell sources the profile for no benefit here.
# stderr folded in inside bash, because $ErrorActionPreference = 'Stop'
# turns a native program's stderr into a terminating error, and mkisofs
# writes a harmless warning there on every single run.
& $Bash -c "cd '$($root -replace '\\','/')' && $cmd 2>&1"
}
# An ISO needs one of these to assemble the filesystem. There is no xorriso
# package for Windows in scoop; cdrtools provides mkisofs, and tools/mkiso.sh
# accepts either -- their El Torito arguments are compatible.
$haveIso = (Get-Command xorriso -ErrorAction SilentlyContinue) -or
(Get-Command mkisofs -ErrorAction SilentlyContinue)
if (-not $haveIso) {
Write-Host "Need xorriso or mkisofs on PATH." -ForegroundColor Yellow
Write-Host " Windows: scoop install cdrtools"
Write-Host " Debian/Ubuntu: apt install xorriso"
Fail "no ISO builder"
}
if ($Clean) {
Write-Host "==> cleaning" -ForegroundColor Cyan
# Not `make clean`: that would drop the ports too, and those take an
# afternoon to rebuild on a host where they are not rebuilt at all.
Invoke-Make "rm -rf build/kernel build/lib build/cmd" | Out-Null
}
Write-Host "==> building (this makes the ramdisk-root kernel, which is larger)" -ForegroundColor Cyan
# Output captured whole rather than piped through a filter. Piping a native
# command into ForEach-Object leaves $LASTEXITCODE reflecting the pipeline
# rather than the command, which reported a perfectly successful `make iso` as
# a failure. Redirect stderr inside bash too: with $ErrorActionPreference set to
# Stop, PowerShell turns a native program's stderr into terminating errors, and
# mkisofs writes a harmless warning there every single run.
$out = Invoke-Make "make iso"
$code = $LASTEXITCODE
$out | Where-Object { $_ -match '^==>|mkiso:|nmeta|rror' } |
ForEach-Object { Write-Host " $_" -ForegroundColor DarkGray }
if ($code -ne 0) {
$out | Select-Object -Last 20 | ForEach-Object { Write-Host $_ }
Fail "make iso returned $code"
}
$iso = Join-Path $root 'schos.iso'
if (-not (Test-Path $iso)) { Fail "schos.iso was not produced" }
# `make iso` leaves the tree holding objects compiled with -DRAMDISK_ROOT. A
# following plain `make` would then fail to link, on a missing ramdisk symbol,
# for reasons that look nothing like their cause. Put it back.
Write-Host "==> restoring the normal (disk-root) build" -ForegroundColor Cyan
Invoke-Make "rm -rf build/kernel build/lib build/cmd && make >/dev/null" | Out-Null
$mb = [Math]::Round((Get-Item $iso).Length / 1MB, 1)
Write-Host ""
Write-Host "==> $iso ($mb MB)" -ForegroundColor Green
Write-Host ""
Write-Host "VMware:" -ForegroundColor Cyan
Write-Host " New VM -> I will install the OS later -> Other / Other 64-bit"
Write-Host " CD/DVD -> Use ISO image file -> $iso, and tick Connect at power on"
Write-Host " Boot order: CD-ROM first (F2 at power on for the firmware setup)"
Write-Host ""
Write-Host " Set the VM to BIOS, not UEFI. SchOS's loader is 16-bit real"
Write-Host " mode and there is no EFI stub yet, so a UEFI-only VM will not boot."
Write-Host ""
Write-Host " Processors: as many as you like. SMP works as of 2026-08-08;"
Write-Host " check with 'cat /proc/cpuinfo', which lists the online ones."
Write-Host ""
Write-Host " RAM: 64 MB is plenty. The old 224 MB floor is gone."
if ($Run) {
Write-Host ""
Write-Host "==> booting the ISO under QEMU, no disk attached" -ForegroundColor Cyan
$log = Join-Path $root 'build/isoboot.log'
if (Test-Path $log) { Clear-Content $log }
$psi = New-Object System.Diagnostics.ProcessStartInfo
$psi.FileName = $Qemu
$psi.Arguments = @(
"-cdrom `"$iso`" -boot d"
'-m 256M -smp 1 -cpu qemu64,+rdtscp -machine pc-i440fx-9.2'
'-display none'
"-chardev stdio,id=c0,logfile=`"$log`""
'-serial chardev:c0'
'-no-reboot'
) -join ' '
$psi.RedirectStandardInput = $true
$psi.UseShellExecute = $false
$p = [System.Diagnostics.Process]::Start($psi)
Start-Sleep -Seconds 25
if (-not $p.HasExited) { $p.Kill() }
Start-Sleep -Milliseconds 600
$text = if (Test-Path $log) { Get-Content $log -Raw } else { "" }
if ($text -match 'init: ready') {
Write-Host "==> the ISO boots to a shell" -ForegroundColor Green
($text -split "`n" | Select-Object -First 12) | ForEach-Object { Write-Host " $_" -ForegroundColor DarkGray }
} else {
Write-Host "==> the ISO did NOT reach a shell" -ForegroundColor Red
Write-Host $text
Pop-Location
exit 1
}
}
Pop-Location