mutex.c File Reference

Per-thread mutex lock stack for deadlock detection. More...

Go to the source code of this file.

Data Structures
struct	thread_lock_stack_t
struct	thread_registry_entry_t
	thread lock stack keeps the values that move through the subsystem: depth, guard, telemetry. Some members are pointers into caller- or subsystem-owned memory, so lifetime follows the API that populated them rather than the struct copy itself. More...
struct	deadlock_state_t
struct	cond_deadlock_snapshot_t
	deadlock state is intentionally a small, concrete record. Fields such as count give callers the identity and current value they need. It is normally borrowed from, or owned by, the surrounding subsystem—not independently managed. More...
struct	cond_deadlock_entry_t
struct	cond_deadlock_batch_t
	When code needs to work with cond deadlock entry, it keeps state here instead of scattering it across globals. Initialization establishes the handles and sizes; teardown must release any allocation, lock, thread, or callback context recorded in those fields. More...

Macros
#define	DEBUG_MUTEX_CYCLE_MSG_BUFFER_SIZE   4096
#define	DEBUG_MUTEX_THREAD_NAME_BUFFER_SIZE   256
#define	DEBUG_MUTEX_MUTEX_NAME_BUFFER_SIZE   256
#define	DEBUG_MUTEX_HELD_BY_NAME_BUFFER_SIZE   256
#define	DEBUG_MUTEX_STUCK_BUFFER_SIZE   64
#define	DEBUG_MUTEX_COND_BUFFER_SIZE   1024
#define	DEBUG_MUTEX_NAME_BUFFER_SIZE   256
#define	MUTEX_STACK_MAX_DEPTH   64
#define	MAX_THREADS   256
#define	MAX_CYCLE_MUTEXES   16
#define	MAX_CYCLE_LEN   64
	DFS-based cycle detection in the waits-for graph Returns cycle start index if found, -1 otherwise Fills cycle_path with indices of threads in the cycle (if found).
#define	COND_DEADLOCK_THRESHOLD_NS   (5ULL * 1000000000ULL)

Functions
void	mutex_stack_push_pending (uintptr_t mutex_key, const char *mutex_name)
	Push a mutex onto the current thread's lock stack (PENDING state).
void	mutex_stack_push_locked (uintptr_t mutex_key, const char *mutex_name)
void	mutex_stack_mark_locked (uintptr_t mutex_key)
	Mark the top of the current thread's lock stack as LOCKED (transitions PENDING -> LOCKED).
void	mutex_stack_pop (uintptr_t mutex_key)
	Pop the top mutex from the current thread's lock stack (unlock).
int	mutex_stack_get_current (mutex_stack_entry_t *out_entries, int max_entries)
	Get the current thread's lock stack.
int	mutex_stack_get_all_threads (mutex_stack_entry_t ***out_stacks, int **out_stack_counts, int *out_thread_count)
	Get all threads' lock stacks for deadlock analysis.
void	mutex_stack_free_all_threads (mutex_stack_entry_t **stacks, int *stack_counts, int thread_count)
	Free memory allocated by mutex_stack_get_all_threads().
bool	mutex_stack_try_snapshot (mutex_wait_snapshot_t *waits, size_t capacity, size_t *count, bool *limited)
void	mutex_stack_detect_deadlocks (void)
	Detect circular wait deadlocks using DFS-based cycle detection.
bool	debug_sync_is_cleanup_in_progress (void)
void	debug_sync_check_cond_deadlocks (void)
	The useful part of cond deadlock batch is in entries, count: together they describe what is pending, who owns it, and how much data is valid. Keep the object with its parent operation and use the parent cleanup path.
int	mutex_stack_init (void)
	Initialize mutex stack system.
void	mutex_stack_cleanup_current_thread (void)
	Cleanup TLS stack for current thread Explicitly frees the thread-local mutex stack. Used to prevent leaks when TLS destructors might not run reliably (e.g., before TLS key deletion).
void	mutex_stack_cleanup (void)
	Cleanup mutex stack system.

Detailed Description

Per-thread mutex lock stack for deadlock detection.

Date

February 2026

