hung_task: extend hung task blocker tracking to rwsems

author Lance Yang <lance.yang@linux.dev>

Fri, 27 Jun 2025 07:29:23 +0000 (15:29 +0800)

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

Sun, 20 Jul 2025 02:08:26 +0000 (19:08 -0700)
author Lance Yang <lance.yang@linux.dev>
Fri, 27 Jun 2025 07:29:23 +0000 (15:29 +0800)
committer Andrew Morton <akpm@linux-foundation.org>
Sun, 20 Jul 2025 02:08:26 +0000 (19:08 -0700)
diff --git a/include/linux/hung_task.h b/include/linux/hung_task.h

index 1bc2b32446138c20789778559d4e43d7d9563ee8..34e615c76ca5335d06ca9a12183951a92051dbbf 100644 (file)
--- a/include/linux/hung_task.h
+++ b/include/linux/hung_task.h
@@ -21,17 +21,17 @@
   * 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)
+ * 00 - Blocked on mutex                       (BLOCKER_TYPE_MUTEX)
+ * 01 - Blocked on semaphore                   (BLOCKER_TYPE_SEM)
+ * 10 - Blocked on rw-semaphore as READER      (BLOCKER_TYPE_RWSEM_READER)
+ * 11 - Blocked on rw-semaphore as WRITER      (BLOCKER_TYPE_RWSEM_WRITER)
   */
-#define BLOCKER_TYPE_MUTEX      0x00UL
-#define BLOCKER_TYPE_SEM        0x01UL
-#define BLOCKER_TYPE_RTMUTEX    0x02UL
-#define BLOCKER_TYPE_RWSEM      0x03UL
+#define BLOCKER_TYPE_MUTEX             0x00UL
+#define BLOCKER_TYPE_SEM               0x01UL
+#define BLOCKER_TYPE_RWSEM_READER      0x02UL
+#define BLOCKER_TYPE_RWSEM_WRITER      0x03UL
  
-#define BLOCKER_TYPE_MASK       0x03UL
+#define BLOCKER_TYPE_MASK              0x03UL
  
  #ifdef CONFIG_DETECT_HUNG_TASK_BLOCKER
  static inline void hung_task_set_blocker(void *lock, unsigned long type)
diff --git a/kernel/hung_task.c b/kernel/hung_task.c

index d2432df2b905bc33da2f2144c97810f53171a1ac..8708a1205f82e3f798d3465a9d52bb5a4305557a 100644 (file)
--- a/kernel/hung_task.c
+++ b/kernel/hung_task.c
@@ -23,6 +23,7 @@
  #include <linux/sched/debug.h>
  #include <linux/sched/sysctl.h>
  #include <linux/hung_task.h>
+#include <linux/rwsem.h>
  
  #include <trace/events/sched.h>
  
@@ -100,6 +101,7 @@ static void debug_show_blocker(struct task_struct *task)
  {
         struct task_struct *g, *t;
         unsigned long owner, blocker, blocker_type;
+       const char *rwsem_blocked_by, *rwsem_blocked_as;
  
         RCU_LOCKDEP_WARN(!rcu_read_lock_held(), "No rcu lock held");
  
@@ -111,12 +113,20 @@ static void debug_show_blocker(struct task_struct *task)
  
         switch (blocker_type) {
         case BLOCKER_TYPE_MUTEX:
-               owner = mutex_get_owner(
-                       (struct mutex *)hung_task_blocker_to_lock(blocker));
+               owner = mutex_get_owner(hung_task_blocker_to_lock(blocker));
                 break;
         case BLOCKER_TYPE_SEM:
-               owner = sem_last_holder(
-                       (struct semaphore *)hung_task_blocker_to_lock(blocker));
+               owner = sem_last_holder(hung_task_blocker_to_lock(blocker));
+               break;
+       case BLOCKER_TYPE_RWSEM_READER:
+       case BLOCKER_TYPE_RWSEM_WRITER:
+               owner = (unsigned long)rwsem_owner(
+                                       hung_task_blocker_to_lock(blocker));
+               rwsem_blocked_as = (blocker_type == BLOCKER_TYPE_RWSEM_READER) ?
+                                       "reader" : "writer";
+               rwsem_blocked_by = is_rwsem_reader_owned(
+                                       hung_task_blocker_to_lock(blocker)) ?
+                                       "reader" : "writer";
                 break;
         default:
                 WARN_ON_ONCE(1);
@@ -134,6 +144,11 @@ static void debug_show_blocker(struct task_struct *task)
                         pr_err("INFO: task %s:%d is blocked on a semaphore, but the last holder is not found.\n",
                                task->comm, task->pid);
                         break;
+               case BLOCKER_TYPE_RWSEM_READER:
+               case BLOCKER_TYPE_RWSEM_WRITER:
+                       pr_err("INFO: task %s:%d is blocked on an rw-semaphore, but the owner is not found.\n",
+                              task->comm, task->pid);
+                       break;
                 }
                 return;
         }
