summaryrefslogtreecommitdiff
path: root/src/host_io.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/host_io.zig')
-rw-r--r--src/host_io.zig123
1 files changed, 106 insertions, 17 deletions
diff --git a/src/host_io.zig b/src/host_io.zig
index 7314affc..c593551b 100644
--- a/src/host_io.zig
+++ b/src/host_io.zig
@@ -136,6 +136,8 @@ pub const Lsp = struct {
/// One language query, owned by the worker that runs it.
pub const Job = struct {
+ callstack_depth: u8 = pardes.lsp.callstack_default_depth,
+ callstack_corners: pardes.lsp.CallstackCorners = .rounded,
id: u32,
kind: pardes.lsp.Kind,
offset: u32,
@@ -170,7 +172,7 @@ pub const Lsp = struct {
const declared_path = if (file) |f| f.path else "";
const path = try gpa.dupe(u8, filesystem.localPath(declared_path) orelse declared_path);
errdefer gpa.free(path);
- const source = try gpa.dupeZ(u8, if (file) |f| f.content else "");
+ const source = try gpa.dupeSentinel(u8, if (file) |f| f.content else "", 0);
errdefer gpa.free(source);
const arg = try gpa.dupe(u8, req.arg);
errdefer gpa.free(arg);
@@ -178,6 +180,8 @@ pub const Lsp = struct {
const root = try gpa.dupe(u8, filesystem.localPath(declared_root) orelse declared_root);
errdefer gpa.free(root);
job.* = .{
+ .callstack_depth = core.settings.callstack_depth,
+ .callstack_corners = core.settings.callstack_corners,
.id = req.id,
.kind = req.kind,
.offset = req.offset,
@@ -206,7 +210,7 @@ pub const Lsp = struct {
if (f.output != null) continue;
const local = filesystem.localPath(f.path) orelse continue;
const other_path = try gpa.dupe(u8, local);
- const other_source = gpa.dupeZ(u8, f.content) catch |err| {
+ const other_source = gpa.dupeSentinel(u8, f.content, 0) catch |err| {
gpa.free(other_path);
return err;
};
@@ -234,6 +238,8 @@ pub const Lsp = struct {
.arg = job.arg,
.root = job.root,
.others = job.others,
+ .callstack_depth = job.callstack_depth,
+ .callstack_corners = job.callstack_corners,
}, &out.writer) catch {
deliver(ctx, job.id, null);
return;
@@ -250,6 +256,8 @@ pub const Lsp = struct {
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
+ core.settings.callstack_depth = 16;
+ core.settings.callstack_corners = .square;
var needle: [6]u8 = "needle".*;
const job = try snapshot(gpa, core, .{
.id = 7,
@@ -260,6 +268,10 @@ pub const Lsp = struct {
});
defer job.free(gpa);
+ core.settings.callstack_depth = 2;
+ core.settings.callstack_corners = .rounded;
+ try std.testing.expectEqual(pardes.lsp.CallstackCorners.square, job.callstack_corners);
+ try std.testing.expectEqual(@as(u8, 16), job.callstack_depth);
try std.testing.expectEqual(@as(u32, 7), job.id);
try std.testing.expectEqual(pardes.lsp.Kind.status, job.kind);
try std.testing.expectEqualStrings("needle", job.arg);
@@ -560,7 +572,7 @@ pub const Shell = struct {
const name = std.mem.sliceTo(@as([*:0]const u8, @ptrCast(&ent.name)), 0);
const pid = rcPid(name) orelse continue;
if (pid == std.c.getpid()) continue;
- if (std.posix.errno(std.c.kill(pid, @enumFromInt(0))) != .SRCH) continue;
+ if (std.posix.errno(std.c.kill(pid, @fromBackingInt(@intCast(0)))) != .SRCH) continue;
if (name.len >= 64 or n == dead.len) continue;
@memcpy(dead[n][0..name.len], name);
dead_len[n] = name.len;
@@ -773,7 +785,7 @@ pub const Shell = struct {
var dir_buf: [4096]u8 = undefined;
const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
var path: [4200:0]u8 = undefined;
- const p = try std.fmt.bufPrintZ(&path, "{s}/mysh", .{dir});
+ const p = try std.fmt.bufPrintSentinel(&path, "{s}/mysh", .{dir}, 0);
try std.testing.expectEqual(Family.bash, familyOf(p.ptr));
try std.testing.expectEqual(Family.none, familyOf("/bin/sh"));
}
@@ -1224,8 +1236,8 @@ pub fn resetChildSignals() void {
const default: posix.Sigaction = .{ .handler = .{ .handler = posix.SIG.DFL }, .mask = posix.sigemptyset(), .flags = 0 };
var sig: u8 = 1;
while (sig < 65) : (sig += 1) {
- if (sig == @intFromEnum(posix.SIG.KILL) or sig == @intFromEnum(posix.SIG.STOP)) continue;
- _ = std.c.sigaction(@enumFromInt(sig), &default, null);
+ if (sig == @backingInt(posix.SIG.KILL) or sig == @backingInt(posix.SIG.STOP)) continue;
+ _ = std.c.sigaction(@fromBackingInt(@intCast(sig)), &default, null);
}
const none = posix.sigemptyset();
posix.sigprocmask(posix.SIG.SETMASK, &none, null);
@@ -1608,13 +1620,13 @@ pub fn forkShell(
if (pid == 0) {
resetChildSignals();
if (cwd_z) |path| if (chdir(path.ptr) != 0) {
- const why = [_]u8{ 'c', @truncate(@intFromEnum(libc.errno(@as(c_int, -1)))) };
+ const why = [_]u8{ 'c', @truncate(@backingInt(libc.errno(@as(c_int, -1)))) };
_ = libc.write(told[1], &why, why.len);
_exit(126);
};
if (envp) |env| _ = execve(spawn.path, &spawn.argv, env);
_ = execv(spawn.path, &spawn.argv);
- const why = [_]u8{ 'x', @truncate(@intFromEnum(libc.errno(@as(c_int, -1)))) };
+ const why = [_]u8{ 'x', @truncate(@backingInt(libc.errno(@as(c_int, -1)))) };
_ = libc.write(told[1], &why, why.len);
_exit(127);
}
@@ -1631,7 +1643,7 @@ pub fn forkShell(
if (failed) |why| {
_ = libc.close(master);
_ = libc.waitpid(pid, null, 0);
- const e: libc.E = @enumFromInt(why[1]);
+ const e: libc.E = @fromBackingInt(@intCast(why[1]));
if (why[0] == 'c') return if (e == .NOENT or e == .NOTDIR) error.FileNotFound else error.AccessDenied;
return switch (e) {
// Itself, or its script's interpreter: told apart by whether it
@@ -1650,7 +1662,7 @@ pub fn forkShell(
test "shell spawn rejects invalid directories before creating a child" {
const rcs: Shell.PromptFiles = .{};
try std.testing.expectError(error.InvalidPath, forkShell(null, 0, &rcs, "/bin/sh", "/tmp\x00/ignored", 24, 80, null));
- const too_long = [_]u8{'x'} ** 4096;
+ const too_long = @as([4096]u8, @splat('x'));
try std.testing.expectError(error.NameTooLong, forkShell(null, 0, &rcs, "/bin/sh", &too_long, 24, 80, null));
var tmp = std.testing.tmpDir(.{});
@@ -1663,7 +1675,7 @@ test "shell spawn rejects invalid directories before creating a child" {
try std.testing.expectError(error.NotDir, forkShell(null, 0, &rcs, "/bin/sh", file, 24, 80, null));
const explicit_file = try std.fmt.bufPrint(&path_buf, "/n/os{s}/file", .{directory});
try std.testing.expectError(error.NotDir, forkShell(null, 0, &rcs, "/bin/sh", explicit_file, 24, 80, null));
- const missing = try std.fmt.bufPrint(&path_buf, "{s}/missing/" ++ ("child/" ** 50), .{directory});
+ const missing = try std.fmt.bufPrint(&path_buf, "{s}/missing/" ++ (std.mem.asBytes(&@as([50][6]u8, @splat("child/".*)))), .{directory});
try std.testing.expect(missing.len > 256);
try std.testing.expectError(error.FileNotFound, forkShell(null, 0, &rcs, "/bin/sh", missing, 24, 80, null));
}
@@ -1708,7 +1720,7 @@ test "shell spawn uses an explicit OS directory longer than 256 bytes" {
if (!haveFile("/bin/sh")) return error.SkipZigTest;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
- const sub_path = "nested-directory-with-more-than-forty-characters/" ** 7;
+ const sub_path = std.mem.asBytes(&@as([7][49]u8, @splat("nested-directory-with-more-than-forty-characters/".*)));
try tmp.dir.createDirPath(std.testing.io, sub_path);
var directory_buf: [4096]u8 = undefined;
const directory = directory_buf[0..try tmp.dir.realPathFile(std.testing.io, sub_path, &directory_buf)];
@@ -1783,13 +1795,90 @@ pub fn shellCwd(pid: libc.pid_t, buf: []u8) ?[]const u8 {
}
}
+/// Where a terminal is. The process forked for it, while it still runs the
+/// shell pardes started (`shell_exe`), as ever: a job it runs, in another
+/// directory (`(cd sub && make)`, a nested pardes), never names the pane.
+/// One that exec'd into something else is a wrapper whose own directory
+/// never moves (fish's `exec 9ns --mntgen -- fish`): the shell is the
+/// foreground group when that is the same shell, and while a job holds the
+/// foreground there is no answer, the last one standing.
+pub fn ttyCwd(shell_pid: libc.pid_t, master_fd: c_int, shell_exe: []const u8, buf: []u8) ?[]const u8 {
+ var exe_buf: [std.fs.max_path_bytes]u8 = undefined;
+ var shell_buf: [std.fs.max_path_bytes]u8 = undefined;
+ const shell = realShell(shell_exe, &shell_buf) orelse return shellCwd(shell_pid, buf);
+ const exe = procExe(shell_pid, &exe_buf) orelse return shellCwd(shell_pid, buf);
+ if (std.mem.eql(u8, exe, shell)) return shellCwd(shell_pid, buf);
+ const fg = tcgetpgrp(master_fd);
+ if (fg <= 0 or fg == shell_pid) return null;
+ const fg_exe = procExe(fg, &exe_buf) orelse return null;
+ return if (std.mem.eql(u8, fg_exe, shell)) shellCwd(fg, buf) else null;
+}
+
+/// `shell_exe` as /proc/<pid>/exe would read it: its links followed.
+fn realShell(shell_exe: []const u8, buf: *[std.fs.max_path_bytes]u8) ?[]const u8 {
+ var z: [std.fs.max_path_bytes:0]u8 = undefined;
+ const path = std.fmt.bufPrintSentinel(&z, "{s}", .{shell_exe}, 0) catch return null;
+ const r = libc.realpath(path, buf) orelse return null;
+ return std.mem.span(@as([*:0]const u8, @ptrCast(r)));
+}
+
+test "a terminal is where its shell is: under a wrapper the foreground shell, never a job's directory" {
+ if (comptime builtin.os.tag != .linux) return error.SkipZigTest;
+ if (!haveFile("/bin/sh") or !haveFile("/usr/bin/timeout")) return error.SkipZigTest;
+ const io = std.testing.io;
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.createDirPath(io, "start/a/b");
+ var path_buf: [4096]u8 = undefined;
+ const start = path_buf[0..try tmp.dir.realPathFile(io, "start", &path_buf)];
+ var inner_buf: [4096]u8 = undefined;
+ const inner = inner_buf[0..try tmp.dir.realPathFile(io, "start/a/b", &inner_buf)];
+ const rcs: Shell.PromptFiles = .{};
+ var result: [4096]u8 = undefined;
+ // A wrapper exec'd over the shell (timeout standing in for 9ns) runs
+ // another, two directories down, in the foreground.
+ {
+ const child = try forkShell(null, 0, &rcs, "/bin/sh", start, 24, 80, null);
+ defer {
+ _ = libc.kill(child.pid, libc.SIG.KILL);
+ _ = libc.waitpid(child.pid, null, 0);
+ _ = libc.close(child.file.handle);
+ }
+ var sh: TestShell = .{ .master = child.file.handle, .pid = child.pid };
+ try std.testing.expect(writeFd(child.file.handle, "exec timeout --foreground 30 /bin/sh -c 'cd a/b && printf \"\\160ardes-in-\\n\" && exec /bin/sh -i'\n"));
+ try std.testing.expect(sh.waitText("pardes-in-", 5_000));
+ // printf runs before the inner shell takes the foreground.
+ var tries: usize = 0;
+ while (ttyCwd(child.pid, child.file.handle, "/bin/sh", &result) == null and tries < 50) : (tries += 1) {
+ const ts: libc.timespec = .{ .sec = 0, .nsec = 20 * std.time.ns_per_ms };
+ _ = libc.nanosleep(&ts, null);
+ }
+ try std.testing.expectEqualStrings(start, shellCwd(child.pid, &result) orelse return error.MissingCwd);
+ try std.testing.expectEqualStrings(inner, ttyCwd(child.pid, child.file.handle, "/bin/sh", &result) orelse return error.MissingCwd);
+ }
+ // A job of the shell's own, gone into a/b, leaves the pane where the
+ // shell is.
+ {
+ const child = try forkShell(null, 0, &rcs, "/bin/sh", start, 24, 80, null);
+ defer {
+ _ = libc.kill(child.pid, libc.SIG.KILL);
+ _ = libc.waitpid(child.pid, null, 0);
+ _ = libc.close(child.file.handle);
+ }
+ var sh: TestShell = .{ .master = child.file.handle, .pid = child.pid };
+ try std.testing.expect(writeFd(child.file.handle, "set -m; (cd a/b && printf '\\160ardes-job\\n' && exec sleep 30)\n"));
+ try std.testing.expect(sh.waitText("pardes-job", 5_000));
+ try std.testing.expectEqualStrings(start, ttyCwd(child.pid, child.file.handle, "/bin/sh", &result) orelse return error.MissingCwd);
+ }
+}
+
test "shell cwd rejects truncation and preserves an owned child path longer than 1024 bytes" {
if (comptime builtin.os.tag != .linux) return error.SkipZigTest;
if (!haveFile("/bin/sh")) return error.SkipZigTest;
const io = std.testing.io;
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
- const nested = "nested-directory-with-more-than-forty-characters/" ** 24;
+ const nested = std.mem.asBytes(&@as([24][49]u8, @splat("nested-directory-with-more-than-forty-characters/".*)));
try tmp.dir.createDirPath(io, nested);
var path_buf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
const directory = path_buf[0..try tmp.dir.realPathFile(io, nested, &path_buf)];
@@ -2155,7 +2244,7 @@ pub fn reapExited(pid: libc.pid_t) ?struct { status: ?u8 } {
if (got != pid) return .{ .status = null };
const s: u32 = @bitCast(status);
if (libc.W.IFEXITED(s)) return .{ .status = @truncate(libc.W.EXITSTATUS(s)) };
- if (libc.W.IFSIGNALED(s)) return .{ .status = @truncate(128 + @as(u32, @intFromEnum(libc.W.TERMSIG(s)))) };
+ if (libc.W.IFSIGNALED(s)) return .{ .status = @truncate(128 + @as(u32, @backingInt(libc.W.TERMSIG(s)))) };
return .{ .status = null };
}
@@ -2182,7 +2271,7 @@ pub fn exitStatus(pid: libc.pid_t, wait_ms: u32) ?u8 {
if (got == pid) {
const s: u32 = @bitCast(status);
if (libc.W.IFEXITED(s)) return @truncate(libc.W.EXITSTATUS(s));
- if (libc.W.IFSIGNALED(s)) return @truncate(128 + @as(u32, @intFromEnum(libc.W.TERMSIG(s))));
+ if (libc.W.IFSIGNALED(s)) return @truncate(128 + @as(u32, @backingInt(libc.W.TERMSIG(s))));
return null;
}
if (got < 0 or waited >= wait_ms) return null;
@@ -2710,8 +2799,8 @@ test "a retired shell that ignores the hangup is killed and reaped, not left a z
retireShell(pid);
// A zombie still answers kill(pid, 0); only a reaped pid is gone.
var waited: i64 = 0;
- while (libc.kill(pid, @enumFromInt(0)) == 0 and waited < 2000) : (waited += 10) sleepMs(10);
- try std.testing.expect(libc.kill(pid, @enumFromInt(0)) != 0);
+ while (libc.kill(pid, @fromBackingInt(@intCast(0))) == 0 and waited < 2000) : (waited += 10) sleepMs(10);
+ try std.testing.expect(libc.kill(pid, @fromBackingInt(@intCast(0))) != 0);
try std.testing.expect(waited >= 90); // it did ignore the hangup
}