Tracks which mutexes are held and pending per thread. Detects circular wait patterns (classic deadlock condition).

Definition in file mutex.c.

Macro Definition Documentation

COND_DEADLOCK_THRESHOLD_NS

#define COND_DEADLOCK_THRESHOLD_NS   (5ULL * 1000000000ULL)

Definition at line 755 of file mutex.c.

Referenced by debug_sync_check_cond_deadlocks().

DEBUG_MUTEX_COND_BUFFER_SIZE

#define DEBUG_MUTEX_COND_BUFFER_SIZE   1024

Definition at line 8 of file mutex.c.

DEBUG_MUTEX_CYCLE_MSG_BUFFER_SIZE

#define DEBUG_MUTEX_CYCLE_MSG_BUFFER_SIZE   4096

Definition at line 3 of file mutex.c.

Referenced by mutex_stack_detect_deadlocks().

DEBUG_MUTEX_HELD_BY_NAME_BUFFER_SIZE

#define DEBUG_MUTEX_HELD_BY_NAME_BUFFER_SIZE   256

Definition at line 6 of file mutex.c.

Referenced by mutex_stack_detect_deadlocks().

DEBUG_MUTEX_MUTEX_NAME_BUFFER_SIZE

#define DEBUG_MUTEX_MUTEX_NAME_BUFFER_SIZE   256

Definition at line 5 of file mutex.c.

Referenced by mutex_stack_detect_deadlocks().

DEBUG_MUTEX_NAME_BUFFER_SIZE

#define DEBUG_MUTEX_NAME_BUFFER_SIZE   256

Definition at line 9 of file mutex.c.

DEBUG_MUTEX_STUCK_BUFFER_SIZE

#define DEBUG_MUTEX_STUCK_BUFFER_SIZE   64

Definition at line 7 of file mutex.c.

DEBUG_MUTEX_THREAD_NAME_BUFFER_SIZE

#define DEBUG_MUTEX_THREAD_NAME_BUFFER_SIZE   256

Definition at line 4 of file mutex.c.

Referenced by mutex_stack_detect_deadlocks().

MAX_CYCLE_LEN

#define MAX_CYCLE_LEN   64

DFS-based cycle detection in the waits-for graph Returns cycle start index if found, -1 otherwise Fills cycle_path with indices of threads in the cycle (if found).

Definition at line 455 of file mutex.c.

Referenced by mutex_stack_detect_deadlocks(), and mutex_stack_try_snapshot().

MAX_CYCLE_MUTEXES

#define MAX_CYCLE_MUTEXES   16

Definition at line 99 of file mutex.c.

Referenced by mutex_stack_detect_deadlocks().

MAX_THREADS

#define MAX_THREADS   256

Definition at line 62 of file mutex.c.

Referenced by mutex_stack_detect_deadlocks(), and mutex_stack_try_snapshot().

MUTEX_STACK_MAX_DEPTH

#define MUTEX_STACK_MAX_DEPTH   64

Definition at line 40 of file mutex.c.

Referenced by mutex_stack_get_all_threads(), and mutex_stack_try_snapshot().

Function Documentation

debug_sync_is_cleanup_in_progress()

bool debug_sync_is_cleanup_in_progress ( void )

extern

Referenced by debug_sync_check_cond_deadlocks().

mutex_stack_cleanup()

void mutex_stack_cleanup

(

void

)

Cleanup mutex stack system.

Definition at line 980 of file mutex.c.

                               {
  // Signal shutdown to prevent new allocations from threads still running
  atomic_store_bool(&g_shutting_down, true);
 
  // Call only after tracked workers stop. Windows FLS key deletion invokes
  // destructors; POSIX key deletion does not. Delete first so those callbacks
  // retire their entries before we free any remaining allocations.
  if (atomic_load_bool(&g_tls_initialized)) {
    platform_tls_key_delete(g_tls_mutex_stack);
    atomic_store_bool(&g_tls_initialized, false);
  }
  registry_lock();
  int count = atomic_load_int(&g_thread_registry_count);
  for (int i = 0; i < count; ++i) {
    free(g_thread_registry[i].stack);
    g_thread_registry[i].stack = NULL;
  }
  registry_unlock();
 
  // Clear registry on cleanup using atomic operations
  atomic_store_int(&g_thread_registry_count, 0);
}