@@ -152,6 +167,12 @@ static void debug_show_blocker(struct task_struct *task)
                         pr_err("INFO: task %s:%d blocked on a semaphore likely last held by task %s:%d\n",
                                task->comm, task->pid, t->comm, t->pid);
                         break;
+               case BLOCKER_TYPE_RWSEM_READER:
+               case BLOCKER_TYPE_RWSEM_WRITER:
+                       pr_err("INFO: task %s:%d <%s> blocked on an rw-semaphore likely owned by task %s:%d <%s>\n",
+                              task->comm, task->pid, rwsem_blocked_as, t->comm,
+                              t->pid, rwsem_blocked_by);
+                       break;
                 }
                 sched_show_task(t);
                 return;
diff --git a/kernel/locking/rwsem.c b/kernel/locking/rwsem.c

index a310eb9896de0beba4c06f4b24332c9b9f9c81aa..92c6332da40137894df571e997bb14b712ad3106 100644 (file)
--- a/kernel/locking/rwsem.c
+++ b/kernel/locking/rwsem.c
@@ -27,6 +27,7 @@
  #include <linux/export.h>
  #include <linux/rwsem.h>
  #include <linux/atomic.h>
+#include <linux/hung_task.h>
  #include <trace/events/lock.h>
  
  #ifndef CONFIG_PREEMPT_RT
@@ -1065,10 +1066,13 @@ queue:
                 wake_up_q(&wake_q);
  
         trace_contention_begin(sem, LCB_F_READ);
+       set_current_state(state);
+
+       if (state == TASK_UNINTERRUPTIBLE)
+               hung_task_set_blocker(sem, BLOCKER_TYPE_RWSEM_READER);
  
         /* wait to be given the lock */
         for (;;) {
-               set_current_state(state);
                 if (!smp_load_acquire(&waiter.task)) {
                         /* Matches rwsem_mark_wake()'s smp_store_release(). */
                         break;
@@ -1083,8 +1087,12 @@ queue:
                 }
                 schedule_preempt_disabled();
                 lockevent_inc(rwsem_sleep_reader);
+               set_current_state(state);
         }
  
+       if (state == TASK_UNINTERRUPTIBLE)
+               hung_task_clear_blocker();
+
         __set_current_state(TASK_RUNNING);
         lockevent_inc(rwsem_rlock);
         trace_contention_end(sem, 0);
@@ -1146,6 +1154,9 @@ rwsem_down_write_slowpath(struct rw_semaphore *sem, int state)
         set_current_state(state);
         trace_contention_begin(sem, LCB_F_WRITE);
  
+       if (state == TASK_UNINTERRUPTIBLE)
+               hung_task_set_blocker(sem, BLOCKER_TYPE_RWSEM_WRITER);
+
         for (;;) {
                 if (rwsem_try_write_lock(sem, &waiter)) {
                         /* rwsem_try_write_lock() implies ACQUIRE on success */
@@ -1179,6 +1190,10 @@ rwsem_down_write_slowpath(struct rw_semaphore *sem, int state)
  trylock_again:
                 raw_spin_lock_irq(&sem->wait_lock);
         }
+
+       if (state == TASK_UNINTERRUPTIBLE)
+               hung_task_clear_blocker();
+
         __set_current_state(TASK_RUNNING);
         raw_spin_unlock_irq(&sem->wait_lock);
         lockevent_inc(rwsem_wlock);
author	Lance Yang <lance.yang@linux.dev>
	Fri, 27 Jun 2025 07:29:23 +0000 (15:29 +0800)
committer	Andrew Morton <akpm@linux-foundation.org>
	Sun, 20 Jul 2025 02:08:26 +0000 (19:08 -0700)
include/linux/hung_task.h		patch \| blob \| blame \| history
kernel/hung_task.c		patch \| blob \| blame \| history
kernel/locking/rwsem.c		patch \| blob \| blame \| history