mirror of
https://github.com/raspberrypi/linux.git
synced 2025-12-06 10:00:17 +00:00
c97513cddc
The blocker tracking mechanism assumes that lock pointers are at least
4-byte aligned to use their lower bits for type encoding.
However, as reported by Eero Tamminen, some architectures like m68k
only guarantee 2-byte alignment of 32-bit values. This breaks the
assumption and causes two related WARN_ON_ONCE checks to trigger.
To fix this, the runtime checks are adjusted to silently ignore any lock
that is not 4-byte aligned, effectively disabling the feature in such
cases and avoiding the related warnings.
Thanks to Geert Uytterhoeven for bisecting!
Link: https://lkml.kernel.org/r/20250909145243.17119-1-lance.yang@linux.dev
Fixes: e711faaafb ("hung_task: replace blocker_mutex with encoded blocker")
Signed-off-by: Lance Yang <lance.yang@linux.dev>
Reported-by: Eero Tamminen <oak@helsinkinet.fi>
Closes: https://lore.kernel.org/lkml/CAMuHMdW7Ab13DdGs2acMQcix5ObJK0O2dG_Fxzr8_g58Rc1_0g@mail.gmail.com
Reviewed-by: Masami Hiramatsu (Google) <mhiramat@kernel.org>
Cc: John Paul Adrian Glaubitz <glaubitz@physik.fu-berlin.de>
Cc: Anna Schumaker <anna.schumaker@oracle.com>
Cc: Boqun Feng <boqun.feng@gmail.com>
Cc: Finn Thain <fthain@linux-m68k.org>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Joel Granados <joel.granados@kernel.org>
Cc: John Stultz <jstultz@google.com>
Cc: Kent Overstreet <kent.overstreet@linux.dev>
Cc: Lance Yang <lance.yang@linux.dev>
Cc: Mingzhe Yang <mingzhe.yang@ly.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Sergey Senozhatsky <senozhatsky@chromium.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Tomasz Figa <tfiga@chromium.org>
Cc: Waiman Long <longman@redhat.com>
Cc: Will Deacon <will@kernel.org>
Cc: Yongliang Gao <leonylgao@tencent.com>
Cc: <stable@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
102 lines
2.6 KiB
C
102 lines
2.6 KiB
C
/* 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.
|
|
*
|
|
* Note that on architectures where this is not guaranteed, or for any
|
|
* unaligned lock, this tracking mechanism is silently skipped for that
|
|
* lock.
|
|
*
|
|
* Type encoding:
|
|
* 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_RWSEM_READER 0x02UL
|
|
#define BLOCKER_TYPE_RWSEM_WRITER 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 (lock_ptr & BLOCKER_TYPE_MASK)
|
|
return;
|
|
|
|
WRITE_ONCE(current->blocker, lock_ptr | type);
|
|
}
|
|
|
|
static inline void hung_task_clear_blocker(void)
|
|
{
|
|
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 */
|