Merge pull request ziglang#20268 from ziglang/keep-calm-and-continue-…

…panicking

lib/std/Progress.zig

@@ -521,6 +521,8 @@ fn windowsApiUpdateThreadRun() void {
 /// Allows the caller to freely write to stderr until `unlockStdErr` is called.
 ///
 /// During the lock, any `std.Progress` information is cleared from the terminal.
+///
+/// The lock is recursive; the same thread may hold the lock multiple times.
 pub fn lockStdErr() void {
     stderr_mutex.lock();
     clearWrittenWithEscapeCodes() catch {};
@@ -1378,4 +1380,7 @@ const have_sigwinch = switch (builtin.os.tag) {
     else => false,
 };
 
-var stderr_mutex: std.Thread.Mutex = .{};
+/// The primary motivation for recursive mutex here is so that a panic while
+/// stderr mutex is held still dumps the stack trace and other debug
+/// information.
+var stderr_mutex = std.Thread.Mutex.Recursive.init;

lib/std/Thread/Mutex.zig

@@ -1,23 +1,11 @@
-//! Mutex is a synchronization primitive which enforces atomic access to a shared region of code known as the "critical section".
-//! It does this by blocking ensuring only one thread is in the critical section at any given point in time by blocking the others.
-//! Mutex can be statically initialized and is at most `@sizeOf(u64)` large.
-//! Use `lock()` or `tryLock()` to enter the critical section and `unlock()` to leave it.
+//! Mutex is a synchronization primitive which enforces atomic access to a
+//! shared region of code known as the "critical section".
 //!
-//! Example:
-//! ```
-//! var m = Mutex{};
+//! It does this by blocking ensuring only one thread is in the critical
+//! section at any given point in time by blocking the others.
 //!
-//! {
-//!     m.lock();
-//!     defer m.unlock();
-//!     // ... critical section code
-//! }
-//!
-//! if (m.tryLock()) {
-//!     defer m.unlock();
-//!     // ... critical section code
-//! }
-//! ```
+//! Mutex can be statically initialized and is at most `@sizeOf(u64)` large.
+//! Use `lock()` or `tryLock()` to enter the critical section and `unlock()` to leave it.
 
 const std = @import("../std.zig");
 const builtin = @import("builtin");
@@ -30,6 +18,8 @@ const Futex = Thread.Futex;
 
 impl: Impl = .{},
 
+pub const Recursive = @import("Mutex/Recursive.zig");
+
 /// Tries to acquire the mutex without blocking the caller's thread.
 /// Returns `false` if the calling thread would have to block to acquire it.
 /// Otherwise, returns `true` and the caller should `unlock()` the Mutex to release it.
@@ -312,3 +302,19 @@ test "many contended" {
 
     try testing.expectEqual(runner.counter.get(), num_increments * num_threads);
 }
+
+// https://github.com/ziglang/zig/issues/19295
+//test @This() {
+//    var m: Mutex = .{};
+//
+//    {
+//        m.lock();
+//        defer m.unlock();
+//        // ... critical section code
+//    }
+//
+//    if (m.tryLock()) {
+//        defer m.unlock();
+//        // ... critical section code
+//    }
+//}

lib/std/Thread/Mutex/Recursive.zig

@@ -0,0 +1,72 @@
+//! A synchronization primitive enforcing atomic access to a shared region of
+//! code known as the "critical section".
+//!
+//! Equivalent to `std.Mutex` except it allows the same thread to obtain the
+//! lock multiple times.
+//!
+//! A recursive mutex is an abstraction layer on top of a regular mutex;
+//! therefore it is recommended to use instead `std.Mutex` unless there is a
+//! specific reason a recursive mutex is warranted.
+
+const std = @import("../../std.zig");
+const Recursive = @This();
+const Mutex = std.Thread.Mutex;
+const assert = std.debug.assert;
+
+mutex: Mutex,
+thread_id: std.Thread.Id,
+lock_count: usize,
+
+pub const init: Recursive = .{
+    .mutex = .{},
+    .thread_id = invalid_thread_id,
+    .lock_count = 0,
+};
+
+/// Acquires the `Mutex` without blocking the caller's thread.
+///
+/// Returns `false` if the calling thread would have to block to acquire it.
+///
+/// Otherwise, returns `true` and the caller should `unlock()` the Mutex to release it.
+pub fn tryLock(r: *Recursive) bool {
+    const current_thread_id = std.Thread.getCurrentId();
+    if (@atomicLoad(std.Thread.Id, &r.thread_id, .unordered) != current_thread_id) {
+        if (!r.mutex.tryLock()) return false;
+        assert(r.lock_count == 0);
+        @atomicStore(std.Thread.Id, &r.thread_id, current_thread_id, .unordered);
+    }
+    r.lock_count += 1;
+    return true;
+}
+
+/// Acquires the `Mutex`, blocking the current thread while the mutex is
+/// already held by another thread.
+///
+/// The `Mutex` can be held multiple times by the same thread.
+///
+/// Once acquired, call `unlock` on the `Mutex` to release it, regardless
+/// of whether the lock was already held by the same thread.
+pub fn lock(r: *Recursive) void {
+    const current_thread_id = std.Thread.getCurrentId();
+    if (@atomicLoad(std.Thread.Id, &r.thread_id, .unordered) != current_thread_id) {
+        r.mutex.lock();
+        assert(r.lock_count == 0);
+        @atomicStore(std.Thread.Id, &r.thread_id, current_thread_id, .unordered);
+    }
+    r.lock_count += 1;
+}
+
+/// Releases the `Mutex` which was previously acquired with `lock` or `tryLock`.
+///
+/// It is undefined behavior to unlock from a different thread that it was
+/// locked from.
+pub fn unlock(r: *Recursive) void {
+    r.lock_count -= 1;
+    if (r.lock_count == 0) {
+        @atomicStore(std.Thread.Id, &r.thread_id, invalid_thread_id, .unordered);
+        r.mutex.unlock();
+    }
+}
+
+/// A value that does not alias any other thread id.
+const invalid_thread_id: std.Thread.Id = std.math.maxInt(std.Thread.Id);

lib/std/debug.zig

@@ -447,9 +447,6 @@ pub fn panicExtra(
 /// The counter is incremented/decremented atomically.
 var panicking = std.atomic.Value(u8).init(0);
 
-// Locked to avoid interleaving panic messages from multiple threads.
-var panic_mutex = std.Thread.Mutex{};
-
 /// Counts how many times the panic handler is invoked by this thread.
 /// This is used to catch and handle panics triggered by the panic handler.
 threadlocal var panic_stage: usize = 0;
@@ -474,8 +471,8 @@ pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize
 
             // Make sure to release the mutex when done
             {
-                panic_mutex.lock();
-                defer panic_mutex.unlock();
+                lockStdErr();
+                defer unlockStdErr();
 
                 const stderr = io.getStdErr().writer();
                 if (builtin.single_threaded) {
@@ -2604,8 +2601,8 @@ fn handleSegfaultPosix(sig: i32, info: *const posix.siginfo_t, ctx_ptr: ?*anyopa
             _ = panicking.fetchAdd(1, .seq_cst);
 
             {
-                panic_mutex.lock();
-                defer panic_mutex.unlock();
+                lockStdErr();
+                defer unlockStdErr();
 
                 dumpSegfaultInfoPosix(sig, code, addr, ctx_ptr);
             }
@@ -2680,8 +2677,8 @@ fn handleSegfaultWindowsExtra(
                 _ = panicking.fetchAdd(1, .seq_cst);
 
                 {
-                    panic_mutex.lock();
-                    defer panic_mutex.unlock();
+                    lockStdErr();
+                    defer unlockStdErr();
 
                     dumpSegfaultInfoWindows(info, msg, label);
                 }