Referenced by asciichat_shared_destroy().

mutex_stack_cleanup_current_thread()

void mutex_stack_cleanup_current_thread

(

void

)

Cleanup TLS stack for current thread Explicitly frees the thread-local mutex stack. Used to prevent leaks when TLS destructors might not run reliably (e.g., before TLS key deletion).

Definition at line 947 of file mutex.c.

                                              {
  // Explicitly free the current thread's TLS stack
  // This is used to prevent leaks when TLS destructors might not run reliably
  // (e.g., debug threads exiting before mutex_stack_cleanup() deletes the TLS key)
 
  if (!atomic_load_bool(&g_tls_initialized)) {
    return; // TLS not initialized, nothing to clean up
  }
 
  thread_lock_stack_t *stack = (thread_lock_stack_t *)platform_tls_get(g_tls_mutex_stack);
  if (!stack) {
    return; // No stack allocated for this thread
  }
 
  // Clear from TLS
  platform_tls_set(g_tls_mutex_stack, NULL);
 
  // Update registry if this thread is registered
  thread_id_t current_thread = thread_self();
  registry_lock();
  int count = atomic_load_int(&g_thread_registry_count);
  for (int i = 0; i < count; i++) {
    if (thread_equal(g_thread_registry[i].thread_id, current_thread) && g_thread_registry[i].stack == stack) {
      g_thread_registry[i].stack = NULL; // Mark as freed in registry
      break;
    }
  }
 
  // Free the stack (raw free to match raw malloc above)
  free(stack);
  registry_unlock();
}

mutex_stack_detect_deadlocks()

void mutex_stack_detect_deadlocks

(

void

)

Detect circular wait deadlocks using DFS-based cycle detection.

Detect and log circular wait deadlocks.

Detects both same-thread and multi-thread deadlock patterns of any length:

Same-thread deadlock:

• Thread tries to acquire a mutex it already holds (recursive lock on non-recursive mutex)

Multi-thread circular wait (2-way, 3-way, N-way):

• Uses DFS to detect cycles in the "waits-for" graph
• Reports all threads involved in the cycle

