hung_task: show the blocker task if the task is hung on semaphore

author Lance Yang <ioworker0@gmail.com>

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

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

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

index 04655faadc2da198d331b436599e45f25efdd8f7..89706157e62234ad4fd2e3b2c3f930e171507f04 100644 (file)
--- a/include/linux/semaphore.h
+++ b/include/linux/semaphore.h
@@ -16,13 +16,25 @@ struct semaphore {
         raw_spinlock_t          lock;
         unsigned int            count;
         struct list_head        wait_list;
+
+#ifdef CONFIG_DETECT_HUNG_TASK_BLOCKER
+       unsigned long           last_holder;
+#endif
  };
  
+#ifdef CONFIG_DETECT_HUNG_TASK_BLOCKER
+#define __LAST_HOLDER_SEMAPHORE_INITIALIZER                            \
+       , .last_holder = 0UL
+#else
+#define __LAST_HOLDER_SEMAPHORE_INITIALIZER
+#endif
+
  #define __SEMAPHORE_INITIALIZER(name, n)                               \
  {                                                                      \
         .lock           = __RAW_SPIN_LOCK_UNLOCKED((name).lock),        \
         .count          = n,                                            \
-       .wait_list      = LIST_HEAD_INIT((name).wait_list),             \
+       .wait_list      = LIST_HEAD_INIT((name).wait_list)              \
+       __LAST_HOLDER_SEMAPHORE_INITIALIZER                             \
  }
  
  /*
@@ -47,5 +59,6 @@ extern int __must_check down_killable(struct semaphore *sem);
  extern int __must_check down_trylock(struct semaphore *sem);
  extern int __must_check down_timeout(struct semaphore *sem, long jiffies);
  extern void up(struct semaphore *sem);
+extern unsigned long sem_last_holder(struct semaphore *sem);
  
  #endif /* __LINUX_SEMAPHORE_H */
diff --git a/kernel/hung_task.c b/kernel/hung_task.c

index 79558d76ef068032c45655d5bbd1b521a9f4e61d..d2432df2b905bc33da2f2144c97810f53171a1ac 100644 (file)
--- a/kernel/hung_task.c
+++ b/kernel/hung_task.c
@@ -99,32 +99,62 @@ static struct notifier_block panic_block = {
  static void debug_show_blocker(struct task_struct *task)
  {
         struct task_struct *g, *t;
-       unsigned long owner, blocker;
+       unsigned long owner, blocker, blocker_type;
  
         RCU_LOCKDEP_WARN(!rcu_read_lock_held(), "No rcu lock held");
  
         blocker = READ_ONCE(task->blocker);
-       if (!blocker ||
-           hung_task_get_blocker_type(blocker) != BLOCKER_TYPE_MUTEX)
+       if (!blocker)
                 return;
  
-       owner = mutex_get_owner(
-               (struct mutex *)hung_task_blocker_to_lock(blocker));
+       blocker_type = hung_task_get_blocker_type(blocker);
+
+       switch (blocker_type) {
+       case BLOCKER_TYPE_MUTEX:
+               owner = mutex_get_owner(
+                       (struct mutex *)hung_task_blocker_to_lock(blocker));
+               break;
+       case BLOCKER_TYPE_SEM:
+               owner = sem_last_holder(
+                       (struct semaphore *)hung_task_blocker_to_lock(blocker));
+               break;
+       default:
+               WARN_ON_ONCE(1);
+               return;
+       }
+
  
         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);
+               switch (blocker_type) {
+               case BLOCKER_TYPE_MUTEX:
+                       pr_err("INFO: task %s:%d is blocked on a mutex, but the owner is not found.\n",
+                              task->comm, task->pid);
+                       break;
+               case BLOCKER_TYPE_SEM:
+                       pr_err("INFO: task %s:%d is blocked on a semaphore, but the last holder is not found.\n",
+                              task->comm, task->pid);
+                       break;
+               }
                 return;
         }
  
         /* Ensure the owner information is correct. */
         for_each_process_thread(g, t) {
-               if ((unsigned long)t == owner) {
+               if ((unsigned long)t != owner)
+                       continue;
+
+               switch (blocker_type) {
+               case BLOCKER_TYPE_MUTEX:
                         pr_err("INFO: task %s:%d is blocked on a mutex likely owned by task %s:%d.\n",
-                               task->comm, task->pid, t->comm, t->pid);
-                       sched_show_task(t);
-                       return;
+                              task->comm, task->pid, t->comm, t->pid);
+                       break;
+               case BLOCKER_TYPE_SEM:
+                       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;
                 }
+               sched_show_task(t);
+               return;
         }
  }
  #else
diff --git a/kernel/locking/semaphore.c b/kernel/locking/semaphore.c

index de9117c0e671e94d4b831ceaf3bd2dbaa8c3b66a..3ef032e22f7ef4a82fa6ad5bf6ee5ecf28e14c91 100644 (file)
--- a/kernel/locking/semaphore.c
+++ b/kernel/locking/semaphore.c
@@ -34,6 +34,7 @@
  #include <linux/spinlock.h>
  #include <linux/ftrace.h>
  #include <trace/events/lock.h>
