diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-11 00:06:30 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-11 01:16:48 -0300 |
| commit | c3d9f7ba5effd615374b1359ad98ecf801559f83 (patch) | |
| tree | 07f85932abc1df23c722bcd1bd1b3b65bca28f2e /anim/src/syscalls.zig | |
| parent | c94ade9e77a811d3ff75ffc2889a65375262ab1f (diff) | |
| download | computeranim-c3d9f7ba5effd615374b1359ad98ecf801559f83.tar.gz computeranim-c3d9f7ba5effd615374b1359ad98ecf801559f83.zip | |
canim: a call followed down to the kernel; rows that say what they do; the heap from the inside
From the user. The disassembly can descend: the syscalls scene is glibc's
hello by instruction, and open is followed from main through its PLT
stub, whose jmp reads the GOT, into libc's wrapper to the syscall row,
which crosses to the kernel's window under it, and back up. The band
keeps the calls so far as strace writes them. Operands lose their size
words and show a width as byte cells only where nothing else says it. A
compare shows its values and the flags it leaves, a jump the flags it
reads, lea its result, an indirect jump its target and the slot it read,
a call that has run its C form. The backtrace has its newest frame at
the bottom. A new scene shows glibc 2.44's heap from blocks that exist:
chunks read by fields (a size with its bits, a protected pointer), the
free list as arcs, the tcache in a loupe, the program's list over
malloc's own.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'anim/src/syscalls.zig')
| -rw-r--r-- | anim/src/syscalls.zig | 252 |
1 files changed, 77 insertions, 175 deletions
diff --git a/anim/src/syscalls.zig b/anim/src/syscalls.zig index e184990..4a46170 100644 --- a/anim/src/syscalls.zig +++ b/anim/src/syscalls.zig @@ -20,7 +20,6 @@ const Stage = @import("stage.zig").Stage; const theme = ui.theme; const time = theme.time; const Rect = ui.Rect; -const k = theme.color.on_kernel; /// A crossing's timetable, in seconds into its step (design/motion.md, "A /// system call"). Staging, one thing at a time and no effect before its @@ -156,11 +155,12 @@ pub fn fills(call: Recording.Syscall) ?Recording.Span { return if (call.nr == @intFromEnum(std.os.linux.SYS.read) and got > 0) .{ .addr = call.args[1], .len = @intCast(got) } else null; } -/// The kernel as a lens: solid vellum, and nothing else on the frame is. -/// The call the step made, decoded (its name, a row an argument by the -/// argument's own name, what came back), the calls before it, the bytes it -/// was given; and the arrow that crosses into it from the registers' -/// side and returns. +/// The `syscalls` lens: the program's conversation with the kernel. Its +/// drawing is the calls so far as strace writes them, a row each, oldest +/// on top and the newest at the bottom (its row comes in once the call is +/// back, with the turned corner); not the kernel, and not on vellum: the +/// kernel is under the program, the floor of the disassembly's `descent`. +/// Its view, the bytes the newest call was given or filled. pub const Crossing = struct { cursor: cursors.Cursor, stage: *const Stage, @@ -182,45 +182,78 @@ pub const Crossing = struct { defer u.unclip(); const now = c.cursor.now(placed); const rec = c.cursor.rec; - const body = u.panel(box.w, box.h, "kernel", .{ .focus = c.focus, .note = "the other side of a system call" }); - u.fill(.{ .x = theme.stroke.rule, .y = body.y, .w = body.w - 2 * theme.stroke.rule, .h = body.h - theme.stroke.rule }, theme.color.kernel); + const room = context.rowsOf(box); + // The calls from the scene's first moment: the program's, not its loader's. + var first: usize = 0; + while (first < rec.syscalls.len and rec.syscalls[first].enter < c.cursor.first) first += 1; + var newest = latest(rec, now.stops[0]); + // A crossing's own row comes in once it is back (rax struck), 12 f. + var arrives: f32 = 1; + if (newest) |n| if (inStep(now) != null and now.walking()) { + const p = Plan.of(rec.syscalls[n]); + arrives = std.math.clamp((now.time - p.struck - 6.0 / 60.0) / theme.time.quick, 0, 1); + }; + if (newest) |n| if (n < first) { + newest = null; + }; + const count = if (newest) |n| n + 1 - first else 0; + const body = u.panel(box.w, box.h, "system calls", .{ .focus = c.focus, .note = if (count > room) u.print("as strace writes them \u{00b7} newest at the bottom \u{00b7} {d} more above", .{count - room}) else "as strace writes them \u{00b7} newest at the bottom" }); context.clipBody(u, box); defer u.unclip(); - u.text(.sans, theme.size.sans.micro, 12, body.y + 22, "calls so far", k.dim); - const newest = latest(rec, now.stops[0]) orelse return; - const live = inStep(now) != null and now.walking(); - const p = Plan.of(rec.syscalls[newest]); - const t: f32 = if (live) now.time else std.math.inf(f32); - if (t >= p.enters) arrows(u, body, t, p, rec.syscalls[newest]); - // No effect before its cause: until the arrow is through the - // line the kernel knows nothing of this call, and shows the last. - if (t < p.name) { - if (newest > 0) c.call(u.faded(1 - theme.ease(.exit, std.math.clamp((t - p.leaves) / (p.name - p.leaves), 0, 1))), body, rec.syscalls[newest - 1], .{}, std.math.inf(f32)); - } else c.call(u, body, rec.syscalls[newest], p, t); + const n = newest orelse return; + const top = body.y + theme.metric.context.pad; + const shown = @min(count, room); + for (0..shown) |j| { + const i = n + 1 - shown + j; + const v = if (i == n) u.faded(arrives) else u; + const y = top + @as(f32, @floatFromInt(j)) * row_h; + logRow(v, rec, rec.syscalls[i], y, box.w - theme.metric.context.side); + if (i == n) v.corner(theme.metric.context.side, y + 2, theme.metric.context.corner, 1); + } + } - // The calls so far, newest on top. This one's row pushes in when - // the kernel has taken the call: the others make room first. - const pushed = cursors.standard(std.math.clamp((t - p.card) / theme.time.quick, 0, 1)); - const arrived = std.math.clamp((t - p.card - theme.time.snap) / theme.time.quick, 0, 1); - const top = body.y + 32; - var i = newest + 1; - while (i > 0) { - i -= 1; - const place = @as(f32, @floatFromInt(newest - i)) - (if (i == newest) 0 else 1 - pushed); - const y = top + place * (row_h + 4) - (if (i == newest) (1 - arrived) * 8 else 0); - if (y + row_h > body.y + body.h - 6) continue; - const v = if (i == newest) u.faded(arrived) else u; - const card: Rect = .{ .x = 12, .y = y, .w = 196, .h = row_h }; - const done = rec.syscalls[i]; - const gold = if (i == newest) arrived >= 1 else i + 1 == newest and arrived < 1; - if (gold) v.fill(card, theme.mark(.current).solid); - v.frame(card, k.ink, theme.stroke.rule); - const name = zt.syscalls.name(done.nr) orelse "?"; - // The result ranged right, when it is short; the name has the rest, and is cut only there. - const words = if ((i != newest or t >= p.returns) and done.exit != null) result(u, done) else ""; - const said = if (words.len > 0 and words.len <= 4) words else ""; - if (said.len > 0) v.text(.mono, size, card.x + card.w - 8 - u.width(.mono, size, said), theme.baseline(card.y, card.h, size), said, k.dim); - v.text(if (gold) .mono_bold else .mono, size, card.x + 8, theme.baseline(card.y, card.h, size), rows.fitted(u, name, card.w - 16 - (if (said.len > 0) u.width(.mono, size, said) + 12 else 0)), k.ink); + /// A call as strace writes it, its arguments by name: `read fd 3 + /// "note" buf 7fffffffecd0 count 32 = 15`, cut at `room` with `…`. + fn logRow(u: ui.Ui, rec: *const Recording, made: Recording.Syscall, y: f32, room: f32) void { + const base = theme.baseline(y, row_h, size); + const adv = ui.advance(size); + var x: f32 = theme.metric.context.side; + const name = zt.syscalls.name(made.nr) orelse "syscall"; + u.text(.mono_bold, size, x, base, name, theme.color.text.bright); + x += u.width(.mono_bold, size, name) + adv; + const names = zt.syscalls.names(made.nr); + const n = @min(zt.syscalls.signature(made.nr).len, 6); + const Part = struct { text: []const u8, ink: u24 }; + var parts: [32]Part = undefined; + var np: usize = 0; + for (0..n) |j| { + const what = if (j < names.len) names[j] else ""; + if (what.len > 0) { + parts[np] = .{ .text = what, .ink = theme.color.text.dim }; + np += 1; + } + parts[np] = .{ .text = @import("disasm.zig").argument(u, rec, made.enter, what, made.args[j]), .ink = theme.color.text.primary }; + np += 1; + if (std.mem.endsWith(u8, what, "fd")) { + const on = rec.openOn(u.f.scratch, made.args[j], made.enter); + if (on.len > 0) { + parts[np] = .{ .text = on, .ink = theme.color.text.faint }; + np += 1; + } + } + } + parts[np] = .{ .text = "=", .ink = theme.color.text.faint }; + np += 1; + parts[np] = .{ .text = if (made.exit != null) result(u, made) else "?", .ink = theme.color.text.primary }; + np += 1; + for (parts[0..np]) |part| { + const w = u.width(.mono, size, part.text); + if (x + w > room) { + u.text(.mono, size, x, base, "\u{2026}", theme.color.text.faint); + return; + } + u.text(.mono, size, x, base, part.text, part.ink); + x += w + adv; } } @@ -236,7 +269,8 @@ pub const Crossing = struct { newest = if (n > 0) n - 1 else null; }; const made: ?Recording.Syscall = if (newest) |n| rec.syscalls[n] else null; - const span: ?Recording.Span = if (made) |given| bufferRead(given) orelse fills(given) orelse if (given.text.len > 0 and std.mem.indexOfScalar(u8, zt.syscalls.signature(given.nr), 's') != null) .{ .addr = given.args[0], .len = given.text.len + 1 } else null else null; + const path_at: ?usize = if (made) |given| std.mem.indexOfScalar(u8, zt.syscalls.signature(given.nr), 's') else null; + const span: ?Recording.Span = if (made) |given| bufferRead(given) orelse fills(given) orelse if (given.text.len > 0 and path_at != null) .{ .addr = given.args[path_at.?], .len = given.text.len + 1 } else null else null; const scratch = context.at(f, placed, c.stage.box(placed, .view)); const about = if (span) |sp| scratch.print("the {s}, {x} to {x}", .{ if (bufferRead(made.?) != null) "buffer given" else if (fills(made.?) != null) "buffer filled" else "path given", sp.addr, sp.addr + sp.len - 1 }) else "the call names no bytes"; const v = hexdump.panel(f, placed, c.stage, about, &.{}); @@ -259,140 +293,8 @@ pub const Crossing = struct { }); v.veil(now); } - - /// A call, decoded: its name, a row for each argument, what came - /// back; and to the right the bytes it was given, as the kernel - /// copies them. - fn call(c: *const Crossing, u: ui.Ui, body: Rect, made: Recording.Syscall, p: Plan, t: f32) void { - const rec = c.cursor.rec; - const x = 236; - const name = zt.syscalls.name(made.nr) orelse "syscall"; - // The name arrives rising, as a caption does. - const named = theme.ease(.enter, std.math.clamp((t - p.name) / theme.time.quick, 0, 1)); - const title = u.faded(named); - const rise = (1 - named) * theme.time.caption_rise; - title.text(.mono_bold, theme.size.mono.value, x, body.y + 46 + rise, name, k.ink); - title.text(.sans, theme.size.sans.micro, x + u.width(.mono_bold, theme.size.mono.value, name) + 16, body.y + 44 + rise, u.print("system call {d}", .{made.nr}), k.dim); - const signature = zt.syscalls.signature(made.nr); - var row_y: f32 = body.y + 62; - var text_used = false; - const row = struct { - /// `note`: faint after the words, what a descriptor is open on (the `value` class `fd`). - fn draw(v: ui.Ui, y: f32, register: []const u8, meaning: []const u8, words: []const u8, note: []const u8) void { - v.fill(.{ .x = x, .y = y, .w = 300, .h = theme.stroke.rule }, k.rule); - const base = theme.baseline(y, row_h + 4, size); - v.text(.mono, size, x, base, register, k.dim); - v.text(.sans_medium, theme.size.sans.tag, x + 52, base, meaning, k.ink); - v.text(.mono, size, x + 130, base, words, k.ink); - v.text(.mono, size, x + 130 + v.width(.mono, size, words) + 8, base, note, k.dim); - } - }.draw; - for (signature, 0..) |kind, arg| { - if (arg >= 4) break; - const shows = std.math.clamp((t - p.rows - @as(f32, @floatFromInt(arg)) * Plan.row) / Plan.row, 0, 1); - const meaning = what(made.nr, kind, arg); - const note = if (std.mem.eql(u8, meaning, "fd")) rec.openOn(u.f.scratch, made.args[arg], made.enter) else ""; - row(u.faded(shows), row_y, carriers[arg], meaning, value(u, made, kind, arg, &text_used), note); - row_y += row_h + 4; - } - const back = t >= p.returns and made.exit != null; - // What `open` returns is a descriptor: open on the path it was given. - const opened = back and std.mem.eql(u8, zt.syscalls.name(made.nr) orelse "", "open") and @as(i64, @bitCast(made.result)) >= 0; - row(u.faded(std.math.clamp((t - p.rows - @as(f32, @floatFromInt(@min(signature.len, 4))) * Plan.row) / Plan.row, 0, 1)), row_y, "rax", "returns", if (back) result(u, made) else "\u{2014}", if (opened) rec.openOn(u.f.scratch, made.result, made.exit.? + 1) else ""); - - if (made.text.len == 0) return; - const bytes_x = 564; - const framed = u.faded(std.math.clamp((t - p.work) / Plan.row, 0, 1)); - framed.text(.sans, theme.size.sans.micro, bytes_x, body.y + 22, if (std.mem.indexOfScalar(u8, signature, 's') != null) "the path it was given" else "the bytes it was given", k.dim); - const shown = @min(made.text.len, shown_bytes); - const text = for (made.text[0..shown]) |byte| { - if (!std.ascii.isPrint(byte) and byte != '\n') break false; - } else true; - for (made.text[0..shown], 0..) |byte, j| { - const cell: Rect = .{ .x = bytes_x + @as(f32, @floatFromInt(j % per_row)) * 28, .y = body.y + 32 + @as(f32, @floatFromInt(j / per_row)) * 30, .w = 26, .h = 26 }; - // Each fills as it is copied, two frames a byte: struck, then held. - const since = t - p.fills - @as(f32, @floatFromInt(j)) * Plan.byte; - if (since < 0) { - framed.frame(cell, k.rule, theme.stroke.rule); - continue; - } - const in = std.math.clamp(since / theme.time.strike.in, 0, 1); - u.fill(cell, ui.mix(theme.color.kernel, ui.mix(theme.mark(.write).solid, k.held, std.math.clamp((since - theme.time.quick) / theme.time.strike.cool, 0, 1)), in)); - u.frame(cell, k.ink, theme.stroke.rule); - if (in < 0.5) continue; - // Text as its characters; anything else (a page of a file) as hex. - if (!text) { - u.label(.mono, size, cell, .center, u.print("{x:0>2}", .{byte}), k.ink); - } else if (std.ascii.isPrint(byte) and byte != ' ') u.label(.mono, size, cell, .center, &.{byte}, k.ink) else if (byte == '\n') u.label(.mono, size, cell, .center, "\\n", k.dim); - } - } - - /// The crossing itself: in from the side the registers are on as the - /// call enters, and back out as it returns. Vellum outside the - /// kernel, ink inside it. Machines do not lob: straight. - /// The crossing itself: up out of the registers below the band (the - /// ones that carried it), into the kernel, as the call enters; and back - /// down as it returns. Machines do not lob: straight. - fn arrows(u: ui.Ui, body: Rect, t: f32, p: Plan, made: Recording.Syscall) void { - // At the drawing's right, where it meets the state column the call leaves from. - const x = body.w - 56; - const bottom = body.y + body.h; - const reach = 64; - // Off promptly, and settling in the kernel. - const up = cursors.standard(std.math.clamp((t - p.enters) / Plan.cross, 0, 1)); - const gone = std.math.clamp((t - p.struck - theme.time.quick) / theme.time.read.out, 0, 1); - const v = u.faded(1 - gone); - if (t < p.back) along(v, x, bottom, bottom - up * reach); - if (made.exit != null and t > p.back) along(v, x + 40, bottom - reach, bottom - reach + cursors.standard(std.math.clamp((t - p.back) / Plan.cross, 0, 1)) * reach); - } - - /// An arrow down the column at `x` from `from` to `to`, in ink: it is inside the kernel. - fn along(u: ui.Ui, x: f32, from: f32, to: f32) void { - if (@abs(to - from) < 1) return; - const w = theme.stroke.arrow; - const head = theme.stroke.flow_head; - const dir: f32 = if (to > from) 1 else -1; - const neck = to - dir * (head[0] - 2); - if ((neck - from) * dir > 0) u.fill(.{ .x = x - w / 2, .y = @min(from, neck), .w = w, .h = @abs(neck - from) }, k.ink); - if (@abs(to - from) < head[0]) return; - sk.draw.polygon(u.f, &.{ .{ x, to }, .{ x - head[1] / 2, to - dir * head[0] }, .{ x + head[1] / 2, to - dir * head[0] } }, u.at.pen(.{ .fill = ui.rgb(k.ink) })); - } }; -/// What an argument is called: by the call's own names where the tracer's -/// table has them, else from its letter in `zt.syscalls.signature`. -fn what(nr: u16, kind: u8, arg: usize) []const u8 { - const names = zt.syscalls.names(nr); - if (arg < names.len) return names[arg]; - return switch (kind) { - 'i' => "number", - 'd' => "size", - 's' => "path", - 'b' => "buffer", - else => "pointer", - }; -} - -fn value(u: ui.Ui, made: Recording.Syscall, kind: u8, arg: usize, text_used: *bool) []const u8 { - // Flags and a mode are bits: hex, said so. - const meaning = what(made.nr, kind, arg); - if (std.mem.eql(u8, meaning, "flags") or std.mem.eql(u8, meaning, "mode")) return u.print("0x{x}", .{made.args[arg]}); - const a = made.args[arg]; - switch (kind) { - 'i' => return u.print("{d}", .{@as(i32, @bitCast(@as(u32, @truncate(a))))}), - 'd' => return u.print("{d}", .{a}), - 's' => if (made.text.len > 0 and !text_used.*) { - text_used.* = true; - const base = std.fs.path.basename(made.text); - // A string cut says so: `…` and no closing quote. - return if (base.len <= 14) u.print("\"{s}\"", .{base}) else u.print("\"{s}\u{2026}", .{base[0..13]}); - }, - else => {}, - } - return u.print("{x}", .{a}); -} - - /// What came back: a count, an address, or an error by name. fn result(u: ui.Ui, made: Recording.Syscall) []const u8 { const ret: i64 = @bitCast(made.result); |
