fix: prevent another race in call()

src/thespian.zig

@@ -691,38 +691,34 @@ const CallContext = struct {
     request: message,
     response: *?message,
     a: std.mem.Allocator,
-    mut: std.Thread.Mutex = std.Thread.Mutex{},
+    done: std.Thread.ResetEvent = .{},
-    cond: std.Thread.Condition = std.Thread.Condition{},
-    timeout: bool = false,
 
     const Self = @This();
     const ReceiverT = Receiver(*Self);
 
     pub fn call(a: std.mem.Allocator, to: pid_ref, timeout_ns: u64, request: message) error{ OutOfMemory, ThespianSpawnFailed, Timeout }!message {
         var response: ?message = null;
-        var self = try a.create(Self);
+        var self: Self = .{
-        self.* = .{
+            .receiver = undefined,
-            .receiver = ReceiverT.init(receive_, self),
             .to = to,
             .request = request,
             .response = &response,
             .a = a,
         };
-
+        self.receiver = ReceiverT.init(receive_, &self);
-        self.mut.lock();
+        const proc = try spawn_link(a, &self, start, @typeName(Self));
-        errdefer self.mut.unlock();
-
-        const proc = try spawn_link(a, self, start, @typeName(Self));
         defer proc.deinit();
-
+        errdefer {
-        self.cond.timedWait(&self.mut, timeout_ns) catch |e| switch (e) {
+            proc.send(.{"timeout"}) catch @panic("CallContext.send.timeout");
+            self.done.wait();
+            if (response) |resp| a.free(resp.buf);
+        }
+        self.done.timedWait(timeout_ns) catch |e| switch (e) {
             error.Timeout => {
-                self.timeout = true;
                 return e;
             },
             else => return e,
         };
-
         return response orelse .{};
     }
 
@@ -731,10 +727,7 @@ const CallContext = struct {
     }
 
     fn start(self: *Self) result {
-        errdefer {
+        errdefer self.done.set();
-            self.cond.signal();
-            self.deinit();
-        }
         _ = set_trap(true);
         try self.to.link();
         try self.to.send_raw(self.request);
@@ -742,12 +735,8 @@ const CallContext = struct {
     }
 
     fn receive_(self: *Self, _: pid_ref, m: message) result {
-        defer self.deinit();
+        defer self.done.set();
-        defer self.cond.signal();
+        self.response.* = m.clone(self.a) catch |e| return exit_error(e);
-        self.mut.lock();
-        defer self.mut.unlock();
-        if (!self.timeout)
-            self.response.* = m.clone(self.a) catch |e| return exit_error(e);
         return exit_normal();
     }
 };