samples-enhance-hung_task-detector-test-with-read-write-semaphore-support.patch removed from -mm tree
The quilt patch titled
Subject: samples: enhance hung_task detector test with read-write semaphore support
has been removed from the -mm tree. Its filename was
samples-enhance-hung_task-detector-test-with-read-write-semaphore-support.patch
This patch was dropped because it was merged into the mm-nonmm-stable branch of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm
------------------------------------------------------
From: Zi Li <[email protected]>
Subject: samples: enhance hung_task detector test with read-write semaphore support
Date: Fri, 27 Jun 2025 15:29:24 +0800
Extend the hung_task detector test module to include read-write semaphore support alongside existing mutex and semaphore tests. This module now creates additional debugfs files under <debugfs>/hung_task, namely 'rw_semaphore_read' and 'rw_semaphore_write', in addition to 'mutex' and 'semaphore'. Reading these files with multiple processes triggers a prolonged sleep (256 seconds) while holding the respective lock, enabling hung_task detector testing for various locking mechanisms.
This change builds on the extensible hung_task_tests module, adding read-write semaphore functionality to improve test coverage for kernel locking primitives. The implementation ensures proper lock handling and includes checks to prevent redundant data reads.
Usage is:
> cd /sys/kernel/debug/hung_task
> cat mutex & cat mutex # Test mutex blocking
> cat semaphore & cat semaphore # Test semaphore blocking
> cat rw_semaphore_write \
& cat rw_semaphore_read # Test rwsem blocking
> cat rw_semaphore_write \
& cat rw_semaphore_write # Test rwsem blocking
Update the Kconfig description to reflect the addition of read-write semaphore debugfs files.
---
samples/Kconfig | 7 -- samples/hung_task/hung_task_tests.c | 81 +++++++++++++++++++++++--- 2 files changed, 77 insertions(+), 11 deletions(-)
samples/hung_task/hung_task_tests.c renamed from samples/hung_task/hung_task_tests.c~samples-enhance-hung_task-detector-test-with-read-write-semaphore-support +74 -7
@@ -4,11 +4,12 @@* semaphore, etc. * * Usage: Load this module and read `<debugfs>/hung_task/mutex`, -* `<debugfs>/hung_task/semaphore`, etc., with 2 or more processes. +* `<debugfs>/hung_task/semaphore`, `<debugfs>/hung_task/rw_semaphore_read`, +* `<debugfs>/hung_task/rw_semaphore_write`, etc., with 2 or more processes. * * This is for testing kernel hung_task error messages with various locking -* mechanisms (e.g., mutex, semaphore, etc.). Note that this may freeze -* your system or cause a panic. Use only for testing purposes. +* mechanisms (e.g., mutex, semaphore, rw_semaphore_read, rw_semaphore_write, etc.). +* Note that this may freeze your system or cause a panic. Use only for testing purposes. */ #include <linux/debugfs.h>
@@ -17,21 +18,29 @@#include <linux/module.h> #include <linux/mutex.h> #include <linux/semaphore.h> +#include <linux/rwsem.h> -#define HUNG_TASK_DIR "hung_task" -#define HUNG_TASK_MUTEX_FILE "mutex" -#define HUNG_TASK_SEM_FILE "semaphore" -#define SLEEP_SECOND 256 +#define HUNG_TASK_DIR "hung_task" +#define HUNG_TASK_MUTEX_FILE "mutex" +#define HUNG_TASK_SEM_FILE "semaphore" +#define HUNG_TASK_RWSEM_READ_FILE "rw_semaphore_read" +#define HUNG_TASK_RWSEM_WRITE_FILE "rw_semaphore_write" +#define SLEEP_SECOND 256static const char dummy_string[] ="This is a dummy string." ;static DEFINE_MUTEX (dummy_mutex); static DEFINE_SEMAPHORE(dummy_sem, 1); +static DECLARE_RWSEM (dummy_rwsem);static struct dentry *hung_task_dir;/* Mutex-based read function */ static ssize_t read_dummy_mutex (struct file *file,char __user *user_buf,size_t count,loff_t *ppos) { +/* Check if data is already read */ +if (*ppos >=sizeof (dummy_string)) +return 0 ; +/* Second task waits on mutex, entering uninterruptible sleep */ guard (mutex)(&dummy_mutex);
@@ -46,6 +55,10 @@ static ssize_t read_dummy_mutex(struct fstatic ssize_t read_dummy_semaphore (struct file *file,char __user *user_buf,size_t count,loff_t *ppos) { +/* Check if data is already read */ +if (*ppos >=sizeof (dummy_string)) +return 0 ; +/* Second task waits on semaphore, entering uninterruptible sleep */ down (&dummy_sem);
@@ -58,6 +71,46 @@ static ssize_t read_dummy_semaphore(stru sizeof(dummy_string)); } +/* Read-write semaphore read function */ +static ssize_t read_dummy_rwsem_read (struct file *file,char __user *user_buf, +size_t count,loff_t *ppos) +{ +/* Check if data is already read */ +if (*ppos >=sizeof (dummy_string)) +return 0 ; + +/* Acquires read lock, allowing concurrent readers but blocks if write lock is held */ +down_read (&dummy_rwsem); + +/* Sleeps here, potentially triggering hung task detection if lock is held too long */ +msleep_interruptible (SLEEP_SECOND *1000 ); + +up_read (&dummy_rwsem); + +return simple_read_from_buffer (user_buf, count, ppos, dummy_string, +sizeof (dummy_string)); +} + +/* Read-write semaphore write function */ +static ssize_t read_dummy_rwsem_write (struct file *file,char __user *user_buf, +size_t count,loff_t *ppos) +{ +/* Check if data is already read */ +if (*ppos >=sizeof (dummy_string)) +return 0 ; + +/* Acquires exclusive write lock, blocking all other readers and writers */ +down_write (&dummy_rwsem); + +/* Sleeps here, potentially triggering hung task detection if lock is held too long */ +msleep_interruptible (SLEEP_SECOND *1000 ); + +up_write (&dummy_rwsem); + +return simple_read_from_buffer (user_buf, count, ppos, dummy_string, +sizeof (dummy_string)); +} +/* File operations for mutex */ static const struct file_operations hung_task_mutex_fops = { .read = read_dummy_mutex,
@@ -68,6 +121,16 @@ static const struct file_operations hung .read = read_dummy_semaphore, }; +/* File operations for rw_semaphore read */ +static const struct file_operations hung_task_rwsem_read_fops = { + .read = read_dummy_rwsem_read, +}; + +/* File operations for rw_semaphore write */ +static const struct file_operations hung_task_rwsem_write_fops = { + .read = read_dummy_rwsem_write, +}; +static int __init hung_task_tests_init (void ) { hung_task_dir =debugfs_create_dir (HUNG_TASK_DIR ,NULL );
@@ -79,6 +142,10 @@ static int __init hung_task_tests_init(v &hung_task_mutex_fops);debugfs_create_file (HUNG_TASK_SEM_FILE ,0400 , hung_task_dir,NULL , &hung_task_sem_fops); +debugfs_create_file (HUNG_TASK_RWSEM_READ_FILE ,0400 , hung_task_dir,NULL , + &hung_task_rwsem_read_fops); +debugfs_create_file (HUNG_TASK_RWSEM_WRITE_FILE ,0400 , hung_task_dir,NULL , + &hung_task_rwsem_write_fops);return 0 ; }
samples/Kconfig renamed from samples/Kconfig~samples-enhance-hung_task-detector-test-with-read-write-semaphore-support +3 -4
@@ -316,10 +316,9 @@ config SAMPLE_HUNG_TASK depends on DETECT_HUNG_TASK && DEBUG_FS help Build a module that provides debugfs files (e.g., mutex, semaphore, - etc.) under <debugfs>/hung_task. If user reads one of these files, - it will sleep long time (256 seconds) with holding a lock. Thus, - if 2 or more processes read the same file concurrently, it will - be detected by the hung_task watchdog. + rw_semaphore_read, rw_semaphore_write) under <debugfs>/hung_task. + Reading these files with multiple processes triggers hung task + detection by holding locks for a long time (256 seconds). source "samples/rust/Kconfig"
_
Patches currently in -mm which might be from [email protected] are