hung_task: replace blocker_mutex with encoded blocker

author Lance Yang <ioworker0@gmail.com>

Mon, 14 Apr 2025 14:59:43 +0000 (22:59 +0800)

committer Andrew Morton <akpm@linux-foundation.org>

Mon, 12 May 2025 00:54:07 +0000 (17:54 -0700)
author Lance Yang <ioworker0@gmail.com>
Mon, 14 Apr 2025 14:59:43 +0000 (22:59 +0800)
committer Andrew Morton <akpm@linux-foundation.org>
Mon, 12 May 2025 00:54:07 +0000 (17:54 -0700)
diff --git a/include/linux/hung_task.h b/include/linux/hung_task.h

new file mode 100644 (file)

index 0000000..1bc2b32
--- /dev/null
+++ b/include/linux/hung_task.h
@@ -0,0 +1,99 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Detect Hung Task: detecting tasks stuck in D state
+ *
+ * Copyright (C) 2025 Tongcheng Travel (www.ly.com)
+ * Author: Lance Yang <mingzhe.yang@ly.com>
+ */
+#ifndef __LINUX_HUNG_TASK_H
+#define __LINUX_HUNG_TASK_H
+
+#include <linux/bug.h>
+#include <linux/sched.h>
+#include <linux/compiler.h>
+
+/*
+ * @blocker: Combines lock address and blocking type.
+ *
+ * Since lock pointers are at least 4-byte aligned(32-bit) or 8-byte
+ * aligned(64-bit). This leaves the 2 least bits (LSBs) of the pointer
+ * always zero. So we can use these bits to encode the specific blocking
+ * type.
+ *
+ * Type encoding:
+ * 00 - Blocked on mutex        (BLOCKER_TYPE_MUTEX)
+ * 01 - Blocked on semaphore    (BLOCKER_TYPE_SEM)
+ * 10 - Blocked on rt-mutex     (BLOCKER_TYPE_RTMUTEX)
+ * 11 - Blocked on rw-semaphore (BLOCKER_TYPE_RWSEM)
+ */
+#define BLOCKER_TYPE_MUTEX      0x00UL
+#define BLOCKER_TYPE_SEM        0x01UL
+#define BLOCKER_TYPE_RTMUTEX    0x02UL
+#define BLOCKER_TYPE_RWSEM      0x03UL
+
+#define BLOCKER_TYPE_MASK       0x03UL
+
+#ifdef CONFIG_DETECT_HUNG_TASK_BLOCKER
+static inline void hung_task_set_blocker(void *lock, unsigned long type)
+{
+       unsigned long lock_ptr = (unsigned long)lock;
+
+       WARN_ON_ONCE(!lock_ptr);
+       WARN_ON_ONCE(READ_ONCE(current->blocker));
+
+       /*
+        * If the lock pointer matches the BLOCKER_TYPE_MASK, return
+        * without writing anything.
+        */
+       if (WARN_ON_ONCE(lock_ptr & BLOCKER_TYPE_MASK))
+               return;
+
+       WRITE_ONCE(current->blocker, lock_ptr | type);
+}
+
+static inline void hung_task_clear_blocker(void)
+{
+       WARN_ON_ONCE(!READ_ONCE(current->blocker));
+
+       WRITE_ONCE(current->blocker, 0UL);
+}
+
+/*
+ * hung_task_get_blocker_type - Extracts blocker type from encoded blocker
+ * address.
+ *
+ * @blocker: Blocker pointer with encoded type (via LSB bits)
+ *
+ * Returns: BLOCKER_TYPE_MUTEX, BLOCKER_TYPE_SEM, etc.
+ */
+static inline unsigned long hung_task_get_blocker_type(unsigned long blocker)
+{
+       WARN_ON_ONCE(!blocker);
+
+       return blocker & BLOCKER_TYPE_MASK;
+}
+
+static inline void *hung_task_blocker_to_lock(unsigned long blocker)
+{
+       WARN_ON_ONCE(!blocker);
+
+       return (void *)(blocker & ~BLOCKER_TYPE_MASK);
+}
+#else
+static inline void hung_task_set_blocker(void *lock, unsigned long type)
+{
+}
+static inline void hung_task_clear_blocker(void)
+{
+}
+static inline unsigned long hung_task_get_blocker_type(unsigned long blocker)
+{
+       return 0UL;
+}
+static inline void *hung_task_blocker_to_lock(unsigned long blocker)
+{
+       return NULL;
+}
+#endif
+
+#endif /* __LINUX_HUNG_TASK_H */
diff --git a/include/linux/sched.h b/include/linux/sched.h

