2005-11-05 08:38:37

by Yan Zheng

[permalink] [raw]
Subject: Question about the usage of kernel_thread

Hi.

In LKD2, Robert say:
Linux delegates several tasks to kernel threads, most notably the pdflush task and the ksoftirqd task. These threads are created on system boot by other kernel threads. Indeed, a kernel thread can be created only by another kernel thread.


But I found that kernel_thread(...) are used wildly like:

#include <linux/kernel.h>
#include <linux/module.h>

static int noop(void *dummy)
{
printk("current->mm = %p\n", current->mm);
return 0;
}

static int test_init(void)
{
kernel_thread(noop, NULL, CLONE_KERNEL | SIGCHLD);
return 0;
}

static void test_exit(void) {}
module_init(test_init);
module_exit(test_exit);


In this circumstances, The thread created by kernel_thread has "current->mm != NULL".

My question is:
The new thread is truely kernel thread ? The usage of kernel_thread(...) like this is correct?

Thanks advance.
Best Regards



2005-11-05 11:31:39

by Fawad Lateef

[permalink] [raw]
Subject: Re: Question about the usage of kernel_thread

On 11/5/05, Yan Zheng <[email protected]> wrote:
> Hi.
>
> In LKD2, Robert say:
> Linux delegates several tasks to kernel threads, most notably the pdflush task and the ksoftirqd task. These threads are created on system boot by other kernel threads. Indeed, a kernel thread can be created only by another kernel thread.
>
>
> But I found that kernel_thread(...) are used wildly like:
>
> #include <linux/kernel.h>
> #include <linux/module.h>
>
> static int noop(void *dummy)
> {
> printk("current->mm = %p\n", current->mm);
> return 0;
> }
>
> static int test_init(void)
> {
> kernel_thread(noop, NULL, CLONE_KERNEL | SIGCHLD);
> return 0;
> }
>
> static void test_exit(void) {}
> module_init(test_init);
> module_exit(test_exit);
>
>
> In this circumstances, The thread created by kernel_thread has "current->mm != NULL".
>
> My question is:
> The new thread is truely kernel thread ? The usage of kernel_thread(...) like this is correct?
>

AFAIK the thread created like above is a true kernel thread but in
general practice what I saw and used that by creating thread from
init_module, the thread first call daemonize which actually drops the
mm related to thread and then through reparent_to_init it makes init
as a parent of the thread/process newly created. So after daemonize
call current->mm becomes NULL and when the scheduling is going to be
done the previous_process->mm will be used as the current->mm and
creating thread like above is correct.

--
Fawad Lateef

2005-11-05 12:20:43

by Yan Zheng

[permalink] [raw]
Subject: Re: Question about the usage of kernel_thread

>
> AFAIK the thread created like above is a true kernel thread but in
> general practice what I saw and used that by creating thread from
> init_module, the thread first call daemonize which actually drops the
> mm related to thread and then through reparent_to_init it makes init
> as a parent of the thread/process newly created. So after daemonize
> call current->mm becomes NULL and when the scheduling is going to be
> done the previous_process->mm will be used as the current->mm and
> creating thread like above is correct.
>
> --
> Fawad Lateef
> -

Thank you very much, Fawad.

I do additional test by follow codes, the result is strange.

========================================
#include <linux/kernel.h>
#include <linux/module.h>

static int noop(void *dummy)
{
int i = 0;
while(i++ < 10) {
printk("current->mm = %p\n", current->mm);
printk("current->active_mm = %p\n", current->active_mm);
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ);
}
return 0;
}

static void create_thread(void *dummy)
{
kernel_thread(noop, NULL, CLONE_KERNEL | SIGCHLD);
}

static struct work_struct work;

static int test_init(void)
{
INIT_WORK(&work, create_thread, NULL);
schedule_work(&work);
return 0;
}
/*
static int test_init(void)
{
kernel_thread(noop, NULL, CLONE_KERNEL | SIGCHLD);
return 0;
}
*/

static void test_exit(void) {}
module_init(test_init);
module_exit(test_exit);
========================================

If use kernel_thread like above. the output is:
current->mm = 00000000
current->active_mm = dffd2640
current->mm = 00000000
current->active_mm = df4d50e0
current->mm = 00000000
current->active_mm = df4463c0
current->mm = 00000000
current->active_mm = df4d50e0
current->mm = 00000000
current->active_mm = c16ee3e0
current->mm = 00000000
current->active_mm = df4463c0
current->mm = 00000000
current->active_mm = c16ee3e0
current->mm = 00000000
current->active_mm = c16ee3e0
current->mm = 00000000
current->active_mm = df796380
current->mm = 00000000
current->active_mm = c16ee3e0