Definition at line 630 of file mutex.c.

                                        {
  // Fixed scratch avoids allocating one list per thread on every 100 ms scan.
  // Skip a busy snapshot rather than interfering with the threads being observed.
  static thread_lock_stack_t snapshots[MAX_THREADS];
  static thread_id_t ids[MAX_THREADS];
  static atomic_flag sampling = ATOMIC_FLAG_INIT;
  if (atomic_flag_test_and_set(&sampling))
    return;
  uint64_t expected = 0;
  if (!atomic_compare_exchange_strong(&g_registry_guard.impl, &expected, 1)) {
    atomic_flag_clear(&sampling);
    return;
  }
  int thread_count = atomic_load_int_impl(&g_thread_registry_count);
  bool complete = true;
  for (int i = 0; i < thread_count; ++i) {
    thread_lock_stack_t *src = g_thread_registry[i].stack;
    ids[i] = g_thread_registry[i].thread_id;
    snapshots[i].depth = 0;
    if (!src)
      continue;
    expected = 0;
    if (!atomic_compare_exchange_strong(&src->guard.impl, &expected, 1)) {
      complete = false;
      break;
    }
    snapshots[i].depth = src->depth;
    memcpy(snapshots[i].stack, src->stack, (size_t)src->depth * sizeof(mutex_stack_entry_t));
    atomic_store(&src->guard.impl, 0);
  }
  atomic_store(&g_registry_guard.impl, 0);
  if (!complete) {
    atomic_flag_clear(&sampling);
    return;
  }
 
  // Check each thread for deadlock conditions
  for (int i = 0; i < thread_count; i++) {
    thread_lock_stack_t *stack_a = &snapshots[i];
    uintptr_t waiting_for = thread_waiting_for_mutex(stack_a);
 
    if (waiting_for == 0)
      continue; // Thread not waiting
 
    // Same-thread deadlock: thread trying to acquire a mutex it already holds
    if (thread_holds_mutex(stack_a, waiting_for)) {
      log_error("%s", colored_string(LOG_COLOR_ERROR, "╔═══════════════════════════════════════════════════════════╗"));
      log_error("%s", colored_string(LOG_COLOR_ERROR, "║  ⚠️  DEADLOCK DETECTED: Same-thread Recursive Lock  ⚠️  ║"));
      log_error("%s", colored_string(LOG_COLOR_ERROR, "╚═══════════════════════════════════════════════════════════╝"));
      log_error("  Thread Address:        0x%lx", (unsigned long)ids[i]);
      log_error("  Mutex:                 0x%lx", waiting_for);
      log_error("  Issue:                 Thread attempts recursive lock on non-recursive mutex");
      continue;
    }
 
    // Multi-thread circular wait: use DFS to detect cycles
    int cycle_path[MAX_CYCLE_LEN];
    int cycle_len = 0;
    int cycle_start = detect_cycle_dfs(snapshots, thread_count, i, cycle_path, &cycle_len);
 
    if (cycle_start >= 0 && cycle_len > 1) {
      // Collect mutexes involved in this deadlock
      uintptr_t cycle_mutexes[MAX_CYCLE_MUTEXES];
      int mutex_count = 0;
      for (int k = 0; k < cycle_len && mutex_count < MAX_CYCLE_MUTEXES; k++) {
        int thread_idx = cycle_path[k];
        thread_lock_stack_t *stack = &snapshots[thread_idx];
        uintptr_t waiting_for = thread_waiting_for_mutex(stack);
        if (waiting_for != 0) {
          cycle_mutexes[mutex_count++] = waiting_for;
        }
      }
 
      // Check if mutexes are different from last deadlock
      bool is_new_deadlock = deadlock_mutexes_changed(cycle_mutexes, mutex_count);
      if (is_new_deadlock) {
        update_deadlock_state(cycle_mutexes, mutex_count);
      }
 
      // Cycle detected! Build complete message in one string
      char cycle_msg[DEBUG_MUTEX_CYCLE_MSG_BUFFER_SIZE];
      int msg_len = 0;
 
      // Leading newline and header box
      msg_len += snprintf(cycle_msg + msg_len, sizeof(cycle_msg) - msg_len, "\n%s\n",
                          colored_string(LOG_COLOR_ERROR, "╔═════════════════════════════════╗"));
      msg_len += snprintf(cycle_msg + msg_len, sizeof(cycle_msg) - msg_len, "%s\n",
                          colored_string(LOG_COLOR_ERROR, "║  DEADLOCK: Circular Wait Cycle  ║"));
      msg_len += snprintf(cycle_msg + msg_len, sizeof(cycle_msg) - msg_len, "%s\n",
                          colored_string(LOG_COLOR_ERROR, "╚═════════════════════════════════╝"));
 
      // Print each thread in the cycle
      for (int k = 0; k < cycle_len; k++) {
        int thread_idx = cycle_path[k];
        int next_thread_idx = cycle_path[(k + 1) % cycle_len];
 
        thread_lock_stack_t *current_stack = &snapshots[thread_idx];
        uintptr_t current_waiting = thread_waiting_for_mutex(current_stack);
 
        char thread_name[DEBUG_MUTEX_THREAD_NAME_BUFFER_SIZE], mutex_name[DEBUG_MUTEX_MUTEX_NAME_BUFFER_SIZE],
            held_by_name[DEBUG_MUTEX_HELD_BY_NAME_BUFFER_SIZE];
        NAMED_GET_BY_PTR((uintptr_t)ids[thread_idx], thread_name, sizeof(thread_name));
        NAMED_GET_BY_PTR((uintptr_t)current_waiting, mutex_name, sizeof(mutex_name));
        NAMED_GET_BY_PTR((uintptr_t)ids[next_thread_idx], held_by_name, sizeof(held_by_name));
 
        msg_len += snprintf(cycle_msg + msg_len, sizeof(cycle_msg) - msg_len, "  T%d: %s waits for %s (held by %s)%s",
                            k + 1, thread_name, mutex_name, held_by_name, k < cycle_len - 1 ? "\n" : "");
      }
 
      // Log repeated deadlock detections (skip first call, throttle subsequent ones)
      if (!is_new_deadlock) {
        log_error_every(1000000, "%s", cycle_msg); // 1000000 µs = 1 second
      }
    }
  }
 
  atomic_flag_clear(&sampling);
}

