tiny.coz.loaded_files

1const std = @import("std");23pub const Index = struct {4    entries: std.StringHashMapUnmanaged(usize) = .empty,56    pub fn deinit(self: *Index, allocator: std.mem.Allocator) void {7        var iter = self.entries.keyIterator();8        while (iter.next()) |key| allocator.free(key.*);9        self.entries.deinit(allocator);10        self.* = .{};11    }1213    pub fn count(self: *const Index) usize {14        return self.entries.count();15    }1617    pub fn get(self: *const Index, path: []const u8) ?usize {18        return self.entries.get(path);19    }2021    pub fn put(self: *Index, allocator: std.mem.Allocator, path: []const u8, load_address: usize) !void {22        if (self.entries.getPtr(path)) |existing| {23            existing.* = load_address;24            return;25        }2627        const owned_path = try allocator.dupe(u8, path);28        errdefer allocator.free(owned_path);29        try self.entries.put(allocator, owned_path, load_address);30    }31};3233pub fn parseProcMaps(allocator: std.mem.Allocator, text: []const u8) !Index {34    var result: Index = .{};35    errdefer result.deinit(allocator);3637    var lines = std.mem.splitScalar(u8, text, '\n');38    while (lines.next()) |line| {39        try parseProcMapsLine(allocator, &result, line);40    }4142    return result;43}4445fn parseProcMapsLine(allocator: std.mem.Allocator, result: *Index, raw_line: []const u8) !void {46    const line = trimLeft(raw_line, " \t\r");47    if (line.len == 0) return;4849    var cursor: usize = 0;50    const address_field = nextField(line, &cursor) orelse return error.InvalidProcMapsLine;51    const perms = nextField(line, &cursor) orelse return error.InvalidProcMapsLine;52    const offset_field = nextField(line, &cursor) orelse return error.InvalidProcMapsLine;53    const dev = nextField(line, &cursor) orelse return error.InvalidProcMapsLine;54    const inode = nextField(line, &cursor) orelse return error.InvalidProcMapsLine;55    const path = trimRight(trimLeft(line[cursor..], " \t"), "\r");5657    if (std.mem.indexOfScalar(u8, dev, ':') == null) return error.InvalidProcMapsLine;58    _ = try parseDecimal(u64, inode);5960    if (perms.len < 3 or perms[2] != 'x') return;61    if (path.len == 0 or path[0] != '/') return;6263    const dash = std.mem.indexOfScalar(u8, address_field, '-') orelse return error.InvalidProcMapsLine;64    const base = try parseHex(usize, address_field[0..dash]);65    _ = try parseHex(usize, address_field[dash + 1 ..]);66    const offset = try parseHex(usize, offset_field);67    const load_address = std.math.sub(usize, base, offset) catch return error.InvalidMappingAddress;6869    try result.put(allocator, path, load_address);70}7172fn nextField(line: []const u8, cursor: *usize) ?[]const u8 {73    while (cursor.* < line.len and isSpace(line[cursor.*])) cursor.* += 1;74    if (cursor.* >= line.len) return null;7576    const start = cursor.*;77    while (cursor.* < line.len and !isSpace(line[cursor.*])) cursor.* += 1;78    return line[start..cursor.*];79}8081fn isSpace(byte: u8) bool {82    return byte == ' ' or byte == '\t';83}8485fn parseHex(comptime T: type, text: []const u8) !T {86    return std.fmt.parseUnsigned(T, text, 16) catch return error.InvalidProcMapsLine;87}8889fn parseDecimal(comptime T: type, text: []const u8) !T {90    return std.fmt.parseUnsigned(T, text, 10) catch return error.InvalidProcMapsLine;91}9293fn trimLeft(bytes: []const u8, values: []const u8) []const u8 {94    var start: usize = 0;95    while (start < bytes.len and std.mem.indexOfScalar(u8, values, bytes[start]) != null) start += 1;96    return bytes[start..];97}9899fn trimRight(bytes: []const u8, values: []const u8) []const u8 {100    var end = bytes.len;101    while (end > 0 and std.mem.indexOfScalar(u8, values, bytes[end - 1]) != null) end -= 1;102    return bytes[0..end];103}104105test "proc maps parser keeps executable absolute mappings" {106    const text =107        \\00400000-00452000 r-xp 00000000 08:02 173521 /usr/bin/app108        \\00652000-00653000 r--p 00052000 08:02 173521 /usr/bin/app109        \\7f0000001000-7f0000011000 r-xp 00002000 08:02 222222 /lib/libc.so.6110        \\7f0000011000-7f0000012000 rw-p 00012000 08:02 222222 /lib/libc.so.6111        \\112    ;113114    var files = try parseProcMaps(std.testing.allocator, text);115    defer files.deinit(std.testing.allocator);116117    try std.testing.expectEqual(@as(usize, 2), files.count());118    try std.testing.expectEqual(@as(usize, 0x00400000), files.get("/usr/bin/app").?);119    try std.testing.expectEqual(@as(usize, 0x7f0000001000 - 0x2000), files.get("/lib/libc.so.6").?);120}121122test "proc maps parser ignores nonabsolute and nonexecutable mappings" {123    const text =124        \\00100000-00110000 rw-p 00000000 00:00 0 /tmp/data125        \\00200000-00210000 r-xp 00000000 00:00 0 [vdso]126        \\00300000-00310000 r-xp 00000000 00:00 0 relative/path127        \\128    ;129130    var files = try parseProcMaps(std.testing.allocator, text);131    defer files.deinit(std.testing.allocator);132133    try std.testing.expectEqual(@as(usize, 0), files.count());134}135136test "proc maps parser preserves path suffixes" {137    const text =138        \\00001000-00002000 r-xp 00000000 00:00 1 /tmp/name with space (deleted)139        \\140    ;141142    var files = try parseProcMaps(std.testing.allocator, text);143    defer files.deinit(std.testing.allocator);144145    try std.testing.expectEqual(@as(usize, 1), files.count());146    try std.testing.expectEqual(@as(usize, 0x1000), files.get("/tmp/name with space (deleted)").?);147}148149test "proc maps parser uses the latest mapping for duplicate paths" {150    const text =151        \\00001000-00002000 r-xp 00000000 00:00 1 /bin/app152        \\00003000-00004000 r-xp 00001000 00:00 1 /bin/app153        \\154    ;155156    var files = try parseProcMaps(std.testing.allocator, text);157    defer files.deinit(std.testing.allocator);158159    try std.testing.expectEqual(@as(usize, 1), files.count());160    try std.testing.expectEqual(@as(usize, 0x2000), files.get("/bin/app").?);161}162163test "proc maps parser rejects malformed mapping lines" {164    const text = "00001000-00002000 r-xp 00000000 00:00 /bin/app\n";165166    try std.testing.expectEqual(error.InvalidProcMapsLine, parseProcMaps(std.testing.allocator, text));167}

1pub const loaded_files = @import("files.zig");