if use kernel_thread directly in module_init(...). the output is:
current->mm = df988060
current->active_mm = df988060
current->mm = df988060
current->active_mm = df988060
current->mm = df988060
current->active_mm = df988060
current->mm = df988060
current->active_mm = df988060
current->mm = df988060
current->active_mm = df988060
current->mm = df988060
current->active_mm = df988060
current->mm = df988060
current->active_mm = df988060
current->mm = df988060
current->active_mm = df988060
current->mm = df988060
current->active_mm = df988060
current->mm = df988060
current->active_mm = df988060

Would you please do some explanation.

Best Regards

2005-11-05 12:54:38

by Fawad Lateef

[permalink] [raw]
Subject: Re: Question about the usage of kernel_thread

On 11/5/05, Yan Zheng <[email protected]> wrote:
>
> I do additional test by follow codes, the result is strange.
>
> ========================================
> #include <linux/kernel.h>
> #include <linux/module.h>
>
> static int noop(void *dummy)
> {
> int i = 0;
> while(i++ < 10) {
> printk("current->mm = %p\n", current->mm);
> printk("current->active_mm = %p\n", current->active_mm);
> set_current_state(TASK_INTERRUPTIBLE);
> schedule_timeout(HZ);
> }
> return 0;
> }
>
> static void create_thread(void *dummy)
> {
> kernel_thread(noop, NULL, CLONE_KERNEL | SIGCHLD);
> }
>
> static struct work_struct work;
>
> static int test_init(void)
> {
> INIT_WORK(&work, create_thread, NULL);
> schedule_work(&work);
> return 0;
> }
> /*
> static int test_init(void)
> {
> kernel_thread(noop, NULL, CLONE_KERNEL | SIGCHLD);
> return 0;
> }
> */
>
> static void test_exit(void) {}
> module_init(test_init);
> module_exit(test_exit);
> ========================================
>
> If use kernel_thread like above. the output is:
> current->mm = 00000000
> current->active_mm = dffd2640
> current->mm = 00000000
> current->active_mm = df4d50e0
> current->mm = 00000000
> current->active_mm = df4463c0
> current->mm = 00000000
> current->active_mm = df4d50e0
> current->mm = 00000000
> current->active_mm = c16ee3e0
> current->mm = 00000000
> current->active_mm = df4463c0
> current->mm = 00000000
> current->active_mm = c16ee3e0
> current->mm = 00000000
> current->active_mm = c16ee3e0
> current->mm = 00000000
> current->active_mm = df796380
> current->mm = 00000000
> current->active_mm = c16ee3e0
>
> if use kernel_thread directly in module_init(...). the output is:
> current->mm = df988060
> current->active_mm = df988060
> current->mm = df988060
> current->active_mm = df988060
> current->mm = df988060
> current->active_mm = df988060
> current->mm = df988060
> current->active_mm = df988060
> current->mm = df988060
> current->active_mm = df988060
> current->mm = df988060
> current->active_mm = df988060
> current->mm = df988060
> current->active_mm = df988060
> current->mm = df988060
> current->active_mm = df988060
> current->mm = df988060
> current->active_mm = df988060
> current->mm = df988060
> current->active_mm = df988060
>
> Would you please do some explanation.
>

The thread created from the code above (means from workqueue) are
by-default have init task as a parent process as init_workqueues
function is called during the booting process init
(http://sosdg.org/~coywolf/lxr/source/init/main.c#L657) from the
function do_basic_setup
(http://sosdg.org/~coywolf/lxr/source/init/main.c#L691) so the
workqueues have current->mm = NULL and when you creates a thread from
the workqueue it also get current->mm = NULL as of parent (workqueue
interface) and current->active_mm contains the mm of the previously
running process (running/scheduled before the current process which is
scheduled)

Whereas, when you create a kernel_thread from init_module it gets the
current->mm of the parent process (insmod is process in init_module
case) and during schedule if current->mm != NULL then the
current->active_mm remains same as that of current->mm, so for
creating a pure kernel thread from init_module daemonize must be
called from thread (I think I was wrong in my previous reply as i
wronggly said "the thread created like above is a true kernel thread")
else without calling daemonize (as I saw from your test) I guess you
can't get the full features of the kernel_thread (like not able to
access __complete__ kernel address space) (CMIIW)



--
Fawad Lateef