References colored_string(), DEBUG_MUTEX_CYCLE_MSG_BUFFER_SIZE, DEBUG_MUTEX_HELD_BY_NAME_BUFFER_SIZE, DEBUG_MUTEX_MUTEX_NAME_BUFFER_SIZE, DEBUG_MUTEX_THREAD_NAME_BUFFER_SIZE, thread_lock_stack_t::depth, thread_lock_stack_t::guard, LOG_COLOR_ERROR, log_error, log_error_every, MAX_CYCLE_LEN, MAX_CYCLE_MUTEXES, MAX_THREADS, NAMED_GET_BY_PTR, and thread_lock_stack_t::stack.

mutex_stack_free_all_threads()

void mutex_stack_free_all_threads	(	mutex_stack_entry_t **	stacks,
		int *	stack_counts,
		int	thread_count )

Free memory allocated by mutex_stack_get_all_threads().

Definition at line 389 of file mutex.c.

                                                                                                     {
 
  if (!stacks || !stack_counts)
    return;
 
  for (int i = 0; i < thread_count; i++) {
    SAFE_FREE(stacks[i]);
  }
 
  SAFE_FREE(stacks);
  SAFE_FREE(stack_counts);
}

References SAFE_FREE.

mutex_stack_get_all_threads()

int mutex_stack_get_all_threads	(	mutex_stack_entry_t ***	out_stacks,
		int **	out_stack_counts,
		int *	out_thread_count )

Get all threads' lock stacks for deadlock analysis.

Allocates memory for all thread stacks. Caller must free with mutex_stack_free_all_threads().

Parameters

out_stacks	Pointer to array of stacks (one per thread)
out_stack_counts	Array of stack sizes corresponding to out_stacks
out_thread_count	Number of threads with lock stacks

Returns

0 on success, -1 on error

Definition at line 339 of file mutex.c.

                                                                                                                  {
 
  if (!out_stacks || !out_stack_counts || !out_thread_count) {
    return -1;
  }
 
  // Read the thread count with acquire semantics (lock-free, no mutex needed)
  // Use memory_order_seq_cst to ensure we get a consistent snapshot
  int thread_count = atomic_load_int(&g_thread_registry_count);
 
  // Allocate arrays for threads in the registry
  // Note: SAFE_MALLOC takes bytes as first parameter, not count
  *out_stacks = SAFE_CALLOC(thread_count, sizeof(mutex_stack_entry_t *), mutex_stack_entry_t **);
  *out_stack_counts = SAFE_CALLOC(thread_count, sizeof(int), int *);
 
  if (!*out_stacks || !*out_stack_counts) {
    SAFE_FREE(*out_stacks);
    SAFE_FREE(*out_stack_counts);
    return -1;
  }
 
  // Copy each thread's stack from the registry
  // Note: the thread count can change concurrently, so we re-read it in the loop
  // to avoid accessing out-of-bounds memory if threads exit during iteration
  for (int i = 0; i < thread_count; i++) {
    // Re-check thread count in case registry shrank
    int current_registry_count = atomic_load_int(&g_thread_registry_count);
    if (i >= current_registry_count) {
      break;
    }
 
    // Allocate before locking because tracked allocation updates the lock stack.
    (*out_stacks)[i] = SAFE_MALLOC(MUTEX_STACK_MAX_DEPTH * sizeof(mutex_stack_entry_t), mutex_stack_entry_t *);
    (*out_stack_counts)[i] = 0;
    registry_lock();
    thread_lock_stack_t *src = g_thread_registry[i].stack;
    if (src) {
      stack_lock(src);
      int depth = src->depth;
      (*out_stack_counts)[i] = depth;
      memcpy((*out_stacks)[i], src->stack, depth * sizeof(mutex_stack_entry_t));
      stack_unlock(src);
    }
    registry_unlock();
  }
 
  *out_thread_count = thread_count;
  return 0;
}

