Synchronization is one of the most important concepts in Linux kernel development. When multiple kernel threads access a shared resource simultaneously, improper synchronization can lead to race conditions, inconsistent data, or even kernel crashes.
One of the synchronization primitives provided by the Linux kernel is mutex_lock_killable(). It behaves similarly to mutex_lock(), but allows a waiting task to return if interrupted by an appropriate fatal signal.
In this article, we'll explore the fundamentals of mutex_lock_killable() through a simple Linux Kernel Module.
Prerequisites
Before following this tutorial, you should be familiar with:
- Linux Kernel Modules
- C Programming
- Kernel Threads
- Basic Linux Commands
- Synchronization Fundamentals
What is a Mutex?
A Mutex (Mutual Exclusion Lock) ensures that only one execution context can access a shared resource at a time.
Without synchronization:
- Race conditions occur
- Shared data becomes inconsistent
- Kernel behavior becomes unpredictable
Using a mutex guarantees exclusive access to the critical section.
Why mutex_lock_killable()?
The Linux kernel provides multiple mutex APIs.
| API |
Behavior |
mutex_lock() |
Wait indefinitely until the lock becomes available |
mutex_lock_interruptible() |
Can be interrupted by interruptible signals |
mutex_lock_killable() |
Can return if interrupted by an appropriate fatal signal |
In many driver scenarios, allowing a blocked task to terminate gracefully is preferable to waiting forever.
Demo Overview
The demonstration module creates two kernel threads.
- Thread-1 acquires the mutex.
- Thread-2 attempts to acquire the same mutex.
- Since the mutex is already held, Thread-2 blocks.
- After Thread-1 releases the mutex, Thread-2 continues execution.
This simple example illustrates how mutual exclusion works inside the Linux kernel.
Core Kernel APIs
The project uses several commonly used kernel APIs.
DEFINE_MUTEX(my_mutex);
mutex_lock_killable(&my_mutex);
mutex_unlock(&my_mutex);
kthread_run(...);
msleep(5000);
pr_info(...);
Each API plays a specific role:
DEFINE_MUTEX() creates a mutex.mutex_lock_killable() acquires the mutex.mutex_unlock() releases it.kthread_run() creates kernel threads.msleep() simulates work.pr_info() prints kernel log messages.
Critical Section
A Critical Section is the portion of code that accesses shared resources.
Only one thread should execute this region at any given time.
In the demo:
- Thread-1 enters the critical section.
- Thread-2 waits.
- After unlocking, Thread-2 proceeds.
This guarantees safe access to shared resources.
Building the Module
Compile the module using:
make
If Secure Boot is enabled, sign the kernel module before loading.
sudo /usr/src/linux-headers-$(uname -r)/scripts/sign-file \
sha256 \
~/kernel_keys/MOK.key \
~/kernel_keys/MOK.crt \
mutex_killable_demo.ko
Loading the Module
Insert the module:
sudo insmod mutex_killable_demo.ko
Monitor kernel logs:
sudo dmesg -wH
Verify the module:
lsmod | grep mutex_killable_demo
View running kernel threads:
ps -eLf | grep killable
Unload the module:
sudo rmmod mutex_killable_demo
Expected Execution
When the module runs, the output typically follows this sequence:
- Thread-1 starts.
- Thread-1 acquires the mutex.
- Thread-2 starts.
- Thread-2 blocks while waiting.
- Thread-1 releases the mutex.
- Thread-2 acquires the mutex.
- Thread-2 completes execution.
- Module unloads successfully.
Practical Use Cases
Understanding kernel synchronization is useful when developing:
- Character Device Drivers
- Platform Drivers
- PCI Drivers
- USB Drivers
- Network Drivers
- Filesystem Modules
- Embedded Linux Systems
- Linux Kernel Subsystems
Key Learning Outcomes
After completing this project, you should understand:
- Linux kernel synchronization
- Kernel threads
- Mutex locking
- Critical sections
- Blocking synchronization
- Kernel logging
- Mutual exclusion
- Safe shared resource access
Important Note
In this educational example, both workers are kernel threads. Since kernel threads typically do not receive user-space signals, the behavior of mutex_lock_killable() appears very similar to mutex_lock().
The primary advantage of mutex_lock_killable() becomes more apparent in kernel drivers where a user-space process blocks while waiting for a mutex and may receive a fatal signal.
Conclusion
Although the demo is intentionally simple, it introduces several core Linux kernel concepts that appear throughout driver development.
Understanding synchronization primitives like mutex_lock_killable() is an important step toward writing reliable kernel modules and avoiding race conditions in concurrent kernel code.
As you continue learning Linux kernel development, you can extend this project by experimenting with additional synchronization mechanisms such as semaphores, spinlocks, completions, wait queues, and reader-writer locks.
GitHub Repository
👉 GitHub Repository:
https://github.com/aj333git/linux_kernel_mutex_killable
Explore the complete source code, build files, and Linux kernel module implementation.
