diff options
Diffstat (limited to 'src/instr/rt.zig')
| -rw-r--r-- | src/instr/rt.zig | 227 |
1 files changed, 227 insertions, 0 deletions
diff --git a/src/instr/rt.zig b/src/instr/rt.zig new file mode 100644 index 0000000..3719409 --- /dev/null +++ b/src/instr/rt.zig @@ -0,0 +1,227 @@ +//! libztrace-rt.a: what compiler-instrumented code calls, linked into the +//! target; every call becomes an event in the ring the tracer handed over, +//! or returns at once when there is none. Two faces: +//! +//! Our pass (llvm/pass.cpp): +//! __zt_line(file, line, column) line a0=file a1=line a2=column +//! __zt_store(addr, size) mem_write a0=addr a1=len, the bytes (see `wrote`) +//! __zt_load(addr, size) mem_read a0=addr a1=len +//! __zt_enter(name, type, sp, site) call a0=function name a1=call site a2=sp a3=function type +//! __zt_exit(name, value, size) ret a0=function name a1=value, aux=bytes of value (0: none) +//! __zt_var(addr, size, name, type, arg) variable a0=addr a1=size a2=name a3=type, aux=N for the Nth parameter +//! file, name and type arrive as pointers to text records and leave as +//! string ids. The records, and the program's globals, sit in two sections +//! the pass filled: before the first event the runtime numbers the texts +//! and emits each as a `string` (from thread 0: no thread), and each global +//! as a `variable` with one `mem_write` of what it holds, from the thread +//! that got there first, which is inside no call yet. A local is declared, +//! never dumped: what it holds arrives with the stores. +//! +//! No pc in `line`, `mem_write` and `mem_read`, though event.zig has a +//! place for one: the source line is the place, and seven bytes would be a +//! third of each of them in a recording. +//! +//! Stock clang, no plugin: +//! -fsanitize-coverage=trace-pc-guard edge a0=pc +//! -fsanitize-coverage=trace-cmp cmp aux=operand bytes a0=pc a1=lhs a2=rhs +//! -finstrument-functions call a0=function address a1=call site a2=frame +//! ret a0=function address +//! +//! Raw syscalls only, no allocation: a store may be anywhere. +// shortcut: one program, one runtime: the texts of a shared library loaded later are never numbered; walk its sections on dlopen when a target needs it. +const std = @import("std"); +const linux = std.os.linux; +const zt = @import("ztrace"); + +/// 0 untried, 1 starting, 2 tracing, 3 not traced. +var state: std.atomic.Value(u8) = .init(0); +var ring: *zt.Ring = undefined; + +fn start(tid: u32) bool { + @branchHint(.cold); + while (true) switch (state.load(.acquire)) { + 2 => return true, + 3 => return false, + // Another thread is emitting the names: nothing may get ahead of them. + 1 => _ = linux.sched_yield(), + else => if (state.cmpxchgStrong(0, 1, .acquire, .monotonic) == null) { + const found = zt.client.get(); + if (found) |r| { + ring = r; + names(); + globals(tid); + } + state.store(if (found != null) 2 else 3, .release); + }, + }; +} + +fn put(tid: u32, kind: zt.Kind, aux: u16, a: [6]u64, payload: []const u8) void { + ring.emit(.{ .ts = zt.event.now(), .tid = tid, .kind = kind, .aux = aux, .a = a }, payload); +} + +const Thread = struct { + /// A gettid a thread, not an event: the syscall would be half the cost + /// of an event. + // shortcut: a forked child keeps its parent's tid; reset it in a fork hook once a target forks. + tid: u32 = 0, + inside: bool = false, +}; +threadlocal var thread: Thread = .{}; + +/// The calling thread, for one event; `inside` is the caller's to clear. +/// Null when nobody listens, or when the thread is already in here: what the +/// runtime calls (memcpy and strlen, in a libc compiled with the pass) must +/// not trace itself. +fn enter() ?*Thread { + const s = state.load(.monotonic); + if (s == 3) return null; + const t = &thread; + if (t.inside) return null; + t.inside = true; + if (t.tid == 0) t.tid = @intCast(linux.gettid()); + if (s == 2 or start(t.tid)) return t; + t.inside = false; + return null; +} + +/// An event with no text in it: a text's id is read after `enter`, which +/// may be what numbers it. +fn emit(kind: zt.Kind, aux: u16, a: [6]u64, payload: []const u8) void { + const t = enter() orelse return; + defer t.inside = false; + put(t.tid, kind, aux, a, payload); +} + +/// The `mem_write`s of one write (a store, a memset, a memcpy, a global's +/// first contents), in pieces that fit the smallest ring. a1 is how much was +/// written from a0 on, so the first piece says the whole length; a payload +/// shorter than a1 is all that is recorded of it. A write is recorded up to +/// `most`: a megabyte cleared is not a megabyte in the recording. +const most = 64 << 10; + +fn wrote(tid: u32, addr: usize, len: usize) void { + var at: usize = 0; + while (at < @min(len, most)) : (at += 2048) { + const bytes: [*]const u8 = @ptrFromInt(addr + at); + put(tid, .mem_write, 0, .{ addr + at, len - at, 0, 0, 0, 0 }, bytes[0..@min(len - at, 2048)]); + } +} + +/// The bounds the linker gives a section named like a C identifier; both 0 +/// when no object has the section. +fn section(comptime name: []const u8) [2]usize { + return .{ + @intFromPtr(@extern(?*const u8, .{ .name = "__start_" ++ name, .linkage = .weak })), + @intFromPtr(@extern(?*const u8, .{ .name = "__stop_" ++ name, .linkage = .weak })), + }; +} + +/// A text of the program, in section ztrace_strs: this, then the text, +/// padded to 8 bytes. +const Text = extern struct { + /// The string id. The pass leaves 0, to be numbered here from 1: ids + /// small enough to cost a recording a byte or two each. It fixes only + /// the ids nothing but a viewer looks up (`types.defId`). + id: u64, + len: u64, +}; + +fn names() void { + var at, const end = section("ztrace_strs"); + var next: u64 = 0; + while (at < end) { + const text: *Text = @ptrFromInt(at); + if (text.id == 0) { + next += 1; + text.id = next; + } + const bytes: [*]const u8 = @ptrFromInt(at + @sizeOf(Text)); + // A text the ring cannot hold is cut: better than none of it. + put(0, .string, 0, .{ text.id, 0, 0, 0, 0, 0 }, bytes[0..@min(text.len, ring.hdr.capacity / 2)]); + at += @sizeOf(Text) + std.mem.alignForward(usize, text.len, 8); + } +} + +/// ztrace_vars: (address, size, name, type)*. +fn globals(tid: u32) void { + var at, const end = section("ztrace_vars"); + while (at < end) : (at += 32) { + const g: *const extern struct { addr: u64, size: u64, name: *const Text, type: *const Text } = @ptrFromInt(at); + put(tid, .variable, 0, .{ g.addr, g.size, g.name.id, g.type.id, 0, 0 }, ""); + wrote(tid, g.addr, g.size); + } +} + +// The pass. + +export fn __zt_line(file: *const Text, line: u32, column: u32) void { + const t = enter() orelse return; + defer t.inside = false; + put(t.tid, .line, 0, .{ file.id, line, column, 0, 0, 0 }, ""); +} + +export fn __zt_store(addr: usize, size: u64) void { + const t = enter() orelse return; + defer t.inside = false; + wrote(t.tid, addr, size); +} + +export fn __zt_load(addr: usize, size: u64) void { + emit(.mem_read, 0, .{ addr, size, 0, 0, 0, 0 }, ""); +} + +export fn __zt_enter(name: *const Text, type_text: *const Text, sp: usize, site: usize) void { + const t = enter() orelse return; + defer t.inside = false; + put(t.tid, .call, 0, .{ name.id, site, sp, type_text.id, 0, 0 }, ""); +} + +export fn __zt_exit(name: *const Text, value: u64, size: u32) void { + const t = enter() orelse return; + defer t.inside = false; + put(t.tid, .ret, @intCast(size), .{ name.id, value, 0, 0, 0, 0 }, ""); +} + +export fn __zt_var(addr: usize, size: u64, name: *const Text, type_text: *const Text, arg: u32) void { + const t = enter() orelse return; + defer t.inside = false; + put(t.tid, .variable, @truncate(arg), .{ addr, size, name.id, type_text.id, 0, 0 }, ""); +} + +// Stock clang. + +export fn __sanitizer_cov_trace_pc_guard_init(_: *u32, _: *u32) void {} + +export fn __sanitizer_cov_trace_pc_guard(_: *u32) void { + emit(.edge, 0, .{ @returnAddress(), 0, 0, 0, 0, 0 }, ""); +} + +comptime { + for (.{ u8, u16, u32, u64 }) |T| { + const f = struct { + fn cmp(lhs: T, rhs: T) callconv(.c) void { + emit(.cmp, @sizeOf(T), .{ @returnAddress(), lhs, rhs, 0, 0, 0 }, ""); + } + }.cmp; + for (.{ "", "const_" }) |c| @export(&f, .{ .name = std.fmt.comptimePrint("__sanitizer_cov_trace_{s}cmp{d}", .{ c, @sizeOf(T) }) }); + } +} + +/// `cases` is (count, bits, values...). One event a switch, not one a case: +/// rhs is the case taken, or the first when it is the default. +export fn __sanitizer_cov_trace_switch(value: u64, cases: [*]const u64) void { + var rhs = cases[2]; + for (cases[2..][0..cases[0]]) |c| { + if (c == value) rhs = c; + } + emit(.cmp, @intCast(cases[1] / 8), .{ @returnAddress(), value, rhs, 0, 0, 0 }, ""); +} + +export fn __cyg_profile_func_enter(function: usize, site: usize) void { + emit(.call, 0, .{ function, site, @frameAddress(), 0, 0, 0 }, ""); +} + +export fn __cyg_profile_func_exit(function: usize, _: usize) void { + emit(.ret, 0, .{ function, 0, 0, 0, 0, 0 }, ""); +} |
