summaryrefslogtreecommitdiff
path: root/src/detached
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/detached
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/detached')
-rw-r--r--src/detached/server.zig29
1 files changed, 18 insertions, 11 deletions
diff --git a/src/detached/server.zig b/src/detached/server.zig
index d6a1f553..6c8d4352 100644
--- a/src/detached/server.zig
+++ b/src/detached/server.zig
@@ -107,17 +107,19 @@ const Mailbox = struct {
status: ?[]u8 = null,
};
- mutex: std.atomic.Mutex = .unlocked,
+ /// Taken by the workers and the loop; `io` is the session's (initAsync).
+ mutex: std.Io.Mutex = .init,
+ io: std.Io = undefined,
batch: Batch = .{},
wake: [2]c_int = .{ -1, -1 },
fn post(box: *Mailbox, completion: Completion) void {
- while (!box.mutex.tryLock()) std.atomic.spinLoopHint();
+ box.mutex.lockUncancelable(box.io);
// Tasks retain their slot until the owner consumes their one completion.
std.debug.assert(box.batch.len < capacity);
box.batch.items[box.batch.len] = completion;
box.batch.len += 1;
- box.mutex.unlock();
+ box.mutex.unlock(box.io);
box.signal();
}
@@ -130,8 +132,8 @@ const Mailbox = struct {
fn take(box: *Mailbox) Batch {
var bytes: [128]u8 = undefined;
while (libc.recv(box.wake[0], &bytes, bytes.len, 0) > 0) {}
- while (!box.mutex.tryLock()) std.atomic.spinLoopHint();
- defer box.mutex.unlock();
+ box.mutex.lockUncancelable(box.io);
+ defer box.mutex.unlock(box.io);
const batch = box.batch;
box.batch.len = 0;
box.batch.status = null;
@@ -184,6 +186,7 @@ pub const Session = struct {
accept_paused_ms: i64 = 0,
pub fn initAsync(s: *Session) !void {
+ s.mailbox.io = s.io;
var pair: [2]c_int = undefined;
if (libc.socketpair(libc.AF.UNIX, libc.SOCK.STREAM, 0, &pair) != 0) return error.SocketFailed;
errdefer for (pair) |fd| {
@@ -410,7 +413,7 @@ pub const Session = struct {
s.core.update(.{ .lsp_resp = .{ .id = request.id, .rows = null } });
return s.core.reportError(request.pane, "lsp", err);
};
- const future = s.io.concurrent(lspWorker, .{ s.worker_gpa, job, &s.mailbox }) catch |err| {
+ const future = s.io.concurrent(lspWorker, .{ s.io, s.worker_gpa, job, &s.mailbox }) catch |err| {
job.free(s.worker_gpa);
s.core.update(.{ .lsp_resp = .{ .id = request.id, .rows = null } });
return s.core.reportError(request.pane, "lsp", err);
@@ -418,8 +421,8 @@ pub const Session = struct {
s.lsp_task = .{ .id = request.id, .future = future };
}
- fn lspWorker(gpa: std.mem.Allocator, job: *host_io.Lsp.Job, box: *Mailbox) anyerror!void {
- host_io.Lsp.work(gpa, job, box, deliverLspRows);
+ fn lspWorker(io: std.Io, gpa: std.mem.Allocator, job: *host_io.Lsp.Job, box: *Mailbox) anyerror!void {
+ host_io.Lsp.work(io, gpa, job, box, deliverLspRows);
}
fn deliverLspRows(ctx: ?*anyopaque, id: u32, rows: ?[]u8) void {
@@ -430,10 +433,10 @@ pub const Session = struct {
fn lspStatus(ctx: ?*anyopaque, text: []const u8) void {
const s = of(ctx);
const copy = s.worker_gpa.dupe(u8, text) catch return;
- while (!s.mailbox.mutex.tryLock()) std.atomic.spinLoopHint();
+ s.mailbox.mutex.lockUncancelable(s.io);
if (s.mailbox.batch.status) |old| s.worker_gpa.free(old);
s.mailbox.batch.status = copy;
- s.mailbox.mutex.unlock();
+ s.mailbox.mutex.unlock(s.io);
s.mailbox.signal();
}
@@ -529,7 +532,8 @@ pub const Session = struct {
if (pane >= s.ptys.len) return;
const pt = &s.ptys[pane];
if (pt.fd < 0) return;
- if (pt.out.items.len > pty_backlog) {
+ // The bound holds with this write in: queued and new together.
+ if (pt.out.items.len + bytes.len > pty_backlog) {
var mbuf: [256]u8 = undefined;
const text = std.fmt.bufPrint(
&mbuf,
@@ -1145,6 +1149,9 @@ pub const Session = struct {
s.queue(c, bytes);
}
+ /// A client's queued output is at most `out_backlog + wire.max_payload`:
+ /// past the backlog it is closed, and one frame lands on top of it first
+ /// (a frame bigger than the backlog must still go out whole).
fn queue(s: *Session, c: *Client, bytes: []const u8) void {
if (c.out.items.len > out_backlog) return s.close(c, .backlog);
s.account();