//! The debugger against the programs in `targets/`, built by //! `build/debugger.zig` and found through the `targets` options. const std = @import("std"); const linux = std.os.linux; const zt = @import("ztrace"); const targets = @import("targets"); const Debugger = zt.Debugger; const gpa = std.testing.allocator; const io = std.testing.io; const no_env = [_:null]?[*:0]const u8{null}; /// Starts a target with its stdout going nowhere: this process's own is the /// test runner's channel to the build. fn spawn(path: []const u8, arg: ?[*:0]const u8, sink: ?zt.Sink) !Debugger { const exe = try gpa.dupeSentinel(u8, path, 0); defer gpa.free(exe); const argv = [_:null]?[*:0]const u8{ exe.ptr, arg, null }; const saved: linux.fd_t = @intCast(linux.dup(1)); const nowhere: linux.fd_t = @intCast(linux.open("/dev/null", .{ .ACCMODE = .WRONLY }, 0)); _ = linux.dup2(nowhere, 1); defer { _ = linux.dup2(saved, 1); _ = linux.close(saved); _ = linux.close(nowhere); } return Debugger.spawn(gpa, io, exe.ptr, &argv, &no_env, sink); } /// Runs to the exit and returns its code. fn finish(d: *Debugger) !u8 { while (true) switch (try d.cont()) { .exited => |code| return code, .killed => return error.Killed, else => {}, }; } /// A sink that keeps every event. const Log = struct { events: std.ArrayList(struct { ev: zt.Event, payload: []u8 }) = .empty, fn sink(l: *Log) zt.Sink { return .{ .ctx = l, .emitFn = emit }; } fn emit(ctx: *anyopaque, ev: *const zt.Event, payload: []const u8) anyerror!void { const l: *Log = @ptrCast(@alignCast(ctx)); try l.events.append(gpa, .{ .ev = ev.*, .payload = try gpa.dupe(u8, payload) }); } fn deinit(l: *Log) void { for (l.events.items) |e| gpa.free(e.payload); l.events.deinit(gpa); } fn count(l: *const Log, kind: zt.Kind) usize { var n: usize = 0; for (l.events.items) |e| n += @intFromBool(e.ev.kind == kind); return n; } /// The entries of one syscall. fn calls(l: *const Log, nr: linux.SYS) usize { var n: usize = 0; for (l.events.items) |e| n += @intFromBool(e.ev.kind == .syscall_enter and e.ev.aux == @backingInt(nr)); return n; } }; test "a breakpoint on fib is hit once a call, in a position-independent executable" { var d = try spawn(targets.fib, "10", null); defer d.deinit(); // Loaded somewhere else than linked: the symbol's address has the bias in it. try std.testing.expect(d.syms.modules.items[0].bias != 0); const at = try d.resolve("fib"); try std.testing.expectEqualStrings("fib", d.syms.symbolAt(at).?.name); try std.testing.expectEqual(@as(u32, 5), d.lineAt(try d.resolve("fib.c:5")).?.line); const id = try d.breakAt(at, null); // -O1 turns fib(n-2) into a loop, so fib(n) makes F(n+1) calls, not // 2F(n+1)-1: 89 for n = 10. gdb counts the same. var hits: usize = 0; var first: u64 = 0; const code = while (true) switch (try d.cont()) { .breakpoint => |hit| { try std.testing.expectEqual(id, hit); try std.testing.expectEqual(at, d.regs.rip); if (hits == 0) first = d.regs.rdi; hits += 1; }, .exited => |code| break code, else => return error.UnexpectedStop, }; try std.testing.expectEqual(@as(usize, 89), hits); try std.testing.expectEqual(@as(u64, 10), first); try std.testing.expectEqual(@as(u8, 0), code); } test "DWARF says how many parameters a function takes" { var d = try spawn(targets.list, "2", null); defer d.deinit(); for ([_][]const u8{ "push", "reverse", "list_done", "main" }, [_]u8{ 2, 1, 1, 2 }) |name, n| { try std.testing.expectEqual(@as(?u8, n), d.syms.parameters(d.symbol(name).?.addr)); } // Only where a function begins; nor in a library without debug info. try std.testing.expectEqual(@as(?u8, null), d.syms.parameters(d.symbol("push").?.addr + 1)); try std.testing.expectEqual(@as(?u8, null), d.syms.parameters(d.regs.rip)); } test "a recording by `ztrace record` has the line of each instruction round the pc, and a call's parameters" { var trace = try zt.Trace.open(gpa, io, targets.fib_recording); defer trace.close(); // The first stop at the breakpoint on fib, and the instructions from there. const m, const pc = find: for (0..trace.len) |i| { const m = try trace.moment(i); var events = try m.events(gpa); defer events.deinit(gpa); while (events.next()) |item| if (item.ev.kind == .breakpoint) break :find .{ m, item.ev.a[0] }; } else return error.NoBreakpoint; var text: [256]u8 = undefined; const here = (try zt.telescope.instruction(m, pc, &text)).?; try std.testing.expectEqual(@as(u32, 4), here.line.?.line); var name: [std.Io.Dir.max_path_bytes]u8 = undefined; try std.testing.expect(std.mem.endsWith(u8, (try m.string(here.line.?.file, &name)).?, "fib.c")); // fib calls itself once (-O1 made the other call a loop): with its one parameter. var at = pc; const call = while (try zt.telescope.instruction(m, at, &text)) |insn| : (at += insn.len) { if (std.mem.startsWith(u8, insn.text, "call")) break insn; } else return error.NoCall; try std.testing.expectEqual(@as(?u8, 1), call.params); try std.testing.expectEqual(@as(u32, 5), call.line.?.line); // The frame that called fib is on its call's line: the call is recorded, `back` from where it returns. const tids = try m.threads(gpa); defer gpa.free(tids); const regs = (try m.regs(tids[0])).?; var chain: [4]u64 = undefined; const frames = try zt.telescope.backtrace(m, ®s, &chain); try std.testing.expect(frames.len >= 2); const after = (try zt.telescope.instruction(m, frames[1], &text)).?; try std.testing.expect(after.back != 0); const caller = (try zt.telescope.instruction(m, frames[1] - after.back, &text)).?; try std.testing.expect(std.mem.startsWith(u8, caller.text, "call")); try std.testing.expect(caller.line != null); } test "PLT stubs and GOT slots are named for the function they lead to, in the program and in libc" { var d = try spawn(targets.hello, null, null); defer d.deinit(); try d.toEntry(); // Not in the program: the mappings are read again, libc's with them. try std.testing.expect(d.symbol("open") != null); var buf: [256]u8 = undefined; var w: std.Io.Writer = .fixed(&buf); for ([_][]const u8{ "open@plt", "read@plt", "close@plt", "open@got", "read@got" }) |name| { w.end = 0; try std.testing.expect(try d.syms.label(&w, d.symbol(name).?.addr)); try std.testing.expectEqualStrings(name, w.buffered()[0 .. w.buffered().len - 2]); } // The function a caller calls, of the four names libc gives open. w.end = 0; _ = try d.syms.label(&w, d.symbol("__open64").?.addr); try std.testing.expectEqualStrings("libc.so.6!open+0", w.buffered()); // libc's own stubs are its IFUNCs', whose relocations name nothing: by the function each resolver is. const libc = for (d.syms.modules.items) |*m| { if (std.mem.endsWith(u8, m.path, "/libc.so.6")) break m; } else return error.NoLibc; var stubs: usize = 0; for (libc.symbols) |sym| if (std.mem.endsWith(u8, sym.name, "@plt")) { stubs += 1; try std.testing.expect(d.symbol(sym.name[0 .. sym.name.len - "@plt".len]) != null); w.end = 0; _ = try d.syms.label(&w, sym.addr + libc.bias); try std.testing.expect(std.mem.startsWith(u8, w.buffered(), "libc.so.6!") and std.mem.endsWith(u8, w.buffered(), "@plt+0")); }; try std.testing.expect(stubs > 10); } test "a call followed down by instruction: through the PLT, the loader's resolver and libc to the kernel, and back" { var trace = try zt.Trace.open(gpa, io, targets.hello_recording); defer trace.close(); const tids = try (try trace.moment(0)).threads(gpa); defer gpa.free(tids); const named_ = struct { fn at(m: zt.store.Moment, addr: u64) []const u8 { return m.trace.strings.get(addr) orelse ""; } }.at; const inMain = struct { fn at(m: zt.store.Moment, addr: u64) bool { return std.mem.startsWith(u8, m.trace.strings.get(addr) orelse "", "main+"); } }.at; // From main's first instruction to its last: the calls it makes, open, read twice and close. var first: ?u64 = null; var last: u64 = 0; for (0..trace.len) |i| { const regs = (try (try trace.moment(i)).regs(tids[0])) orelse continue; if (!inMain(try trace.moment(i), regs.rip)) continue; if (first == null) first = i; last = i; } var stubs: [4][]const u8 = undefined; var n_stubs: usize = 0; var entries: [4][]const u8 = undefined; var n_entries: usize = 0; var crossings: [4]u16 = undefined; var n_crossings: usize = 0; var returns: usize = 0; var resolver: usize = 0; var back_to: u64 = 0; var was_in_main = true; var text: [256]u8 = undefined; for (first.?..last + 1) |i| { const m = try trace.moment(i); const regs = (try m.regs(tids[0])).?; const here = named_(m, regs.rip); var chain_buf: [32]u64 = undefined; const chain = try zt.telescope.backtrace(m, ®s, &chain_buf); const in_main = inMain(m, regs.rip); if (in_main) { // After the ret: the instruction after the call. if (!was_in_main) { try std.testing.expectEqual(back_to, regs.rip); returns += 1; } } else { // main waits under every frame of the call, the resolver's too. for (chain[1..]) |pc| { if (inMain(m, pc)) break; } else { std.debug.print("moment {d} at {s}: main lost\n", .{ i, here }); return error.MainLost; } if (std.mem.startsWith(u8, here, "ld-linux")) resolver += 1; } was_in_main = in_main; // The stub's jmp, named for the function it leads to, its GOT slot // too; lazy at a function's first call, bound at the second read's. if (std.mem.endsWith(u8, here, "@plt+0")) { stubs[n_stubs] = here; n_stubs += 1; try std.testing.expect(inMain(m, chain[1])); const stub = zt.telescope.function(m, regs.rip).?; try std.testing.expectEqual(regs.rip, stub.start); try std.testing.expectEqual(@as(u64, 16), stub.len); var events = try m.events(gpa); defer events.deinit(gpa); const slot = while (events.next()) |item| { if (item.ev.kind == .touch and item.ev.a[2] == regs.rip) break item.ev.a[0]; } else return error.NoTouch; const function_name = here[0 .. here.len - "@plt+0".len]; try std.testing.expectEqualStrings(try std.fmt.bufPrint(&text, "{s}@got+0", .{function_name}), named_(m, slot)); const held = (try zt.telescope.got(m, slot)).?; try std.testing.expectEqual(@as(?bool, n_stubs != 3), held.lazy); } // The callee's first instruction, by the name its caller used. if (std.mem.startsWith(u8, here, "libc.so.6!") and std.mem.endsWith(u8, here, "+0")) { entries[n_entries] = here; n_entries += 1; try std.testing.expect(inMain(m, chain[1])); back_to = chain[1]; // The caller's three rows: the one before the call, the call, the one it returns to. const after = (try zt.telescope.instruction(m, back_to, &text)).?; const call_at = back_to - after.back; const call = (try zt.telescope.instruction(m, call_at, &text)).?; try std.testing.expect(std.mem.startsWith(u8, call.text, "call")); try std.testing.expect(call.back != 0 and try zt.telescope.instruction(m, call_at - call.back, &text) != null); // main's bounds, from the recording: where its name says it begins. const f = zt.telescope.function(m, back_to - 1).?; try std.testing.expectEqual(back_to - try std.fmt.parseInt(u64, named_(m, back_to)["main+".len..], 10), f.start); try std.testing.expect(back_to < f.start + f.len); } // At a syscall instruction: the next moment is the call, entry and // exit, with the registers after it. if (i + 1 < trace.len) { const next = try trace.moment(i + 1); var events = try next.events(gpa); defer events.deinit(gpa); var enter: ?zt.store.Events.Item = null; var exit: ?zt.store.Events.Item = null; while (events.next()) |item| switch (item.ev.kind) { .syscall_enter => enter = item, .syscall_exit => exit = item, else => {}, }; if (enter) |e| { const nr = e.ev.aux; crossings[n_crossings] = nr; n_crossings += 1; try std.testing.expectEqual(nr, exit.?.ev.aux); try std.testing.expectEqual(@as(u64, nr), regs.rax); try std.testing.expect(!inMain(m, regs.rip)); const after = (try next.regs(tids[0])).?; // The instruction's own clobbers: rcx the return address, r11 the flags (with the step's trap flag). try std.testing.expectEqual(regs.rip + 2, after.rcx); try std.testing.expectEqual(regs.rip + 2, after.rip); try std.testing.expectEqual(regs.eflags | 0x100, after.r11 | 0x100); try std.testing.expectEqual(exit.?.ev.a[0], after.rax); var out: std.Io.Writer = .fixed(&text); try zt.syscalls.formatEnter(&out, &e.ev, e.payload); try zt.syscalls.formatExit(&out, &exit.?.ev); const call = out.buffered(); if (std.mem.eql(u8, zt.syscalls.name(nr).?, "openat")) { try std.testing.expect(std.mem.startsWith(u8, call, "openat(-100, \"/")); try std.testing.expect(std.mem.endsWith(u8, call, "/hello\", 0x0, 0x0) = 3")); } if (std.mem.eql(u8, zt.syscalls.name(nr).?, "read")) try std.testing.expect(std.mem.startsWith(u8, call, "read(3, 0x") and std.mem.endsWith(u8, call, ", 16) = 16")); } } } const want_stubs = [_][]const u8{ "open@plt+0", "read@plt+0", "read@plt+0", "close@plt+0" }; const want_entries = [_][]const u8{ "libc.so.6!open+0", "libc.so.6!read+0", "libc.so.6!read+0", "libc.so.6!close+0" }; try std.testing.expectEqual(want_stubs.len, n_stubs); for (want_stubs, stubs, want_entries, entries) |ws, s, we, e| { try std.testing.expectEqualStrings(ws, s); try std.testing.expectEqualStrings(we, e); } try std.testing.expectEqual(@as(usize, 4), n_crossings); for ([_][]const u8{ "openat", "read", "read", "close" }, crossings) |want, nr| try std.testing.expectEqualStrings(want, zt.syscalls.name(nr).?); try std.testing.expectEqual(@as(usize, 4), returns); // Three first calls ran the resolver, hundreds of instructions each. try std.testing.expect(resolver > 300); } /// Every jump and return a recording by instruction made, tied to its /// block's edge: the `branch` event at a stop is the instruction at its /// pc, the last of its block; the next stop is at the edge it took. /// Returns how many were tied, and how many were in code with no bounds, /// recorded as no blocks. fn tieBranches(trace: *const zt.Trace) ![2]usize { var tied: usize = 0; var loose: usize = 0; var out: [512]zt.telescope.Block = undefined; var text: [256]u8 = undefined; for (0..trace.len - 1) |i| { const m = try trace.moment(i); var events = try m.events(gpa); defer events.deinit(gpa); const branch = while (events.next()) |item| { if (item.ev.kind == .branch and (item.ev.aux == 2 or item.ev.aux == 3)) break item.ev; } else continue; const pc = branch.a[2]; const g = zt.telescope.blocks(m, pc, &out) orelse { // Code with no bounds: no symbol with a size, no unwind information (the C runtime's start). try std.testing.expect(zt.telescope.function(m, pc) == null); loose += 1; continue; }; const block = g.blocks[g.here.?]; try std.testing.expectEqual(block.start + block.len, pc + (try zt.telescope.instruction(m, pc, &text)).?.len); // The next stop of the same thread: the next moment by instruction, or the one after a syscall's. const next = next: for (i + 1..trace.len) |j| { const later = try trace.moment(j); var after = try later.events(gpa); defer after.deinit(gpa); while (after.next()) |item| if (item.ev.kind == .step and item.ev.tid == branch.tid) break :next item.ev.a[0]; } else unreachable; switch (block.end) { .ret => try std.testing.expectEqual(@as(u16, 3), branch.aux), .jump, .tail => try std.testing.expectEqual(block.to.?, next), .branch => try std.testing.expectEqual(if (branch.a[1] != 0) block.to.? else block.falls.?, next), // A jump through memory goes where the event says. .indirect => try std.testing.expectEqual(branch.a[0], next), else => return error.NotABranch, } tied += 1; } return .{ tied, loose }; } test "a function's basic blocks from a recording, and the edges a run took: two loops" { var trace = try zt.Trace.open(gpa, io, targets.list_recording); defer trace.close(); var out: [16]zt.telescope.Block = undefined; // Their blocks, by `objdump -d` of zig-out/targets/list (-O1): // // reverse: +0 test rdi, rdi list_done: +0 test rdi, rdi // +3 je +25 +3 je +1e // +5 push rbp +5 push rbp // +6 mov rbp, rsp +6 mov rbp, rsp // +9 xor eax, eax +9 xor eax, eax // +b nop +b nop // +10 mov rcx, rax +10 add rax, [rdi] // +13 mov rax, rdi +13 mov rdi, [rdi + 8] // +16 mov rdi, [rdi + 8] +17 test rdi, rdi // +1a mov [rax + 8], rcx +1a jne +10 // +1e test rdi, rdi +1c pop rbp // +21 jne +10 +1d ret // +23 pop rbp +1e xor eax, eax // +24 ret +20 ret // +25 xor eax, eax // +27 ret // // The empty list's test, the frame falling into the loop, the loop // back to itself, and two returns. const Want = struct { u64, u64, zt.Debugger.End, ?u64, ?u64 }; for ([_][]const u8{ "reverse", "list_done" }, [_][5]Want{ .{ .{ 0, 5, .branch, 0x25, 5 }, .{ 5, 0xb, .fall, null, 0x10 }, .{ 0x10, 0x13, .branch, 0x10, 0x23 }, .{ 0x23, 2, .ret, null, null }, .{ 0x25, 3, .ret, null, null } }, .{ .{ 0, 5, .branch, 0x1e, 5 }, .{ 5, 0xb, .fall, null, 0x10 }, .{ 0x10, 0xc, .branch, 0x10, 0x1c }, .{ 0x1c, 2, .ret, null, null }, .{ 0x1e, 3, .ret, null, null } }, }) |name, want| { // The first stop in the function. const m, const pc = find: for (0..trace.len) |i| { const m = try trace.moment(i); const tids = try m.threads(gpa); defer gpa.free(tids); const regs = (try m.regs(tids[0])) orelse continue; if (std.mem.startsWith(u8, m.trace.strings.get(regs.rip) orelse "", name)) break :find .{ m, regs.rip }; } else return error.NotReached; const g = zt.telescope.blocks(m, pc, &out).?; try std.testing.expect(g.text); try std.testing.expectEqual(want.len, g.count); const here: []const u8 = m.trace.strings.get(pc).?; try std.testing.expectEqual(g.start, pc - try std.fmt.parseInt(u64, here[name.len + 1 ..], 10)); for (want, g.blocks) |w, b| { try std.testing.expectEqual(g.start + w[0], b.start); try std.testing.expectEqual(w[1], b.len); try std.testing.expectEqual(w[2], b.end); try std.testing.expectEqual(if (w[3]) |to| g.start + to else null, b.to); try std.testing.expectEqual(if (w[4]) |falls| g.start + falls else null, b.falls); } } const tied, const loose = try tieBranches(&trace); try std.testing.expect(tied > 10 and loose == 0); } test "a libc function's basic blocks, from its unwind bounds, at its system call" { var trace = try zt.Trace.open(gpa, io, targets.hello_recording); defer trace.close(); var out: [64]zt.telescope.Block = undefined; var text: [256]u8 = undefined; var checked: usize = 0; for (0..trace.len) |i| { const m = try trace.moment(i); const tids = try m.threads(gpa); defer gpa.free(tids); const regs = (try m.regs(tids[0])) orelse continue; const insn = (try zt.telescope.instruction(m, regs.rip, &text)) orelse continue; if (!std.mem.eql(u8, insn.text, "syscall") or !std.mem.startsWith(u8, m.trace.strings.get(regs.rip) orelse "", "libc.so.6!open+")) continue; const g = zt.telescope.blocks(m, regs.rip, &out).?; // open's, whole: from its first instruction, every instruction's text there. try std.testing.expectEqualStrings("libc.so.6!open+0", m.trace.strings.get(g.start).?); try std.testing.expect(g.text and g.count <= out.len); const here = g.blocks[g.here.?]; try std.testing.expect(here.start <= regs.rip and regs.rip < here.start + here.len); // The blocks run end to end, each a run of instructions, every edge in the function to a block's start. var at = g.start; for (g.blocks) |b| { try std.testing.expectEqual(at, b.start); at += b.len; var pc = b.start; while (pc < b.start + b.len) pc += (try zt.telescope.instruction(m, pc, &text)).?.len; try std.testing.expectEqual(b.start + b.len, pc); for ([_]?u64{ b.to, b.falls }) |edge| if (edge) |to| if (to -% g.start < g.len) { for (g.blocks) |c| { if (c.start == to) break; } else return error.EdgeIntoABlock; }; } try std.testing.expectEqual(g.start + g.len, at); // Its return, and a call that does not return: __stack_chk_fail. var ends: [2]bool = @splat(false); for (g.blocks) |b| { if (b.end == .ret) ends[0] = true; if (b.end == .noreturn) if (b.to) |callee| if (std.mem.indexOf(u8, m.trace.strings.get(callee) orelse "", "__stack_chk_fail") != null) { ends[1] = true; }; } try std.testing.expectEqual([2]bool{ true, true }, ends); checked += 1; } try std.testing.expectEqual(@as(usize, 1), checked); // Every jump and return of main, the PLT, the resolver and libc, tied to its edge. const tied, const loose = try tieBranches(&trace); try std.testing.expect(tied > 300 and loose < 10); } /// Runs a command, its output kept, with the environment ASan wants under a /// tracer: no leak check (LeakSanitizer cannot work under ptrace). fn runQuiet(argv: []const []const u8) !std.process.RunResult { var env = std.process.Environ.Map.init(gpa); defer env.deinit(); try env.put("ASAN_OPTIONS", "detect_leaks=0"); return std.process.run(gpa, io, .{ .argv = argv, .environ_map = &env }); } fn exited(result: std.process.RunResult) ?u8 { defer gpa.free(result.stdout); defer gpa.free(result.stderr); return switch (result.term) { .exited => |code| code, else => null, }; } /// The last moment's events of a kind, from a recording: the stops and exits that end a run. fn lastOf(trace: *const zt.Trace, kind: zt.Kind) !?zt.Event { var found: ?zt.Event = null; for (0..trace.len) |i| { var events = try (try trace.moment(i)).events(gpa); defer events.deinit(gpa); while (events.next()) |item| if (item.ev.kind == kind) { found = item.ev; }; } return found; } test "a stack overflow built plain: past the buffer, its own counter smashed, it writes to the stack's end and faults there" { var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var dir_buf: [std.Io.Dir.max_path_bytes]u8 = undefined; const dir = dir_buf[0..try tmp.dir.realPath(io, &dir_buf)]; const path = try std.fs.path.join(gpa, &.{ dir, "plain.ztrace" }); defer gpa.free(path); try std.testing.expectEqual(@as(?u8, 0), exited(try runQuiet(&.{ targets.ztrace, "record", "--by", "syscall", "--from", "fill", "-o", path, "--", targets.overflow, "x" }))); var trace = try zt.Trace.open(gpa, io, path); defer trace.close(); // SIGSEGV at a store of the loop in fill, its address just past the stack's top. const signal = (try lastOf(&trace, .signal)).?; try std.testing.expectEqual(@as(u16, @backingInt(linux.SIG.SEGV)), signal.aux); const m = try trace.moment(trace.len - 1); try std.testing.expect(std.mem.startsWith(u8, m.trace.strings.get(signal.a[1]) orelse "", "fill+")); var name: []const u8 = ""; var buf: [64]u8 = undefined; try std.testing.expect(try m.mapping(signal.a[0], null, &buf) == null); _ = (try m.mapping(signal.a[0] - 1, &name, &buf)).?; try std.testing.expectEqualStrings("[stack]", name); try std.testing.expectEqual(@as(u64, 128 + @backingInt(linux.SIG.SEGV)), (try lastOf(&trace, .exit)).?.a[0]); } test "the same overflow built with ASan, by gcc and by clang: its shadow round the buffer, the branch into its report, the report's text and the exit" { var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var dir_buf: [std.Io.Dir.max_path_bytes]u8 = undefined; const dir = dir_buf[0..try tmp.dir.realPath(io, &dir_buf)]; var built: usize = 0; for ([_][]const u8{ "gcc", "clang" }) |cc| { const exe = try std.fs.path.join(gpa, &.{ dir, cc }); defer gpa.free(exe); // A compiler that is not here, or has no ASan runtime, is passed over. const compiled = exited(runQuiet(&.{ cc, "-fsanitize=address", "-O0", "-g", targets.overflow_source, "-o", exe }) catch continue); if (compiled != 0) continue; built += 1; // By instruction from fill into the report: the stop at its first instruction. const steps = try std.fs.path.join(gpa, &.{ dir, "steps.ztrace" }); defer gpa.free(steps); try std.testing.expectEqual(@as(?u8, 0), exited(try runQuiet(&.{ targets.ztrace, "record", "--by", "insn", "--from", "fill", "--asan", "--stack", "512", "--steps", "3000", "-o", steps, "--", exe, "x" }))); var trace = try zt.Trace.open(gpa, io, steps); defer trace.close(); const at = for (1..trace.len) |i| { const m = try trace.moment(i); const tids = try m.threads(gpa); defer gpa.free(tids); const regs = (try m.regs(tids[0])) orelse continue; if (std.mem.indexOf(u8, m.trace.strings.get(regs.rip) orelse "", "__asan_report_store1+0") != null) break i; } else return error.NoReport; const m = try trace.moment(at); const tids = try m.threads(gpa); defer gpa.free(tids); const regs = (try m.regs(tids[0])).?; // Its argument is the first byte past buf: buf's 16 bytes addressable // (00 00), the left redzone before them (f1), the right one from there (f3). for ([_]i64{ -48, -40, -32, -24, -16, -8, 0, 8 }, [_]u8{ 0xf1, 0xf1, 0xf1, 0xf1, 0, 0, 0xf3, 0xf3 }) |off, want| { const s = (try zt.telescope.shadow(m, regs.rdi +% @as(u64, @bitCast(off)))).?; try std.testing.expectEqual(@as(?u8, want), s.value); } // Reached by a branch taken (gcc's through its PLT stub), and walked back to main. var events = try (try trace.moment(at - 1)).events(gpa); defer events.deinit(gpa); const into = while (events.next()) |item| { if (item.ev.kind == .branch) break item.ev; } else return error.NoBranch; try std.testing.expectEqual(regs.rip, into.a[0]); try std.testing.expectEqual(@as(u64, 1), into.a[1]); var chain_buf: [16]u64 = undefined; const chain = try zt.telescope.backtrace(m, ®s, &chain_buf); try std.testing.expect(std.mem.startsWith(u8, m.trace.strings.get(chain[1]).?, "fill+")); try std.testing.expect(std.mem.startsWith(u8, m.trace.strings.get(chain[2]).?, "main+")); // The runtime's calls in fill are named: its fake stack's allocation too. var names = trace.strings.valueIterator(); while (names.next()) |text| { if (std.mem.indexOf(u8, text.*, "__asan_stack_malloc_") != null) break; } else return error.NoStackMalloc; // By syscall to the end: the report as it was written, and the exit. const end = try std.fs.path.join(gpa, &.{ dir, "end.ztrace" }); defer gpa.free(end); try std.testing.expectEqual(@as(?u8, 0), exited(try runQuiet(&.{ targets.ztrace, "record", "--by", "syscall", "--from", "fill", "--asan", "-s", "4096", "-o", end, "--", exe, "x" }))); var whole = try zt.Trace.open(gpa, io, end); defer whole.close(); var reported = false; for (0..whole.len) |i| { var all = try (try whole.moment(i)).events(gpa); defer all.deinit(gpa); while (all.next()) |item| if (item.ev.kind == .syscall_enter and item.ev.aux == @backingInt(linux.SYS.write) and item.ev.a[0] == 2) { if (std.mem.indexOf(u8, item.payload, "ERROR: AddressSanitizer: stack-buffer-overflow") != null) reported = true; }; } try std.testing.expect(reported); try std.testing.expectEqual(@as(u64, 1), (try lastOf(&whole, .exit)).?.a[0]); } if (built == 0) return error.SkipZigTest; } test "step walks the source lines, in and out of calls, as gdb does" { var d = try spawn(targets.list, "2", null); defer d.deinit(); _ = try d.breakAt(try d.resolve("reverse"), null); try std.testing.expectEqual(Debugger.Stop{ .breakpoint = 1 }, try d.cont()); // The loop of `reverse` twice, back to main, through `list_done`, and // printf run through as one line. const expected = [_]u32{ 20, 21, 22, 20, 21, 22, 20, 26, 40, 31, 32, 40, 41 }; var lines: [expected.len]u32 = undefined; lines[0] = d.lineAt(d.regs.rip).?.line; for (lines[1..]) |*line| { try std.testing.expectEqual(Debugger.Stop.step, try d.step()); line.* = d.lineAt(d.regs.rip).?.line; } try std.testing.expectEqualSlices(u32, &expected, &lines); try std.testing.expectEqualStrings("main", d.syms.symbolAt(d.regs.rip).?.name); // The call chain from inside `push`, on a second run. var d2 = try spawn(targets.list, "2", null); defer d2.deinit(); _ = try d2.breakAt(try d2.resolve("push"), null); _ = try d2.cont(); var frames: [8]u64 = undefined; const chain = Debugger.backtrace(&d2, &d2.regs, false, &frames); try std.testing.expect(chain.len >= 3); try std.testing.expectEqualStrings("push", d2.syms.symbolAt(chain[0]).?.name); try std.testing.expectEqualStrings("main", d2.syms.symbolAt(chain[1]).?.name); } /// The target's memory with no call frame information: what the call chain /// is walked by without it, the frame pointer alone. const FramePointer = struct { d: *Debugger, pub fn read(mem: FramePointer, addr: u64, buf: []u8) usize { return mem.d.read(addr, buf); } }; fn named(d: *Debugger, pc: u64) []const u8 { return if (d.syms.symbolAt(pc)) |sym| sym.name else ""; } test "the call chain by the unwind tables: through a frameless wrapper, at a function's first instruction" { var d = try spawn(targets.fib, "5", null); defer d.deinit(); // A brk from malloc, inside libc: its wrapper keeps no frame, so the // frame pointer's walk passes over its caller. gdb shows the same chain. d.syscalls = .stop; var by_cfi: [32]u64 = undefined; var by_fp: [32]u64 = undefined; const cfi, const fp = find: while (true) switch (try d.cont()) { .syscall_enter => |nr| if (nr == @backingInt(linux.SYS.brk)) { const chain = Debugger.backtrace(&d, &d.regs, false, &by_cfi); for (chain) |pc| if (std.mem.eql(u8, named(&d, pc), "main")) break :find .{ chain, Debugger.backtrace(FramePointer{ .d = &d }, &d.regs, false, &by_fp) }; }, .exited => return error.NoBrkFromMain, else => {}, }; try std.testing.expect(cfi.len > fp.len); // Every frame the frame pointer finds is found, in order, and the walks end alike. var at: usize = 0; for (fp) |pc| { at = (std.mem.indexOfScalarPos(u64, cfi, at, pc) orelse return error.FrameLost) + 1; } try std.testing.expectEqual(fp[fp.len - 1], cfi[cfi.len - 1]); d.syscalls = .ignore; // At fib's first instruction its caller is main's frame still, which // the frame pointer's walk, not told so, passes over. var d2 = try spawn(targets.fib, "5", null); defer d2.deinit(); _ = try d2.breakAt(d2.symbol("fib").?.addr, null); _ = try d2.cont(); try std.testing.expectEqualStrings("main", named(&d2, Debugger.backtrace(&d2, &d2.regs, false, &by_cfi)[1])); try std.testing.expect(!std.mem.eql(u8, "main", named(&d2, Debugger.backtrace(FramePointer{ .d = &d2 }, &d2.regs, false, &by_fp)[1]))); } test "a recording tells each stack word's role: saved registers, return addresses, locals, the process's start" { var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var dir_buf: [std.Io.Dir.max_path_bytes]u8 = undefined; const dir = dir_buf[0..try tmp.dir.realPath(io, &dir_buf)]; const path = try std.fs.path.join(gpa, &.{ dir, "roles.ztrace" }); defer gpa.free(path); var rec = try zt.Recorder.create(gpa, io, path); { errdefer rec.close() catch {}; var d = try spawn(targets.list_O0, "2", rec.sink()); defer d.deinit(); // DWARF's locals: at -O0 each parameter and variable has a place by the frame base. const push = d.syms.functionAt(d.symbol("push").?.addr).?; try std.testing.expectEqual(@as(u8, 6), push.base); try std.testing.expectEqual(@as(usize, 3), push.locals.len); for (push.locals, [_][]const u8{ "head", "value", "n" }) |local, name| { try std.testing.expectEqualStrings(name, local.name); try std.testing.expectEqual(@as(u32, 8), local.size); try std.testing.expect(local.offset < 0); } // main's i is its loop's, a block within it. for (d.syms.functionAt(d.symbol("main").?.addr).?.locals) |local| { if (std.mem.eql(u8, local.name, "i")) try std.testing.expect(local.from > 0 and local.to < 0x1000); } d.telescope = 1; d.stack_watch = 4096; // In push's body: its frame made, its locals above the stack pointer. _ = try d.breakAt(try d.resolve("list.c:13"), null); _ = try d.cont(); try std.testing.expectEqual(@as(u8, 0), try finish(&d)); } try rec.close(); var trace = try zt.Trace.open(gpa, io, path); defer trace.close(); const m = find: for (0..trace.len) |i| { const m = try trace.moment(i); var events = try m.events(gpa); defer events.deinit(gpa); while (events.next()) |item| if (item.ev.kind == .breakpoint) break :find m; } else return error.NoBreakpoint; const tids = try m.threads(gpa); defer gpa.free(tids); const regs = (try m.regs(tids[0])).?; var found: [8]Debugger.Frame = undefined; const chain = try zt.telescope.frames(m, ®s, &found); try std.testing.expect(chain.len >= 3); const Slot = zt.telescope.Slot; var buf: [512]Slot = undefined; const words = try zt.telescope.slots(m, ®s, regs.rsp, &buf); // push's frame: its locals, rbp saved under the return address. var seen: [3]bool = @splat(false); for (words, 0..) |w, i| { const addr = regs.rsp + 8 * i; if (addr >= chain[0].high) break; try std.testing.expectEqual(@as(?u8, 0), w.frame); if (w.role == .local) for ([_][]const u8{ "head", "value", "n" }, &seen) |name, *s| { if (std.mem.eql(u8, w.role.local.name, name)) s.* = true; }; } try std.testing.expectEqual([3]bool{ true, true, true }, seen); const at = struct { fn word(all: []const Slot, rsp: u64, addr: u64) Slot { return all[(addr - rsp) / 8]; } }.word; try std.testing.expectEqual(zt.telescope.Role.return_address, at(words, regs.rsp, chain[0].high - 8).role); try std.testing.expectEqualStrings("rbp", at(words, regs.rsp, chain[0].high - 16).role.saved); // main's frame, next: its own locals, and its return address into libc. try std.testing.expectEqual(@as(?u8, 1), at(words, regs.rsp, chain[1].low).frame); try std.testing.expectEqual(zt.telescope.Role.return_address, at(words, regs.rsp, chain[1].high - 8).role); // The call is in the loop: its i is named too. var in_main: [2]bool = @splat(false); for (words[(chain[1].low - regs.rsp) / 8 .. (chain[1].high - regs.rsp) / 8]) |w| { if (w.role == .local) for ([_][]const u8{ "head", "i" }, &in_main) |name, *seen_it| { if (std.mem.eql(u8, w.role.local.name, name)) seen_it.* = true; }; } try std.testing.expectEqual([2]bool{ true, true }, in_main); // The process's first stack: argc 2, ./list-O0 and "2", no environment, then the auxiliary vector. var start_at: ?usize = null; for (words, 0..) |w, i| if (w.role == .argc) { start_at = i; break; }; const s = words[start_at orelse return error.NoArgc ..]; for ([_]zt.telescope.Role{ .argc, .{ .argv = 0 }, .{ .argv = 1 }, .{ .argv = 2 }, .{ .envp = 0 }, .{ .auxv = 0 }, .{ .auxv = 1 } }, s[0..7]) |want, have| { try std.testing.expectEqual(want, have.role); } var argc: [8]u8 = undefined; try m.read(regs.rsp + 8 * start_at.?, &argc, null); try std.testing.expectEqual(@as(u64, 2), std.mem.readInt(u64, &argc, .little)); } test "by instruction, a call into the vDSO is run through to its return: its retry loop is no stops, whatever a stop costs" { var counts: [2]usize = undefined; for ([_]usize{ 1024, 0 }, &counts) |stack, *count| { var log: Log = .{}; defer log.deinit(); var d = try spawn(targets.clock, null, log.sink()); defer d.deinit(); d.telescope = 3; d.stack_watch = stack; _ = try d.breakAt(try d.resolve("main"), null); _ = try d.cont(); count.* = 0; while (try d.stepi() != .exited) : (count.* += 1) { const in = d.syms.mappingAt(d.regs.rip) orelse continue; try std.testing.expect(!std.mem.eql(u8, in.name, "[vdso]")); } } // The same stops however long a stop takes. try std.testing.expectEqual(counts[0], counts[1]); } test "the telescope records the region round what a pointer leads to" { var log: Log = .{}; defer log.deinit(); var d = try spawn(targets.list, "3", log.sink()); defer d.deinit(); d.telescope = 1; d.telescope_around = 16; // The heap is a mapping the debugger learns of from the program's brk. d.syscalls = .record; // At `list_done(head)`: rdi leads to a node on the heap, malloc's header before it. _ = try d.breakAt(try d.resolve("list_done"), null); _ = try d.cont(); const node = d.regs.rdi; // Sixteen bytes before it to sixteen past its 32, in however many writes. var seen: u64 = 0; for (log.events.items) |e| { if (e.ev.kind != .mem_write) continue; for (0..64) |i| { const at = node - 16 + i; if (at >= e.ev.a[0] and at < e.ev.a[0] + e.payload.len) seen |= @as(u64, 1) << @intCast(i); } } try std.testing.expectEqual(~@as(u64, 0), seen); } test "a hook snapshots the linked list; the recording's last moment has what the program built" { var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var dir_buf: [std.Io.Dir.max_path_bytes]u8 = undefined; const dir = dir_buf[0..try tmp.dir.realPath(io, &dir_buf)]; const path = try std.fs.path.join(gpa, &.{ dir, "list.ztrace" }); defer gpa.free(path); var rec = try zt.Recorder.create(gpa, io, path); var head: u64 = 0; { errdefer rec.close() catch {}; var d = try spawn(targets.list, "6", rec.sink()); defer d.deinit(); // At `list_done(head)`: record every node, and let the program go on. const hook = struct { fn run(ctx: ?*anyopaque, dbg: *Debugger, _: Debugger.Stop) anyerror!Debugger.Action { const out: *u64 = @ptrCast(@alignCast(ctx.?)); out.* = dbg.regs.rdi; var node = dbg.regs.rdi; while (node != 0) { try dbg.snapshot(node, 16); var next: [8]u8 = undefined; if (dbg.read(node + 8, &next) != 8) return error.BadAddress; node = std.mem.readInt(u64, &next, .little); } return .go; } }.run; _ = try d.breakAt(try d.resolve("list_done"), .{ .ctx = &head, .func = hook }); try std.testing.expectEqual(@as(u8, 0), try finish(&d)); } try rec.close(); var trace = try zt.Trace.open(gpa, io, path); defer trace.close(); const last = try trace.moment(trace.len - 1); // 36, 25, ... 1 pushed, each before the last, and then reversed: 36 first again. var node = head; for ([_]u64{ 6, 5, 4, 3, 2, 1 }) |i| { var bytes: [16]u8 = undefined; var known: [16]bool = undefined; try last.read(node, &bytes, &known); try std.testing.expect(std.mem.allEqual(bool, &known, true)); try std.testing.expectEqual(@as(u64, i * i), std.mem.readInt(u64, bytes[0..8], .little)); node = std.mem.readInt(u64, bytes[8..16], .little); } try std.testing.expectEqual(@as(u64, 0), node); // Nothing of them is in the first moment: they were not built yet. var known: [16]bool = undefined; var bytes: [16]u8 = undefined; try (try trace.moment(0)).read(head, &bytes, &known); try std.testing.expect(std.mem.allEqual(bool, &known, false)); } test "a watch sends a word when it changes, and each moment keeps the region as it was" { var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var dir_buf: [std.Io.Dir.max_path_bytes]u8 = undefined; const dir = dir_buf[0..try tmp.dir.realPath(io, &dir_buf)]; const path = try std.fs.path.join(gpa, &.{ dir, "graph.ztrace" }); defer gpa.free(path); var rec = try zt.Recorder.create(gpa, io, path); rec.cut &= ~zt.Kind.line.bit(); var log: Log = .{}; defer log.deinit(); // Events to the log and to the recorder both. const Tee = struct { a: zt.Sink, b: zt.Sink, fn emit(ctx: *anyopaque, ev: *const zt.Event, payload: []const u8) anyerror!void { const t: *@This() = @ptrCast(@alignCast(ctx)); try t.a.emit(ev.*, payload); try t.b.emit(ev.*, payload); } }; var tee: Tee = .{ .a = log.sink(), .b = rec.sink() }; var dist: u64 = 0; { errdefer rec.close() catch {}; var d = try spawn(targets.graph, null, .{ .ctx = &tee, .emitFn = Tee.emit }); defer d.deinit(); const sym = d.symbol("dist").?; try std.testing.expectEqual(@as(u64, 8), sym.size); dist = sym.addr; try d.watch(dist, 8); _ = try d.breakAt(try d.resolve("graph.bfs"), null); try std.testing.expectEqual(Debugger.Stop{ .breakpoint = 1 }, try d.cont()); // A source line a stop, to the exit: the sum of the distances. const code = while (true) switch (try d.step()) { .exited => |code| break code, .step => {}, else => return error.UnexpectedStop, }; try std.testing.expectEqual(@as(u8, 18), code); } try rec.close(); // `dist` is one word: sent whole at the first stop, then once for each // of the 8 distances the search fills in, and at no other stop. var writes: usize = 0; for (log.events.items) |e| { if (e.ev.kind != .mem_write or e.ev.a[0] != dist) continue; try std.testing.expectEqual(@as(usize, 8), e.payload.len); writes += 1; } try std.testing.expectEqual(@as(usize, 9), writes); try std.testing.expect(log.count(.step) > 100); // Lines come from one file here, defined once; the one other string is where the stack began. try std.testing.expect(log.count(.line) > 100); for (log.events.items) |e| { if (e.ev.kind == .string and e.ev.a[0] != zt.event.frameId(0)) try std.testing.expect(std.mem.endsWith(u8, e.payload, ".zig")); } var trace = try zt.Trace.open(gpa, io, path); defer trace.close(); var bytes: [8]u8 = undefined; try (try trace.moment(trace.len - 1)).read(dist, &bytes, null); try std.testing.expectEqualSlices(u8, &.{ 0, 1, 1, 2, 3, 4, 5, 2 }, &bytes); // Going back: the search half done, then not begun. var seen_partial = false; for (0..trace.len) |index| { try (try trace.moment(index)).read(dist, &bytes, null); if (std.mem.eql(u8, &bytes, &.{ 0, 1, 1, 2, 0xff, 0xff, 0xff, 2 })) seen_partial = true; } try std.testing.expect(seen_partial); try (try trace.moment(1)).read(dist, &bytes, null); try std.testing.expectEqualSlices(u8, &@as([8]u8, @splat(0xff)), &bytes); // The last stop before the exit knows its line, in a file with a name. const before_exit = try trace.moment(trace.len - 2); var events = try before_exit.events(gpa); defer events.deinit(gpa); const line = (try before_exit.line(events.next().?.ev.tid)).?; var name: [std.Io.Dir.max_path_bytes]u8 = undefined; try std.testing.expect(std.mem.endsWith(u8, (try before_exit.string(line.file, &name)).?, ".zig")); } test "the same program under glibc and under musl: the syscalls tell them apart" { var glibc: Log = .{}; defer glibc.deinit(); var musl: Log = .{}; defer musl.deinit(); for ([_][]const u8{ targets.libc_glibc, targets.libc_musl }, [_]*Log{ &glibc, &musl }) |path, log| { var d = try spawn(path, null, log.sink()); defer d.deinit(); d.syscalls = .record; try std.testing.expectEqual(@as(u8, 0), try finish(&d)); try std.testing.expectEqual(@as(usize, 1), log.count(.exit)); // Both give malloc(1 MiB) its own mapping, a page more for the header, and unmap it at free. var mapped = false; var unmapped = false; for (log.events.items) |e| { if (e.ev.kind != .syscall_enter) continue; if (e.ev.aux == @backingInt(linux.SYS.mmap) and e.ev.a[1] == (1 << 20) + 4096) mapped = true; if (e.ev.aux == @backingInt(linux.SYS.munmap) and e.ev.a[1] == (1 << 20) + 4096) unmapped = true; } try std.testing.expect(mapped and unmapped); try std.testing.expectEqual(@as(usize, 1), log.calls(.exit_group)); } // glibc, dynamic: the loader opens the library, the heap comes from brk, // stdout is checked with fstat and written with write. try std.testing.expect(glibc.calls(.openat) >= 1); try std.testing.expect(glibc.calls(.brk) >= 2); try std.testing.expectEqual(@as(usize, 1), glibc.calls(.write)); try std.testing.expectEqual(@as(usize, 0), glibc.calls(.writev)); var opened_libc = false; var buffer: u64 = 0; for (glibc.events.items) |e| { if (e.ev.kind != .syscall_enter) continue; if (e.ev.aux == @backingInt(linux.SYS.openat) and std.mem.endsWith(u8, e.payload, "libc.so.6")) opened_libc = true; if (e.ev.aux == @backingInt(linux.SYS.write)) { try std.testing.expectEqualStrings("small b\n", e.payload); buffer = e.ev.a[1]; } } try std.testing.expect(opened_libc); // What is written is memory too, as it was when the kernel took it. var in_memory = false; for (glibc.events.items) |e| { if (e.ev.kind != .mem_write or e.ev.a[0] > buffer or buffer + 8 > e.ev.a[0] + e.payload.len) continue; in_memory = std.mem.eql(u8, "small b\n", e.payload[buffer - e.ev.a[0] ..][0..8]); } try std.testing.expect(in_memory); // The library and its mappings are known as they appear. var mapped_libc = false; for (glibc.events.items) |e| { if (e.ev.kind == .map and std.mem.endsWith(u8, e.payload, "libc.so.6") and e.ev.a[2] & 4 != 0) mapped_libc = true; } try std.testing.expect(mapped_libc); // musl, static: no file is opened and brk is never called (its heap is // mmap), stdout is asked whether it is a terminal with an ioctl and // written with writev. try std.testing.expectEqual(@as(usize, 0), musl.calls(.openat)); try std.testing.expectEqual(@as(usize, 0), musl.calls(.brk)); try std.testing.expectEqual(@as(usize, 0), musl.calls(.write)); try std.testing.expectEqual(@as(usize, 1), musl.calls(.writev)); try std.testing.expectEqual(@as(usize, 1), musl.calls(.ioctl)); // And it starts with a third of the syscalls or fewer. try std.testing.expect(musl.count(.syscall_enter) * 3 <= glibc.count(.syscall_enter)); } test "a syscall hook sees entries and exits, and can stop the target at one" { var d = try spawn(targets.fib, "3", null); defer d.deinit(); d.syscalls = .record; var seen: struct { enters: usize = 0, exits: usize = 0 } = .{}; d.on_syscall = .{ .ctx = &seen, .func = struct { fn run(ctx: ?*anyopaque, _: *Debugger, stop: Debugger.Stop) anyerror!Debugger.Action { const s: *@TypeOf(seen) = @ptrCast(@alignCast(ctx.?)); switch (stop) { .syscall_enter => |nr| { s.enters += 1; if (nr == @backingInt(linux.SYS.write)) return .stop; }, else => s.exits += 1, } return .go; } }.run }; // Stopped at the write of the result: its bytes are the argument. const stop = try d.cont(); try std.testing.expectEqual(Debugger.Stop{ .syscall_enter = @backingInt(linux.SYS.write) }, stop); try std.testing.expectEqualStrings("fib(3) = 2\n", try d.decode(stop.syscall_enter)); try std.testing.expectEqualStrings("write", zt.syscalls.name(stop.syscall_enter).?); try std.testing.expectEqual(@as(u8, 0), try finish(&d)); // exit_group is entered and never left. try std.testing.expectEqual(seen.enters, seen.exits + 1); } test "the threads a target makes are followed" { var log: Log = .{}; defer log.deinit(); var d = try spawn(targets.threads, null, log.sink()); defer d.deinit(); d.syscalls = .record; _ = try d.breakAt(try d.resolve("work"), null); // Each of the two threads reaches `work`, as itself. var workers: [2]linux.pid_t = undefined; for (&workers) |*tid| { try std.testing.expectEqual(Debugger.Stop{ .breakpoint = 1 }, try d.cont()); tid.* = d.proc.tid; try std.testing.expect(tid.* != d.proc.pid); } try std.testing.expect(workers[0] != workers[1]); try std.testing.expectEqual(@as(u8, 0), try finish(&d)); try std.testing.expectEqual(@as(usize, 2), log.count(.thread_start)); try std.testing.expectEqual(@as(usize, 2), log.count(.thread_exit)); try std.testing.expectEqual(@as(usize, 2), log.count(.breakpoint)); // The result, 1000 * (1 + 2), is what main printed: no thread lost a step to the tracer. for (log.events.items) |e| { if (e.ev.kind == .syscall_enter and e.ev.aux == @backingInt(linux.SYS.write)) try std.testing.expectEqualStrings("total = 3000\n", e.payload); } } test "a running process is attached to, looked at and let go" { const rc = linux.fork(); if (rc == 0) { while (true) _ = linux.pause(); } const pid: linux.pid_t = @intCast(rc); defer { _ = linux.kill(pid, .KILL); var status: u32 = 0; _ = linux.waitpid(pid, @ptrCast(&status), 0); } var d = try Debugger.attach(gpa, io, pid, null); // It is this test's own program, stopped in its pause. try std.testing.expect(d.syms.moduleAt(d.regs.rip) != null); try std.testing.expect(d.syms.mappingAt(d.regs.rsp) != null); var word: [8]u8 = undefined; try std.testing.expectEqual(@as(usize, 8), d.read(d.regs.rsp, &word)); d.deinit(); // Let go, it is alive and can be attached to again. var again = try Debugger.attach(gpa, io, pid, null); again.deinit(); }