What is a Kernel thread?

Question

i am just started coding of device driver and new to threading, went through many documents for getting an idea about threads. i still have some doubts.

1. what is a kernel thread ?.
2. how it differs from user thread ?.
3. what is the relationship between the two threads ?.
4. how can i implement kernel threads ?.
5. where can i see the output of the implementation?.

Can anyone help me ?. thanks.

Solution 1

A kernel thread is a kernel task running only in kernel mode; it usually has not been created by fork() or clone() system calls. An example is kworker or kswapd.

You probably should not implement kernel threads if you don't know what they are.

Google gives many pages about kernel threads, e.g. Frey's page.

Solution 2

1. A kernel thread is a task_struct with no userspace components.
2. Besides the lack of userspace, it has different ancestors (kthreadd kernel thread instead of the init process) and is created by a kernel-only API instead of sequences of clone from fork/exec system calls.
3. Two kernel threads have kthreadd as a parent. Apart from that, kernel threads enjoy the same "independence" one from another as userspace processes.
4. Use the kthread_run function/macro from the kthread.h header You will most probably have to write a kernel module in order to call this function, so you should take a look a the Linux Device Drivers
5. If you are referring to the text output of your implementation (via printk calls), you can see this output in the kernel log using the dmesg command.

Solution 3

user threads & stack:

Each thread has its own stack so that it can use its own local variables, thread’s share global variables which are part of .data or .bss sections of linux executable. Since threads share global variables i.e we use synchronization mechanisms like mutex when we want to access/modify global variables in multi threaded application. Local variables are part of thread individual stack, so no need of any synchronization.

Kernel threads Kernel threads have emerged from the need to run kernel code in process context. Kernel threads are the basis of the workqueue mechanism. Essentially, a thread kernel is a thread that only runs in kernel mode and has no user address space or other user attributes.

To create a thread kernel, use kthread_create():

#include <linux/kthread.h>

structure task_struct *kthread_create(int (*threadfn)(void *data),
                                      void *data, const char namefmt[], ...);

kernel threads & stack: Kernel threads are used to do post processing tasks for kernel like pdf flush threads, workq threads etc. Kernel threads are basically new process only without address space(can be created using clone() call with required flags), means they can’t switch to user-space. kernel threads are schedulable and preempt-able as normal processes.

kernel threads have their own stacks, which they use to manage local info.

More about kernel stacks:- https://www.kernel.org/doc/Documentation/x86/kernel-stacks

Solution 4

Since you're comparing kernel threads with user[land] threads, I assume you mean something like the following.

The normal way of implementing threads nowadays is to do it in the kernel, so those can be considered "normal" threads. It's however also possible to do it in userland, using signals such as SIGALRM, whose handler will save the current process state (registers, mostly) and change them to another one previously saved. Several OSes used this as a way to implement threads before they got proper kernel thread support. They can be faster, since you don't have to go into kernel mode, but in practice they've faded away.

There's also cooperative userland threads, where one thread runs until it calls a special function (usually called yield), which then switches to another thread in a similar way as with SIGALRM above. The advantage here is that the program is in total control, which can be useful when you have timing concerns (a game for example). You also don't have to care much about thread safety. The big disadvantage is that only one thread can run at a time, and therefore this method is also uncommon now that processors have multiple cores.

Kernel threads are implemented in the kernel. Perhaps you meant how to use them? The most common way is to call pthread_create.

View more solutions

Comments

[Ilya Matveychikov]

Just for the information task->mm for kernel thread is actually NULL.