ke/wait: add wait_reason

src/kern/queue.zig

@@ -75,7 +75,9 @@ pub const Queue = struct {
         self.hdr.lock.release(ipl);
 
         // Wait until the queue has something for us.
-        _ = try ke.wait.wait_one(&self.hdr, .{ .timeout = timeout });
+        _ = try ke.wait.wait_one(&self.hdr, "queue", .{
+            .timeout = timeout,
+        });
 
         // Grab the queue item and set it to null.
         const ret = td.queue_item orelse unreachable;

src/kern/thread.zig

@@ -99,6 +99,8 @@ pub const Thread = struct {
     /// Current wait status.
     wait_status: std.atomic.Value(ki.wait.Status),
     waitblocks: [4]ki.wait.WaitBlock,
+    /// Reason for the wait, if any.
+    wait_reason: ?[]const u8,
     /// Timer used for timeouts.
     timer: ke.Timer,
     /// Turnstile.
@@ -146,6 +148,7 @@ pub const Thread = struct {
             .runq_idx = 0,
             .wait_status = .init(.Satisfied),
             .waitblocks = undefined,
+            .wait_reason = null,
             .timer = undefined,
             .turnstile = undefined,
             .turnstile_waiter = null,

src/kern/turnstile.zig

@@ -441,7 +441,7 @@ pub fn block(turnstile: ?*Turnstile, obj: *anyopaque, own: Ownership, queue: Que
 
     // Now block on the event.
     _ = ke.ipl.lower(.Passive);
-    _ = ke.wait.wait_one(&waiter.event.hdr, .{}) catch unreachable;
+    _ = ke.wait.wait_one(&waiter.event.hdr, "turnstile:waiter", .{}) catch unreachable;
     _ = ke.ipl.raise(ipl);
 }
 

src/kern/wait.zig

@@ -105,9 +105,9 @@ const Options = struct {
 /// Wait for the provided object to be signaled.
 /// This will only return an error if `timeout` is provided and
 /// the wait times out.
-pub fn wait_one(object: *DispatchHeader, opts: Options) !usize {
+pub fn wait_one(object: *DispatchHeader, reason: []const u8, opts: Options) !usize {
     var objects = [_]*DispatchHeader{object};
-    return wait_any(&objects, opts);
+    return wait_any(&objects, reason, opts);
 }
 
 /// Wait for any of the provided objects to be signaled.
@@ -116,7 +116,7 @@ pub fn wait_one(object: *DispatchHeader, opts: Options) !usize {
 /// If `timeout` is not provided, it will wait indefinitely.
 /// If `waitblocks` is specified, then the wait will use those waitblocks for the operation.
 /// Note that if `timeout` is provided, then one additional waitblock must be allocated.
-pub fn wait_any(objects: []*DispatchHeader, opts: Options) !usize {
+pub fn wait_any(objects: []*DispatchHeader, reason: []const u8, opts: Options) !usize {
     const ipl = ke.ipl.raise(.Dispatch);
     defer ke.ipl.lower(ipl);
     const curtd = ki.sched.percpu.local().current_thread.?;
@@ -206,6 +206,7 @@ pub fn wait_any(objects: []*DispatchHeader, opts: Options) !usize {
             }
         }
 
+        curtd.wait_reason = reason;
         // We're good, now actually block.
         ki.sched.block_locked(curtd);
     } else {
@@ -221,6 +222,8 @@ pub fn wait_any(objects: []*DispatchHeader, opts: Options) !usize {
         ke.timer.cancel(timer);
     }
 
+    curtd.wait_reason = null;
+
     // Find the object that satisfied us.
     for (0..total_count) |i| {
         const is_timer = has_timeout and i == timer_i;