+#include <linux/hung_task.h>
  
  static noinline void __down(struct semaphore *sem);
  static noinline int __down_interruptible(struct semaphore *sem);
@@ -41,6 +42,41 @@ static noinline int __down_killable(struct semaphore *sem);
  static noinline int __down_timeout(struct semaphore *sem, long timeout);
  static noinline void __up(struct semaphore *sem, struct wake_q_head *wake_q);
  
+#ifdef CONFIG_DETECT_HUNG_TASK_BLOCKER
+static inline void hung_task_sem_set_holder(struct semaphore *sem)
+{
+       WRITE_ONCE((sem)->last_holder, (unsigned long)current);
+}
+
+static inline void hung_task_sem_clear_if_holder(struct semaphore *sem)
+{
+       if (READ_ONCE((sem)->last_holder) == (unsigned long)current)
+               WRITE_ONCE((sem)->last_holder, 0UL);
+}
+
+unsigned long sem_last_holder(struct semaphore *sem)
+{
+       return READ_ONCE(sem->last_holder);
+}
+#else
+static inline void hung_task_sem_set_holder(struct semaphore *sem)
+{
+}
+static inline void hung_task_sem_clear_if_holder(struct semaphore *sem)
+{
+}
+unsigned long sem_last_holder(struct semaphore *sem)
+{
+       return 0UL;
+}
+#endif
+
+static inline void __sem_acquire(struct semaphore *sem)
+{
+       sem->count--;
+       hung_task_sem_set_holder(sem);
+}
+
  /**
   * down - acquire the semaphore
   * @sem: the semaphore to be acquired
@@ -59,7 +95,7 @@ void __sched down(struct semaphore *sem)
         might_sleep();
         raw_spin_lock_irqsave(&sem->lock, flags);
         if (likely(sem->count > 0))
-               sem->count--;
+               __sem_acquire(sem);
         else
                 __down(sem);
         raw_spin_unlock_irqrestore(&sem->lock, flags);
@@ -83,7 +119,7 @@ int __sched down_interruptible(struct semaphore *sem)
         might_sleep();
         raw_spin_lock_irqsave(&sem->lock, flags);
         if (likely(sem->count > 0))
-               sem->count--;
+               __sem_acquire(sem);
         else
                 result = __down_interruptible(sem);
         raw_spin_unlock_irqrestore(&sem->lock, flags);
@@ -110,7 +146,7 @@ int __sched down_killable(struct semaphore *sem)
         might_sleep();
         raw_spin_lock_irqsave(&sem->lock, flags);
         if (likely(sem->count > 0))
-               sem->count--;
+               __sem_acquire(sem);
         else
                 result = __down_killable(sem);
         raw_spin_unlock_irqrestore(&sem->lock, flags);
@@ -140,7 +176,7 @@ int __sched down_trylock(struct semaphore *sem)
         raw_spin_lock_irqsave(&sem->lock, flags);
         count = sem->count - 1;
         if (likely(count >= 0))
-               sem->count = count;
+               __sem_acquire(sem);
         raw_spin_unlock_irqrestore(&sem->lock, flags);
  
         return (count < 0);
@@ -165,7 +201,7 @@ int __sched down_timeout(struct semaphore *sem, long timeout)
         might_sleep();
         raw_spin_lock_irqsave(&sem->lock, flags);
         if (likely(sem->count > 0))
-               sem->count--;
+               __sem_acquire(sem);
         else
                 result = __down_timeout(sem, timeout);
         raw_spin_unlock_irqrestore(&sem->lock, flags);
@@ -187,6 +223,9 @@ void __sched up(struct semaphore *sem)
         DEFINE_WAKE_Q(wake_q);
  
         raw_spin_lock_irqsave(&sem->lock, flags);
+
+       hung_task_sem_clear_if_holder(sem);
+
         if (likely(list_empty(&sem->wait_list)))
                 sem->count++;
         else
@@ -228,8 +267,10 @@ static inline int __sched ___down_common(struct semaphore *sem, long state,
                 raw_spin_unlock_irq(&sem->lock);
                 timeout = schedule_timeout(timeout);
                 raw_spin_lock_irq(&sem->lock);
-               if (waiter.up)
+               if (waiter.up) {
+                       hung_task_sem_set_holder(sem);
                         return 0;
+               }
         }
  
   timed_out:
@@ -246,10 +287,14 @@ static inline int __sched __down_common(struct semaphore *sem, long state,
  {
         int ret;
  
+       hung_task_set_blocker(sem, BLOCKER_TYPE_SEM);
+
         trace_contention_begin(sem, 0);
         ret = ___down_common(sem, state, timeout);
         trace_contention_end(sem, ret);
  
+       hung_task_clear_blocker();
+
         return ret;
  }
author	Lance Yang <ioworker0@gmail.com>
	Mon, 14 Apr 2025 14:59:44 +0000 (22:59 +0800)
committer	Andrew Morton <akpm@linux-foundation.org>
	Mon, 12 May 2025 00:54:08 +0000 (17:54 -0700)
include/linux/semaphore.h		patch \| blob \| blame \| history
kernel/hung_task.c		patch \| blob \| blame \| history
kernel/locking/semaphore.c		patch \| blob \| blame \| history