diff options
Diffstat (limited to 'anim/src/descent.zig')
| -rw-r--r-- | anim/src/descent.zig | 620 |
1 files changed, 620 insertions, 0 deletions
diff --git a/anim/src/descent.zig b/anim/src/descent.zig new file mode 100644 index 0000000..302de38 --- /dev/null +++ b/anim/src/descent.zig @@ -0,0 +1,620 @@ +//! `descent` (design/README.md, "3. Panels"): the disassembly a level up, +//! a call followed down. The panel is a stack of windows, one a call deep: +//! the scene's function's on top, each callee's under the row that called +//! it (that row `waiting`, ringed; a PLT stub gone through keeps its `jmp`, +//! `pass`), a head row over each, the call lane from ring to head; and +//! under the deepest, while a system call crosses, the kernel on vellum. +//! Down is deeper, and the way back up is drawn. +//! +//! Every row has a key (an instruction's address, a head's function), so +//! the panel at one moment and at the next are two lists of the same +//! rows: a step is the rows both have gliding, and the others leaving or +//! arriving, on the timetable of its verb (`descend`, `ascend`, `cross`; +//! design/motion.md, "A call followed down", "A system call"). +const std = @import("std"); +const sk = @import("sketch"); +const anim = @import("anim"); +const ui = @import("ui.zig"); +const rows = @import("rows.zig"); +const cursors = @import("cursor.zig"); +const Recording = @import("Recording.zig"); +const ties = @import("ties.zig"); +const map = @import("map.zig"); +const context = @import("context.zig"); +const disasm = @import("disasm.zig"); +const syscalls = @import("syscalls.zig"); +const Stage = @import("stage.zig").Stage; +const theme = ui.theme; +const Rect = ui.Rect; +const t = theme.color.text; +const k = theme.color.on_kernel; +const m = theme.metric.context; +const c = theme.metric.insn; +const size = theme.size.mono.context; +const adv = size * 3 / 5; +const Insn = disasm.Insn; + +/// Frames at 60 a second, as motion.md counts them. +fn f(n: f32) f32 { + return n / 60.0; +} + +fn clamp01(v: f32) f32 { + return std.math.clamp(v, 0, 1); +} + +/// One step of `by` from where the cursor is, timed as its verb +/// (design/motion.md, "A call followed down"): into a call (`descend`, 2.7 +/// s), on through a PLT stub's `jmp` (2.0 s), out by a `ret` (`ascend`, 2.3 +/// s), across into the kernel (`cross`: `syscalls.step`); any other walked. +pub fn step(cur: cursors.Cursor, s: *anim.Frame, by: Recording.Stop) void { + const rec = cur.rec; + const from = cur.moment(s); + const to = rec.next(by, from); + for (rec.syscalls) |made| if (made.enter > from and made.enter <= to) return syscalls.step(cur, s, by); + if (to != from + 1) return cur.walk(s, by, to); + const b = rec.insn_branches[from] orelse return cur.walk(s, by, to); + var name_buf: [256]u8 = undefined; + const here = (rec.moment(from).string(rec.register(from, "rip"), &name_buf) catch null) orelse ""; + const plan: cursors.Plan = switch (b.kind) { + .call => .{ .at = .{ f(24), f(60), f(60) }, .advance = f(126), .travel = f(12), .total = f(162) }, + .ret => .{ .at = .{ f(36), f(18), f(36) }, .advance = f(102), .travel = f(12), .total = f(138) }, + .jump => if (std.mem.indexOf(u8, here, "@plt") != null) .{ .at = .{ f(18), f(24), f(24) }, .advance = f(84), .travel = f(12), .total = f(120) } else return cur.walk(s, by, to), + .none => return cur.walk(s, by, to), + }; + cur.step(s, to, plan, plan.total); +} + +/// A row of the panel. +const Item = struct { + key: u64, + row: f32, + /// The window it is in, 0 the top. + window: u8, + what: union(enum) { insn: Insn, head: struct { name: []const u8, note: []const u8 }, more: []const u8 }, + state: enum { plain, waiting, pass, current } = .plain, + /// A waiting or passed row: the moment it ran. + at: u64 = 0, +}; + +/// The panel at a moment. +const Layout = struct { + items: []Item, + /// Windows of code (a fold counts as none). + windows: usize, + /// The bottom three rows are the kernel's (the pc is at, or has just + /// come back from, a `syscall`). + kernel: bool, + /// The deepest function and its module: the panel's tag. + tag: []const u8, + in_stub: bool, +}; + +pub const Descent = struct { + cursor: cursors.Cursor, + stage: *const Stage, + focus: bool = false, + /// The function whose window is on top: where the scene follows from. + root: []const u8 = "main", + + pub fn draw(d: *const Descent, fr: *sk.Frame, placed: anim.Placed) void { + const box = d.stage.box(placed, .disasm); + const u = context.at(fr, placed, box); + const now = d.cursor.now(placed); + const rec = d.cursor.rec; + const room = theme.layout.rowsIn(box.h); + const before = layout(u, rec, now.stops[1], room, d.root); + const after = layout(u, rec, now.stops[0], room, d.root); + const tm = now.time; + const going = now.advancing(); + const kind: enum { same, down, through, up } = if (now.resting() or now.stops[0] == now.stops[1]) .same else if (after.windows > before.windows) (if (before.in_stub) .through else .down) else if (after.windows < before.windows) .up else .same; + const shown = if (going >= 0.5) after else before; + const body = u.panel(box.w, box.h, "disassembly", .{ .focus = d.focus, .note = shown.tag }); + const top = body.y + m.pad; + u.clip(.{ .x = theme.stroke.rule, .y = m.tag, .w = box.w - 2 * theme.stroke.rule, .h = box.h - m.tag - theme.stroke.rule }); + defer u.unclip(); + + // How far the rows both lists have are on their way, and how much + // of each that leaves or comes shows: the verb's timetable. + const move: f32 = switch (kind) { + .same => cursors.glide(going), + .down => cursors.glide(clamp01((tm - f(72)) / f(18))), + .through => cursors.glide(clamp01((tm - f(24)) / f(18))), + .up => cursors.glide(clamp01((tm - f(84)) / f(18))), + }; + const Placed = struct { item: Item, y: f32, shows: f32, rise: f32, old: ?Item, new: ?Item }; + var placed_items: std.ArrayList(Placed) = .empty; + const a = u.f.scratch; + // Leaving: bottom up when a window closes, all at once when a caller gives up rows. + var leaving: usize = 0; + var i = before.items.len; + while (i > 0) { + i -= 1; + const it = before.items[i]; + if (find(after.items, it.key)) |_| continue; + const shows: f32 = switch (kind) { + .same => 1 - clamp01(2 * going), + .down => 1 - clamp01((tm - f(66)) / f(12)), + .through => 1 - clamp01((tm - f(24)) / f(12)), + .up => 1 - clamp01((tm - f(48) - @as(f32, @floatFromInt(leaving)) * f(2)) / f(12)), + }; + leaving += 1; + placed_items.append(a, .{ .item = it, .y = top + it.row * m.row, .shows = shows, .rise = 0, .old = it, .new = null }) catch {}; + } + // Arriving: a head rising, then its rows top down, 2 f apart. + var arriving: usize = 0; + for (after.items) |it| { + if (find(before.items, it.key)) |old| { + const y = top + std.math.lerp(old.row, it.row, move) * m.row; + // Going up the rows keep what they were (the ring) until the advance. + const now_item = switch (kind) { + .same, .up => if (going >= 0.5) it else old, + // The call row is current until its plaque becomes the ring; a stub's jmp until it passes. + .down => if (tm >= f(72)) it else old, + .through => if (tm >= f(24)) it else old, + }; + placed_items.append(a, .{ .item = now_item, .y = y, .shows = 1, .rise = 0, .old = old, .new = it }) catch {}; + continue; + } + const head = it.what == .head; + const shows: f32 = switch (kind) { + .same => clamp01(2 * going - 1), + .down => if (head) clamp01((tm - f(96)) / f(12)) else clamp01((tm - f(102) - @as(f32, @floatFromInt(arriving)) * f(2)) / f(12)), + .through => if (head) clamp01((tm - f(54)) / f(12)) else clamp01((tm - f(60) - @as(f32, @floatFromInt(arriving)) * f(2)) / f(12)), + .up => clamp01((tm - f(84)) / f(18)), + }; + if (!head) arriving += 1; + placed_items.append(a, .{ .item = it, .y = top + it.row * m.row, .shows = shows, .rise = if (head and kind != .same) (1 - cursors.standard(shows)) * theme.time.caption_rise else 0, .old = null, .new = it }) catch {}; + } + std.mem.sort(Placed, placed_items.items, {}, struct { + fn above(_: void, x: Placed, y: Placed) bool { + return x.y < y.y; + } + }.above); + + // The marks: the pc's plaque, leaving the row it was on and landing + // on the next; the ring on a waiting call; a passed stub's bar. + const marked = now.marks[if (going >= 0.5) 1 else 0]; + const plaque = [2]f32{ + // The one it leaves: in a descend it becomes the ring (72 to 84 f), + // through a stub the pass bar (24 to 36), up it closes with its window. + switch (kind) { + .same => 1, + .down => 1 - clamp01((tm - f(72)) / f(12)), + .through => 1 - clamp01((tm - f(24)) / f(12)), + .up => 1 - clamp01((tm - f(48)) / f(12)), + }, + // The one it lands on, with the advance. + if (kind == .same) 1 else clamp01(going * 2), + }; + var pc_y = [2]?f32{ null, null }; + for (placed_items.items) |p| { + if (p.old) |o| if (o.state == .current) { + pc_y[0] = p.y; + }; + if (p.new) |n| if (n.state == .current) { + pc_y[1] = p.y; + }; + } + // In one window the plaque slides from row to row, with the advance. + var mark: ?struct { y: f32, shows: f32 } = null; + if (kind == .same) { + if (pc_y[0] != null and pc_y[1] != null) mark = .{ .y = std.math.lerp(pc_y[0].?, pc_y[1].?, cursors.standard(going)), .shows = 1 } else if (pc_y[1]) |y| { + mark = .{ .y = y, .shows = clamp01(2 * going - 1) }; + } else if (pc_y[0]) |y| { + mark = .{ .y = y, .shows = 1 - clamp01(2 * going) }; + } + } + const fire = now.fires(.disasm); + if (mark) |mk| plaqueAt(u, box.w, mk.y, mk.shows, fire) else { + if (pc_y[0]) |y| if (going < 0.5) plaqueAt(u, box.w, y, plaque[0], fire); + if (pc_y[1]) |y| if (going >= 0.5) plaqueAt(u, box.w, y, plaque[1], 0); + } + + // Which rows ran in the last three steps: the trail. + const ran = recentRows(a, now, if (going >= 0.5) 0 else 1); + const current_line = rec.own[marked]; + const widen0 = rows.numberRoom(rec.line_count); + var covered: usize = 0; + var runs: disasm.Runs = .{}; + var last_line: ?u32 = null; + var last_window: ?u8 = null; + const dd: disasm.Disasm = .{ .cursor = d.cursor, .stage = d.stage }; + const base: usize = if (going >= 0.5) 0 else 1; + for (placed_items.items) |p| { + const v = u.faded(p.shows); + const y = p.y + p.rise; + if (p.shows <= 0) continue; + if (last_window == null or last_window.? != p.item.window) last_line = null; + last_window = p.item.window; + switch (p.item.what) { + .head => |h| { + v.fill(.{ .x = theme.stroke.rule, .y = y, .w = box.w - 2 * theme.stroke.rule, .h = theme.stroke.rule }, theme.color.rule); + v.text(.sans_medium, theme.size.sans.micro, c.address, y + 18, h.name, t.primary); + v.text(.sans, theme.size.sans.micro, box.w - m.side - v.width(.sans, theme.size.sans.micro, h.note), y + 18, h.note, t.faint); + covered -|= 1; + }, + .more => |words| { + _ = v.arrow(c.address, y + m.row / 2, .more); + v.text(.mono, size, c.address + m.arrow_w + adv, rows.baseline(y), words, t.faint); + covered -|= 1; + }, + .insn => |row| { + const window_items = windowOf(placed_items.items, p.item.window); + var addrs: [80]u64 = undefined; + var n: usize = 0; + for (window_items) |w| if (w.item.what == .insn and n < addrs.len) { + addrs[n] = w.item.key; + n += 1; + }; + const lead = ui.shared(addrs[0..n]); + const wide = @as(f32, @floatFromInt(@max(ui.digits(row.addr), 7) - 7)) * adv; + const line = if (row.outside) null else row.line; + const state: disasm.Disasm.State = switch (p.item.state) { + // The row the plaque has not reached yet is ahead. + .current => if (p.old == null or p.old.?.state != .current) (if (going >= 0.5) .current else .ahead) else if (p.new == null or p.new.?.state != .current) (if (going < 0.5) .current else .ahead) else .current, + .waiting => .{ .waiting = p.item.at }, + .pass => .{ .ran = .{ .k = 0, .at = p.item.at } }, + .plain => if (ranOf(ran, row.addr)) |r| .{ .ran = r } else .ahead, + }; + // The marks at the row's left: the trail, the ring, the pass. + switch (p.item.state) { + .plain => if (ranOf(ran, row.addr)) |r| v.trail(c.mark, y, r.k), + .pass => v.trail(c.mark, y, 0), + .waiting => { + // The ring comes as the plaque leaves; going up it becomes a trail bar. + const ring: f32 = if (p.old != null and p.old.?.state == .waiting) (if (kind == .up) 1 - clamp01((tm - f(102)) / f(12)) else 1) else if (kind == .down) clamp01((tm - f(72)) / f(12)) else 1; + ringAt(v.faded(ring), y); + if (ring < 1) v.faded(1 - ring).trail(c.mark, y, 0); + }, + .current => {}, + } + runs.add(line != null and line.? == current_line, y, y + m.row); + const hangs = dd.insn(v, now, row, y, box.w, widen0 + wide, line, line != last_line, current_line, lead, state, base, covered > 0, .{ addrs[0], addrs[n -| 1] }, null); + covered = @max(covered -| 1, hangs); + last_line = line; + map.row(.disasm, row.addr, u, .{ .x = 0, .y = y, .w = box.w, .h = m.row }); + }, + } + } + runs.add(false, box.h, box.h); + disasm.threadRuns(u, box.w, .{ .{}, runs }, 1); + + // The call lane: from each waiting ring (or passed jmp) down to the + // head of the window under it, turning in to its name. + for (placed_items.items) |p| { + if (p.item.what != .head or p.item.window == 0) continue; + const from = for (placed_items.items) |q| { + if (q.item.window + 1 == p.item.window and (q.item.state == .waiting or q.item.state == .pass)) break q; + } else continue; + const drawn: f32 = if (p.old != null and p.new != null) 1 else if (p.new != null) switch (kind) { + .down => clamp01((tm - f(84)) / f(18)), + .through => clamp01((tm - f(42)) / f(18)), + else => clamp01(2 * going - 1), + } else switch (kind) { + .up => 1 - clamp01((tm - f(72)) / f(12)), + else => 1 - clamp01(2 * going), + }; + if (drawn <= 0) continue; + const ya = from.y + m.row - 3; + const yb = p.y + m.row / 2; + u.route(&.{ .{ 14, ya }, .{ 14, yb }, .{ c.address - 4, yb } }, t.primary, .{ .width = theme.stroke.rule, .head = .{ 7, 8 }, .radius = 4, .progress = cursors.standard(drawn) }); + } + map.window(.disasm, first(shown), last(shown)); + if (pc_y[1] orelse pc_y[0]) |y| ties.anchor(u, .pc, .{ .x = 0, .y = y, .w = theme.metric.plaque.pc, .h = m.row }); + kernel(u, now, box, top, room, pc_y[0] orelse pc_y[1]); + context.veiled(u, box, now.veil); + } +}; + +/// The pc's plaque on the row at `y`. +fn plaqueAt(u: ui.Ui, w: f32, y: f32, shows: f32, fire: f32) void { + if (shows <= 0) return; + const v = u.faded(shows); + v.current(.{ .x = theme.stroke.rule, .y = y, .w = w - 2 * theme.stroke.rule, .h = m.row }, theme.metric.plaque.pc, fire); + sk.draw.polygon(u.f, &.{ .{ 20, y + m.row / 2 }, .{ 10, y + 6 }, .{ 10, y + m.row - 6 } }, v.at.pen(.{ .fill = ui.rgb(theme.mark(.current).on_solid) })); +} + +/// `waiting`: the plaque's place ringed, a 2-unit primary frame 24 by 24 +/// with a primary head in it, as a waiting call node is; no wash. +fn ringAt(u: ui.Ui, y: f32) void { + u.frame(.{ .x = c.mark + 1, .y = y + 1, .w = 22, .h = 22 }, t.primary, theme.stroke.rule); + sk.draw.polygon(u.f, &.{ .{ 19, y + m.row / 2 }, .{ 10, y + 7 }, .{ 10, y + m.row - 7 } }, u.at.pen(.{ .fill = ui.rgb(t.primary) })); +} + +fn find(items: []const Item, key: u64) ?Item { + for (items) |it| if (it.key == key) return it; + return null; +} + +fn windowOf(items: anytype, window: u8) @TypeOf(items) { + var lo: usize = items.len; + var hi: usize = 0; + for (items, 0..) |p, j| if (p.item.window == window) { + lo = @min(lo, j); + hi = j + 1; + }; + return if (lo < hi) items[lo..hi] else items[0..0]; +} + +fn first(l: Layout) u64 { + for (l.items) |it| if (it.what == .insn) return it.key; + return 0; +} + +fn last(l: Layout) u64 { + var out: u64 = 0; + for (l.items) |it| if (it.what == .insn) { + out = it.key; + }; + return out; +} + +const Ran = disasm.Disasm.Ran; +const RanRow = struct { addr: u64, ran: Ran }; + +/// The rows the last three steps ran (`base`: 1 while the mark is still +/// on the step's first row), the newest step's mark on each. +fn recentRows(a: std.mem.Allocator, now: cursors.Now, base: usize) []const RanRow { + var out: std.ArrayList(RanRow) = .empty; + for (0..3) |s| { + const from = now.stops[@min(base + 1 + s, now.stops.len - 1)]; + const to = now.stops[base + s]; + var at = to; + while (at > from and to - at < 512) { + at -= 1; + const pc = now.rec.register(at, "rip"); + if (ranOf(out.items, pc) == null) out.append(a, .{ .addr = pc, .ran = .{ .k = s, .at = at } }) catch break; + // A return marks the call it comes back from: it has run, with its result. + if (now.rec.insn_branches[at]) |b| if (b.kind == .ret) { + var buf: [256]u8 = undefined; + const after = now.rec.instruction(at, b.to, &buf) orelse continue; + if (after.back == 0) continue; + const call = b.to - after.back; + if (ranOf(out.items, call) == null) out.append(a, .{ .addr = call, .ran = .{ .k = s, .at = madeAt(now.rec, at, call) } }) catch break; + }; + } + } + return out.items; +} + +fn ranOf(list: []const RanRow, addr: u64) ?Ran { + for (list) |r| if (r.addr == addr) return r.ran; + return null; +} + +/// A level of the descent: a function's window. +const Level = struct { at: u64, kind: enum { caller, pass, deepest }, name: []const u8, moment: u64 = 0 }; + +/// The panel at moment `i`, `room` rows: the root's window on top, a +/// window a call deep under it, the deepest round the pc, three at most +/// (a longer chain keeps the first and the last two, the rest one row). +fn layout(u: ui.Ui, rec: *const Recording, i: u64, room: usize, root: []const u8) Layout { + const a = u.f.scratch; + var items: std.ArrayList(Item) = .empty; + const pc = rec.register(i, "rip"); + var buf: [24]context.Frame = undefined; + const chain = context.frames(rec, i, &buf); + var r: usize = 0; + for (chain, 0..) |fr, j| if (std.mem.eql(u8, context.frameName(u, rec, fr.pc), root)) { + r = j; + break; + }; + var levels: [24]Level = undefined; + var n: usize = 0; + var j = r; + while (j > 0 and n + 2 < levels.len) : (j -= 1) { + const call = callBefore(u, rec, i, chain[j].pc) orelse break; + levels[n] = .{ .at = call.addr, .kind = .caller, .name = context.frameName(u, rec, chain[j].pc), .moment = madeAt(rec, i, call.addr) }; + n += 1; + // Through a stub to a function that is not it: the stub's jmp, passed. + if (disasm.target(call)) |to| { + const stub = context.frameName(u, rec, to); + if (std.mem.endsWith(u8, stub, "@plt") and !std.mem.eql(u8, stub, context.frameName(u, rec, chain[j - 1].pc))) { + levels[n] = .{ .at = to, .kind = .pass, .name = stub, .moment = madeAt(rec, i, to) }; + n += 1; + } + } + } + const here = context.frameName(u, rec, pc); + const in_stub = std.mem.endsWith(u8, here, "@plt"); + levels[n] = .{ .at = pc, .kind = .deepest, .name = here }; + n += 1; + // Folded past three windows: the first, then a row of `more`, then the last two. + var fold: []const u8 = ""; + var kept: []const Level = levels[0..n]; + var kept_buf: [3]Level = undefined; + if (n > 3) { + fold = u.print("{d} calls:", .{n - 3}); + for (levels[1 .. n - 2]) |l| fold = u.print("{s} {s}", .{ fold, l.name }); + kept_buf = .{ levels[0], levels[n - 2], levels[n - 1] }; + kept = &kept_buf; + } + // At a `syscall`, or just back from one: the floor is the kernel's. + const at_syscall = isSyscall(rec, i, pc) or (i > 0 and isSyscall(rec, i - 1, rec.register(i - 1, "rip")) and rec.register(i - 1, "rip") + 2 == pc); + var fixed: usize = if (at_syscall and kept.len > 1) 3 else 0; + for (kept, 0..) |l, li| { + if (li > 0) fixed += 1; + fixed += switch (l.kind) { + .caller => 3, + .pass => 1, + .deepest => 0, + }; + } + if (fold.len > 0) fixed += 1; + const remaining = room -| fixed; + const deepest_rows = if (kept.len == 1) room else if (in_stub) @min(remaining, stubRows(rec, i, pc)) else remaining; + const extra = remaining -| deepest_rows; + var row: f32 = 0; + var tag: []const u8 = ""; + for (kept, 0..) |l, li| { + const window: u8 = @intCast(li); + if (li == 1 and fold.len > 0) { + items.append(a, .{ .key = std.hash.Wyhash.hash(1, fold), .row = row, .window = window, .what = .{ .more = fold } }) catch {}; + row += 1; + } + if (li > 0) { + items.append(a, .{ .key = std.hash.Wyhash.hash(0, l.name) | 1 << 63, .row = row, .window = window, .what = .{ .head = .{ .name = l.name, .note = headNote(u, rec, i, l) } } }) catch {}; + row += 1; + } + const nearest = li + 2 == kept.len and l.kind == .caller; + const count: usize = switch (l.kind) { + .caller => 3 + if (nearest) extra else 0, + .pass => 1, + .deepest => deepest_rows, + }; + const above: usize = switch (l.kind) { + .caller => (count - 1) / 2, + .pass => 0, + // Under a `syscall` four rows hold its arguments. + .deepest => if (in_stub) 0 else if (isSyscall(rec, i, pc) and count > 5) count - 5 else (count -| 1) / 2, + }; + const list = disasm.listingAt(u, rec, i, l.at, count, above); + for (list.rows, 0..) |insn, q| { + const on = q == list.pc; + items.append(a, .{ .key = insn.addr, .row = row + @as(f32, @floatFromInt(q)), .window = window, .what = .{ .insn = insn }, .state = if (!on) .plain else switch (l.kind) { + .caller => .waiting, + .pass => .pass, + .deepest => .current, + }, .at = l.moment }) catch {}; + } + row += @floatFromInt(count); + if (l.kind == .deepest) tag = if (kept.len == 1) l.name else u.print("{s} \u{00b7} {s}", .{ l.name, moduleOf(u, rec, i, pc) }); + } + return .{ .items = items.items, .windows = kept.len, .kernel = at_syscall, .tag = tag, .in_stub = in_stub }; +} + +/// The call instruction a return address `ret` comes back after. +fn callBefore(u: ui.Ui, rec: *const Recording, i: u64, ret: u64) ?Insn { + var buf: [256]u8 = undefined; + const after = rec.instruction(i, ret, &buf) orelse return null; + if (after.back == 0) return null; + const at = ret - after.back; + const call = rec.instruction(i, at, &buf) orelse return null; + if (!std.mem.startsWith(u8, call.text, "call")) return null; + return .{ .addr = at, .len = call.len, .text = u.print("{s}", .{call.text}) }; +} + +/// The moment the instruction at `addr` last ran, at or before `i`. +fn madeAt(rec: *const Recording, i: u64, addr: u64) u64 { + var at = i; + while (at > 0 and i - at < 4096) : (at -= 1) if (rec.register(at, "rip") == addr) return at; + return i; +} + +fn isSyscall(rec: *const Recording, i: u64, pc: u64) bool { + var buf: [256]u8 = undefined; + const here = rec.instruction(i, pc, &buf) orelse return false; + return std.mem.eql(u8, here.text, "syscall"); +} + +/// How many instructions a PLT stub at `pc` has (three: its `jmp`, a push, a jmp to the resolver). +fn stubRows(rec: *const Recording, i: u64, pc: u64) usize { + var buf: [256]u8 = undefined; + var at = pc; + var n: usize = 0; + while (n < 4) : (n += 1) { + const one = rec.instruction(i, at, &buf) orelse break; + if (n > 0 and one.back == 0) break; + at += one.len; + } + return @max(n, 1); +} + +/// A window's head note: what the code is (`libc.so.6 · no source`, +/// `the PLT · its jmp reads open@got, 403fd8`, the program's file). +fn headNote(u: ui.Ui, rec: *const Recording, i: u64, l: Level) []const u8 { + if (std.mem.endsWith(u8, l.name, "@plt")) { + if (l.kind == .pass) return "the PLT, jumped through"; + var buf: [256]u8 = undefined; + const jmp = rec.instruction(i, l.at, &buf) orelse return "the PLT"; + const ops = std.mem.trim(u8, jmp.text[(std.mem.indexOfScalar(u8, jmp.text, ' ') orelse jmp.text.len)..], " "); + const at = std.mem.indexOf(u8, ops, "[rip + 0x") orelse return "the PLT"; + const close = std.mem.indexOfScalarPos(u8, ops, at, ']') orelse return "the PLT"; + const slot = l.at + jmp.len + (std.fmt.parseInt(u64, ops[at + 9 .. close], 16) catch return "the PLT"); + const named = ui.symbol(u, rec.strings.get(slot) orelse ""); + return u.print("the PLT \u{00b7} its jmp reads {s}, {x}", .{ named[0 .. std.mem.lastIndexOfScalar(u8, named, '+') orelse named.len], slot }); + } + const module = moduleOf(u, rec, i, l.at); + if (std.mem.eql(u8, module, "[vdso]")) return "vdso \u{00b7} the kernel's code, run here"; + var buf: [256]u8 = undefined; + if ((@import("ztrace").telescope.instruction(rec.moment(i), l.at, &buf) catch null)) |here| if (here.line != null) return rec.file; + return u.print("{s} \u{00b7} no source", .{module}); +} + +/// The file `addr`'s mapping is of, by its base name. +fn moduleOf(u: ui.Ui, rec: *const Recording, i: u64, addr: u64) []const u8 { + var name: []const u8 = ""; + var buf: [256]u8 = undefined; + _ = (rec.moment(i).mapping(addr, &name, &buf) catch null) orelse return ""; + return u.print("{s}", .{std.fs.path.basename(name)}); +} + +/// The kernel's window, at the floor, while a step crosses: the crossing +/// lane down from the pc's plaque, the vellum filling down from its head, +/// the head and the call in C's form, `returns` and what crossed back +/// with what it clobbered; the answer up the lane; and at the advance the +/// window drawing back up into the lane. +fn kernel(u: ui.Ui, now: cursors.Now, box: Rect, top: f32, room: usize, pc_y: ?f32) void { + if (!now.crossings or !now.walking()) return; + const made = syscalls.inStep(now) orelse return; + const rec = now.rec; + const p = syscalls.Plan.of(made); + const tm = now.time; + const y0 = top + @as(f32, @floatFromInt(room -| 3)) * m.row; + const from = (pc_y orelse y0 - m.row) + m.row; + const back_up = clamp01((tm - now.plan.advance) / f(12)); + // The lane: down 24 f from the plaque, 3 units of vellum; back into it after the window. + const down = cursors.standard(clamp01((tm - p.enters) / syscalls.Plan.cross)); + const lane_gone = clamp01((tm - now.plan.advance - f(12)) / f(12)); + if (down > 0 and lane_gone < 1) { + const end = std.math.lerp(from, y0 + 4, down * (1 - lane_gone)); + u.fill(.{ .x = 14 - 1.5, .y = from, .w = 3, .h = @max(end - from, 0) }, theme.color.kernel); + } + // The answer climbs the lane to the `syscall` row: a head of vellum going up it. + const climb = cursors.standard(clamp01((tm - p.back) / syscalls.Plan.cross)); + if (climb > 0 and climb < 1) { + const yh = std.math.lerp(y0, from, climb); + sk.draw.polygon(u.f, &.{ .{ 14, yh - 8 }, .{ 7, yh + 2 }, .{ 21, yh + 2 } }, u.at.pen(.{ .fill = ui.rgb(theme.color.kernel) })); + } + const opens = cursors.standard(clamp01((tm - p.enters - f(18)) / f(12))) * (1 - back_up); + if (opens <= 0) return; + const h = 3 * m.row * opens; + u.fill(.{ .x = theme.stroke.rule, .y = y0, .w = box.w - 2 * theme.stroke.rule, .h = h }, theme.color.kernel); + u.clip(.{ .x = 0, .y = y0, .w = box.w, .h = h }); + defer u.unclip(); + // The lane's head, in ink on the vellum. + sk.draw.polygon(u.f, &.{ .{ 14, y0 + 10 }, .{ 10, y0 + 2 }, .{ 18, y0 + 2 } }, u.at.pen(.{ .fill = ui.rgb(k.ink) })); + const name = @import("ztrace").syscalls.name(made.nr) orelse "syscall"; + const head = u.faded(clamp01((tm - p.enters - f(30)) / f(6))); + head.text(.sans_medium, theme.size.sans.micro, c.address, y0 + 18, "the kernel", k.ink); + const what = u.print("{s}, system call {d}", .{ name, made.nr }); + head.text(.sans, theme.size.sans.micro, box.w - m.side - u.width(.sans, theme.size.sans.micro, what), y0 + 18, what, k.dim); + // The call in C's form, as the kernel took it. + const names = @import("ztrace").syscalls.names(made.nr); + const n = @min(@import("ztrace").syscalls.signature(made.nr).len, 6); + var call: []const u8 = u.print("{s}(", .{name}); + for (0..n) |j| call = u.print("{s}{s}{s}", .{ call, if (j > 0) ", " else "", disasm.argument(u, rec, made.enter, if (j < names.len) names[j] else "", made.args[j]) }); + call = u.print("{s})", .{call}); + u.faded(clamp01((tm - p.enters - f(36)) / f(6))).text(.mono, size, c.address, rows.baseline(y0 + m.row), rows.fitted(u, call, box.w - m.side - c.address), k.ink); + // `returns`: the value, struck as it lands in the kernel's rows. + const ry = y0 + 2 * m.row; + const returns = tm - p.returns; + u.faded(clamp01((tm - p.enters - f(36)) / f(6))).text(.mono, size, c.address, rows.baseline(ry), "returns", k.dim); + if (returns >= 0 and made.exit != null) { + const got: i64 = @bitCast(made.result); + const value = u.print("{d}", .{got}); + const x = c.address + 8 * adv; + const cell: Rect = .{ .x = x, .y = ry, .w = @as(f32, @floatFromInt(value.len)) * adv, .h = m.row }; + const heat = now.heat(0, null, returns); + const ink = u.written(cell, heat) orelse ui.Ink{ .ink = ui.rgb(k.ink) }; + u.text(ink.face, size, x, rows.baseline(ry), value, ink.ink); + var end = x + cell.w + adv; + const on = rec.openOn(u.f.scratch, made.result, made.exit.? + 1); + if (std.mem.eql(u8, name, "openat") or std.mem.eql(u8, name, "open")) if (on.len > 0) { + u.text(.mono, size, end, rows.baseline(ry), on, k.dim); + end += u.width(.mono, size, on) + 2 * adv; + }; + u.text(.mono, size, end + adv, rows.baseline(ry), "rcx, r11: clobbered", k.dim); + } +} |
