summaryrefslogtreecommitdiff
path: root/src/agent/watch.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 11:44:48 -0300
committerGabriel Schneider <[email protected]>2026-11-10 12:09:34 -0300
commitce7c0abf14e7ab056d5479adc3f05df9976e94e4 (patch)
tree8931de9a55b3d7c2ec2d52d3b3817c6f7eb5db5a /src/agent/watch.zig
parente7aa7801c10ed34194b7fe3f5ca8722a72404e65 (diff)
downloadcomputeranim-ce7c0abf14e7ab056d5479adc3f05df9976e94e4.tar.gz
computeranim-ce7c0abf14e7ab056d5479adc3f05df9976e94e4.zip
agent: the in-process backend, and ztrace run's options for it
libztrace-agent.so (preloaded) and libztrace-agent.a (linked in), one source: map and thread_start at startup; alloc/free from the interposed allocator; syscall_enter/exit through Syscall User Dispatch; call/ret from int3 hooks; mem_write from watched regions diffed in-process; the target-side API (include/ztrace.h, and the ztrace-agent module for Zig). ztrace run turns each on (--alloc --syscalls --hook --watch), chooses the moments (--cut), and stops the target at event kinds without ptrace (--stop-at, --read, -i). test-agent records real targets and checks the recordings. Co-Authored-By: Claude Fable 5.2 <[email protected]>
Diffstat (limited to 'src/agent/watch.zig')
-rw-r--r--src/agent/watch.zig130
1 files changed, 130 insertions, 0 deletions
diff --git a/src/agent/watch.zig b/src/agent/watch.zig
new file mode 100644
index 0000000..356dac8
--- /dev/null
+++ b/src/agent/watch.zig
@@ -0,0 +1,130 @@
+//! Watched memory: regions whose changes become `mem_write` events. Each
+//! region has a shadow copy in the agent's own memory; `diff` compares the
+//! two and emits the runs that changed. Plain memory compares in the target's
+//! own address space: no syscall, no page protection, any granularity. The
+//! agent calls `diff` before every event that ends a moment, so a moment's
+//! memory is what the target had when that event happened.
+const std = @import("std");
+const linux = std.os.linux;
+const agent = @import("agent.zig");
+
+const Region = struct {
+ addr: usize,
+ len: usize,
+ shadow: [*]u8,
+ /// The thread that asked, and how many hooked calls it had open: the
+ /// region is forgotten when that call returns, as the recorder forgets
+ /// its `variable`. Depth 0 lives forever.
+ tid: u32,
+ depth: u32,
+};
+
+// shortcut: 64 regions, each compared whole at every moment; when a target
+// watches megabytes, find the dirty pages first (PAGEMAP_SCAN) and compare those.
+var table: [64]Region = undefined;
+var count: usize = 0;
+var busy: std.atomic.Value(bool) = .init(false);
+
+/// The memory must stay mapped for as long as it is watched.
+pub fn add(memory: []const u8, tid: u32, depth: u32) void {
+ if (memory.len == 0) return;
+ const shadow = linux.mmap(null, memory.len, .{ .READ = true, .WRITE = true }, .{ .TYPE = .PRIVATE, .ANONYMOUS = true }, -1, 0);
+ if (linux.errno(shadow) != .SUCCESS) return;
+ while (busy.swap(true, .acquire)) std.atomic.spinLoopHint();
+ defer busy.store(false, .release);
+ if (count == table.len) {
+ _ = linux.munmap(@ptrFromInt(shadow), memory.len);
+ return;
+ }
+ table[count] = .{ .addr = @intFromPtr(memory.ptr), .len = memory.len, .shadow = @ptrFromInt(shadow), .tid = tid, .depth = depth };
+ @memcpy(table[count].shadow, memory);
+ count += 1;
+}
+
+/// Forgets what `tid` watched from inside calls deeper than `depth`.
+pub fn drop(tid: u32, depth: u32) void {
+ if (count == 0) return;
+ while (busy.swap(true, .acquire)) std.atomic.spinLoopHint();
+ defer busy.store(false, .release);
+ var i: usize = 0;
+ while (i < count) {
+ const r = table[i];
+ if (r.tid != tid or r.depth <= depth) {
+ i += 1;
+ continue;
+ }
+ _ = linux.munmap(r.shadow, r.len);
+ count -= 1;
+ table[i] = table[count];
+ }
+}
+
+/// Emits what changed in every region since the last time.
+pub fn diff() void {
+ if (count == 0) return;
+ // Busy: another thread is at it, or this one is, below this frame.
+ if (busy.swap(true, .acquire)) return;
+ defer busy.store(false, .release);
+ for (table[0..count]) |r| {
+ var changes: Changes = .{ .old = r.shadow[0..r.len], .new = @as([*]const u8, @ptrFromInt(r.addr))[0..r.len] };
+ while (changes.next()) |run| agent.write(r.addr + run.at, run.bytes);
+ }
+}
+
+/// The runs of bytes where `new` differs from `old`, each brought into `old`
+/// as it is returned. Changes less than 8 bytes apart travel as one run.
+pub const Changes = struct {
+ old: []u8,
+ new: []const u8,
+ at: usize = 0,
+
+ pub const Run = struct { at: usize, bytes: []const u8 };
+
+ pub fn next(c: *Changes) ?Run {
+ const from = c.at + same(c.old[c.at..], c.new[c.at..]);
+ if (from == c.new.len) {
+ c.at = from;
+ return null;
+ }
+ var to = from + 1;
+ var i = to;
+ while (i < c.new.len and i - to < 8) : (i += 1) {
+ if (c.old[i] != c.new[i]) to = i + 1;
+ }
+ @memcpy(c.old[from..to], c.new[from..to]);
+ c.at = to;
+ // From the copy: the target may be writing there right now.
+ return .{ .at = from, .bytes = c.old[from..to] };
+ }
+
+ /// How many bytes at the start of `a` and `b` are equal.
+ fn same(a: []const u8, b: []const u8) usize {
+ const V = @Vector(32, u8);
+ var i: usize = 0;
+ while (i + 32 <= a.len) : (i += 32) {
+ const differ: u32 = @bitCast(@as(V, a[i..][0..32].*) != @as(V, b[i..][0..32].*));
+ if (differ != 0) return i + @ctz(differ);
+ }
+ while (i < a.len and a[i] == b[i]) i += 1;
+ return i;
+ }
+};
+
+test "changes are found as runs and folded into the old copy" {
+ var old: [200]u8 = @splat(0);
+ var new: [200]u8 = @splat(0);
+ new[3] = 1;
+ new[9] = 2; // 5 equal bytes after the first: one run
+ new[100] = 3;
+ new[199] = 4;
+ var changes: Changes = .{ .old = &old, .new = &new };
+ const a = changes.next().?;
+ try std.testing.expectEqual(@as(usize, 3), a.at);
+ try std.testing.expectEqualSlices(u8, &.{ 1, 0, 0, 0, 0, 0, 2 }, a.bytes);
+ try std.testing.expectEqual(@as(usize, 100), changes.next().?.at);
+ try std.testing.expectEqual(@as(usize, 199), changes.next().?.at);
+ try std.testing.expect(changes.next() == null);
+ try std.testing.expectEqualSlices(u8, &new, &old);
+ changes.at = 0;
+ try std.testing.expect(changes.next() == null);
+}