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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
|
//! Addons: shared libraries that each bring a kind of pane (Kind.zig),
//! the host's side of it. Each `*.so` of `$XDG_DATA_HOME/pardes/addons`
//! and then `<prefix>/lib/pardes/addons` at start, and `Addon load
//! <path>` after. An addon exports `pardes_addon`, a `pa_ops`
//! (src/kinds/pardes_addon.h); Kind.register checks it and takes it in.
//!
//! An addon runs in this process: one that crashes takes the session
//! with it. So a load is marked first (`addon-loading` in the data
//! directory, holding its path) and unmarked after; a start that finds
//! the mark moves it to `addon-crashed`, and skips that addon at every
//! start until `Addon load` asks for it by path again.
const std = @import("std");
const Kind = @import("Kind.zig");
const dump = @import("dump.zig");
const pardes = @import("pardes.zig");
const Why = Kind.Buf(160);
/// The core's `addon` effect performed, its answer the `addon` event:
/// `arg` a path to load (or reload), or the kind's name to let go.
pub fn perform(p: *pardes.Pardes, op: Kind.AddonOp, pane: u8, arg: []const u8) void {
var why: Why = .{};
const ok = switch (op) {
.load => load(arg, &why),
.unload => ok: {
why.set(arg);
break :ok unload(arg);
},
.reload => ok: {
if (!reload(p, arg, &why)) break :ok false;
why.set(arg);
break :ok true;
},
};
p.update(.{ .addon = .{ .op = op, .pane = pane, .ok = ok, .text = why.slice() } });
}
/// The addon at `path` loaded and its kind taken in: true, or false
/// with why not in `why`.
pub fn load(path: []const u8, why: *Why) bool {
var data_buf: [4096]u8 = undefined;
return loadMarked(dataDir(&data_buf), path, why);
}
/// Where the crash mark goes: the data directory, none in a test (a
/// test's loads are no user's).
fn dataDir(buf: []u8) []const u8 {
if (@import("builtin").is_test) return "";
return dump.defaultDirectory(buf) orelse "";
}
fn loadMarked(data: []const u8, path: []const u8, why: *Why) bool {
if (path.len >= 4096) return fail(why, "{s}: the path is too long", .{path});
Kind.forgetRefused(path);
mark(data, path);
defer unmark();
var hash: [32]u8 = undefined;
const lib = open(path, &hash, why) orelse {
Kind.note(path, why.slice());
return false;
};
const sym = std.c.dlsym(lib, "pardes_addon") orelse {
_ = std.c.dlclose(lib);
Kind.note(path, "refused: it has no pardes_addon");
return fail(why, "{s}: refused: it has no pardes_addon", .{std.fs.path.basename(path)});
};
const ops: *const Kind.Ops = @ptrCast(@alignCast(sym));
if (Kind.registerHashed(ops, path, lib, hash)) |refused| {
_ = std.c.dlclose(lib);
return fail(why, "{s}: {s}", .{ std.fs.path.basename(path), refused });
}
why.set(Kind.headName(ops));
return true;
}
/// The library at `path` opened from a copy of its bytes in memory, so a
/// reload of a path already open is the file as it is now (dlopen hands
/// back the handle it has for a path it has), and their BLAKE3 in `hash`.
fn open(path: []const u8, hash: *[32]u8, why: *Why) ?*anyopaque {
var z: [4096]u8 = undefined;
const path_z = std.fmt.bufPrintSentinel(&z, "{s}", .{path}, 0) catch return failNull(why, "the path is too long", .{});
const f = std.c.fopen(path_z, "r") orelse return failNull(why, "cannot read it", .{});
defer _ = std.c.fclose(f);
const gpa = std.heap.page_allocator;
var bytes: std.ArrayList(u8) = .empty;
defer bytes.deinit(gpa);
var chunk: [64 << 10]u8 = undefined;
while (true) {
const n = std.c.fread(&chunk, 1, chunk.len, f);
if (n == 0) break;
bytes.appendSlice(gpa, chunk[0..n]) catch return failNull(why, "out of memory", .{});
if (bytes.items.len > 256 << 20) return failNull(why, "it is over 256 MiB", .{});
}
std.crypto.hash.Blake3.hash(bytes.items, hash, .{});
const fd = std.c.memfd_create("pardes-addon", 0);
if (fd < 0) return failNull(why, "no memfd for it", .{});
// shortcut: the fd stays open while the process lives. dlopen hands
// back the library it has for a path it has, and /proc/self/fd/<n> of
// a closed fd is the next load's path too: an fd kept is a name kept
// (one an addon load; a dev loop of a hundred reloads is a hundred).
errdefer _ = std.c.close(fd);
var off: usize = 0;
while (off < bytes.items.len) {
const n = std.c.write(fd, bytes.items.ptr + off, bytes.items.len - off);
if (n <= 0) return failNull(why, "cannot copy it", .{});
off += @intCast(n);
}
var proc: [64]u8 = undefined;
const at = std.fmt.bufPrintSentinel(&proc, "/proc/self/fd/{d}", .{fd}, 0) catch unreachable;
return std.c.dlopen(at, .{ .NOW = true }) orelse {
_ = std.c.close(fd);
return failNull(why, "{s}", .{if (std.c.dlerror()) |e| std.mem.span(e) else "cannot load it"});
};
}
fn failNull(why: *Why, comptime fmt: []const u8, args: anytype) ?*anyopaque {
_ = why.print(fmt, args);
return null;
}
/// `Addon reload <name>`: its library loaded again from its path and
/// swapped in, or the old one left running and why not.
pub fn reload(p: *pardes.Pardes, name: []const u8, why: *Why) bool {
var path: [256]u8 = undefined;
const at = for (Kind.kinds()) |*l| {
if (l.ops != null and std.mem.eql(u8, l.nameOf(), name)) {
@memcpy(path[0..l.path.len], l.path.slice());
break path[0..l.path.len];
}
} else return fail(why, "no addon brought kind {s}", .{name});
var data_buf: [4096]u8 = undefined;
mark(dataDir(&data_buf), at);
defer unmark();
var hash: [32]u8 = undefined;
const lib = open(at, &hash, why) orelse return false;
const sym = std.c.dlsym(lib, "pardes_addon") orelse {
_ = std.c.dlclose(lib);
return fail(why, "refused: it has no pardes_addon", .{});
};
var old: ?*anyopaque = null;
if (!Kind.replace(p, name, @ptrCast(@alignCast(sym)), lib, hash, &old, why)) {
_ = std.c.dlclose(lib);
return false;
}
if (old) |o| _ = std.c.dlclose(o);
return true;
}
/// Every addon let go, and the refused forgotten: the kinds a process
/// starts with (a test's session ends so, the kinds being the process's).
pub fn unloadAll() void {
for (0..Kind.max_kinds) |_| {
const l = for (Kind.kinds()) |*k| {
if (k.lib != null and k.ops != null) break k;
} else break;
var name: [16]u8 = l.name;
_ = unload(std.mem.sliceTo(&name, 0));
}
for (0..Kind.max_kinds) |_| {
const l = for (Kind.kinds()) |*k| {
if (k.ops == null) break k;
} else break;
var path: [256]u8 = undefined;
@memcpy(path[0..l.path.len], l.path.slice());
Kind.forgetRefused(path[0..l.path.len]);
}
}
/// The kind `name` out, its library closed: false when none is loaded.
/// The caller has seen that no pane of it is open.
pub fn unload(name: []const u8) bool {
const gone = Kind.unregister(name) orelse return false;
if (gone.lib) |lib| _ = std.c.dlclose(lib);
return true;
}
fn fail(why: *Why, comptime fmt: []const u8, args: anytype) bool {
_ = why.print(fmt, args);
return false;
}
/// Every library of the two directories, in name order each, the user's
/// first (a kind of a name taken is refused, and listed so). A library
/// that crashed at its last load is listed, not loaded.
pub fn scan() void {
var data_buf: [4096]u8 = undefined;
const data = dataDir(&data_buf);
const crashed = crashedPath(data);
var dir_buf: [4096]u8 = undefined;
if (data.len > 0) scanDir(data, std.fmt.bufPrint(&dir_buf, "{s}/addons", .{data}) catch "", crashed.slice());
var exe: [4096]u8 = undefined;
const n = std.c.readlink("/proc/self/exe", &exe, exe.len);
if (n > 0) {
const bin_dir = std.fs.path.dirname(exe[0..@intCast(n)]) orelse return;
const prefix = std.fs.path.dirname(bin_dir) orelse return;
scanDir(data, std.fmt.bufPrint(&dir_buf, "{s}/lib/pardes/addons", .{prefix}) catch "", crashed.slice());
}
}
fn scanDir(data: []const u8, dir: []const u8, crashed: []const u8) void {
if (dir.len == 0) return;
var z: [4096]u8 = undefined;
const dz = std.fmt.bufPrintSentinel(&z, "{s}", .{dir}, 0) catch return;
const d = std.c.opendir(dz) orelse return;
defer _ = std.c.closedir(d);
var names: [32][256]u8 = undefined;
var lens: [32]usize = undefined;
var count: usize = 0;
while (std.c.readdir(d)) |e| {
const name = std.mem.sliceTo(@as([*:0]const u8, @ptrCast(&e.name)), 0);
if (!std.mem.endsWith(u8, name, ".so") or name.len > 255 or count == names.len) continue;
@memcpy(names[count][0..name.len], name);
lens[count] = name.len;
count += 1;
}
var order: [32]usize = undefined;
for (0..count) |i| order[i] = i;
std.mem.sort(usize, order[0..count], Sort{ .names = &names, .lens = &lens }, Sort.lt);
for (order[0..count]) |i| {
var full: [4096]u8 = undefined;
const path = std.fmt.bufPrint(&full, "{s}/{s}", .{ dir, names[i][0..lens[i]] }) catch continue;
if (crashed.len > 0 and std.mem.eql(u8, path, crashed)) {
Kind.note(path, "skipped: it crashed its last load (Addon load asks for it again)");
continue;
}
var why: Why = .{};
_ = loadMarked(data, path, &why);
}
}
const Sort = struct {
names: *const [32][256]u8,
lens: *const [32]usize,
fn lt(s: Sort, a: usize, b: usize) bool {
return std.mem.lessThan(u8, s.names[a][0..s.lens[a]], s.names[b][0..s.lens[b]]);
}
};
// ---- the crash mark ----
var marked: [4096]u8 = undefined;
var marked_len: usize = 0;
fn markPath(buf: []u8, data: []const u8, comptime name: []const u8) ?[:0]const u8 {
return std.fmt.bufPrintSentinel(buf, "{s}/" ++ name, .{data}, 0) catch null;
}
/// The load of `path` under way, on disk until `unmark`.
fn mark(data: []const u8, path: []const u8) void {
if (data.len == 0) return;
var buf: [4096]u8 = undefined;
const at = markPath(&buf, data, "addon-loading") orelse return;
const f = std.c.fopen(at, "w") orelse return;
_ = std.c.fwrite(path.ptr, 1, path.len, f);
_ = std.c.fclose(f);
@memcpy(marked[0..at.len], at);
marked_len = at.len;
// `Addon load` of the one that crashed asks for it again.
var cbuf: [4096]u8 = undefined;
const crashed = markPath(&cbuf, data, "addon-crashed") orelse return;
const was = readSmall(crashed);
if (std.mem.eql(u8, was.slice(), path)) _ = std.c.unlink(crashed);
}
fn unmark() void {
if (marked_len == 0) return;
marked[marked_len] = 0;
_ = std.c.unlink(@ptrCast(&marked));
marked_len = 0;
}
/// The library that crashed its session's load: a mark left by a start
/// that never finished one becomes `kind-crashed`, which it stays.
fn crashedPath(data: []const u8) Kind.Buf(4096) {
var out: Kind.Buf(4096) = .{};
if (data.len == 0) return out;
var lbuf: [4096]u8 = undefined;
var cbuf: [4096]u8 = undefined;
const loading = markPath(&lbuf, data, "addon-loading") orelse return out;
const crashed = markPath(&cbuf, data, "addon-crashed") orelse return out;
if (std.c.access(loading, 0) == 0) _ = std.c.rename(loading, crashed);
out.set(readSmall(crashed).slice());
return out;
}
fn readSmall(path: [*:0]const u8) Kind.Buf(4096) {
var out: Kind.Buf(4096) = .{};
const f = std.c.fopen(path, "r") orelse return out;
defer _ = std.c.fclose(f);
const n = std.c.fread(&out.bytes, 1, out.bytes.len, f);
out.len = @intCast(n);
return out;
}
test "a load that never finished is skipped at the next start, and every start after, until a load asks for it" {
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
var buf: [4096]u8 = undefined;
const data = buf[0..try tmp.dir.realPath(std.testing.io, &buf)];
try tmp.dir.createDirPath(std.testing.io, "addons");
try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "addons/crashy.so", .data = "not a library" });
var lib_buf: [4096]u8 = undefined;
const lib = try std.fmt.bufPrint(&lib_buf, "{s}/addons/crashy.so", .{data});
// The mark a load leaves when its session dies in it.
try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "addon-loading", .data = lib });
var dir_buf: [4096]u8 = undefined;
const dir = try std.fmt.bufPrint(&dir_buf, "{s}/addons", .{data});
for (0..2) |_| {
scanDir(data, dir, crashedPath(data).slice());
const last = Kind.kinds()[Kind.kinds().len - 1];
try std.testing.expectEqualStrings(lib, last.path.slice());
try std.testing.expect(std.mem.startsWith(u8, last.why.slice(), "skipped: it crashed its last load"));
Kind.forgetRefused(lib);
}
// Asked for by name, it is tried again (and refused here for what it is).
var why: Why = .{};
try std.testing.expect(!loadMarked(data, lib, &why));
try std.testing.expect(std.mem.indexOf(u8, Kind.kinds()[Kind.kinds().len - 1].why.slice(), "skipped") == null);
try std.testing.expectError(error.FileNotFound, tmp.dir.access(std.testing.io, "addon-crashed", .{}));
try std.testing.expectError(error.FileNotFound, tmp.dir.access(std.testing.io, "addon-loading", .{}));
Kind.forgetRefused(lib);
}
|