summaryrefslogtreecommitdiff
path: root/src/host/memory.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/host/memory.zig')
-rw-r--r--src/host/memory.zig406
1 files changed, 406 insertions, 0 deletions
diff --git a/src/host/memory.zig b/src/host/memory.zig
new file mode 100644
index 0000000..dd9f632
--- /dev/null
+++ b/src/host/memory.zig
@@ -0,0 +1,406 @@
+//! Sketch memory by lifetime.
+//!
+//! `StateFile`: one `MAP_SHARED` file holding the live state and its snapshot
+//! slots, plus a header describing the layout, so the state outlives restarts,
+//! a probe can read it from another process, and a reload with a changed
+//! layout can carry the old values over field by field.
+const std = @import("std");
+const posix = std.posix;
+const linux = std.os.linux;
+const abi = @import("abi");
+const field_value = @import("fields.zig");
+
+pub const page = std.heap.page_size_min;
+/// Slot 0 is live; 1..7 are snapshots.
+pub const slot_count = 8;
+pub const header_len = 64 * 1024;
+pub const file_magic = "SKETCH01".*;
+
+pub const Header = extern struct {
+ magic: [8]u8 = file_magic,
+ size: u64,
+ alignment: u64,
+ hash: u64,
+ /// Distance between slots, page aligned.
+ stride: u64,
+ /// Bit `i`: slot `i` holds state.
+ used: u32,
+ field_count: u32,
+ strings_len: u32,
+ reserved: u32 = 0,
+};
+
+/// A leaf as stored in the file: strings are offsets into the string table.
+pub const StoredField = extern struct {
+ offset: u32,
+ size: u32,
+ hash: u64,
+ path: u32,
+ path_len: u16,
+ tags_len: u16,
+ tags: u32,
+ kind: abi.Field.Kind,
+ reserved: [3]u8 = @splat(0),
+};
+
+/// A layout the host owns: copied out of a sketch, or read from a file.
+pub const Layout = struct {
+ size: usize = 0,
+ alignment: usize = 1,
+ hash: u64 = 0,
+ fields: []const Leaf = &.{},
+
+ pub const Leaf = struct {
+ path: []const u8,
+ offset: u32,
+ size: u32,
+ kind: abi.Field.Kind,
+ hash: u64,
+ tags: []const u8,
+
+ pub fn bytes(leaf: Leaf, memory: []const u8) []const u8 {
+ return memory[leaf.offset..][0..leaf.size];
+ }
+ };
+
+ pub fn copy(arena: std.mem.Allocator, l: abi.Layout) !Layout {
+ const fields = try arena.alloc(Leaf, l.fields.len);
+ for (fields, l.fields) |*to, from| to.* = .{
+ .path = try arena.dupe(u8, std.mem.span(from.path)),
+ .offset = from.offset,
+ .size = from.size,
+ .kind = from.kind,
+ .hash = from.hash,
+ .tags = try arena.dupe(u8, std.mem.span(from.tags)),
+ };
+ return .{ .size = l.size, .alignment = l.alignment, .hash = l.hash, .fields = fields };
+ }
+
+ pub fn find(self: Layout, path: []const u8) ?Leaf {
+ for (self.fields) |leaf| if (std.mem.eql(u8, leaf.path, path)) return leaf;
+ return null;
+ }
+};
+
+pub const Migration = struct { kept: usize = 0, reset: usize = 0 };
+
+/// Copies every leaf of `from` whose path and type are unchanged into `to`,
+/// which already holds the new defaults.
+pub fn migrate(from: Layout, old: []const u8, to: Layout, new: []u8) Migration {
+ var result: Migration = .{};
+ for (to.fields) |leaf| {
+ const before = from.find(leaf.path) orelse {
+ result.reset += 1;
+ continue;
+ };
+ if (before.hash == leaf.hash and before.size == leaf.size) {
+ @memcpy(new[leaf.offset..][0..leaf.size], before.bytes(old));
+ result.kept += 1;
+ } else if (before.kind == .@"enum" and leaf.kind == .@"enum" and remapEnum(before, old, leaf, new)) {
+ result.kept += 1;
+ } else result.reset += 1;
+ }
+ return result;
+}
+
+/// Carries an enum over by tag name; false when its name no longer exists.
+fn remapEnum(from: Layout.Leaf, old: []const u8, to: Layout.Leaf, new: []u8) bool {
+ const name = field_value.tagName(from.tags, field_value.readInt(i64, from.bytes(old))) orelse return false;
+ const value = field_value.tagValue(to.tags, name) orelse return false;
+ field_value.writeInt(new[to.offset..][0..to.size], value);
+ return true;
+}
+
+pub const StateFile = struct {
+ fd: posix.fd_t,
+ map: []align(page) u8,
+ /// Layout of the bytes in the file, owned by `arena`.
+ layout: Layout,
+ arena: std.heap.ArenaAllocator,
+
+ /// Opens or creates `path`. A missing or foreign file has no layout and no
+ /// used slots: the first `adopt` fills it.
+ pub fn open(gpa: std.mem.Allocator, path: []const u8) !StateFile {
+ const fd = try posix.openat(posix.AT.FDCWD, path, .{ .ACCMODE = .RDWR, .CREAT = true }, 0o600);
+ errdefer _ = posix.system.close(fd);
+ var self: StateFile = .{ .fd = fd, .map = &.{}, .layout = .{}, .arena = .init(gpa) };
+ errdefer self.arena.deinit();
+ const len = try fileSize(fd);
+ if (len >= header_len) {
+ self.map = try mapFile(fd, @intCast(len), .{ .READ = true, .WRITE = true });
+ if (self.valid()) {
+ self.layout = try readLayout(self.arena.allocator(), self.map) orelse .{};
+ return self;
+ }
+ posix.munmap(self.map);
+ self.map = &.{};
+ }
+ try self.resize(0);
+ self.header().* = .{ .size = 0, .alignment = 1, .hash = 0, .stride = 0, .used = 0, .field_count = 0, .strings_len = 0 };
+ return self;
+ }
+
+ pub fn close(self: *StateFile) void {
+ if (self.map.len != 0) posix.munmap(self.map);
+ _ = posix.system.close(self.fd);
+ self.arena.deinit();
+ }
+
+ pub fn header(self: *StateFile) *Header {
+ return @ptrCast(self.map.ptr);
+ }
+
+ pub fn slot(self: *StateFile, index: usize) []align(page) u8 {
+ std.debug.assert(index < slot_count);
+ const h = self.header();
+ const start = header_len + index * h.stride;
+ return @alignCast(self.map[start..][0..h.size]);
+ }
+
+ pub fn used(self: *StateFile, index: usize) bool {
+ return self.header().used & (@as(u32, 1) << @intCast(index)) != 0;
+ }
+
+ pub fn markUsed(self: *StateFile, index: usize, value: bool) void {
+ const bit = @as(u32, 1) << @intCast(index);
+ if (value) self.header().used |= bit else self.header().used &= ~bit;
+ }
+
+ pub const Adoption = union(enum) {
+ unchanged,
+ created,
+ migrated: Migration,
+ };
+
+ /// Makes the file hold `new`'s layout. Used slots are migrated: `defaults`
+ /// writes the new default values, then unchanged fields are copied over.
+ pub fn adopt(self: *StateFile, gpa: std.mem.Allocator, new: abi.Layout, defaults: *const fn (abi.Memory, [*]u8) callconv(.c) void) !Adoption {
+ if (self.layout.hash == new.hash and self.layout.size == new.size and self.header().used & 1 != 0) return .unchanged;
+ const had_state = self.header().used & 1 != 0;
+
+ // Keep the old bytes and layout while the file is rebuilt.
+ var old_arena: std.heap.ArenaAllocator = .init(gpa);
+ defer old_arena.deinit();
+ const old_layout = self.layout;
+ var old_slots: [slot_count]?[]u8 = @splat(null);
+ for (&old_slots, 0..) |*copy, i| {
+ if (self.used(i)) copy.* = try old_arena.allocator().dupe(u8, self.slot(i));
+ }
+ const old_used = self.header().used;
+ // `old_layout` points into `self.arena`: move it aside before resetting.
+ var kept = self.arena;
+ defer kept.deinit();
+ self.arena = .init(gpa);
+
+ self.layout = try Layout.copy(self.arena.allocator(), new);
+ const stride = std.mem.alignForward(usize, @max(new.size, 1), page);
+ try self.resize(stride);
+ const h = self.header();
+ h.* = .{ .size = new.size, .alignment = new.alignment, .hash = new.hash, .stride = stride, .used = old_used, .field_count = 0, .strings_len = 0 };
+ try self.writeLayout();
+
+ var total: Migration = .{};
+ for (old_slots, 0..) |maybe_old, i| {
+ const old = maybe_old orelse continue;
+ const bytes = self.slot(i);
+ @memset(bytes, 0);
+ defaults(.state, bytes.ptr);
+ const m = migrate(old_layout, old, self.layout, bytes);
+ total.kept += m.kept;
+ if (i == 0) total.reset = m.reset;
+ }
+ if (!had_state) {
+ self.markUsed(0, false);
+ return .created;
+ }
+ return .{ .migrated = total };
+ }
+
+ fn valid(self: *StateFile) bool {
+ const h = self.header();
+ if (!std.mem.eql(u8, &h.magic, &file_magic)) return false;
+ return self.map.len >= header_len + slot_count * h.stride and h.size <= h.stride;
+ }
+
+ fn resize(self: *StateFile, stride: usize) !void {
+ const len = header_len + slot_count * stride;
+ if (self.map.len != 0) posix.munmap(self.map);
+ self.map = &.{};
+ switch (posix.errno(posix.system.ftruncate(self.fd, @intCast(len)))) {
+ .SUCCESS => {},
+ else => |err| return posix.unexpectedErrno(err),
+ }
+ self.map = try mapFile(self.fd, len, .{ .READ = true, .WRITE = true });
+ }
+
+ fn writeLayout(self: *StateFile) !void {
+ const h = self.header();
+ const fields: [*]StoredField = @ptrCast(@alignCast(self.map.ptr + @sizeOf(Header)));
+ const strings_start = @sizeOf(Header) + self.layout.fields.len * @sizeOf(StoredField);
+ var strings: usize = 0;
+ for (self.layout.fields, 0..) |leaf, i| {
+ if (strings_start + strings + leaf.path.len + leaf.tags.len > header_len) return error.LayoutTooLarge;
+ const base = strings_start + strings;
+ @memcpy(self.map[base..][0..leaf.path.len], leaf.path);
+ @memcpy(self.map[base + leaf.path.len ..][0..leaf.tags.len], leaf.tags);
+ fields[i] = .{
+ .offset = leaf.offset,
+ .size = leaf.size,
+ .hash = leaf.hash,
+ .kind = leaf.kind,
+ .path = @intCast(strings),
+ .path_len = @intCast(leaf.path.len),
+ .tags = @intCast(strings + leaf.path.len),
+ .tags_len = @intCast(leaf.tags.len),
+ };
+ strings += leaf.path.len + leaf.tags.len;
+ }
+ h.field_count = @intCast(self.layout.fields.len);
+ h.strings_len = @intCast(strings);
+ }
+};
+
+/// The layout stored in a state file's header, or null if it has none.
+pub fn readLayout(arena: std.mem.Allocator, map: []const u8) !?Layout {
+ const h: *const Header = @ptrCast(@alignCast(map.ptr));
+ if (h.hash == 0 and h.field_count == 0) return null;
+ const stored: [*]const StoredField = @ptrCast(@alignCast(map.ptr + @sizeOf(Header)));
+ const strings_start = @sizeOf(Header) + h.field_count * @sizeOf(StoredField);
+ if (strings_start + h.strings_len > header_len) return error.CorruptHeader;
+ const strings = map[strings_start..][0..h.strings_len];
+ const leaves = try arena.alloc(Layout.Leaf, h.field_count);
+ for (leaves, stored[0..h.field_count]) |*leaf, f| {
+ if (f.path + f.path_len > strings.len or f.tags + f.tags_len > strings.len) return error.CorruptHeader;
+ // Copied: the mapping moves when the file is resized.
+ leaf.* = .{
+ .path = try arena.dupe(u8, strings[f.path..][0..f.path_len]),
+ .offset = f.offset,
+ .size = f.size,
+ .kind = f.kind,
+ .hash = f.hash,
+ .tags = try arena.dupe(u8, strings[f.tags..][0..f.tags_len]),
+ };
+ }
+ return .{ .size = h.size, .alignment = h.alignment, .hash = h.hash, .fields = leaves };
+}
+
+pub fn mapFile(fd: posix.fd_t, len: usize, prot: posix.PROT) ![]align(page) u8 {
+ return posix.mmap(null, len, prot, .{ .TYPE = .SHARED }, fd, 0);
+}
+
+pub fn fileSize(fd: posix.fd_t) !u64 {
+ var stat: linux.Statx = undefined;
+ switch (linux.errno(linux.statx(fd, "", linux.AT.EMPTY_PATH, .{ .SIZE = true }, &stat))) {
+ .SUCCESS => {},
+ else => |err| return posix.unexpectedErrno(err),
+ }
+ return stat.size;
+}
+
+/// Maps a whole file read-only; empty when missing or empty.
+pub fn mapReadOnly(path: []const u8) []align(page) const u8 {
+ const fd = posix.openat(posix.AT.FDCWD, path, .{ .ACCMODE = .RDONLY }, 0) catch return &.{};
+ defer _ = posix.system.close(fd);
+ const len = fileSize(fd) catch return &.{};
+ if (len == 0) return &.{};
+ return posix.mmap(null, @intCast(len), .{ .READ = true }, .{ .TYPE = .SHARED }, fd, 0) catch &.{};
+}
+
+/// Session memory: survives reloads while its layout hash is unchanged.
+/// `heap` is released with it.
+pub const Session = struct {
+ bytes: []align(16) u8 = &.{},
+ hash: u64 = 0,
+ heap: std.heap.ArenaAllocator,
+
+ pub fn init(gpa: std.mem.Allocator) Session {
+ return .{ .heap = .init(gpa) };
+ }
+
+ pub fn deinit(self: *Session, gpa: std.mem.Allocator) void {
+ gpa.free(self.bytes);
+ self.heap.deinit();
+ }
+
+ /// True when the session was reset to `layout`'s defaults.
+ pub fn adopt(self: *Session, gpa: std.mem.Allocator, layout: abi.Layout, defaults: *const fn (abi.Memory, [*]u8) callconv(.c) void) !bool {
+ if (self.hash == layout.hash and self.bytes.len == @max(layout.size, 1)) return false;
+ if (layout.alignment > 16) return error.SessionOveraligned;
+ gpa.free(self.bytes);
+ self.bytes = &.{};
+ _ = self.heap.reset(.free_all);
+ self.bytes = try gpa.alignedAlloc(u8, .@"16", @max(layout.size, 1));
+ @memset(self.bytes, 0);
+ defaults(.session, self.bytes.ptr);
+ self.hash = layout.hash;
+ return true;
+ }
+};
+
+test "enums migrate by tag name" {
+ const V1 = struct { mood: enum(u8) { calm, lost, angry } = .calm, gone: enum(u8) { a, b } = .b };
+ const V2 = struct { mood: enum(u16) { angry = 7, calm, sleepy } = .sleepy, gone: enum(u8) { c } = .c };
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ const l1 = try Layout.copy(arena.allocator(), abi.layout.of(V1, .forbidden));
+ const l2 = try Layout.copy(arena.allocator(), abi.layout.of(V2, .forbidden));
+ for ([_]struct { @FieldType(V1, "mood"), @FieldType(V2, "mood") }{ .{ .calm, .calm }, .{ .angry, .angry }, .{ .lost, .sleepy } }) |case| {
+ const old: V1 = .{ .mood = case[0] };
+ var new: V2 = .{};
+ _ = migrate(l1, std.mem.asBytes(&old), l2, std.mem.asBytes(&new));
+ try std.testing.expectEqual(case[1], new.mood);
+ try std.testing.expectEqual(.c, new.gone);
+ }
+}
+
+test "migration keeps unchanged fields and defaults the rest" {
+ const V1 = extern struct { a: u32 = 1, b: f32 = 2, gone: u8 = 3 };
+ const V2 = extern struct { b: f32 = 20, a: u32 = 10, b2: [2]u8 = .{ 7, 7 } };
+ var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
+ defer arena.deinit();
+ const l1 = try Layout.copy(arena.allocator(), abi.layout.of(V1, .forbidden));
+ const l2 = try Layout.copy(arena.allocator(), abi.layout.of(V2, .forbidden));
+ const old: V1 = .{ .a = 42, .b = 0.5 };
+ var new: V2 = .{};
+ const m = migrate(l1, std.mem.asBytes(&old), l2, std.mem.asBytes(&new));
+ try std.testing.expectEqual(V2{ .a = 42, .b = 0.5 }, new);
+ try std.testing.expectEqual(@as(usize, 2), m.kept);
+ try std.testing.expectEqual(@as(usize, 1), m.reset);
+}
+
+test "state file migrates live state and snapshots, and a reopen reads the layout back" {
+ const V1 = extern struct { score: u32 = 0, name: [4]u8 = "none".* };
+ const V2 = extern struct { level: u16 = 1, score: u32 = 0 };
+ const D = struct {
+ fn v1(_: abi.Memory, p: [*]u8) callconv(.c) void {
+ @as(*V1, @ptrCast(@alignCast(p))).* = .{};
+ }
+ fn v2(_: abi.Memory, p: [*]u8) callconv(.c) void {
+ @as(*V2, @ptrCast(@alignCast(p))).* = .{};
+ }
+ };
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ var buf: [std.fs.max_path_bytes]u8 = undefined;
+ const path = try std.fmt.bufPrint(&buf, ".zig-cache/tmp/{s}/test.state", .{&tmp.sub_path});
+ const gpa = std.testing.allocator;
+ {
+ var file = try StateFile.open(gpa, path);
+ defer file.close();
+ try std.testing.expectEqual(StateFile.Adoption.created, try file.adopt(gpa, abi.layout.of(V1, .forbidden), D.v1));
+ file.markUsed(0, true);
+ @as(*V1, @ptrCast(file.slot(0).ptr)).score = 99;
+ @memcpy(file.slot(3), file.slot(0));
+ file.markUsed(3, true);
+ }
+ var file = try StateFile.open(gpa, path);
+ defer file.close();
+ try std.testing.expectEqual(abi.layout.hash(V1), file.layout.hash);
+ const adoption = try file.adopt(gpa, abi.layout.of(V2, .forbidden), D.v2);
+ try std.testing.expectEqual(@as(usize, 1), adoption.migrated.reset);
+ for ([_]usize{ 0, 3 }) |i| {
+ const s: *V2 = @ptrCast(file.slot(i).ptr);
+ try std.testing.expectEqual(V2{ .level = 1, .score = 99 }, s.*);
+ }
+ try std.testing.expect(!file.used(1));
+}