diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-10 11:44:48 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-10 12:09:34 -0300 |
| commit | ce7c0abf14e7ab056d5479adc3f05df9976e94e4 (patch) | |
| tree | 8931de9a55b3d7c2ec2d52d3b3817c6f7eb5db5a /src/agent/symbols.zig | |
| parent | e7aa7801c10ed34194b7fe3f5ca8722a72404e65 (diff) | |
| download | computeranim-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/symbols.zig')
| -rw-r--r-- | src/agent/symbols.zig | 158 |
1 files changed, 158 insertions, 0 deletions
diff --git a/src/agent/symbols.zig b/src/agent/symbols.zig new file mode 100644 index 0000000..6504ff6 --- /dev/null +++ b/src/agent/symbols.zig @@ -0,0 +1,158 @@ +//! Where things are in a process: its mappings (/proc/PID/maps) and the +//! symbols of the ELF files mapped there. Raw syscalls and no allocation: +//! the agent runs this on itself at startup, the tracer on its child. +const std = @import("std"); +const linux = std.os.linux; +const Elf = std.elf.Elf64; + +pub const Map = struct { + start: u64, + end: u64, + /// PROT_READ 1, PROT_WRITE 2, PROT_EXEC 4. + prot: u32, + offset: u64, + /// Empty for anonymous memory. Valid until the next `next`. + path: []const u8, +}; + +pub const Maps = struct { + fd: linux.fd_t, + buf: [8192]u8 = undefined, + len: usize = 0, + at: usize = 0, + + /// `pid` null: this process. + pub fn open(pid: ?linux.pid_t) ?Maps { + var name: [32]u8 = undefined; + const path: [*:0]const u8 = if (pid) |p| @ptrCast(std.fmt.bufPrint(&name, "/proc/{d}/maps\x00", .{p}) catch unreachable) else "/proc/self/maps"; + const rc = linux.open(path, .{}, 0); + return if (linux.errno(rc) == .SUCCESS) .{ .fd = @intCast(rc) } else null; + } + + pub fn close(m: *Maps) void { + _ = linux.close(m.fd); + } + + pub fn next(m: *Maps) ?Map { + while (true) { + if (std.mem.indexOfScalarPos(u8, m.buf[0..m.len], m.at, '\n')) |end| { + const line = m.buf[m.at..end]; + m.at = end + 1; + return parse(line) orelse continue; + } + // No whole line left: keep the rest and read more. + std.mem.copyForwards(u8, &m.buf, m.buf[m.at..m.len]); + m.len -= m.at; + m.at = 0; + const n = linux.read(m.fd, m.buf[m.len..].ptr, m.buf.len - m.len); + if (linux.errno(n) != .SUCCESS or n == 0) return null; + m.len += n; + } + } + + /// "55d0c0a00000-55d0c0a01000 r-xp 00001000 08:02 1234 /usr/bin/true" + fn parse(line: []const u8) ?Map { + var it = std.mem.tokenizeScalar(u8, line, ' '); + const range = it.next() orelse return null; + const perms = it.next() orelse return null; + const offset = it.next() orelse return null; + _ = it.next(); // device + _ = it.next(); // inode + const dash = std.mem.indexOfScalar(u8, range, '-') orelse return null; + if (perms.len < 3) return null; + return .{ + .start = std.fmt.parseInt(u64, range[0..dash], 16) catch return null, + .end = std.fmt.parseInt(u64, range[dash + 1 ..], 16) catch return null, + .prot = @as(u32, @intFromBool(perms[0] == 'r')) | @as(u32, @intFromBool(perms[1] == 'w')) << 1 | @as(u32, @intFromBool(perms[2] == 'x')) << 2, + .offset = std.fmt.parseInt(u64, offset, 16) catch return null, + .path = it.rest(), + }; + } +}; + +pub const Symbol = struct { addr: u64, size: u64 }; + +/// The function or object called `name` in the first file mapped in `pid` +/// (null: this process) that has one, lowest address first: the executable +/// before its libraries. Static symbols count when the file is not stripped. +pub fn lookup(pid: ?linux.pid_t, name: []const u8) ?Symbol { + var maps = Maps.open(pid) orelse return null; + defer maps.close(); + while (maps.next()) |m| { + // A file's first mapping starts at its ELF header. + if (m.offset != 0 or m.path.len == 0 or m.path[0] != '/') continue; + if (inFile(m.path, m.start, name)) |symbol| return symbol; + } + return null; +} + +/// What "ADDR", "ADDR:LEN" or a symbol's name stands for in `pid`. +pub fn find(pid: ?linux.pid_t, spec: []const u8) ?Symbol { + if (spec.len == 0 or !std.ascii.isDigit(spec[0])) return lookup(pid, spec); + const colon = std.mem.indexOfScalar(u8, spec, ':') orelse spec.len; + return .{ + .addr = std.fmt.parseInt(u64, spec[0..colon], 0) catch return null, + .size = if (colon == spec.len) 0 else std.fmt.parseInt(u64, spec[colon + 1 ..], 0) catch return null, + }; +} + +fn inFile(path: []const u8, base: u64, name: []const u8) ?Symbol { + var path_z: [4097]u8 = undefined; + if (path.len >= path_z.len) return null; + @memcpy(path_z[0..path.len], path); + path_z[path.len] = 0; + const rc = linux.open(@ptrCast(&path_z), .{}, 0); + if (linux.errno(rc) != .SUCCESS) return null; + const fd: linux.fd_t = @intCast(rc); + const size: usize = @intCast(linux.lseek(fd, 0, linux.SEEK.END)); + const mapped = linux.mmap(null, size, .{ .READ = true }, .{ .TYPE = .PRIVATE }, fd, 0); + _ = linux.close(fd); + if (linux.errno(mapped) != .SUCCESS) return null; + defer _ = linux.munmap(@ptrFromInt(mapped), size); + const file = @as([*]const u8, @ptrFromInt(mapped))[0..size]; + + if (size < @sizeOf(Elf.Ehdr) or !std.mem.eql(u8, file[0..5], "\x7fELF\x02")) return null; + const ehdr: *align(1) const Elf.Ehdr = @ptrCast(file.ptr); + const phdrs = table(Elf.Phdr, file, ehdr.phoff, ehdr.phnum) orelse return null; + const shdrs = table(Elf.Shdr, file, ehdr.shoff, ehdr.shnum) orelse return null; + + // `base` is where the lowest loaded page of the file went. + var low: u64 = std.math.maxInt(u64); + for (phdrs) |ph| { + if (ph.type == .LOAD) low = @min(low, ph.vaddr & ~@as(u64, 4095)); + } + for (shdrs) |sh| { + if (sh.type != .SYMTAB and sh.type != .DYNSYM) continue; + if (sh.link >= shdrs.len) continue; + const syms = table(Elf.Sym, file, sh.offset, sh.size / @sizeOf(Elf.Sym)) orelse continue; + const names = table(u8, file, shdrs[sh.link].offset, shdrs[sh.link].size) orelse continue; + for (syms) |sym| { + if (sym.shndx == 0 or sym.name >= names.len) continue; + switch (sym.info.type) { + .FUNC, .OBJECT, .NOTYPE => {}, + else => continue, + } + const rest = names[sym.name..]; + if (rest.len > name.len and rest[name.len] == 0 and std.mem.startsWith(u8, rest, name)) return .{ .addr = sym.value -% low +% base, .size = sym.size }; + } + } + return null; +} + +fn table(comptime T: type, file: []const u8, offset: u64, count: u64) ?[]align(1) const T { + if (offset > file.len or count > (file.len - offset) / @sizeOf(T)) return null; + return @as([*]align(1) const T, @ptrCast(file.ptr + offset))[0..count]; +} + +test "this process's mappings and a symbol of its executable" { + var maps = Maps.open(null).?; + defer maps.close(); + const here = @intFromPtr(&inFile); + var found = false; + while (maps.next()) |m| { + if (here >= m.start and here < m.end) found = m.prot & 4 != 0 and m.path.len > 0; + } + try std.testing.expect(found); + try std.testing.expect(lookup(null, "no such symbol anywhere") == null); + try std.testing.expectEqual(Symbol{ .addr = 0x1000, .size = 64 }, find(null, "0x1000:64").?); +} |
