nexoniarz/SchOS
nexoniarz/SchOS
Watch
1
0
Fork
You've already forked SchOS
 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

tools: group scripts by what runs them

Browse source 
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
Download patch file Download diff file Expand all files Collapse all files

161
tools/splashshot.ps1
View file

@ -1,161 +0,0 @@
# Photograph the boot splash.
#
# The splash is on screen from the moment stage2 draws it until
# console_takeover() clears it at the first exec(), which is a window of a
# couple of seconds -- so a single screendump at a guessed delay is a coin
# flip. This takes a burst instead and keeps every frame, which makes the
# question "what does boot actually look like, second by second" answerable
# rather than a matter of catching it at the right instant.
#
# Same shape as tools/crashshot.ps1: monitor on TCP because QEMU on Windows has
# no unix sockets, serial to a logfile so the transcript survives.
#
# tools/splashshot.ps1 frames every 400ms for 8s
# tools/splashshot.ps1 -Every 200 -For 4
param(
[int]$Every = 400, # milliseconds between frames
[int]$For = 8, # seconds to keep capturing
[string]$OutDir = "build/shots",
[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'
$root = Split-Path $PSScriptRoot -Parent
$log = Join-Path $root 'build/splashshot.log'
$dir = Join-Path $root $OutDir
Remove-Item -Recurse -Force $dir -ErrorAction SilentlyContinue
New-Item -ItemType Directory -Force $dir | Out-Null
Remove-Item -Force $log -ErrorAction SilentlyContinue
$hda = Join-Path $root 'schos.img'
# The root filesystem. SchFS is the only root there is: the kernel mounts
# device 1 in forkret() and panics if it is not a SchFS volume, so this is
# not a choice and there is no -SchFS switch any more. It used to default to
# build/fs.img, which stopped being bootable the moment SchFS became root.
$hdb = Join-Path $root 'build/schfs.img'
$monPort = 55556 # not crashshot's port, so the two can run back to back
$psi = New-Object System.Diagnostics.ProcessStartInfo
$psi.FileName = $Qemu
$psi.Arguments = @(
# -snapshot with file.locking=off, rather than booting from copies. QEMU
# takes an exclusive lock on its drive images, so an interactive session the
# developer already has open would otherwise make this fail with "Failed to
# get write lock" -- and a capture script is exactly the thing you want to
# run without first shutting down what you were looking at. Copying was the
# first fix and it meant duplicating build/fs.img, all 153 MB of it, on
# every run. -snapshot keeps writes in a temporary overlay, so the originals
# are untouched either way.
"-drive file=`"$hda`",format=raw,index=0,media=disk,file.locking=off"
"-drive file=`"$hdb`",format=raw,index=1,media=disk,file.locking=off"
'-snapshot'
'-m 1G -smp 1 -cpu qemu64,+rdtscp -machine pc-i440fx-9.2'
'-display none'
"-chardev stdio,id=c0,logfile=`"$log`""
'-serial chardev:c0'
"-monitor tcp:127.0.0.1:$monPort,server,nowait"
) -join ' '
$psi.RedirectStandardInput = $true
$psi.UseShellExecute = $false
Write-Host "==> booting" -ForegroundColor Cyan
$p = [System.Diagnostics.Process]::Start($psi)
$frames = @()
try {
# Connect immediately -- the interesting frames are the early ones, so any
# fixed warm-up sleep here is time spent missing them.
$client = $null
for ($i = 0; $i -lt 40 -and -not $client; $i++) {
try { $client = New-Object System.Net.Sockets.TcpClient('127.0.0.1', $monPort) }
catch { Start-Sleep -Milliseconds 100 }
}
if (-not $client) { throw "could not reach the QEMU monitor on port $monPort" }
$writer = New-Object System.IO.StreamWriter($client.GetStream())
$writer.AutoFlush = $true
$n = [int](($For * 1000) / $Every)
$sw = [System.Diagnostics.Stopwatch]::StartNew()
for ($i = 0; $i -lt $n; $i++) {
$ms = [int]$sw.ElapsedMilliseconds
$f = Join-Path $dir ("{0:d5}ms.ppm" -f $ms)
$writer.WriteLine("screendump $f")
$frames += $f
Start-Sleep -Milliseconds $Every
}
$writer.WriteLine('quit')
Start-Sleep -Milliseconds 500
$client.Close()
} finally {
if (-not $p.HasExited) { $p.Kill() }
Start-Sleep -Milliseconds 800
}
# Report each frame by its distinct-colour count. Two colours means a text
# console (or a blank screen); an anti-aliased logo pushes it into the dozens.
# The same reason the full-stack harness counted pixels rather than log lines: a capture
# that exists is not a capture that drew anything.
Write-Host "==> frames" -ForegroundColor Cyan
$kept = 0
foreach ($f in $frames) {
if (-not (Test-Path $f)) { continue }
$kept++
$b = [System.IO.File]::ReadAllBytes($f)
# PPM P6: "P6\n<w> <h>\n255\n" then raw RGB. Skip three whitespace-run
# separated header fields rather than assuming a fixed header length --
# QEMU's is compact but that is not guaranteed.
$pos = 2; $fields = 0
while ($fields -lt 3 -and $pos -lt $b.Length) {
while ($pos -lt $b.Length -and [char]$b[$pos] -match '\s') { $pos++ }
while ($pos -lt $b.Length -and [char]$b[$pos] -notmatch '\s') { $pos++ }
$fields++
}
$pos++
$seen = @{}
for ($i = $pos; $i + 2 -lt $b.Length; $i += 3 * 7) { # sample every 7th pixel
$seen[($b[$i] -shl 16) -bor ($b[$i+1] -shl 8) -bor $b[$i+2]] = 1
}
$name = Split-Path $f -Leaf
$c = $seen.Count
$tag = if ($c -ge 16) { 'graphical' } elseif ($c -le 3) { 'flat/text' } else { 'sparse' }
$col = if ($c -ge 16) { 'Green' } else { 'DarkGray' }
Write-Host (" {0,-12} {1,4} colours {2}" -f $name, $c, $tag) -ForegroundColor $col
}
if ($kept -eq 0) { Write-Host "FAIL: no frames captured" -ForegroundColor Red; exit 1 }
Write-Host "==> $kept frames in $dir" -ForegroundColor Green
# Convert to PNG if ImageMagick is around, so they can just be looked at.
if (Get-Command magick -ErrorAction SilentlyContinue) {
foreach ($f in $frames) {
if (Test-Path $f) { & magick $f ([System.IO.Path]::ChangeExtension($f, '.png')) }
}
Write-Host "==> PNGs alongside" -ForegroundColor Green
}