What You Will Learn

• What a kernel thread is and how it differs from a timer callback or a workqueue item
• How to create and start a kernel thread with kthread_run()
• How to stop a kernel thread cleanly using kthread_stop() and kthread_should_stop()
• A complete, original polling-loop example

Prerequisites

This Linux kernel threads tutorial builds on the previous two lectures in this free Linux kernel development course — delay functions and kernel timers. Make sure you understand process versus atomic context before continuing.

Why Use a Kernel Thread At All

A kernel thread is a task that lives entirely inside the kernel, has its own stack, and is scheduled by the same scheduler as any user-space process — except it never returns to user space. It is the right tool when you need a background loop that can genuinely sleep between iterations, unlike a timer callback which must never block.

The Modern kthread API

#include <linux/module.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/sched.h>

static struct task_struct *ep_thread;

static int ep_worker_fn(void *data)
{
    unsigned int count = 0;

    while (!kthread_should_stop()) {
        pr_info("ep_worker: still alive, tick %u\n", count++);

        /* schedule_timeout_interruptible lets the thread sleep
         * while still waking up promptly if kthread_stop() fires */
        set_current_state(TASK_INTERRUPTIBLE);
        schedule_timeout(msecs_to_jiffies(1000));
    }

    pr_info("ep_worker: stopping cleanly\n");
    return 0;
}

static int __init ep_kthread_init(void)
{
    ep_thread = kthread_run(ep_worker_fn, NULL, "ep_worker");
    if (IS_ERR(ep_thread))
        return PTR_ERR(ep_thread);

    pr_info("ep_kthread: module loaded\n");
    return 0;
}

static void __exit ep_kthread_exit(void)
{
    kthread_stop(ep_thread);
    pr_info("ep_kthread: module unloaded\n");
}

module_init(ep_kthread_init);
module_exit(ep_kthread_exit);
MODULE_LICENSE("GPL");

Why kthread_should_stop() Must Be Checked Every Loop

kthread_stop() does not forcibly kill the thread. It sets an internal flag and wakes the thread, then waits for it to return on its own. Your loop must actively check kthread_should_stop() after every wakeup, otherwise kthread_stop() will hang forever waiting for a thread that never checks the flag.

Common Mistakes

• Using msleep() in a loop that ignores kthread_should_stop(), which delays shutdown by up to the full sleep interval or worse.
• Calling kthread_stop() before the thread has actually started running, which is safe by design but easy to reason about incorrectly.
• Forgetting to check IS_ERR() on the return value of kthread_run().
• Spawning a new kernel thread for every minor background task instead of reusing a workqueue, which wastes memory on unnecessary kernel stacks.

Best Practices

• Always check kthread_should_stop() right after waking from sleep, before doing any work.
• Prefer a workqueue over a dedicated kernel thread unless you truly need a persistent, always-running loop.
• Give threads a descriptive name — it shows up directly in ps and makes debugging much easier.

Performance Considerations

Each kernel thread carries its own kernel stack (typically several kilobytes) and adds one more entity for the scheduler to track. For infrequent or event-driven work, a workqueue is usually lighter-weight than a dedicated kernel thread that spends most of its life asleep.

Key Takeaways

• Kernel threads are full scheduled tasks that can sleep, unlike timer callbacks.
• kthread_run() both creates and starts a thread in one call.
• Cooperative shutdown via kthread_should_stop() is mandatory, not optional.
• Reach for a workqueue instead when the work is occasional rather than continuous.

Conclusion

This Linux kernel threads tutorial covered the complete lifecycle of a kthread-based background loop, from creation to cooperative shutdown. In the final lecture of this mini-series inside our free Linux kernel development course, we’ll cover workqueues — the preferred mechanism for deferred, sleepable work that doesn’t need a dedicated always-on thread.

Frequently Asked Questions