index f96ac198289349199b9c671240a20fc7826228ad..393d81978f40a4917216e5255343af4cac682d9d 100644 (file)
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1240,7 +1240,11 @@ struct task_struct {
  #endif
  
  #ifdef CONFIG_DETECT_HUNG_TASK_BLOCKER
-       struct mutex                    *blocker_mutex;
+       /*
+        * Encoded lock address causing task block (lower 2 bits = type from
+        * <linux/hung_task.h>). Accessed via hung_task_*() helpers.
+        */
+       unsigned long                   blocker;
  #endif
  
  #ifdef CONFIG_DEBUG_ATOMIC_SLEEP
diff --git a/kernel/hung_task.c b/kernel/hung_task.c

index dc898ec93463f67e515725a0930ce6a66368d008..79558d76ef068032c45655d5bbd1b521a9f4e61d 100644 (file)
--- a/kernel/hung_task.c
+++ b/kernel/hung_task.c
@@ -22,6 +22,7 @@
  #include <linux/sched/signal.h>
  #include <linux/sched/debug.h>
  #include <linux/sched/sysctl.h>
+#include <linux/hung_task.h>
  
  #include <trace/events/sched.h>
  
@@ -98,16 +99,18 @@ static struct notifier_block panic_block = {
  static void debug_show_blocker(struct task_struct *task)
  {
         struct task_struct *g, *t;
-       unsigned long owner;
-       struct mutex *lock;
+       unsigned long owner, blocker;
  
         RCU_LOCKDEP_WARN(!rcu_read_lock_held(), "No rcu lock held");
  
-       lock = READ_ONCE(task->blocker_mutex);
-       if (!lock)
+       blocker = READ_ONCE(task->blocker);
+       if (!blocker ||
+           hung_task_get_blocker_type(blocker) != BLOCKER_TYPE_MUTEX)
                 return;
  
-       owner = mutex_get_owner(lock);
+       owner = mutex_get_owner(
+               (struct mutex *)hung_task_blocker_to_lock(blocker));
+
         if (unlikely(!owner)) {
                 pr_err("INFO: task %s:%d is blocked on a mutex, but the owner is not found.\n",
                         task->comm, task->pid);
diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c

index 555e2b3a665a304c87530182fe73b4d31ccb3474..61fa97da7989ece3b6508cd5596e9b457db0cd91 100644 (file)
--- a/kernel/locking/mutex.c
+++ b/kernel/locking/mutex.c
@@ -29,6 +29,7 @@
  #include <linux/interrupt.h>
  #include <linux/debug_locks.h>
  #include <linux/osq_lock.h>
+#include <linux/hung_task.h>
  
  #define CREATE_TRACE_POINTS
  #include <trace/events/lock.h>
@@ -191,7 +192,7 @@ __mutex_add_waiter(struct mutex *lock, struct mutex_waiter *waiter,
                    struct list_head *list)
  {
  #ifdef CONFIG_DETECT_HUNG_TASK_BLOCKER
-       WRITE_ONCE(current->blocker_mutex, lock);
+       hung_task_set_blocker(lock, BLOCKER_TYPE_MUTEX);
  #endif
         debug_mutex_add_waiter(lock, waiter, current);
  
@@ -209,7 +210,7 @@ __mutex_remove_waiter(struct mutex *lock, struct mutex_waiter *waiter)
  
         debug_mutex_remove_waiter(lock, waiter, current);
  #ifdef CONFIG_DETECT_HUNG_TASK_BLOCKER
-       WRITE_ONCE(current->blocker_mutex, NULL);
+       hung_task_clear_blocker();
  #endif
  }
author	Lance Yang <ioworker0@gmail.com>
	Mon, 14 Apr 2025 14:59:43 +0000 (22:59 +0800)
committer	Andrew Morton <akpm@linux-foundation.org>
	Mon, 12 May 2025 00:54:07 +0000 (17:54 -0700)
include/linux/hung_task.h	[new file with mode: 0644]	patch \| blob
include/linux/sched.h		patch \| blob \| blame \| history
kernel/hung_task.c		patch \| blob \| blame \| history
kernel/locking/mutex.c		patch \| blob \| blame \| history