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
|
//! 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 private copy with a fresh name. The copy is
//! deleted right after loading: the mapping keeps the code alive, and nothing
//! is left behind if the host dies.
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,
pub fn open(path: [:0]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) return error.AbiMismatch;
return .{ .object = object, .sketch = sketch };
}
/// Loads `source` through a uniquely named copy in `scratch_dir`.
pub fn openCopy(io: std.Io, source: []const u8, scratch_dir: []const u8, serial: usize) !Library {
var buf: [std.fs.max_path_bytes]u8 = undefined;
const copy = try std.mem.printSentinel(&buf, "{s}/sketchbook-{d}-{d}.so", .{ scratch_dir, linux.getpid(), serial }, 0);
const cwd = std.Io.Dir.cwd();
try cwd.copyFile(source, cwd, copy, io, .{});
defer cwd.deleteFile(io, copy) catch {};
return open(copy);
}
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;
}
}
}
}
};
|