summaryrefslogtreecommitdiff
path: root/src/fs.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/fs.zig')
-rw-r--r--src/fs.zig956
1 files changed, 578 insertions, 378 deletions
diff --git a/src/fs.zig b/src/fs.zig
index 7f416440..08379697 100644
--- a/src/fs.zig
+++ b/src/fs.zig
@@ -6,7 +6,6 @@ const config = @import("config.zig");
const lsp = @import("lsp/lsp.zig");
const ninep_io = @import("9p_io.zig");
const panes = @import("panes.zig");
-const mvzr = @import("mvzr");
const modal = @import("modal.zig");
const look = @import("look.zig");
pub const tree = @import("ninep/tree.zig");
@@ -20,7 +19,14 @@ const Reply = tree.Reply;
const E = tree.E;
/// The served README; tree.zig answers it.
-pub const help = @embedFile("fs-help.txt");
+/// The tree's README; a build that embeds no sources lists no src/.
+pub const help = help: {
+ const raw = @embedFile("fs-help.txt");
+ if (limits.embedded_sources) break :help raw;
+ const both = "os/, src/ the host filesystem; the editor's own sources";
+ const at = std.mem.indexOf(u8, raw, both) orelse @compileError("fs-help.txt no longer lists os/, src/");
+ break :help raw[0..at] ++ "os/ the host filesystem" ++ raw[at + both.len ..];
+};
/// Host filesystem nodes: the root, and one hashed node per path a client walked to.
pub const os_root: u64 = (1 << 63) + 2;
@@ -36,6 +42,23 @@ else
const source_files = [_]Source{
.{ .path = "src/pardes.zig", .contents = @embedFile("pardes.zig") },
.{ .path = "src/panes.zig", .contents = @embedFile("panes.zig") },
+ .{ .path = "src/Text.zig", .contents = @embedFile("Text.zig") },
+ .{ .path = "src/surface.zig", .contents = @embedFile("surface.zig") },
+ .{ .path = "src/colors.zig", .contents = @embedFile("colors.zig") },
+ .{ .path = "src/Messages.zig", .contents = @embedFile("Messages.zig") },
+ .{ .path = "src/body_layer.zig", .contents = @embedFile("body_layer.zig") },
+ .{ .path = "src/tagline.zig", .contents = @embedFile("tagline.zig") },
+ .{ .path = "src/edit.zig", .contents = @embedFile("edit.zig") },
+ .{ .path = "src/normal.zig", .contents = @embedFile("normal.zig") },
+ .{ .path = "src/mouse.zig", .contents = @embedFile("mouse.zig") },
+ .{ .path = "src/exec.zig", .contents = @embedFile("exec.zig") },
+ .{ .path = "src/Pipe.zig", .contents = @embedFile("Pipe.zig") },
+ .{ .path = "src/File.zig", .contents = @embedFile("File.zig") },
+ .{ .path = "src/Output.zig", .contents = @embedFile("Output.zig") },
+ .{ .path = "src/mini.zig", .contents = @embedFile("mini.zig") },
+ .{ .path = "src/image.zig", .contents = @embedFile("image.zig") },
+ .{ .path = "src/terminal.zig", .contents = @embedFile("terminal.zig") },
+ .{ .path = "src/pdf_view.zig", .contents = @embedFile("pdf_view.zig") },
.{ .path = "src/layout.zig", .contents = @embedFile("layout.zig") },
.{ .path = "src/fs.zig", .contents = @embedFile("fs.zig") },
.{ .path = "src/look.zig", .contents = @embedFile("look.zig") },
@@ -62,8 +85,18 @@ pub const WriteError = error{
NoSpaceLeft,
OpenFailed,
WriteFailed,
+ // The rest are open(2)'s errno, named so errorWords says them.
+ NoSuchFileOrDirectory,
+ NotDir,
+ InvalidArgument,
+ FileBusy,
+ SymLinkLoop,
+ NoSuchDeviceOrAddress,
+ FileTooBig,
};
+/// The host takes the bytes. The caller has given the turn up (`write`),
+/// because the path may be a mount this editor serves.
pub fn writeFile(path: []const u8, bytes: []const u8) WriteError!void {
var pathbuf: [4096:0]u8 = undefined;
if (path.len >= pathbuf.len) return error.PathTooLong;
@@ -77,6 +110,13 @@ pub fn writeFile(path: []const u8, bytes: []const u8) WriteError!void {
.ROFS => error.ReadOnlyFilesystem,
.NOSPC, .DQUOT => error.NoSpaceLeft,
.NAMETOOLONG => error.PathTooLong,
+ .NOENT => error.NoSuchFileOrDirectory,
+ .NOTDIR => error.NotDir,
+ .INVAL => error.InvalidArgument,
+ .BUSY, .TXTBSY => error.FileBusy,
+ .LOOP => error.SymLinkLoop,
+ .NXIO, .NODEV => error.NoSuchDeviceOrAddress,
+ .FBIG => error.FileTooBig,
else => error.OpenFailed,
};
var off: usize = 0;
@@ -121,12 +161,21 @@ fn osNode(p: *pardes.Pardes, path: []const u8) !u64 {
return node;
}
+/// The host filesystem under /os. Every syscall here may go out through a
+/// mount this editor serves, so the turn is given up around each and taken
+/// back before the core is touched; `path` is the table entry's own copy and
+/// outlives the yield, and nothing is staged into the shared reply buffer
+/// until the turn is back.
pub fn osHandle(p: *pardes.Pardes, req: Req) Reply {
if (comptime !platform_has_fs) return Reply.fail(req.tag, E.NOENT);
const path = osPath(p, req.node) orelse return Reply.fail(req.tag, E.NOENT);
if (req.op == .release) return .{ .tag = req.tag };
const io = std.Io.Threaded.global_single_threaded.io();
- const stat = std.Io.Dir.cwd().statFile(io, path, .{}) catch return Reply.fail(req.tag, E.NOENT);
+ const stat = stat: {
+ pardes.turn.yield();
+ defer pardes.turn.back();
+ break :stat statPath(io, path, .{}) catch return Reply.fail(req.tag, E.NOENT);
+ };
const attr: Reply.Attr = .{ .name = if (req.node == os_root) "os" else std.fs.path.basename(path), .node = req.node, .dir = stat.kind == .directory, .size = stat.size, .mode = if (stat.kind == .directory) 0o755 else 0o644, .mtime = std.math.cast(u32, stat.mtime.toSeconds()) orelse 0 };
switch (req.op) {
.getattr => return .{ .tag = req.tag, .attr = attr },
@@ -147,52 +196,72 @@ pub fn osHandle(p: *pardes.Pardes, req: Req) Reply {
return osHandle(p, .{ .tag = req.tag, .op = .getattr, .node = node });
},
.readdir => {
- var dir = std.Io.Dir.cwd().openDir(io, path, .{ .iterate = true }) catch return Reply.fail(req.tag, E.NOTDIR);
- defer dir.close(io);
- var it = dir.iterate();
- const out = p.fs.stage(p.gpa);
- var skip = req.off;
- while (it.next(io) catch return Reply.fail(req.tag, E.IO)) |entry| {
- var buf: [4096]u8 = undefined;
- const joined = std.fmt.bufPrint(&buf, "{s}/{s}", .{ std.mem.trimEnd(u8, path, "/"), entry.name }) catch continue;
- var normalized_buf: [4096]u8 = undefined;
- const normalized = resolveOs(joined, &normalized_buf) orelse continue;
- const child = dir.statFile(io, entry.name, .{}) catch continue;
- if (skip > 0) {
- skip -= 1;
- continue;
+ // Listed into a buffer of this request's own first; the shared
+ // reply buffer is another request's to use while the turn is out.
+ var listing: [16 * 1024]u8 = undefined;
+ var fixed: std.heap.FixedBufferAllocator = .init(&listing);
+ var listed: std.ArrayList(u8) = .empty;
+ {
+ pardes.turn.yield();
+ defer pardes.turn.back();
+ var dir = std.Io.Dir.cwd().openDir(io, path, .{ .iterate = true }) catch return Reply.fail(req.tag, E.NOTDIR);
+ defer dir.close(io);
+ var it = dir.iterate();
+ var skip = req.off;
+ while (it.next(io) catch return Reply.fail(req.tag, E.IO)) |entry| {
+ var buf: [4096]u8 = undefined;
+ const joined = std.fmt.bufPrint(&buf, "{s}/{s}", .{ std.mem.trimEnd(u8, path, "/"), entry.name }) catch continue;
+ var normalized_buf: [4096]u8 = undefined;
+ const normalized = resolveOs(joined, &normalized_buf) orelse continue;
+ const child = dir.statFile(io, entry.name, .{}) catch continue;
+ if (skip > 0) {
+ skip -= 1;
+ continue;
+ }
+ const node = if (std.mem.eql(u8, normalized.path, "/")) os_root else os_node | (std.hash.Wyhash.hash(0, normalized.path) & (os_node - 1));
+ tree.stageDirent(&listed, fixed.allocator(), node, child.kind == .directory, entry.name);
+ if (listed.items.len >= @max(req.size, 512)) break;
}
- const node = if (std.mem.eql(u8, normalized.path, "/")) os_root else os_node | (std.hash.Wyhash.hash(0, normalized.path) & (os_node - 1));
- tree.stageDirent(out, p.gpa, node, child.kind == .directory, entry.name);
- if (out.items.len >= @max(req.size, 512)) break;
}
+ const out = p.fs.stage(p.gpa);
+ out.appendSlice(p.gpa, listed.items) catch return Reply.fail(req.tag, E.NOMEM);
return .{ .tag = req.tag, .payload = .{ .staged = @intCast(out.items.len) } };
},
.read, .write, .setattr => {
+ // A rename or a mode change (`mv`, `chmod`) is refused as not
+ // permitted, EACCES through a mount: /os reads and writes the
+ // files it shows and changes nothing about them.
+ if (req.op == .setattr and (req.set.name or req.set.mode))
+ return tree.failText(req.tag, E.PERM, "permission denied: /os renames nothing and changes no mode");
if (stat.kind != .file) return Reply.fail(req.tag, E.PERM);
var z: [4096]u8 = undefined;
const path_z = std.fmt.bufPrintSentinel(&z, "{s}", .{path}, 0) catch return Reply.fail(req.tag, E.NOENT);
- const fd = libc.open(path_z, .{ .ACCMODE = if (req.op == .read) .RDONLY else .WRONLY, .NONBLOCK = true, .CLOEXEC = true });
- if (fd < 0) return Reply.fail(req.tag, E.PERM);
- defer _ = libc.close(fd);
- if (req.op == .setattr) {
- if (!req.truncate or req.off != 0 or libc.ftruncate(fd, 0) != 0) return Reply.fail(req.tag, E.INVAL);
- var truncated = attr;
- truncated.size = 0;
- return .{ .tag = req.tag, .attr = truncated };
- }
- if (req.off > std.math.maxInt(i64)) return Reply.fail(req.tag, E.INVAL);
- if (libc.lseek(fd, @intCast(req.off), libc.SEEK.SET) < 0) return Reply.fail(req.tag, E.IO);
- if (req.op == .write) {
- const written = libc.write(fd, req.data.ptr, req.data.len);
- if (written < 0) return Reply.fail(req.tag, E.IO);
- return .{ .tag = req.tag, .written = @intCast(written) };
- }
+ var buf: [ninep_io.msize]u8 = undefined; // a read never asks for more than a frame
+ const got = io: {
+ pardes.turn.yield();
+ defer pardes.turn.back();
+ const fd = libc.open(path_z, .{ .ACCMODE = if (req.op == .read) .RDONLY else .WRONLY, .NONBLOCK = true, .CLOEXEC = true });
+ if (fd < 0) return Reply.fail(req.tag, E.PERM);
+ defer _ = libc.close(fd);
+ if (req.op == .setattr) {
+ if (!req.truncate or req.off != 0 or libc.ftruncate(fd, 0) != 0) return tree.failText(req.tag, E.INVAL, "invalid truncate: only to zero");
+ var truncated = attr;
+ truncated.size = 0;
+ return .{ .tag = req.tag, .attr = truncated };
+ }
+ if (req.off > std.math.maxInt(i64)) return tree.failText(req.tag, E.INVAL, "invalid offset: past what a file may hold");
+ if (libc.lseek(fd, @intCast(req.off), libc.SEEK.SET) < 0) return Reply.fail(req.tag, E.IO);
+ if (req.op == .write) {
+ const written = libc.write(fd, req.data.ptr, req.data.len);
+ if (written < 0) return Reply.fail(req.tag, E.IO);
+ return .{ .tag = req.tag, .written = @intCast(written) };
+ }
+ const got = libc.read(fd, &buf, @min(req.size, buf.len));
+ if (got < 0) return Reply.fail(req.tag, E.IO);
+ break :io @as(usize, @intCast(got));
+ };
const out = p.fs.stage(p.gpa);
- out.resize(p.gpa, @min(req.size, 65536)) catch return Reply.fail(req.tag, E.NOMEM);
- const got = libc.read(fd, out.items.ptr, out.items.len);
- if (got < 0) return Reply.fail(req.tag, E.IO);
- out.shrinkRetainingCapacity(@intCast(got));
+ out.appendSlice(p.gpa, buf[0..got]) catch return Reply.fail(req.tag, E.NOMEM);
return .{ .tag = req.tag, .payload = .{ .staged = @intCast(got) } };
},
else => return Reply.fail(req.tag, E.PERM),
@@ -206,6 +275,30 @@ pub fn validMountName(name: []const u8) bool {
return true;
}
+test "/os refuses a rename or a mode change as not permitted, in words, and still truncates to zero" {
+ if (comptime !pardes.hosted) return error.SkipZigTest;
+ const p = try th.withFile(std.testing.allocator, "x\n");
+ defer p.deinit();
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "kept.txt", .data = "kept\n" });
+ var dir_buf: [4096]u8 = undefined;
+ const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
+ var node: u64 = os_root;
+ var parts = std.mem.tokenizeScalar(u8, dir, '/');
+ while (parts.next()) |part| node = th.look_up(p, node, part).reply.attr.node;
+ node = th.look_up(p, node, "kept.txt").reply.attr.node;
+ for ([_]Req{
+ .{ .tag = 1, .op = .setattr, .node = node, .set = .{ .mode = true } },
+ .{ .tag = 2, .op = .setattr, .node = node, .set = .{ .name = true }, .data = "moved.txt" },
+ }) |req| {
+ const r = th.call(p, req);
+ try std.testing.expectEqual(E.PERM, r.errno());
+ try std.testing.expectStringStartsWith(r.reply.ename, "permission denied");
+ }
+ try std.testing.expectEqual(tree.Status.ok, th.call(p, .{ .tag = 3, .op = .setattr, .node = node, .truncate = true }).reply.status);
+}
+
test "mounts own their names and dials and reject duplicate or reserved names" {
const gpa = std.testing.allocator;
var ns: Namespace = .{};
@@ -260,12 +353,13 @@ test "unmount refuses pane paths inherited directories and queued save targets"
}
gpa.free(pane.file.?.path);
pane.file.?.path = try gpa.dupe(u8, "/n/peer2/file");
- const shell = try p.newShell(1, "/n/peer/dir");
- p.setCwd(1, "/n/peer/dir");
+ const slot = p.freeSlot().?;
+ const shell = try p.newShell(slot, "/n/peer/dir");
+ p.setCwd(slot, "/n/peer/dir");
try std.testing.expectError(error.MountInUse, unmount(p, "peer"));
pane.cwd = .{ .inherited = shell };
try std.testing.expectError(error.MountInUse, unmount(p, "peer"));
- p.setCwd(1, "/");
+ p.setCwd(slot, "/");
while (p.nextEffect()) |_| {}
p.emit(.{ .save_text = .{ .pane = 0, .serial = pane.serial, .path = .from("/n/peer/pending") } });
try std.testing.expectError(error.MountInUse, unmount(p, "peer"));
@@ -281,8 +375,10 @@ test "virtual writes enforce permissions even when contents are empty" {
const p = try pardes.Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer p.deinit();
for ([_][]const u8{ "", "bytes" }) |bytes| {
- for ([_][]const u8{ "/virtual/index", "/virtual/screen", "/virtual/README", "/n/self/log" }) |path|
+ for ([_][]const u8{ "/virtual/index", "/virtual/screen", "/virtual/README" }) |path|
try std.testing.expectError(error.ReadOnlyFilesystem, write(p, path, bytes));
+ // /log takes one word, `follow`, and only on the open it changes.
+ if (bytes.len > 0) if (write(p, "/n/self/log", bytes)) |_| return error.TestUnexpectedResult else |_| {};
try std.testing.expectError(error.IsDirectory, write(p, "/virtual/pane", bytes));
try std.testing.expectError(error.FileNotFound, write(p, "/virtual/missing", bytes));
try std.testing.expectError(error.FileNotFound, write(p, "/virtual/cons", bytes));
@@ -292,7 +388,7 @@ test "virtual writes enforce permissions even when contents are empty" {
try std.testing.expectError(error.IsDirectory, write(p, "/virtual/src", bytes));
} else try std.testing.expectError(error.FileNotFound, write(p, "/virtual/src/fs.zig", bytes));
}
- for (p.fs.snapshots) |snapshot| try std.testing.expect(snapshot.node == 0);
+ for (p.fs.opens) |o| try std.testing.expect(o.node == 0);
}
test "direct self reads and writes use the same dot paths as Look" {
@@ -374,21 +470,22 @@ test "bounded reads accept exact OS file lengths and empty files" {
const empty = try readLimit(p, explicit, 0);
defer gpa.free(empty);
try std.testing.expectEqual(@as(usize, 0), empty.len);
- try std.testing.expectEqual(@as(usize, 0), p.fs.os_paths.items.len);
+ // The directory's node stays in the table for the listener to collect
+ // once no connection names it (src/9p_io.zig, collectOs): a client may
+ // have walked to the same directory meanwhile and hold it by that node.
+ try std.testing.expectEqual(@as(usize, 1), p.fs.os_paths.items.len);
+ try std.testing.expectEqualStrings(native, p.fs.os_paths.items[0].path);
}
test "bounded reads apply the same limits to self bodies and embedded sources" {
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true });
defer p.deinit();
- p.fs.socket_path = "/tmp/pardes-limited-in-process.sock";
- try p.fs.mount(gpa, "own", p.fs.socket_path);
var contents: [8209]u8 = @splat('x');
contents[contents.len - 1] = '\n';
for ([_][]const u8{ &contents, "" }) |expected| {
const pane = try p.setTestFile(expected);
- for ([_][]const u8{ "/virtual", "/n/self", "/n/own" }) |prefix| {
- if (!platform_has_fs and std.mem.eql(u8, prefix, "/n/own")) continue;
+ for ([_][]const u8{ "/virtual", "/n/self" }) |prefix| {
var path_buf: [128]u8 = undefined;
const path = try std.fmt.bufPrint(&path_buf, "{s}/pane/{d}/body", .{ prefix, pane.serial });
const bytes = try readLimit(p, path, expected.len);
@@ -403,8 +500,7 @@ test "bounded reads apply the same limits to self bodies and embedded sources" {
}
if (limits.embedded_sources) {
const source = findEmbeddedSource("src/look.zig", false).?;
- for ([_][]const u8{ "/virtual/src/look.zig", "/n/self/src/look.zig", "/n/own/src/look.zig" }) |path| {
- if (!platform_has_fs and std.mem.startsWith(u8, path, "/n/own/")) continue;
+ for ([_][]const u8{ "/virtual/src/look.zig", "/n/self/src/look.zig" }) |path| {
const bytes = try readLimit(p, path, source.contents.len);
defer gpa.free(bytes);
try std.testing.expectEqualStrings(source.contents, bytes);
@@ -421,10 +517,8 @@ test "bounded reads count rendered directory paths and unknown self lengths" {
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true });
defer p.deinit();
- p.fs.socket_path = "/tmp/pardes-limited-in-process.sock";
- try p.fs.mount(gpa, "own", p.fs.socket_path);
- for ([_][]const u8{ "/n", "/virtual", "/n/self", "/n/own", "/n/own/pane", "/virtual/listeners", "/virtual/README" }) |path| {
- if (!platform_has_fs and std.mem.startsWith(u8, path, "/n/own")) continue;
+ p.fs.socket_path = "/tmp/pardes-limited-in-process.sock"; // so listeners has a line
+ for ([_][]const u8{ "/n", "/virtual", "/n/self", "/virtual/pane", "/virtual/listeners", "/virtual/README" }) |path| {
const expected = try read(p, path);
defer gpa.free(expected);
try std.testing.expect(expected.len > 0);
@@ -448,15 +542,12 @@ test "bounded reads release terminal snapshots after success and size refusal" {
defer gpa.free(empty);
try std.testing.expectEqual(@as(usize, 0), empty.len);
p.update(.{ .output = .{ .pane = 0, .bytes = "limited terminal output" } });
- const expected = "limited terminal output";
+ const expected = "limited terminal output\n"; // a line ends with its newline
const bytes = try readLimit(p, path, expected.len);
defer gpa.free(bytes);
try std.testing.expectEqualStrings(expected, bytes);
try std.testing.expectError(error.FileTooLarge, readLimit(p, path, expected.len - 1));
- for (p.fs.snapshots) |snapshot| {
- try std.testing.expectEqual(@as(u64, 0), snapshot.node);
- try std.testing.expect(snapshot.bytes == null);
- }
+ for (p.fs.opens) |o| try std.testing.expectEqual(@as(u64, 0), o.node);
}
test "bounded reads probe size-unknown proc files at the exact limit" {
@@ -558,8 +649,9 @@ test "virtual body writes can read their input from the same pane" {
const path = try std.fmt.bufPrint(&path_buffer, "/virtual/pane/{d}/body", .{pane.serial});
try write(p, path, pane.file.?.content);
try std.testing.expectEqualStrings("same pane contents\n", pane.file.?.content);
- try std.testing.expectEqual(@as(usize, 2), pane.file.?.history.undo_len);
- const events = &p.fs.panes[p.active].events;
+ // The truncation and the write are one undo step.
+ try std.testing.expectEqual(@as(usize, 1), pane.file.?.history.undo_len);
+ const events = &p.panes[p.active].?.fs.events;
try std.testing.expect(std.mem.startsWith(u8, events.peek().?, "ED"));
events.pop();
try std.testing.expect(std.mem.startsWith(u8, events.peek().?, "EI"));
@@ -569,52 +661,55 @@ test "virtual body writes can read their input from the same pane" {
try std.testing.expectEqualStrings("pane contents\n", pane.file.?.content);
}
-test "same-core mount directories preserve their mount prefix across reads" {
- if (!platform_has_fs) return error.SkipZigTest;
- const gpa = std.testing.allocator;
- const p = try pardes.Pardes.init(gpa, .{ .tty_only = true });
- defer p.deinit();
- const socket_path = "/tmp/pardes-in-process-mount.sock";
- p.fs.socket_path = socket_path;
- try p.fs.mount(gpa, "own", socket_path);
- const roots = try read(p, "/n/own");
- defer gpa.free(roots);
- try std.testing.expect(std.mem.startsWith(u8, roots, "/n/own/README\n/n/own/index\n"));
- try std.testing.expect(std.mem.indexOf(u8, roots, "/n/own/pane/\n/n/own/os/\n") != null);
- try std.testing.expectError(error.NotADirectory, read(p, "/n/own/index/.."));
- try std.testing.expectError(error.FileNotFound, read(p, "/n/own/self/index"));
+pub fn isVirtual(path: []const u8) bool {
+ return std.mem.eql(u8, path, "/virtual") or std.mem.startsWith(u8, path, "/virtual/") or
+ std.mem.eql(u8, path, "/n") or std.mem.startsWith(u8, path, "/n/");
+}
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- for (0..520) |i| {
- var name: [32]u8 = undefined;
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = try std.fmt.bufPrint(&name, "entry-{d:0>4}.txt", .{i}), .data = "child\n" });
- }
- var directory_buffer: [4096]u8 = undefined;
- const directory = directory_buffer[0..try tmp.dir.realPath(std.testing.io, &directory_buffer)];
- const held_node = try osNode(p, directory);
- const path = try std.fmt.allocPrint(gpa, "/n/own/os{s}", .{directory});
- defer gpa.free(path);
- const listing = try read(p, path);
- defer gpa.free(listing);
- var entries = std.mem.tokenizeScalar(u8, listing, '\n');
- var count: usize = 0;
- while (entries.next()) |entry| {
- try std.testing.expect(std.mem.startsWith(u8, entry, path));
- const child = try read(p, entry);
- defer gpa.free(child);
- try std.testing.expectEqualStrings("child\n", child);
- try std.testing.expectEqual(@as(usize, 1), p.fs.os_paths.items.len);
- count += 1;
+/// std's `statFile`, but a name with a part over 255 bytes is NameTooLong:
+/// std's own takes the kernel's ENAMETOOLONG for that for a bug and panics
+/// (Io.Threaded dirStatFileLinux), and such a name comes from anyone who
+/// writes one to `name`, `look` or DumpDir.
+pub fn statPath(io: std.Io, path: []const u8, options: std.Io.Dir.StatFileOptions) !std.Io.File.Stat {
+ var parts = std.mem.tokenizeScalar(u8, path, '/');
+ while (parts.next()) |part| if (part.len > 255) return error.NameTooLong;
+ return std.Io.Dir.cwd().statFile(io, path, options);
+}
+
+test "a path with a part over 255 bytes is NameTooLong, never a panic" {
+ const long = "/tmp/" ++ &@as([300]u8, @splat('x')) ++ "/f";
+ try std.testing.expectError(error.NameTooLong, statPath(std.testing.io, long, .{}));
+}
+
+/// Make `dir` and each directory above it that is missing, as `mkdir -p`
+/// does: one already there is no failure. A failure shows at the open
+/// that follows.
+pub fn makeDirs(dir: []const u8) void {
+ if (comptime !platform_has_fs) return;
+ if (dir.len == 0) return;
+ pardes.turn.yield();
+ defer pardes.turn.back();
+ _ = std.Io.Dir.cwd().createDirPathStatus(std.Io.Threaded.global_single_threaded.io(), dir, .fromMode(0o755)) catch {};
+}
+
+/// Whether `dir` is not there to make because one above it refuses: its
+/// nearest ancestor that is there may not be searched or written (EACCES:
+/// `noperm/a/b`, `/proc/1/root/x`).
+pub fn deniedAbove(dir: []const u8) bool {
+ if (comptime !platform_has_fs) return false;
+ var at: ?[]const u8 = dir;
+ while (at) |d| : (at = std.fs.path.dirname(d)) {
+ var z: [4096]u8 = undefined;
+ const dz = std.fmt.bufPrintSentinel(&z, "{s}", .{d}, 0) catch return false;
+ if (libc.access(dz.ptr, 0) != 0) continue; // F_OK
+ return libc.access(dz.ptr, 2 | 1) != 0; // W_OK | X_OK
}
- try std.testing.expectEqual(@as(usize, 520), count);
- try std.testing.expectEqual(held_node, p.fs.os_paths.items[0].node);
- try std.testing.expectEqualStrings(directory, p.fs.os_paths.items[0].path);
+ return false;
}
-pub fn isVirtual(path: []const u8) bool {
- return std.mem.eql(u8, path, "/virtual") or std.mem.startsWith(u8, path, "/virtual/") or
- std.mem.eql(u8, path, "/n") or std.mem.startsWith(u8, path, "/n/");
+test "a directory under one that may not be searched or written is denied, one merely missing is not" {
+ try std.testing.expect(deniedAbove("/proc/1/root/x/y"));
+ try std.testing.expect(!deniedAbove("/tmp/pardes-surely-missing-dir/a/b"));
}
pub fn localPath(path: []const u8) ?[]const u8 {
@@ -672,7 +767,9 @@ pub fn resolve(p: ?*pardes.Pardes, word: []const u8, cwd: []const u8, out: *[409
if (std.mem.startsWith(u8, joined, "/virtual/")) return resolveVirtual(p, joined[8..], out);
if (resolveOs(joined, out)) |found| return found;
if (resolveVirtual(p, joined, out)) |found| return found;
- if (resolveVirtual(p, word, out)) |found| return found;
+ // `.`, `..` and `./x` name the pane's directory, never the served tree:
+ // with that directory gone they name nothing (`.` would be /virtual/).
+ if (!dotRelative(word)) if (resolveVirtual(p, word, out)) |found| return found;
if (resolveEmbedded(word, cwd, out)) |source| {
const path = std.fmt.bufPrint(out, "/virtual/{s}", .{source.path}) catch return null;
return .{ .path = path };
@@ -680,10 +777,76 @@ pub fn resolve(p: ?*pardes.Pardes, word: []const u8, cwd: []const u8, out: *[409
return null;
}
+/// Whether `word` is spelled relative to the directory it is looked from:
+/// `.`, `..`, `./x`, `../x`.
+pub fn dotRelative(word: []const u8) bool {
+ const w = std.mem.trimEnd(u8, word, "/");
+ return std.mem.eql(u8, w, ".") or std.mem.eql(u8, w, "..") or
+ std.mem.startsWith(u8, word, "./") or std.mem.startsWith(u8, word, "../");
+}
+
+/// Where a path really is on the host, and whether it is a directory. The
+/// path may lie in a mount this editor serves, so the turn is given up for
+/// the syscalls: another thread answers them.
+/// A path's leading `~` -- alone, or before `/` or `:` (`~/x:12`) -- is the
+/// home directory: $HOME, else the passwd entry's. `~user/...` is that
+/// user's. As in a shell, `~` is home even beside a file named `~` in the
+/// current directory. Every entry point that takes a path the user typed
+/// runs it through here: look (B3 and 9P), name, Save, ThemeFile, DumpDir,
+/// Restore, a forwarded `pardes ~/x`. The path itself when there is no
+/// `~` to expand, or no home for it.
+pub fn expandHome(path: []const u8, out: *[4096]u8) []const u8 {
+ if (comptime !pardes.hosted) return path;
+ return expandHomeFrom(path, out, std.c.getenv("HOME"));
+}
+
+/// expandHome with HOME given (null: unset), so a test need not change the
+/// process's environment, which a child spawned later reads.
+fn expandHomeFrom(path: []const u8, out: *[4096]u8, env_home: ?[*:0]const u8) []const u8 {
+ if (path.len == 0 or path[0] != '~') return path;
+ const end = std.mem.indexOfAny(u8, path, "/:") orelse path.len;
+ const home = (if (end == 1) homeDir(env_home) else userHome(path[1..end])) orelse return path;
+ const trimmed = std.mem.trimEnd(u8, home, "/");
+ const rest = path[end..];
+ if (trimmed.len == 0 and (rest.len == 0 or rest[0] != '/')) return std.fmt.bufPrint(out, "/{s}", .{rest}) catch path;
+ return std.fmt.bufPrint(out, "{s}{s}", .{ trimmed, rest }) catch path;
+}
+
+fn homeDir(env_home: ?[*:0]const u8) ?[]const u8 {
+ if (env_home) |h| if (h[0] != 0) return std.mem.span(h);
+ const pw = std.c.getpwuid(std.c.getuid()) orelse return null;
+ return std.mem.span(pw.dir orelse return null);
+}
+
+fn userHome(name: []const u8) ?[]const u8 {
+ var z: [256]u8 = undefined;
+ const name_z = std.fmt.bufPrintSentinel(&z, "{s}", .{name}, 0) catch return null;
+ const pw = std.c.getpwnam(name_z) orelse return null;
+ return std.mem.span(pw.dir orelse return null);
+}
+
+test "a leading ~ is home, from HOME or else the passwd entry" {
+ var out: [4096]u8 = undefined;
+ const home = homeDir(std.c.getenv("HOME")) orelse return error.SkipZigTest;
+ var want: [4096]u8 = undefined;
+ try std.testing.expectEqualStrings(try std.fmt.bufPrint(&want, "{s}/x:12", .{std.mem.trimEnd(u8, home, "/")}), expandHome("~/x:12", &out));
+ try std.testing.expectEqualStrings(std.mem.trimEnd(u8, home, "/"), expandHome("~", &out));
+ try std.testing.expectEqualStrings("a/~/b", expandHome("a/~/b", &out));
+ try std.testing.expectEqualStrings("~no-such-user-pardes/x", expandHome("~no-such-user-pardes/x", &out));
+ try std.testing.expectEqualStrings("/", expandHome("~root", &out)[0..1]);
+
+ // HOME unset: the passwd entry's home.
+ const pw = std.c.getpwuid(std.c.getuid()) orelse return error.SkipZigTest;
+ var from_passwd: [4096]u8 = undefined;
+ try std.testing.expectEqualStrings(try std.fmt.bufPrint(&from_passwd, "{s}/y", .{std.mem.trimEnd(u8, std.mem.span(pw.dir.?), "/")}), expandHomeFrom("~/y", &out, null));
+}
+
pub fn resolveOs(path: []const u8, out: *[4096]u8) ?Resolved {
if (comptime !platform_has_fs) return null;
var z: [4096]u8 = undefined;
const path_z = std.fmt.bufPrintSentinel(&z, "{s}", .{path}, 0) catch return null;
+ pardes.turn.yield();
+ defer pardes.turn.back();
const resolved = realpath(path_z, out) orelse return null;
return .{ .path = std.mem.span(resolved), .dir = isDir(resolved) };
}
@@ -727,11 +890,8 @@ pub fn readLimit(p: *pardes.Pardes, path: []const u8, max_bytes: usize) ![]u8 {
var native_buf: [4096]u8 = undefined;
const native = resolveOs(remote_path, &native_buf) orelse return readFileLimit(p.gpa, path, limit);
if (!native.dir) return readFileLimit(p.gpa, path, limit);
- const saved_paths = p.fs.os_paths.items.len;
- defer {
- for (p.fs.os_paths.items[saved_paths..]) |temporary| p.gpa.free(temporary.path);
- p.fs.os_paths.shrinkRetainingCapacity(saved_paths);
- }
+ // The node stays in the table until no connection names it either
+ // (src/9p_io.zig, collectOs): a client may have walked to it too.
const node = try osNode(p, native.path);
return readNode(p, node, path, limit);
}
@@ -741,25 +901,10 @@ pub fn readLimit(p: *pardes.Pardes, path: []const u8, max_bytes: usize) ![]u8 {
}
for (p.fs.mounts.items) |mount| {
if (!std.mem.eql(u8, name, mount.name)) continue;
- if (ninep_io.Client.sameSession(mount.dial, p.fs.socket_path, p.fs.tcp_address, p.fs.quic_address)) {
- const saved_paths = p.fs.os_paths.items.len;
- defer {
- for (p.fs.os_paths.items[saved_paths..]) |temporary| p.gpa.free(temporary.path);
- p.fs.os_paths.shrinkRetainingCapacity(saved_paths);
- }
- var node = tree.root;
- var directory = true;
- var parts = std.mem.tokenizeScalar(u8, remote_path, '/');
- while (parts.next()) |part| {
- if (!directory) return error.NotADirectory;
- if (std.mem.eql(u8, part, ".")) continue;
- const reply = tree.handle(p, .{ .tag = 0, .op = .lookup, .node = node, .data = part });
- if (reply.status != .ok) return error.FileNotFound;
- node = reply.attr.node;
- directory = reply.attr.dir;
- }
- return readNode(p, node, path, limit);
- }
+ // A peer answers on its own time, and the peer may be this very
+ // editor: the turn goes out with the request.
+ pardes.turn.yield();
+ defer pardes.turn.back();
return ninep_io.Client.readLimit(p.gpa, mount.dial, remote_path, path, limit);
}
return error.FileNotFound;
@@ -820,60 +965,64 @@ fn readNode(p: *pardes.Pardes, initial_node: u64, path: []const u8, limit: usize
}
}
+/// The editor's, between steps: a save or a dump the shell is performing,
+/// never a step of the core.
pub fn write(p: *pardes.Pardes, path: []const u8, bytes: []const u8) !void {
if (std.mem.eql(u8, std.mem.trimEnd(u8, path, "/"), "/n")) return error.IsDirectory;
- var self_path: ?[]const u8 = null;
- if (std.mem.eql(u8, path, "/virtual")) self_path = "";
- if (std.mem.startsWith(u8, path, "/virtual/")) self_path = path[9..];
- if (std.mem.startsWith(u8, path, "/n/")) {
- const explicit = path[3..];
- const cut = std.mem.indexOfScalar(u8, explicit, '/') orelse explicit.len;
- const name = explicit[0..cut];
- const remote_path = if (cut < explicit.len) explicit[cut..] else "/";
- if (std.mem.eql(u8, name, "os")) return writeFile(remote_path, bytes);
- if (std.mem.eql(u8, name, "self")) {
- self_path = remote_path;
- } else {
- for (p.fs.mounts.items) |mount| {
- if (!std.mem.eql(u8, name, mount.name)) continue;
- if (ninep_io.Client.sameSession(mount.dial, p.fs.socket_path, p.fs.tcp_address, p.fs.quic_address)) {
- var buf: [4096]u8 = undefined;
- const local = try std.fmt.bufPrint(&buf, "/n{s}", .{remote_path});
- return write(p, local, bytes);
- }
- return ninep_io.Client.write(p.gpa, mount.dial, remote_path, bytes);
- }
- return error.FileNotFound;
- }
+ if (std.mem.eql(u8, path, "/virtual")) return writeSelf(p, "", bytes);
+ if (std.mem.startsWith(u8, path, "/virtual/")) return writeSelf(p, path[9..], bytes);
+ if (!std.mem.startsWith(u8, path, "/n/")) return writeOut(p, null, path, bytes);
+ const explicit = path[3..];
+ const cut = std.mem.indexOfScalar(u8, explicit, '/') orelse explicit.len;
+ const name = explicit[0..cut];
+ const remote_path = if (cut < explicit.len) explicit[cut..] else "/";
+ if (std.mem.eql(u8, name, "os")) return writeOut(p, null, remote_path, bytes);
+ if (std.mem.eql(u8, name, "self")) return writeSelf(p, remote_path, bytes);
+ for (p.fs.mounts.items) |mount| {
+ if (std.mem.eql(u8, name, mount.name)) return writeOut(p, mount.dial, remote_path, bytes);
}
- if (self_path) |name| {
- var node = tree.resolveSelf(p, name) orelse return error.FileNotFound;
- const attributes = tree.handle(p, .{ .tag = 0, .op = .getattr, .node = node });
- if (attributes.status != .ok) return error.FileNotFound;
- if (attributes.attr.dir) return error.IsDirectory;
- if (attributes.attr.mode & 0o200 == 0) return error.ReadOnlyFilesystem;
- const opened = tree.handle(p, .{ .tag = 0, .op = .open, .node = node });
- if (opened.status != .ok) return error.OpenFailed;
- if (opened.attr.node != 0) node = opened.attr.node;
- defer _ = tree.handle(p, .{ .tag = 0, .op = .release, .node = node, .handle = opened.handle });
- var preserved: ?[]u8 = null;
- defer if (preserved) |copy| p.gpa.free(copy);
- const target = tree.Node.target(node);
- if (target != null and target.? == .pane and target.?.pane.file == .body) {
- preserved = try p.gpa.dupe(u8, bytes);
- const trunc = tree.handle(p, .{ .tag = 0, .op = .setattr, .node = node, .truncate = true });
- if (trunc.status != .ok) return error.WriteFailed;
- }
- const contents = preserved orelse bytes;
- var off: usize = 0;
- while (off < contents.len) {
- const reply = tree.handle(p, .{ .tag = 0, .op = .write, .node = node, .off = off, .data = contents[off..] });
- if (reply.status != .ok or reply.written == 0) return error.WriteFailed;
- off += reply.written;
- }
- return;
+ return error.FileNotFound;
+}
+
+/// The host, or the peer at `dial`, takes the bytes with the turn given up
+/// entirely -- the peer may be this very editor, and a write it serves may
+/// change any pane -- so they are copied first: `bytes` is usually a pane's
+/// own text.
+fn writeOut(p: *pardes.Pardes, dial: ?[]const u8, path: []const u8, bytes: []const u8) !void {
+ const copy = try p.gpa.dupe(u8, bytes);
+ defer p.gpa.free(copy);
+ pardes.turn.rest();
+ defer pardes.turn.wake();
+ if (dial) |d| return ninep_io.Client.write(p.gpa, d, path, copy);
+ return writeFile(path, copy);
+}
+
+/// This editor's own tree, written in place.
+fn writeSelf(p: *pardes.Pardes, name: []const u8, bytes: []const u8) !void {
+ var node = tree.resolveSelf(p, name) orelse return error.FileNotFound;
+ const attributes = tree.handle(p, .{ .tag = 0, .op = .getattr, .node = node });
+ if (attributes.status != .ok) return error.FileNotFound;
+ if (attributes.attr.dir) return error.IsDirectory;
+ if (attributes.attr.mode & 0o200 == 0) return error.ReadOnlyFilesystem;
+ const opened = tree.handle(p, .{ .tag = 0, .op = .open, .node = node });
+ if (opened.status != .ok) return error.OpenFailed;
+ if (opened.attr.node != 0) node = opened.attr.node;
+ defer _ = tree.handle(p, .{ .tag = 0, .op = .release, .node = node, .handle = opened.handle });
+ var preserved: ?[]u8 = null;
+ defer if (preserved) |copy| p.gpa.free(copy);
+ const target = tree.Node.target(node);
+ if (target != null and target.? == .pane and target.?.pane.file == .body) {
+ preserved = try p.gpa.dupe(u8, bytes);
+ const trunc = tree.handle(p, .{ .tag = 0, .op = .setattr, .node = node, .truncate = true });
+ if (trunc.status != .ok) return error.WriteFailed;
+ }
+ const contents = preserved orelse bytes;
+ var off: usize = 0;
+ while (off < contents.len) {
+ const reply = tree.handle(p, .{ .tag = 0, .op = .write, .node = node, .off = off, .data = contents[off..] });
+ if (reply.status != .ok or reply.written == 0) return error.WriteFailed;
+ off += reply.written;
}
- return writeFile(path, bytes);
}
fn resolveEmbedded(word: []const u8, cwd: []const u8, scratch: *[4096]u8) ?Source {
@@ -928,190 +1077,53 @@ pub const platform_has_fs = !pardes.isolated and switch (pardes.platform) {
};
const find_max_hits = 512;
-const find_max_depth = 16;
-const find_max_steps = 100_000;
-pub const search_max_output_bytes = pardes.MAX_PANES * find_max_hits * (4096 + 320);
-
-const find_skip = [_][]const u8{
- ".git", ".jj", "target", "node_modules",
- ".venv", "__pycache__", ".zig-cache", "zig-out",
-};
-
-pub fn find(arena: std.mem.Allocator, dir: []const u8, pat: []const u8, out: []u8) !usize {
- var hits: [find_max_hits][]const u8 = undefined;
- var hits_len: usize = 0;
- if (platform_has_fs) {
- const io = std.Io.Threaded.global_single_threaded.io();
- var root = try std.Io.Dir.cwd().openDir(io, dir, .{ .iterate = true });
- defer root.close(io);
- var w = try root.walkSelectively(arena);
- defer w.deinit();
- var steps: usize = 0;
- walk: while (steps < find_max_steps and hits_len < hits.len) {
- steps += 1; // an unreadable dir burns a step too, so it cannot spin
- const e = (try w.next(io)) orelse break;
- if (std.ascii.indexOfIgnoreCase(e.basename, pat) != null) {
- hits[hits_len] = try arena.dupe(u8, e.path);
- hits_len += 1;
- }
- if (e.kind != .directory or e.depth() >= find_max_depth) continue;
- for (find_skip) |s| if (std.mem.eql(u8, e.basename, s)) continue :walk;
- try w.enter(io, e);
- }
- } else {
- for (sources) |s| {
- if (hits_len >= hits.len) break;
- if (std.ascii.indexOfIgnoreCase(std.fs.path.basename(s.path), pat) != null) {
- hits[hits_len] = s.path;
- hits_len += 1;
- }
- }
- }
- std.mem.sort([]const u8, hits[0..hits_len], {}, struct {
- fn lt(_: void, a: []const u8, b: []const u8) bool {
- return std.mem.lessThan(u8, a, b);
- }
- }.lt);
- var written: usize = 0;
- for (hits[0..hits_len]) |h| {
- if (h.len + 1 > out.len - written) break;
- @memcpy(out[written..][0..h.len], h);
- written += h.len;
- out[written] = '\n';
- written += 1;
- }
- return written;
-}
-const grep_max_bytes = 256 * 1024;
-const grep_max_files = 20_000;
+/// What a Find or Grep walk passed over, said under its hits: directories
+/// it might not open, and caps it stopped at.
+pub const WalkNotes = struct {
+ skipped: usize = 0,
+ hits_cut: bool = false,
+ /// A pane search's matching lines it stopped at, its rows filling
+ /// look.search_text_output_bytes; 0 if none.
+ rows_cut: usize = 0,
+ /// The cap on entries walked it stopped at, 0 if none.
+ walk_cut: usize = 0,
-const GrepResult = struct { bytes: usize, hits: usize };
+ pub const max_hits = find_max_hits;
+ pub const max_files = grep_max_files;
+ pub const max_depth = find_max_depth;
-fn grepText(path: []const u8, text: []const u8, pat: []const u8, out: []u8, budget: usize) GrepResult {
- var result: GrepResult = .{ .bytes = 0, .hits = 0 };
- var line: usize = 0;
- var it = std.mem.splitScalar(u8, text, '\n');
- while (it.next()) |raw| {
- line += 1;
- if (result.hits >= budget) break;
- const at = std.ascii.indexOfIgnoreCase(raw, pat) orelse continue;
- const ln = std.mem.trimEnd(u8, raw, " \t\r");
- var cut = @min(ln.len, 200);
- while (cut > 0 and cut < ln.len and ln[cut] & 0xc0 == 0x80) cut -= 1;
- const row = std.fmt.bufPrint(out[result.bytes..], "{s}:{d}:{d}{c}{d} {s}\n", .{
- path, line, at + 1, config.range_sep, at + pat.len, ln[0..cut],
- }) catch break;
- result.bytes += row.len;
- result.hits += 1;
+ /// The lines that say it, each ending in a newline, into `out`.
+ pub fn write(n: WalkNotes, out: []u8) usize {
+ var w = std.Io.Writer.fixed(out);
+ if (n.hits_cut) w.print("cut at {d} hits\n", .{max_hits}) catch {};
+ if (n.rows_cut > 0) w.print("cut at {d} lines\n", .{n.rows_cut}) catch {};
+ if (n.walk_cut > 0) w.print("walk cut at {d} entries\n", .{n.walk_cut}) catch {};
+ if (n.skipped > 0) w.print("{d} director{s} skipped: permission denied\n", .{ n.skipped, if (n.skipped == 1) "y" else "ies" }) catch {};
+ return w.buffered().len;
}
- return result;
-}
-pub fn grep(arena: std.mem.Allocator, gpa: std.mem.Allocator, dir: []const u8, base: []const u8, pat: []const u8, out: []u8) !usize {
- var hits: usize = 0;
- var written: usize = 0;
- if (!platform_has_fs) {
- for (sources) |s| {
- if (hits >= find_max_hits or written == out.len) break;
- const result = grepText(s.path, s.contents, pat, out[written..], find_max_hits - hits);
- hits += result.hits;
- written += result.bytes;
- }
- return written;
- }
- const root_path = std.mem.trimEnd(u8, dir, "/");
- const home = std.mem.trimEnd(u8, base, "/");
- const files = try arena.alloc([]const u8, grep_max_files);
- var files_len: usize = 0;
- {
- const io = std.Io.Threaded.global_single_threaded.io();
- var root = try std.Io.Dir.cwd().openDir(io, dir, .{ .iterate = true });
- defer root.close(io);
- var w = try root.walkSelectively(arena);
- defer w.deinit();
- var steps: usize = 0;
- walk: while (steps < find_max_steps and files_len < files.len) {
- steps += 1;
- const e = (try w.next(io)) orelse break;
- if (e.kind == .directory) {
- if (e.depth() >= find_max_depth) continue;
- for (find_skip) |s| if (std.mem.eql(u8, e.basename, s)) continue :walk;
- try w.enter(io, e);
- continue;
- }
- if (e.kind != .file) continue;
- files[files_len] = try std.fmt.allocPrint(arena, "{s}/{s}", .{ root_path, e.path });
- files_len += 1;
- }
- }
- std.mem.sort([]const u8, files[0..files_len], {}, struct {
- fn lt(_: void, a: []const u8, b: []const u8) bool {
- return std.mem.lessThan(u8, a, b);
- }
- }.lt);
- const buf = try gpa.alloc(u8, grep_max_bytes);
- defer gpa.free(buf);
- for (files[0..files_len]) |path| {
- if (hits >= find_max_hits or written == out.len) break;
- var pathbuf: [4096]u8 = undefined;
- const path_z = std.fmt.bufPrintSentinel(&pathbuf, "{s}", .{path}, 0) catch return error.PathTooLong;
- const fd = libc.open(path_z, .{ .ACCMODE = .RDONLY, .CLOEXEC = true, .NONBLOCK = true });
- if (fd < 0) continue;
- var len: usize = 0;
- var readable = true;
- while (len < buf.len) {
- const n = libc.read(fd, buf[len..].ptr, buf.len - len);
- if (n < 0) {
- if (libc.errno(n) == .INTR) continue;
- readable = false;
- break;
- }
- if (n == 0) break;
- len += @intCast(n);
- }
- _ = libc.close(fd);
- if (!readable) continue;
- const text = buf[0..len];
- if (std.mem.indexOfScalar(u8, text[0..@min(len, 1024)], 0) != null) continue;
- const shown = lsp.rel(home, path);
- const result = grepText(shown, text, pat, out[written..], find_max_hits - hits);
- hits += result.hits;
- written += result.bytes;
- }
- return written;
-}
-
-test "grep skips a file it cannot read instead of abandoning the search" {
- if (!platform_has_fs) return;
- const gpa = std.testing.allocator;
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- var base_buf: [std.fs.max_path_bytes]u8 = undefined;
- const dir = base_buf[0..try tmp.dir.realPath(std.testing.io, &base_buf)];
-
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "a-locked.txt", .data = "needle here\n" });
- try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "b-open.txt", .data = "needle here\n" });
- var locked_buf: [std.fs.max_path_bytes]u8 = undefined;
- const locked = try std.fmt.bufPrintSentinel(&locked_buf, "{s}/a-locked.txt", .{dir}, 0);
- if (libc.chmod(locked, 0) != 0) return;
- const probe = libc.open(locked, .{ .ACCMODE = .RDONLY });
- if (probe >= 0) {
- _ = libc.close(probe);
- _ = libc.chmod(locked, 0o644);
- return error.SkipZigTest;
+ /// Whether `line` is one of those, not a hit.
+ pub fn isNote(line: []const u8) bool {
+ if (std.mem.startsWith(u8, line, "cut at ") or std.mem.startsWith(u8, line, "walk cut at ")) return true;
+ const digits = for (line, 0..) |c, i| {
+ if (!std.ascii.isDigit(c)) break i;
+ } else line.len;
+ if (digits == 0) return false;
+ const rest = line[digits..];
+ return std.mem.startsWith(u8, rest, " director") or std.mem.startsWith(u8, rest, " file");
}
+};
+const find_max_depth = 16;
- var arena: std.heap.ArenaAllocator = .init(gpa);
- defer arena.deinit();
- const out = try gpa.alloc(u8, 64 * 1024);
- defer gpa.free(out);
- const n = try grep(arena.allocator(), gpa, dir, dir, "needle", out);
- _ = libc.chmod(locked, 0o644); // so `tmp.cleanup` can remove it
+pub const find_skip = [_][]const u8{
+ ".git", ".jj", "target", "node_modules",
+ ".venv", "__pycache__", ".zig-cache", "zig-out",
+};
- try std.testing.expect(std.mem.indexOf(u8, out[0..n], "b-open.txt") != null);
- try std.testing.expect(std.mem.indexOf(u8, out[0..n], "a-locked.txt") == null);
-}
+// Find and Grep walk on the disk engine's worker now (Stream.zig); what is
+// left here is what their notes and skips were.
+const grep_max_files = 20_000;
fn isDir(path: [*:0]const u8) bool {
const fd = libc.open(path, .{ .ACCMODE = .RDONLY, .DIRECTORY = true, .CLOEXEC = true });
@@ -1126,12 +1138,36 @@ pub fn readFile(gpa: std.mem.Allocator, path: []const u8) ![]u8 {
/// Restore first tries a relative argument under the default dump directory,
/// then preserves the ordinary file lookup. Absolute paths remain verbatim.
-pub fn readRestore(gpa: std.mem.Allocator, path: []const u8) ![]u8 {
+pub fn readRestore(gpa: std.mem.Allocator, typed: []const u8, dir_setting: []const u8) ![]u8 {
+ var home_buf: [4096]u8 = undefined;
+ const path = expandHome(typed, &home_buf);
var dir_buf: [4096]u8 = undefined;
- const dir = @import("dump.zig").defaultDirectory(&dir_buf);
+ const dir = @import("dump.zig").directory(&dir_buf, dir_setting);
return readRestoreIn(gpa, path, dir);
}
+/// The file a Restore of `typed` reads, whole: `~` expanded, a relative name
+/// the DumpDir's when one is there, else the current directory's. What the
+/// log and the message say, not the name as typed. `typed` itself (home
+/// expanded) when nothing resolves: the read then says why.
+pub fn restorePath(typed: []const u8, dir_setting: []const u8, out: *[4096]u8) []const u8 {
+ var home_buf: [4096]u8 = undefined;
+ const path = expandHome(typed, &home_buf);
+ if (!std.fs.path.isAbsolute(path)) {
+ var dir_buf: [4096]u8 = undefined;
+ if (@import("dump.zig").directory(&dir_buf, dir_setting)) |base| {
+ var buf: [4096]u8 = undefined;
+ if (std.fmt.bufPrint(&buf, "{s}/{s}", .{ base, path })) |candidate| {
+ if (resolveOs(candidate, out)) |r| if (!r.dir) return r.path;
+ } else |_| {}
+ }
+ }
+ if (resolveOs(path, out)) |r| return r.path;
+ const n = @min(path.len, out.len);
+ @memcpy(out[0..n], path[0..n]);
+ return out[0..n];
+}
+
fn readRestoreIn(gpa: std.mem.Allocator, path: []const u8, dir: ?[]const u8) ![]u8 {
if (!std.fs.path.isAbsolute(path)) {
if (dir) |base| {
@@ -1194,6 +1230,10 @@ fn readFileLimit(gpa: std.mem.Allocator, path: []const u8, limit: usize) ![]u8 {
var pathbuf: [4096]u8 = undefined;
const native = localPath(path) orelse return error.OpenFailed;
const path_z = std.fmt.bufPrintSentinel(&pathbuf, "{s}", .{native}, 0) catch return error.PathTooLong;
+ // The path may be a mount this editor serves: the turn goes out with the
+ // syscalls, and the bytes come back into memory of the caller's own.
+ pardes.turn.yield();
+ defer pardes.turn.back();
const fd = libc.open(path_z, .{ .ACCMODE = .RDONLY, .NONBLOCK = true });
if (fd < 0) return switch (libc.errno(fd)) {
.ACCES, .PERM => error.PermissionDenied,
@@ -1204,8 +1244,21 @@ fn readFileLimit(gpa: std.mem.Allocator, path: []const u8, limit: usize) ![]u8 {
};
defer _ = libc.close(fd);
+ // A device (/dev/zero, a tty) is no file to read whole: said so, not
+ // read to the stream limit and called too large.
+ if (ninep_io.statNoFollow(path_z)) |facts| {
+ const kind = facts.mode & 0o170000;
+ if (kind == 0o040000) return error.IsDirectory;
+ if (kind == 0o020000 or kind == 0o060000) return error.NotAFile;
+ }
const end = libc.lseek(fd, 0, libc.SEEK.END);
- if (end < 0 and libc.errno(end) == .SPIPE) return error.NotAFile;
+ // Not seekable: a pipe or a FIFO is no file; a regular file that is a
+ // stream (a 9ns mount's log or screen, opened nonseekable) is read to
+ // its end, as one with no length is.
+ if (end < 0 and libc.errno(end) == .SPIPE) {
+ const facts = ninep_io.statNoFollow(path_z) orelse return error.NotAFile;
+ if (facts.mode & 0o170000 != 0o100000) return error.NotAFile;
+ }
const size: usize = if (end < 0) 0 else @intCast(end);
if (end >= 0 and libc.lseek(fd, 0, libc.SEEK.SET) < 0) return error.ReadFailed;
if (size == 0) {
@@ -1246,6 +1299,36 @@ fn readFileLimit(gpa: std.mem.Allocator, path: []const u8, limit: usize) ![]u8 {
return buf;
}
+/// A 9P write of an Edit held while its commands run (Namespace.edit_hold).
+pub const EditHold = struct {
+ /// The listener's: the connection that asked, and its park.
+ asker: *anyopaque,
+ slot: u16,
+ seq: u64,
+ tag: u64,
+ node: u64,
+ handle: u32,
+ written: u32,
+ /// The Edit is done: applied, or failed with `said`.
+ done: bool = false,
+ errno: u16 = 0,
+ said: [256]u8 = undefined,
+ said_len: u16 = 0,
+
+ pub fn names(h: *const EditHold, req: tree.Req) bool {
+ return req.op == .write and req.tag == h.tag and req.node == h.node and req.handle == h.handle;
+ }
+
+ /// Its answer, the held record let go: the words copied out first.
+ pub fn answer(ns: *Namespace) tree.Reply {
+ const h = ns.edit_hold.?;
+ ns.edit_hold = null;
+ if (h.errno == 0) return .{ .tag = h.tag, .written = h.written };
+ @memcpy(ns.edit_said[0..h.said_len], h.said[0..h.said_len]);
+ return tree.failText(h.tag, h.errno, ns.edit_said[0..h.said_len]);
+ }
+};
+
pub const Namespace = struct {
socket_path: []const u8 = "",
tcp_address: ?std.Io.net.IpAddress = null,
@@ -1253,18 +1336,130 @@ pub const Namespace = struct {
mounts: std.ArrayList(Mount) = .empty,
node_name: [16]u8 = undefined,
os_paths: std.ArrayList(OsPath) = .empty,
- snapshots: [tree.screen.snapshot_slots]tree.screen.Snapshot = @splat(.{}),
+ /// What each open holds between its open and its release.
+ opens: [tree.open_slots]tree.Open = @splat(.{}),
out: std.ArrayList(u8) = .empty,
- panes: [MAX_PANES]tree.pane.State = @splat(.{}),
listeners: u16 = 0,
origin: u8 = 'K',
- /// The editor-wide event stream, recorded only while /log is held open.
- log: tree.events.Queue = .{},
- log_readers: u16 = 0,
- /// What the last ctl command created or touched, answered by reading /ctl.
+ /// A ctl write is running builtins: one that would open a prompt for
+ /// its argument refuses (`refused`), since nobody is at the prompt, and
+ /// the first error one reports (`failure`) fails the write, as acme's
+ /// ctl answers a command's error (editors/acme/xfid.c:700).
+ no_prompt: bool = false,
+ /// The root ctl is running a session builtin: its messages are the
+ /// session's, logged `msg -`, though shown on the active pane.
+ session_write: bool = false,
+ /// A ctl write's failure is being said: its err record logs it, so
+ /// no msg does (Messages.reportFailure).
+ unlogged: bool = false,
+ /// A 9P write of clicks (look, exec, tagexec, a column's exec) is running
+ /// one: a builtin's failure is the write's, as a ctl line's is (no_prompt,
+ /// which also refuses prompts, which a click may open).
+ capturing: bool = false,
+ /// A 9P request is being served (Pardes.serveFs): a prompt it opens is
+ /// a question for the log (`ask`), answered with `answer`.
+ serving: bool = false,
+ refused: bool = false,
+ failure: [256]u8 = undefined,
+ failure_len: u16 = 0,
+ /// What went wrong performing a write's effects after it was answered
+ /// by the core (a save the host could not do): the 9P write, which
+ /// waits for them, fails with it (src/9p_io.zig).
+ /// A header tag truncated by an open not yet released (ninep/cols.zig):
+ /// 0 the workspace's, a column's its index + 1; and whether the newline
+ /// that ended its last write is held back.
+ header_rewrite: ?u32 = null,
+ /// A column's or the workspace's tag truncated, not yet done (as a
+ /// pane tag's `tag_trunc_pending`): its key, the workspace's 0.
+ header_trunc_pending: ?u32 = null,
+ /// A look or exec a 9P write made found every pane slot taken; the
+ /// write fails with what was said, kept at the head of `ename`.
+ no_pane_slot: bool = false,
+ no_pane_slot_len: u16 = 0,
+ header_held: bool = false,
+ /// The newest failure said (reportFailure), fitted as an err is: its
+ /// path cut in the middle, never its reason, which the message row's
+ /// first 256 bytes lose. `said_at` is the `failures` count it was.
+ said: [256]u8 = undefined,
+ said_len: u16 = 0,
+ said_at: u32 = 0,
+ late_failure: [256]u8 = undefined,
+ late_failure_len: u16 = 0,
+ /// A 9P write asked a language server something: the answer count it
+ /// waits to change (`turn.lsp_answers`), so its failure is the write's.
+ lsp_answer_at: ?u64 = null,
+ /// The request being served started an Edit whose `<`, `|` or `>`
+ /// commands run off the loop (edit_cmd.zig): the listener holds it.
+ edit_started: bool = false,
+ /// That write, held: answered once `done` (9p_io answerHeld), or
+ /// asked again by a retry of its park (Pardes.serveFs); a flush or a
+ /// hang-up stops the Edit (9p_io watchEdit).
+ edit_hold: ?EditHold = null,
+ /// The words a held Edit write was refused with, kept for its answer.
+ edit_said: [256]u8 = undefined,
+ /// The pane a language answer filled (a Rename's preview): what the
+ /// waiting 9P write answers once it is in (9p_io).
+ lsp_result: ?u32 = null,
+ /// The most a Twrite of the request being served can carry (msize less
+ /// its header), 0 when unknown: a write shorter than it is the whole of
+ /// what its client wrote, one that fills it may be cut and go on.
+ write_room: u32 = 0,
+ /// A 9P write waits on what the editor performs for it (a Save's disk
+ /// write, a shell, a language server): a failure said meanwhile is that
+ /// write's err, so it posts no msg (Messages.reportFailure).
+ write_waits: bool = false,
+ /// The whole text of the newest counted log record, hashed: its record
+ /// may be cut, and a repeat is only the same whole text again.
+ log_full_hash: u64 = 0,
+ /// Writes one open made in a row into one place of a pane's body (an
+ /// append to `body`, an insert at `data`'s address), held and put in
+ /// as one edit when anything else comes (ninep/pane.zig flushBatch): a
+ /// 10 MB write in 8 KB pieces is one copy and one undo step, not 1280.
+ /// The text of /pager opens closed before a read put it in, each with
+ /// its +Pager's serial, for the editor's step to put in (ctl.fillPager):
+ /// a close through a mount may not wait for the editor to be quiet,
+ /// as 9ns answers nothing else on that mount while a clunk is out.
+ pages: std.ArrayList(struct { serial: u32, bytes: std.ArrayList(u8) }) = .empty,
+ /// The last line each closed open wrote with no newline after it, with
+ /// the node it was written to, for the editor's step to run
+ /// (tree.runClosedLines): a close is answered at once, for the same
+ /// reason as `pages`.
+ closed_lines: std.ArrayList(struct { node: u64, bytes: std.ArrayList(u8) }) = .empty,
+ batch: struct {
+ serial: u32 = 0,
+ node: u64 = 0,
+ handle: u32 = 0,
+ at: usize = 0,
+ bytes: std.ArrayList(u8) = .empty,
+ /// The editor's clock at the last write held: its step puts them in
+ /// once the writes have paused (`batch_pause_ns`).
+ last_ns: u64 = 0,
+ } = .{},
+ /// The serial of the pane the root's exec or look last ran a line at
+ /// (the keyboard's), 0 before one: its err record names that pane.
+ ran_at: u32 = 0,
+ /// The output pane a search just filled again rather than made
+ /// (Output.fillResults): what an exec reads back.
+ refilled: ?u32 = null,
+ /// Every failure said (Messages.reportFailure), counted: a builtin
+ /// that said one while it ran failed.
+ failures: u32 = 0,
+ /// A refusal that quotes the message it refuses, as Plan 9's cmderror
+ /// does (kernel/misc/parse.c:82); answered at once (src/9p_io.zig).
+ ename: [320]u8 = undefined,
+ /// Something a held read may be waiting on changed since they were last
+ /// answered: a record queued, a run answered, a pane gone.
+ news: bool = false,
+ /// A Restore is about to hang every client up: a follower's held read
+ /// of /log takes every queued record that fits, not one (events.readLog).
+ hanging_up: bool = false,
+ /// The editor-wide event ring: panes made, renamed, saved and closed, and
+ /// what the editor said. Recorded whether or not anyone reads /log.
+ log: tree.events.Queue = .{ .cap = limits.log_bytes },
+ /// What the last look or exec created or touched, answered by reading
+ /// either of those files.
results: [MAX_PANES]u32 = undefined,
results_len: u8 = 0,
- results_valid: bool = false,
/// Process start, the mtime of everything that has no edit time of its own.
started: u32 = 0,
@@ -1276,8 +1471,11 @@ pub const Namespace = struct {
st.mounts.deinit(gpa);
for (st.os_paths.items) |entry| gpa.free(entry.path);
st.os_paths.deinit(gpa);
- for (st.snapshots) |snapshot| if (snapshot.bytes) |bytes| gpa.free(bytes);
- for (&st.panes) |*pf| pf.deinit(gpa);
+ for (&st.opens) |*o| o.deinit(gpa);
+ for (st.pages.items) |*page| page.bytes.deinit(gpa);
+ st.pages.deinit(gpa);
+ for (st.closed_lines.items) |*line| line.bytes.deinit(gpa);
+ st.closed_lines.deinit(gpa);
st.log.deinit(gpa);
st.out.deinit(gpa);
}
@@ -1300,16 +1498,6 @@ pub const Namespace = struct {
st.out.ensureTotalCapacity(gpa, tree.out_reserve) catch {};
return &st.out;
}
-
- pub fn forget(st: *Namespace, gpa: std.mem.Allocator, id: usize) void {
- if (id >= MAX_PANES) return;
- st.listeners -= @min(st.listeners, st.panes[id].readers);
- st.panes[id].deinit(gpa);
- }
-
- pub fn scripted(st: *const Namespace, id: usize) bool {
- return id < MAX_PANES and st.panes[id].readers != 0;
- }
};
pub fn unmount(p: *Pardes, name: []const u8) !void {
@@ -1346,3 +1534,15 @@ pub fn unmount(p: *Pardes, name: []const u8) !void {
test {
_ = tree;
}
+
+test "the tree's README lists src/ only when the build serves it" {
+ try std.testing.expectEqual(limits.embedded_sources, std.mem.indexOf(u8, help, "src/") != null);
+}
+
+test "a write open(2) refuses says its errno in words" {
+ if (comptime @import("builtin").os.tag != .linux or !pardes.hosted) return error.SkipZigTest;
+ // /proc takes no new file: ENOENT, which used to read "open failed".
+ try std.testing.expectError(error.NoSuchFileOrDirectory, writeFile("/proc/pardes-no-such-file", "x"));
+ var words: [128]u8 = undefined;
+ try std.testing.expectEqualStrings("no such file or directory", pardes.Messages.errorWords(error.NoSuchFileOrDirectory, &words));
+}