The Linux scheduler is one of the most important components of the operating system. Every running program, background service, and kernel thread eventually interacts with the scheduler.
In this article, I will build a Linux Kernel Module (LKM) that exposes scheduler information through the /proc filesystem, allowing us to inspect processes directly from kernel space.
The module targets Ubuntu 22.04 (Linux Kernel 5.15.x) and uses only modern kernel APIs.
What I will Learn
By the end of this article I will understand:
- Linux scheduler fundamentals
- What
task_struct represents
- The
current process pointer
- Process priorities
- Nice values
- Process states
- CPU assignment
- The
/proc filesystem
- The
seq_file interface
- Safe kernel reads using
READ_ONCE()
- Process iteration using
for_each_process()
Why Build This Project?
Most Linux users interact with commands like:
ps
top
htop
These utilities obtain process information from the kernel.
Instead of only using these tools, this project demonstrates how the kernel itself provides scheduler information.
This makes it an excellent project for learning:
- Linux Kernel Programming
- Operating Systems
- Device Driver Development
- Embedded Linux
- Linux Internals
Project Overview
The kernel module creates a new file:
/proc/scheduler_demo
Reading this file displays scheduler information about every process currently running on the system.
Example:
cat /proc/scheduler_demo
How the Module Works
The execution flow is straightforward:
- Load the kernel module.
- Register a new
/proc entry.
- The user reads the file.
- The kernel invokes a callback.
- Process information is collected.
- Results are returned to userspace.
Building Blocks Used
| Component |
Purpose |
| Kernel Module |
Extends kernel functionality |
/proc |
Exposes runtime kernel information |
seq_file |
Safely generates formatted output |
task_struct |
Represents a process |
| Scheduler APIs |
Read scheduler information |
Understanding task_struct
Every process in Linux is represented by a task_struct.
It contains information such as:
- Process ID
- Process name
- Scheduling priority
- Nice value
- Current CPU
- Memory information
- Parent and child relationships
- Process state
- Credentials
- Scheduling class
Nearly every scheduler-related API operates on a task_struct.
The current Pointer
Linux always knows which process is currently executing.
That process is accessible through:
current
From this pointer we can obtain information such as:
- PID
- Process name
- Priority
- Nice value
- Current scheduler state
Enumerating Every Process
The kernel provides an iterator for traversing every process.
for_each_process(task)
{
/* Scheduler information */
}
This macro walks through the kernel's process list and allows the module to inspect each task.
Reading the Current CPU
Every process executes on a CPU core.
The kernel provides:
task_cpu(task)
which returns the CPU currently associated with that task.
This is useful when studying:
- SMP systems
- CPU scheduling
- Load balancing
- Processor affinity
Understanding Priorities
Linux scheduling uses several priority values.
This project prints:
- Scheduler priority
- Static priority
- Normal priority
- Nice value
Together these values determine how the scheduler treats a process.
Nice Values
User processes can influence scheduling through the nice value.
Typical range:
| Nice Value |
Meaning |
| -20 |
Highest priority |
| 0 |
Default |
| +19 |
Lowest priority |
The module retrieves it using:
task_nice(task)
Process States
Processes constantly transition between states.
Examples include:
- Running
- Runnable
- Sleeping
- Stopped
- Zombie
The module safely reads the scheduler state using:
READ_ONCE(task->__state)
Using READ_ONCE() prevents compiler optimizations from producing inconsistent reads when scheduler data changes concurrently.
Detecting Runnable Tasks
The module checks whether a process is runnable using:
task_is_running(task)
This modern helper is preferred over manually interpreting scheduler state bits.
Why Use /proc?
The /proc filesystem is designed to expose runtime kernel and process information.
Examples include:
/proc/cpuinfo
/proc/meminfo
/proc/modules
/proc/uptime
Our module simply adds another entry:
/proc/scheduler_demo
Why seq_file?
Kernel output can become very large.
Instead of manually managing buffers, Linux provides the seq_file interface.
Benefits include:
- Automatic buffering
- Safe iteration
- Large output support
- Simpler implementation
- Better maintainability
The module prints information using:
seq_printf(...)
Creating the /proc Entry
The module creates the file using:
proc_create(...)
When the module is unloaded, it removes the entry using:
remove_proc_entry(...)
This keeps the filesystem clean and avoids leaving stale entries behind.
Kernel Module Lifecycle
Every Linux Kernel Module follows a lifecycle.
Initialization:
module_init(...)
Cleanup:
module_exit(...)
Initialization registers resources, while cleanup releases them before the module is unloaded.
APIs Covered
| API |
Purpose |
current |
Current executing process |
task_struct |
Process descriptor |
for_each_process() |
Iterate over all processes |
task_cpu() |
CPU associated with a task |
task_nice() |
Retrieve nice value |
task_is_running() |
Check runnable state |
READ_ONCE() |
Safe concurrent read |
proc_create() |
Create /proc entry |
remove_proc_entry() |
Remove /proc entry |
seq_printf() |
Generate /proc output |
single_open() |
Connect /proc with callback |
module_init() |
Module initialization |
module_exit() |
Module cleanup |
Key Takeaways
This project demonstrates several important Linux kernel concepts in a compact and practical example.
You learned how to:
- Create a Linux Kernel Module
- Add custom entries to the
/proc filesystem
- Traverse every process in the kernel
- Read scheduler metadata
- Display process priorities and nice values
- Access CPU information
- Safely inspect process states
- Generate formatted kernel output using
seq_file
- Follow modern Linux Kernel 5.15 programming practices
Although intentionally simple, this module forms a strong foundation for studying advanced scheduler topics such as the Completely Fair Scheduler (CFS), scheduling classes, CPU affinity, load balancing, kernel threads, and scheduler internals.
Conclusion
The Linux scheduler is responsible for deciding which process runs, when it runs, and on which CPU. By exposing scheduler information through a custom /proc entry, this project provides a practical way to explore those internals without modifying the kernel itself.
For learning Linux kernel programming, operating systems, embedded Linux, or device driver development, implementing small projects like this is one of the most effective ways to understand how the kernel works beneath the surface.
GitHub Repository: 👉 linux_kernel_scheduler Explore the complete source code, build files, and module implementation on GitHub.
