summaryrefslogtreecommitdiff
path: root/src/host/library.zig
blob: 91b2296a8fbc67a2f264d78d5b00e92e08ac9317 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
//! Loading sketch libraries, and noticing when a build replaces one.
//!
//! `dlopen` returns the handle it already has for a path it loaded before, so
//! every load goes through a symlink with a fresh name to an fd open on the
//! library: what loads is the file that was opened, whatever a build renames
//! over it meanwhile. The link is deleted right after loading: the mapping
//! keeps the code alive, and nothing is left behind if the host dies. A
//! library rewritten in place instead (same inode) would not load again, and
//! would change the code under the running host.
const std = @import("std");
const linux = std.os.linux;
const c = @import("c");
const abi = @import("abi");

pub const Library = struct {
    object: *c.SDL_SharedObject,
    sketch: abi.Sketch,

    /// Loads the library at `path`; `source` names it in messages.
    pub fn open(path: [:0]const u8, source: []const u8) !Library {
        const object = c.SDL_LoadObject(path.ptr) orelse return error.LoadLibrary;
        errdefer c.SDL_UnloadObject(object);
        var sketch: abi.Sketch = undefined;
        inline for (comptime std.meta.fieldNames(abi.Sketch)) |name| {
            const symbol = @field(abi.Sketch.symbols, name);
            const address = c.SDL_LoadFunction(object, symbol) orelse return error.MissingEntryPoint;
            @field(sketch, name) = @ptrCast(address);
        }
        if (sketch.info().abi != abi.hash) {
            const address = c.SDL_LoadFunction(object, "sketch_build") orelse {
                std.log.err("{s}: built by an older sketchbook: rebuild it", .{source});
                return error.AbiMismatch;
            };
            const build = std.mem.span(@as([*:0]const u8, @ptrFromInt(@intFromPtr(address))));
            if (std.mem.eql(u8, build, abi.build)) {
                std.log.err("{s}: built against other abi types: restart the host to load it", .{source});
            } else {
                const mode = build[std.mem.lastIndexOfScalar(u8, build, ' ').? + 1 ..];
                std.log.err("{s}: built by zig {s}, this host by zig {s}; Zig calls cross the boundary, so both need the same compiler, backend and mode: build the host like the library (`zig build run -Doptimize={s}`) or the library like the host", .{ source, build, abi.build, mode });
            }
            return error.AbiMismatch;
        }
        return .{ .object = object, .sketch = sketch };
    }

    /// Loads `source` through a uniquely named symlink in `scratch_dir`.
    pub fn openFresh(io: std.Io, source: []const u8, scratch_dir: []const u8, serial: usize) !Library {
        const cwd = std.Io.Dir.cwd();
        const file = try cwd.openFile(io, source, .{});
        defer file.close(io);
        var target_buf: [32]u8 = undefined;
        const target = try std.mem.print(&target_buf, "/proc/self/fd/{d}", .{file.handle});
        var buf: [std.fs.max_path_bytes]u8 = undefined;
        const link = try std.mem.printSentinel(&buf, "{s}/sketchbook-{d}-{d}.so", .{ scratch_dir, linux.getpid(), serial }, 0);
        try cwd.symLink(io, target, link, .{});
        defer cwd.deleteFile(io, link) catch {};
        return open(link, source);
    }

    pub fn close(self: *Library) void {
        c.SDL_UnloadObject(self.object);
    }
};

/// inotify on a library's directory, filtered to its file name. Builds
/// replace files by renaming (`MOVED_TO`) or rewrite them (`CLOSE_WRITE`).
pub const Watch = struct {
    fd: i32,
    name: []const u8,

    pub fn init(path: []const u8) !Watch {
        const fd: i32 = @intCast(@as(isize, @bitCast(linux.inotify_init1(linux.IN.NONBLOCK | linux.IN.CLOEXEC))));
        if (fd < 0) return error.WatchFailed;
        errdefer _ = linux.close(fd);
        var buf: [std.fs.max_path_bytes]u8 = undefined;
        const dir = std.fs.path.dirname(path) orelse ".";
        const dir_z = try std.mem.printSentinel(&buf, "{s}", .{dir}, 0);
        if (@as(isize, @bitCast(linux.inotify_add_watch(fd, dir_z, linux.IN.MOVED_TO | linux.IN.CLOSE_WRITE))) < 0) return error.WatchFailed;
        return .{ .fd = fd, .name = std.fs.path.basename(path) };
    }

    pub fn deinit(self: Watch) void {
        _ = linux.close(self.fd);
    }

    /// Drains pending events; true if any named the library.
    pub fn changed(self: Watch) bool {
        var found = false;
        var buf: [4096]u8 align(@alignOf(linux.inotify_event)) = undefined;
        while (true) {
            const rc = linux.read(self.fd, &buf, buf.len);
            const len: isize = @bitCast(rc);
            if (len <= 0) return found;
            var off: usize = 0;
            while (off + @sizeOf(linux.inotify_event) <= @as(usize, @intCast(len))) {
                const event: *const linux.inotify_event = @ptrCast(@alignCast(&buf[off]));
                off += @sizeOf(linux.inotify_event) + event.len;
                if (event.getName()) |name| {
                    if (std.mem.eql(u8, name, self.name)) found = true;
                }
            }
        }
    }
};