1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
//! 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 });
}
}
|