//! ztrace show: what a recording holds, and the program's state at a moment. const std = @import("std"); const zt = @import("ztrace"); const util = @import("util.zig"); pub const usage = \\usage: ztrace show FILE [MOMENT] \\ \\Without MOMENT: how many moments and events, and events by kind. \\With one (negative counts from the end): each thread's registers, source \\line and open calls, the live heap, the named variables with their \\bytes, and the mapped regions, as of that moment. \\ ; pub fn run(init: std.process.Init, args: []const [:0]const u8) !void { if (args.len < 1 or args.len > 2) util.fail(usage, .{}); var trace = try zt.Trace.open(init.gpa, init.io, args[0]); defer trace.close(); var buf: [4096]u8 = undefined; var file_writer = std.Io.File.stdout().writer(init.io, &buf); const w = &file_writer.interface; const result = if (args.len == 1) summary(init.gpa, &trace, w) else blk: { const n = std.fmt.parseInt(i64, args[1], 10) catch util.fail(usage, .{}); const index = if (n < 0) @as(i64, @intCast(trace.len)) + n else n; if (index < 0 or index >= trace.len) util.fail("{s}: {d} moments, no moment {d}\n", .{ args[0], trace.len, n }); break :blk state(init.arena.allocator(), &trace, @intCast(index), w); }; result catch |err| switch (err) { // The reader went away (`| head`): not an error. error.WriteFailed => return, else => |e| return e, }; w.flush() catch {}; } fn summary(gpa: std.mem.Allocator, trace: *zt.Trace, w: *std.Io.Writer) !void { var by_kind: [64]u64 = @splat(0); var total: u64 = 0; for (0..trace.len) |index| { var events = try (try trace.moment(index)).events(gpa); defer events.deinit(gpa); while (events.next()) |item| : (total += 1) by_kind[@intFromEnum(item.ev.kind) & 63] += 1; } try w.print("{d} moments, {d} events\n", .{ trace.len, total }); for (by_kind, 0..) |n, kind| { if (n != 0) try w.print("{d:>10} {t}\n", .{ n, @as(zt.Kind, @enumFromInt(kind)) }); } } /// A string id as text, or the id itself when the recording never defined it. fn name(m: zt.store.Moment, arena: std.mem.Allocator, id: u64) ![]const u8 { const buf = try arena.alloc(u8, 4096); return (try m.string(id, buf)) orelse std.fmt.allocPrint(arena, "#{x}", .{id}); } fn state(arena: std.mem.Allocator, trace: *zt.Trace, index: u64, w: *std.Io.Writer) !void { const m = try trace.moment(index); try w.print("moment {d} of {d}, {d} events so far\n", .{ index, trace.len, try m.count() }); for (try m.threads(arena)) |tid| { try w.print("\nthread {d}", .{tid}); if (try m.line(tid)) |line| try w.print(" {s}:{d}:{d}", .{ try name(m, arena, line.file), line.line, line.column }); try w.writeAll("\n"); if (try m.regs(tid)) |regs| { inline for (zt.Regs.names, 0..) |reg, i| { try w.print(" {s:<6} {x:0>16}{s}", .{ reg, @field(regs, reg), if (i % 3 == 2) "\n" else "" }); } if (zt.Regs.names.len % 3 != 0) try w.writeAll("\n"); } for (try m.stack(arena, tid), 0..) |frame, depth| { try w.print(" #{d} {s} from {x} sp {x}\n", .{ depth, try name(m, arena, frame.function), frame.site, frame.sp }); } } const heap = try m.heap(arena); if (heap.len > 0) try w.print("\nheap: {d} live\n", .{heap.len}); for (heap) |a| try w.print(" {x:0>12} {d:>8} bytes, by {x}, event {d}\n", .{ a.ptr, a.size, a.pc, a.born }); const variables = try m.variables(arena); if (variables.len > 0) try w.writeAll("\nvariables\n"); for (variables) |v| { var bytes: [16]u8 = undefined; var known: [16]bool = undefined; const n: usize = @intCast(@min(v.size, bytes.len)); try m.read(v.addr, bytes[0..n], known[0..n]); try w.print(" {x:0>12} {s}: {s} =", .{ v.addr, try name(m, arena, v.name), try name(m, arena, v.type) }); for (bytes[0..n], known[0..n]) |byte, k| { if (k) try w.print(" {x:0>2}", .{byte}) else try w.writeAll(" ??"); } try w.print("{s}\n", .{if (v.size > n) " ..." else ""}); } const mappings = try m.mappings(arena); if (mappings.len > 0) try w.writeAll("\nmappings\n"); for (mappings) |region| { var path: []const u8 = ""; var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined; _ = try m.mapping(region.addr, &path, &path_buf); try w.print(" {x:0>12}-{x:0>12} {s}\n", .{ region.addr, region.addr + region.len, path }); } }