summaryrefslogtreecommitdiff
path: root/src/host_io.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-23 17:10:58 -0300
committerGabriel Schneider <[email protected]>2026-10-23 17:10:58 -0300
commit0073d05329335dbb0eb85f5c3044e42805d144e5 (patch)
tree744edfc317719b2018b1c3a8657c223aec058d47 /src/host_io.zig
parenta8b457a306a4442975210bcac3f04b56513c61c3 (diff)
downloadpardes-0073d05329335dbb0eb85f5c3044e42805d144e5.tar.gz
pardes-0073d05329335dbb0eb85f5c3044e42805d144e5.zip
Callstack lists every caller and pages a tree too big for one query; memory bounds and resident-size fixes
Callstack walks while the server answers, counts on the message row past a second, puts test callers last at each level, and ends a tree past one query's memory (memory.limits.arena.lsp_query, a 256 MiB region taken and given back per query) in a row whose Callstack shows the next page. Grep reads whole files. New hard limits: undo text per file, image decode pixels, the LSP snapshot of other open files, one paste. Safe builds no longer fill worst-case buffers with 0xAA (memory.unfilled), big regions are kept off transparent huge pages, and malloc_trim runs after big results. Also: Look's git show pages into a +Diff, and dropped marks in File. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'src/host_io.zig')
-rw-r--r--src/host_io.zig103
1 files changed, 82 insertions, 21 deletions
diff --git a/src/host_io.zig b/src/host_io.zig
index c593551b..2c736e20 100644
--- a/src/host_io.zig
+++ b/src/host_io.zig
@@ -203,11 +203,14 @@ pub const Lsp = struct {
}
others.deinit(gpa);
}
+ var copied: usize = 0;
for (core.panes, 0..) |slot, i| {
const other = slot orelse continue;
if (i == req.pane) continue;
const f = other.file orelse continue;
if (f.output != null) continue;
+ if (copied + f.content.len > pardes.memory.limits.lsp_snapshot_bytes) continue;
+ copied += f.content.len;
const local = filesystem.localPath(f.path) orelse continue;
const other_path = try gpa.dupe(u8, local);
const other_source = gpa.dupeSentinel(u8, f.content, 0) catch |err| {
@@ -224,13 +227,19 @@ pub const Lsp = struct {
// Null is failure; the receiver frees non-null rows with the job's allocator.
pub const Deliver = *const fn (ctx: ?*anyopaque, id: u32, rows: ?[]u8) void;
- pub fn work(gpa: std.mem.Allocator, job: *Job, ctx: ?*anyopaque, deliver: Deliver) void {
+ pub fn work(io: std.Io, gpa: std.mem.Allocator, job: *Job, ctx: ?*anyopaque, deliver: Deliver) void {
defer job.free(gpa);
- var arena: std.heap.ArenaAllocator = .init(gpa);
- defer arena.deinit();
+ // The query's memory is the fixed region memory.zig reserved at
+ // startup: a hard bound, reused by each query in turn.
+ const region = pardes.memory.takeLspQuery() orelse {
+ deliver(ctx, job.id, null);
+ return;
+ };
+ var arena: std.heap.FixedBufferAllocator = .init(region);
+ defer pardes.memory.giveLspQuery(arena.end_index);
var out: std.Io.Writer.Allocating = .init(gpa);
defer out.deinit();
- pardes.lsp.query(gpa, arena.allocator(), .{
+ pardes.lsp.query(io, gpa, arena.allocator(), .{
.kind = job.kind,
.path = job.path,
.source = job.source,
@@ -240,6 +249,7 @@ pub const Lsp = struct {
.others = job.others,
.callstack_depth = job.callstack_depth,
.callstack_corners = job.callstack_corners,
+ .budget = &arena,
}, &out.writer) catch {
deliver(ctx, job.id, null);
return;
@@ -367,7 +377,7 @@ pub const Lsp = struct {
.offset = 0,
.arg = "",
});
- work(gpa, job, null, Sink.take);
+ work(std.testing.io, gpa, job, null, Sink.take);
// `status` is the one kind that answers with no file and no cursor, which
// is what makes it assertable here without a language server on the box.
@@ -416,7 +426,7 @@ pub const Lsp = struct {
.arg = "renamed",
});
if (fail) failing.fail_index = failing.alloc_index;
- work(failing.allocator(), job, &sink, Sink.take);
+ work(std.testing.io, failing.allocator(), job, &sink, Sink.take);
try std.testing.expectEqual(fail, sink.failed);
try std.testing.expect(core.lsp_wait == null);
if (fail) {
@@ -482,7 +492,7 @@ pub const Lsp = struct {
defer core.deinit();
const job = try snapshot(gpa, core, .{ .id = 37, .kind = .status, .pane = @intCast(core.active), .offset = 0, .arg = "" });
var sink: Sink = .{};
- work(gpa, job, &sink, Sink.take);
+ work(std.testing.io, gpa, job, &sink, Sink.take);
if (sink.rows) |rows| gpa.free(rows);
try std.testing.expect(allocator.failed);
try std.testing.expectEqual(@as(usize, 1), sink.calls);
@@ -1179,7 +1189,7 @@ pub const Shell = struct {
if (builtin.os.tag == .windows) return;
var saved_buf: [std.fs.max_path_bytes:0]u8 = @splat(0);
const saved: ?[:0]const u8 = if (std.c.getenv("XDG_RUNTIME_DIR")) |v| std.fmt.bufPrintSentinel(&saved_buf, "{s}", .{std.mem.span(v)}, 0) catch null else null;
- defer _ = if (saved) |v| setenv("XDG_RUNTIME_DIR", v.ptr, 1) else unsetenv("XDG_RUNTIME_DIR");
+ defer _ = if (saved) |v| setenv("XDG_RUNTIME_DIR", v.ptr, 1) else testUnsetenv("XDG_RUNTIME_DIR");
var tmp = std.testing.tmpDir(.{});
defer tmp.cleanup();
@@ -1213,7 +1223,7 @@ pub const Shell = struct {
try std.testing.expectEqualStrings(bash_rc, readSmall(c.bashPath().?, &buf) orelse return error.ReadFailed);
// No runtime dir: private files, one per owner, gone at teardown.
- _ = unsetenv("XDG_RUNTIME_DIR");
+ _ = testUnsetenv("XDG_RUNTIME_DIR");
var d = PromptFiles.init();
var e = PromptFiles.init();
defer e.deinit();
@@ -1294,6 +1304,44 @@ pub const ChildEnv = struct {
"TERM_PROGRAM=" ++ pardes.config.child_term_program,
};
+ /// What this editor tells its children of itself (exportPaneEnv, `$winid`),
+ /// kept here rather than set into this process's environment: std's Io read
+ /// that block at startup, and setenv/unsetenv rewrite it in place under it
+ /// (a spawn then scans a null inside it). `build` puts each exported one in
+ /// place of an inherited variable of its name; a cleared one hides it; one
+ /// never exported is inherited as it is.
+ pub const exported_names = [_][]const u8{ "PARDES_PID", "PARDES_9P", "PARDES_PANE", "PARDES_MOUNT", "winid" };
+ var exported_state: [exported_names.len]enum { inherited, cleared, set } = @splat(.inherited);
+ var exported_line: [exported_names.len][pardes.memory.limits.host_path_cap + 64:0]u8 = undefined;
+
+ /// Set (or, null, clear) what children are told for `var_name`.
+ pub fn exportVar(var_name: []const u8, value: ?[]const u8) void {
+ const i = exportedIndex(var_name).?;
+ const v = value orelse {
+ exported_state[i] = .cleared;
+ return;
+ };
+ const line = std.fmt.bufPrintSentinel(&exported_line[i], "{s}={s}", .{ var_name, v }, 0) catch {
+ exported_state[i] = .cleared;
+ return;
+ };
+ exported_state[i] = .set;
+ _ = line;
+ }
+
+ /// What children are told for `var_name`, as `exportVar` left it; null
+ /// when cleared or never exported.
+ pub fn exported(var_name: []const u8) ?[]const u8 {
+ const i = exportedIndex(var_name) orelse return null;
+ if (exported_state[i] != .set) return null;
+ return std.mem.span(@as([*:0]const u8, &exported_line[i]))[var_name.len + 1 ..];
+ }
+
+ fn exportedIndex(var_name: []const u8) ?usize {
+ for (exported_names, 0..) |n, i| if (std.mem.eql(u8, n, var_name)) return i;
+ return null;
+ }
+
/// Wide enough for any real environment; `build` answers null rather than
/// truncate, because a child missing half its variables is a worse bug
/// than one missing TERM, and the caller then execs with `environ` intact.
@@ -1318,7 +1366,8 @@ pub const ChildEnv = struct {
if (std.mem.eql(u8, inherited, name(mine))) break true;
} else false;
if (shadowed) continue;
- if (n + own.len + 1 > slots.len) return null;
+ if (exportedIndex(inherited)) |e| if (exported_state[e] != .inherited) continue;
+ if (n + own.len + exported_names.len + 1 > slots.len) return null;
slots[n] = entry;
n += 1;
}
@@ -1336,10 +1385,14 @@ pub const ChildEnv = struct {
if (std.mem.eql(u8, name(entry.?), name(default))) break true;
} else false;
if (set) continue;
- if (n + own.len + 4 > slots.len) return null;
+ if (n + own.len + exported_names.len + 4 > slots.len) return null;
slots[n] = default;
n += 1;
}
+ for (&exported_line, exported_state) |*line, state| if (state == .set) {
+ slots[n] = line;
+ n += 1;
+ };
for (own) |mine| {
slots[n] = mine;
n += 1;
@@ -1411,14 +1464,14 @@ test "the child environment replaces the launcher's terminal identity exactly on
defer if (restore) |t| {
_ = Shell.setenv("TERM", t.ptr, 1);
} else {
- _ = unsetenv("TERM");
+ _ = testUnsetenv("TERM");
};
// A launcher TERM must be shadowed rather than duplicated, and the rest of
// the environment must arrive untouched.
try std.testing.expectEqual(@as(c_int, 0), Shell.setenv("TERM", "dumb", 1));
try std.testing.expectEqual(@as(c_int, 0), Shell.setenv("PARDES_CHILD_ENV_PROBE", "1", 1));
- defer _ = unsetenv("PARDES_CHILD_ENV_PROBE");
+ defer _ = testUnsetenv("PARDES_CHILD_ENV_PROBE");
var slots: ChildEnv.Slots = undefined;
// Where the user named no pager: a terminal's shell pages into a
@@ -1481,6 +1534,16 @@ test "the child environment replaces the launcher's terminal identity exactly on
extern "c" fn unsetenv(name: [*:0]const u8) c_int;
+/// For tests: unset `name` without compacting the environment block std
+/// captured at startup (std.testing.environ and Io's spawns read it later). A
+/// new variable first moves glibc's `environ` to a heap copy, which unsetenv
+/// then compacts instead. Runtime code never changes this process's
+/// environment (ChildEnv.exportVar).
+pub fn testUnsetenv(name: [*:0]const u8) c_int {
+ _ = Shell.setenv("PARDES_TEST_ENVIRON_COPIED", "1", 1);
+ return unsetenv(name);
+}
+
/// The environment a pane's command is given (exportPaneEnv, `$winid`,
/// ChildEnv), as `NAME=value` lines in `arena`, for a command that is not a
/// pane's: an Edit's filters, run from pane `serial`.
@@ -1497,10 +1560,7 @@ pub fn commandEnv(arena: std.mem.Allocator, serial: u32, adopts: bool) ![]const
fn exportWinid(serial: u32) void {
var buf: [16]u8 = undefined;
- if (serial != 0) if (std.fmt.bufPrintSentinel(&buf, "{d}", .{serial}, 0)) |text| {
- if (Shell.setenv("winid", text, 1) == 0) return;
- } else |_| {};
- _ = unsetenv("winid");
+ ChildEnv.exportVar("winid", if (serial == 0) null else std.fmt.bufPrint(&buf, "{d}", .{serial}) catch null);
}
/// The longest line a command pane runs (exec.zig refuses a longer one).
@@ -1587,17 +1647,18 @@ pub fn forkShell(
if (helper) |path| {
const c = core.?;
const pn = c.panes[pane].?;
- const socket = libc.getenv("PARDES_9P") orelse return error.SessionSocketRequired;
+ const socket = ChildEnv.exported("PARDES_9P") orelse return error.SessionSocketRequired;
var command: std.Io.Writer.Allocating = .init(c.gpa);
defer command.deinit();
- try @import("linux/v9fs.zig").writeLaunchCommand(&command.writer, path, std.mem.span(socket), &spawn.argv);
+ try @import("linux/v9fs.zig").writeLaunchCommand(&command.writer, path, socket, &spawn.argv);
if (!try pardes.panes.terminal.queuePendingCommand(pn, command.written())) return error.ShellAlreadyStarted;
}
// Built here and not after the fork: between fork and exec the child may
// not call setenv, whose malloc can deadlock against a pty reader thread
// that held the heap when the fork took its snapshot.
var env_slots: ChildEnv.Slots = undefined;
- const paging: ChildEnv.Paging = if (one_line != null)
+ const pages = if (core) |c| if (c.panes[pane]) |pn| pn.command_pages else false else false;
+ const paging: ChildEnv.Paging = if (one_line != null and !pages)
.command
else if (core) |c| (if (c.settings.pager == .off) .terminal_off else .terminal) else .terminal;
const envp = ChildEnv.build(&env_slots, paging);
@@ -1695,7 +1756,7 @@ test "a forked shell is told which terminal it is talking to" {
defer if (restore) |t| {
_ = Shell.setenv("TERM", t.ptr, 1);
} else {
- _ = unsetenv("TERM");
+ _ = testUnsetenv("TERM");
};
_ = Shell.setenv("TERM", "dumb", 1);