References thread_lock_stack_t::depth, MUTEX_STACK_MAX_DEPTH, SAFE_CALLOC, SAFE_FREE, SAFE_MALLOC, and thread_lock_stack_t::stack.

mutex_stack_get_current()

int mutex_stack_get_current	(	mutex_stack_entry_t *	out_entries,
		int	max_entries )

Get the current thread's lock stack.

Parameters

out_entries	Pointer to array where entries will be stored
max_entries	Maximum number of entries to return

Returns

Number of entries in the stack (may be > max_entries if truncated)

Definition at line 321 of file mutex.c.

                                                                               {
  thread_lock_stack_t *stack = get_thread_local_stack();
  if (!stack || !out_entries) {
    return 0;
  }
 
  stack_lock(stack);
  int depth = stack->depth;
  int count = (depth < max_entries) ? depth : max_entries;
  memcpy(out_entries, stack->stack, count * sizeof(mutex_stack_entry_t));
  stack_unlock(stack);
  return depth; // Return actual depth even if truncated
}

References thread_lock_stack_t::depth, and thread_lock_stack_t::stack.

mutex_stack_init()

int mutex_stack_init

(

void

)

Initialize mutex stack system.

Returns

0 on success, -1 on error

Definition at line 939 of file mutex.c.

                           {
#ifndef NDEBUG
  atomic_store(&g_next_cond_check_ns, 0);
#endif
  // No initialization needed - registry uses lock-free atomic operations
  return 0;
}

mutex_stack_mark_locked()

void mutex_stack_mark_locked

(

uintptr_t

mutex_key

)

Mark the top of the current thread's lock stack as LOCKED (transitions PENDING -> LOCKED).

Parameters

mutex_key

Pointer to mutex (must match most recent pending push)

Definition at line 271 of file mutex.c.

                                                  {
  thread_lock_stack_t *stack = get_thread_local_stack();
  if (!stack) {
    return;
  }
 
  // Mark the top of the stack as locked
  stack_lock(stack);
  if (stack->depth == 0) {
    stack_unlock(stack);
    return;
  }
  int top = stack->depth - 1;
  if (stack->stack[top].mutex_key == mutex_key) {
    stack->stack[top].state = MUTEX_STACK_STATE_LOCKED;
    stack->stack[top].timestamp_ns = time_get_ns();
  }
  stack_unlock(stack);
 
  // Thread-local only. Registry is populated on-demand by mutex_stack_get_all_threads()
}

References thread_lock_stack_t::depth, mutex_stack_entry_t::mutex_key, MUTEX_STACK_STATE_LOCKED, thread_lock_stack_t::stack, mutex_stack_entry_t::state, and mutex_stack_entry_t::timestamp_ns.

mutex_stack_pop()

void mutex_stack_pop

(

uintptr_t

mutex_key

)

Pop the top mutex from the current thread's lock stack (unlock).

Parameters

mutex_key

Pointer to mutex (used for validation)

Definition at line 293 of file mutex.c.

                                          {
  thread_lock_stack_t *stack = get_thread_local_stack();
  if (!stack) {
    return;
  }
 
  // Validate top matches
  stack_lock(stack);
  if (stack->depth == 0) {
    stack_unlock(stack);
    return;
  }
  // Locks may be released out of acquisition order. Remove the most recent
  // matching acquisition, preserving any recursive acquisitions below it.
  for (int i = stack->depth - 1; i >= 0; --i) {
    if (stack->stack[i].mutex_key == mutex_key) {
      memmove(&stack->stack[i], &stack->stack[i + 1], (size_t)(stack->depth - i - 1) * sizeof(stack->stack[0]));
      --stack->depth;
      break;
    }
  }
  stack_unlock(stack);
 
  // Thread-local only. Registry is populated on-demand by mutex_stack_get_all_threads()
}

References thread_lock_stack_t::depth, mutex_stack_entry_t::mutex_key, and thread_lock_stack_t::stack.

mutex_stack_push_locked()

void mutex_stack_push_locked	(	uintptr_t	mutex_key,
		const char *	mutex_name )

Record an already acquired lock without publishing a transient pending wait.

Definition at line 267 of file mutex.c.

                                                                          {
  mutex_stack_push(mutex_key, mutex_name, MUTEX_STACK_STATE_LOCKED);
}

References MUTEX_STACK_STATE_LOCKED.

mutex_stack_push_pending()

void mutex_stack_push_pending	(	uintptr_t	mutex_key,
		const char *	mutex_name )

Push a mutex onto the current thread's lock stack (PENDING state).

Parameters

mutex_key	Pointer to mutex (used as unique ID)
mutex_name	Human-readable name of mutex

Definition at line 263 of file mutex.c.

                                                                           {
  mutex_stack_push(mutex_key, mutex_name, MUTEX_STACK_STATE_PENDING);
}

References MUTEX_STACK_STATE_PENDING.

mutex_stack_try_snapshot()

bool mutex_stack_try_snapshot	(	mutex_wait_snapshot_t *	waits,
		size_t	capacity,
		size_t *	count,
		bool *	limited )

Definition at line 507 of file mutex.c.

                                                                                                           {
  // A single collector owns this scratch space. Never dereference names from
  // copied stacks: their registry entries may have been removed meanwhile.
  static thread_lock_stack_t snapshots[MAX_THREADS];
  static thread_id_t ids[MAX_THREADS];
  static atomic_flag sampling = ATOMIC_FLAG_INIT;
  if (atomic_flag_test_and_set(&sampling))
    return false;
  uint64_t expected = 0;
  if (!atomic_compare_exchange_strong(&g_registry_guard.impl, &expected, 1)) {
    atomic_flag_clear(&sampling);
    return false;
  }
  int threads = atomic_load_int_impl(&g_thread_registry_count);
  bool complete = true;
  for (int i = 0; i < threads; ++i) {
    thread_lock_stack_t *stack = g_thread_registry[i].stack;
    ids[i] = g_thread_registry[i].thread_id;
    snapshots[i].depth = 0;
    if (!stack)
      continue;
    expected = 0;
    if (!atomic_compare_exchange_strong(&stack->guard.impl, &expected, 1)) {
      complete = false;
      break;
    }
    snapshots[i].depth = stack->depth;
    memcpy(snapshots[i].stack, stack->stack, sizeof(stack->stack));
    snapshots[i].telemetry = stack->telemetry;
    atomic_store(&stack->guard.impl, 0);
  }
  atomic_store(&g_registry_guard.impl, 0);
  if (complete) {
    *count = 0;
    *limited = threads >= MAX_CYCLE_LEN;
    for (int i = 0; i < threads; ++i) {
      uintptr_t key = thread_waiting_for_mutex(&snapshots[i]);
      *limited |= snapshots[i].depth == MUTEX_STACK_MAX_DEPTH;
      if (!key)
        continue;
      if (*count == capacity) {
        *limited = true;
        continue;
      }
      int path[MAX_CYCLE_LEN], length = 0;
      bool cycle = thread_holds_mutex(&snapshots[i], key);
      if (detect_cycle_dfs(snapshots, threads, i, path, &length) >= 0)
        for (int j = 0; j < length; ++j)
          cycle |= path[j] == i;
      mutex_wait_snapshot_t *wait = &waits[(*count)++];
      *wait = snapshots[i].telemetry;
      wait->mutex_key = key;
      wait->thread_key = (uintptr_t)ids[i];
      wait->since_ns = snapshots[i].stack[snapshots[i].depth - 1].timestamp_ns;
      wait->cycle = cycle;
    }
  }
  atomic_flag_clear(&sampling);
  return complete;
}

References mutex_wait_snapshot_t::cycle, thread_lock_stack_t::depth, thread_lock_stack_t::guard, MAX_CYCLE_LEN, MAX_THREADS, mutex_wait_snapshot_t::mutex_key, MUTEX_STACK_MAX_DEPTH, mutex_wait_snapshot_t::since_ns, thread_lock_stack_t::stack, thread_lock_stack_t::telemetry, mutex_wait_snapshot_t::thread_key, and mutex_stack_entry_t::timestamp_ns.