* SIGKILL and a sleeping kernel module
@ 2013-02-19 8:37 Kevin Wilson
2013-02-19 9:11 ` Silviu Popescu
` (2 more replies)
0 siblings, 3 replies; 10+ messages in thread
From: Kevin Wilson @ 2013-02-19 8:37 UTC (permalink / raw)
To: kernelnewbies
Hi all,
I am trying to send a SIGKILL to a kernel module which is sleeping.
I added a printk after the sleep command.
Sending a SIGLKILL (by kill -9 SIGLKILL pidOfKernelThread) does **not**
yield the message from printk("calling do_exit\n");
which is immediately after the msleep() command, as I expected.
Moreover, ps before and after the kill show 'D' in the STAT column
(STATUS), which means that the process is sleeping (If I am not
wrong).
Any ideas why ?
below is the code:
#include<linux/init.h>
#include<linux/module.h>
#include<linux/kernel.h>
#include<linux/kthread.h>
#include<linux/sched.h>
#include <linux/delay.h>
struct task_struct *task;
int thread_function(void *data)
{
int exit_sig = SIGKILL;
allow_signal(SIGKILL);
printk("in %s\n",__func__);
// sleep for a second
msleep(60000);
printk("calling do_exit\n");
do_exit(exit_sig);
return 0;
}
static int kernel_init(void)
{
task = kthread_create(thread_function,NULL,"MY_KERNEL_THREAD");
return 0;
}
static void kernel_exit(void)
{
printk("in kernel_exit\n");
kthread_stop(task);
}
module_init(kernel_init);
module_exit(kernel_exit);
MODULE_AUTHOR("Tester");
MODULE_DESCRIPTION("test");
MODULE_LICENSE("GPL");
rgs,
Kevin
^ permalink raw reply [flat|nested] 10+ messages in thread* SIGKILL and a sleeping kernel module 2013-02-19 8:37 SIGKILL and a sleeping kernel module Kevin Wilson @ 2013-02-19 9:11 ` Silviu Popescu 2013-02-19 9:16 ` Srivatsa S. Bhat 2013-02-19 10:33 ` Valdis.Kletnieks at vt.edu 2 siblings, 0 replies; 10+ messages in thread From: Silviu Popescu @ 2013-02-19 9:11 UTC (permalink / raw) To: kernelnewbies On Tue, Feb 19, 2013 at 10:37 AM, Kevin Wilson <wkevils@gmail.com> wrote: > Hi all, > I am trying to send a SIGKILL to a kernel module which is sleeping. > I added a printk after the sleep command. > Sending a SIGLKILL (by kill -9 SIGLKILL pidOfKernelThread) does **not** > yield the message from printk("calling do_exit\n"); > which is immediately after the msleep() command, as I expected. > > Moreover, ps before and after the kill show 'D' in the STAT column > (STATUS), which means that the process is sleeping (If I am not > wrong). > > Any ideas why ? > below is the code: > > #include<linux/init.h> > #include<linux/module.h> > #include<linux/kernel.h> > #include<linux/kthread.h> > #include<linux/sched.h> > #include <linux/delay.h> > > struct task_struct *task; > > int thread_function(void *data) > { > int exit_sig = SIGKILL; > > allow_signal(SIGKILL); > > printk("in %s\n",__func__); > // sleep for a second > msleep(60000); > printk("calling do_exit\n"); > do_exit(exit_sig); > > return 0; > } > > static int kernel_init(void) > { > task = kthread_create(thread_function,NULL,"MY_KERNEL_THREAD"); > return 0; > } > > static void kernel_exit(void) > { > printk("in kernel_exit\n"); > kthread_stop(task); > } > > > module_init(kernel_init); > module_exit(kernel_exit); > > MODULE_AUTHOR("Tester"); > MODULE_DESCRIPTION("test"); > MODULE_LICENSE("GPL"); > Hello Kevin! According to the man page of ps[1], the D state corresponds to an "Uninterruptible sleep (usually IO)". That means that signals (such as SIGKILL) will have no effect on the process. Your signal would have worked if the process was in the S state, which is interruptible sleep. Hope this helps a little. [1] http://linux.die.net/man/1/ps -- Silviu Popescu -------------- next part -------------- An HTML attachment was scrubbed... URL: http://lists.kernelnewbies.org/pipermail/kernelnewbies/attachments/20130219/ca43f65f/attachment.html ^ permalink raw reply [flat|nested] 10+ messages in thread
* SIGKILL and a sleeping kernel module 2013-02-19 8:37 SIGKILL and a sleeping kernel module Kevin Wilson 2013-02-19 9:11 ` Silviu Popescu @ 2013-02-19 9:16 ` Srivatsa S. Bhat 2013-02-19 11:32 ` Kevin Wilson 2013-02-19 19:54 ` Anatol Pomozov 2013-02-19 10:33 ` Valdis.Kletnieks at vt.edu 2 siblings, 2 replies; 10+ messages in thread From: Srivatsa S. Bhat @ 2013-02-19 9:16 UTC (permalink / raw) To: kernelnewbies On 02/19/2013 02:07 PM, Kevin Wilson wrote: > Hi all, > I am trying to send a SIGKILL to a kernel module which is sleeping. > I added a printk after the sleep command. > Sending a SIGLKILL (by kill -9 SIGLKILL pidOfKernelThread) does **not** > yield the message from printk("calling do_exit\n"); > which is immediately after the msleep() command, as I expected. > > Moreover, ps before and after the kill show 'D' in the STAT column > (STATUS), which means that the process is sleeping (If I am not > wrong). > > Any ideas why ? There are 2 ways in which a task can sleep - interruptible sleep and uninterruptible sleep. Interruptible sleep means, the task can get interrupted by a signal. A task doing uninterruptible sleep doesn't get woken up by any signal. The 'D' state indicates that the task is doing uninterruptible sleep, that's why your signals aren't working. Regards, Srivatsa S. Bhat > below is the code: > > #include<linux/init.h> > #include<linux/module.h> > #include<linux/kernel.h> > #include<linux/kthread.h> > #include<linux/sched.h> > #include <linux/delay.h> > > struct task_struct *task; > > int thread_function(void *data) > { > int exit_sig = SIGKILL; > > allow_signal(SIGKILL); > > printk("in %s\n",__func__); > // sleep for a second > msleep(60000); > printk("calling do_exit\n"); > do_exit(exit_sig); > > return 0; > } > > static int kernel_init(void) > { > task = kthread_create(thread_function,NULL,"MY_KERNEL_THREAD"); > return 0; > } > > static void kernel_exit(void) > { > printk("in kernel_exit\n"); > kthread_stop(task); > } > > > module_init(kernel_init); > module_exit(kernel_exit); > > MODULE_AUTHOR("Tester"); > MODULE_DESCRIPTION("test"); > MODULE_LICENSE("GPL"); > > rgs, > Kevin > ^ permalink raw reply [flat|nested] 10+ messages in thread
* SIGKILL and a sleeping kernel module 2013-02-19 9:16 ` Srivatsa S. Bhat @ 2013-02-19 11:32 ` Kevin Wilson [not found] ` <5123643C.1000907@linux.vnet.ibm.com> 2013-02-20 6:29 ` Srinivas Ganji 2013-02-19 19:54 ` Anatol Pomozov 1 sibling, 2 replies; 10+ messages in thread From: Kevin Wilson @ 2013-02-19 11:32 UTC (permalink / raw) To: kernelnewbies Hi, Thanks about the info about ps. This raises two new questions: 1) The following code is a very basic kernel module (based on my previous code, removing somethings). I do not understand something: I call /* sleep for a millisecond */ msleep(1); printk("calling do_exit\n"); msleep(60000); In my understanding, after 1 millisecond, it should have been available to the scheduler, and after returning to the line after msleep(1), it should print "calling do_exit". However, I see no such log message. Any ideas why ? can something be added to enable this ? 2)How can I create a kernel thread so that it will be in TASK_INTERRUPTIBLE state ? there must be a way, since I see many kernel threads where ps shows "S" in the status coumn. struct task_struct *task; int thread_function(void *data) { int exit_sig = SIGKILL; printk("in %s\n",__func__); /* sleep for a millisecond */ msleep(1); printk("calling do_exit\n"); msleep(60000); do_exit(exit_sig); return 0; } static int kernel_init(void) { printk("in kernel_init\n"); task = kthread_create(thread_function,NULL,"MY_KERNEL_THREAD"); return 0; } static void kernel_exit(void) { printk("in kernel_exit\n"); kthread_stop(task); } module_init(kernel_init); module_exit(kernel_exit); rgs Kevin ^ permalink raw reply [flat|nested] 10+ messages in thread
[parent not found: <5123643C.1000907@linux.vnet.ibm.com>]
* SIGKILL and a sleeping kernel module [not found] ` <5123643C.1000907@linux.vnet.ibm.com> @ 2013-02-19 12:00 ` Kevin Wilson 2013-02-19 18:55 ` Mulyadi Santosa 0 siblings, 1 reply; 10+ messages in thread From: Kevin Wilson @ 2013-02-19 12:00 UTC (permalink / raw) To: kernelnewbies Hi, 1) changing to msleep_interruptible() did not change the situation. 2) What is strange is that I *do* see the printk messages of kernel_init/kernel_exit, but I do not see the printk messages in the thread function, thread_function() (also before the first mslee()/msleep_interruptible() ). And they are the same printk level; I also tried with printk(KERN_ERR.. in the thread_function(), but it did not help. Any ideas what can be the problem ? I will really appreciate if somebody will try to create a kernel thread and add printk inside the kernel method and look if it does print anything, Rgs, Kevin On Tue, Feb 19, 2013 at 1:38 PM, Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com> wrote: > On 02/19/2013 05:02 PM, Kevin Wilson wrote: >> Hi, >> >> Thanks about the info about ps. >> This raises two new questions: >> 1) The following code is a very basic kernel module (based on my >> previous code, removing somethings). >> I do not understand something: >> I call >> /* sleep for a millisecond */ >> msleep(1); >> printk("calling do_exit\n"); >> msleep(60000); >> >> In my understanding, after 1 millisecond, it should have been >> available to the scheduler, and after returning to the line after >> msleep(1), it should print "calling do_exit". However, >> I see no such log message. Any ideas why ? can something be >> added to enable this ? >> > > Are you sure your settings related to logging are fine? IOW, is this > the only print you are not seeing, or are you not seeing *any* > printk messages? > >> 2)How can I create a kernel thread so that it will be in >> TASK_INTERRUPTIBLE state ? there must be a way, >> since I see many kernel threads where ps shows "S" in the >> status coumn. >> > > Try using msleep_interruptible(). > > Regards, > Srivatsa S. Bhat > >> >> struct task_struct *task; >> >> int thread_function(void *data) >> { >> int exit_sig = SIGKILL; >> >> printk("in %s\n",__func__); >> /* sleep for a millisecond */ >> msleep(1); >> printk("calling do_exit\n"); >> msleep(60000); >> do_exit(exit_sig); >> >> return 0; >> } >> >> static int kernel_init(void) >> { >> printk("in kernel_init\n"); >> task = kthread_create(thread_function,NULL,"MY_KERNEL_THREAD"); >> return 0; >> } >> >> static void kernel_exit(void) >> { >> printk("in kernel_exit\n"); >> kthread_stop(task); >> } >> >> >> module_init(kernel_init); >> module_exit(kernel_exit); >> >> >> rgs >> Kevin >> > ^ permalink raw reply [flat|nested] 10+ messages in thread
* SIGKILL and a sleeping kernel module 2013-02-19 12:00 ` Kevin Wilson @ 2013-02-19 18:55 ` Mulyadi Santosa 0 siblings, 0 replies; 10+ messages in thread From: Mulyadi Santosa @ 2013-02-19 18:55 UTC (permalink / raw) To: kernelnewbies On Tue, Feb 19, 2013 at 7:00 PM, Kevin Wilson <wkevils@gmail.com> wrote: > Hi, > 1) changing to msleep_interruptible() did not change the situation. > 2) What is strange is that I *do* see the printk messages > of kernel_init/kernel_exit, but I do not see the printk messages > in the thread function, thread_function() (also before the first > mslee()/msleep_interruptible() ). > And they are the same printk level; I also tried with > printk(KERN_ERR.. > in the thread_function(), but it did not help. Please don't top post, ok :) BTW, maybe you don't such message because your thread hasn't running yet. IMHO you need to use kthread_run(). Kindly check this: http://lxr.linux.no/linux+*/include/linux/kthread.h#L31 -- regards, Mulyadi Santosa Freelance Linux trainer and consultant blog: the-hydra.blogspot.com training: mulyaditraining.blogspot.com ^ permalink raw reply [flat|nested] 10+ messages in thread
* SIGKILL and a sleeping kernel module 2013-02-19 11:32 ` Kevin Wilson [not found] ` <5123643C.1000907@linux.vnet.ibm.com> @ 2013-02-20 6:29 ` Srinivas Ganji 2013-02-20 6:33 ` Srinivas Ganji 1 sibling, 1 reply; 10+ messages in thread From: Srinivas Ganji @ 2013-02-20 6:29 UTC (permalink / raw) To: kernelnewbies On Tue, Feb 19, 2013 at 5:02 PM, Kevin Wilson <wkevils@gmail.com> wrote: > Hi, > > Thanks about the info about ps. > This raises two new questions: > 1) The following code is a very basic kernel module (based on my > previous code, removing somethings). > I do not understand something: > I call > /* sleep for a millisecond */ > msleep(1); > printk("calling do_exit\n"); > msleep(60000); > > In my understanding, after 1 millisecond, it should have been > available to the scheduler, and after returning to the line after > msleep(1), it should print "calling do_exit". However, > I see no such log message. Any ideas why ? can something be > added to enable this ? > > 2)How can I create a kernel thread so that it will be in > TASK_INTERRUPTIBLE state ? there must be a way, > since I see many kernel threads where ps shows "S" in the > status coumn. > > > struct task_struct *task; > > int thread_function(void *data) > { > int exit_sig = SIGKILL; > > printk("in %s\n",__func__); > /* sleep for a millisecond */ > msleep(1); > printk("calling do_exit\n"); > msleep(60000); > do_exit(exit_sig); > > return 0; > } > > static int kernel_init(void) > { > printk("in kernel_init\n"); > task = kthread_create(thread_function,NULL,"MY_KERNEL_THREAD"); > return 0; > } > > static void kernel_exit(void) > { > printk("in kernel_exit\n"); > kthread_stop(task); > } > > > module_init(kernel_init); > module_exit(kernel_exit); > > > rgs > Kevin > > After creating the kernel thread, you can use wake_up_process(task) call which will run your thread function. Generally, when we create a kernel thread using kthread_create, > _______________________________________________ > Kernelnewbies mailing list > Kernelnewbies at kernelnewbies.org > http://lists.kernelnewbies.org/mailman/listinfo/kernelnewbies > -------------- next part -------------- An HTML attachment was scrubbed... URL: http://lists.kernelnewbies.org/pipermail/kernelnewbies/attachments/20130220/2c97dc9f/attachment-0001.html ^ permalink raw reply [flat|nested] 10+ messages in thread
* SIGKILL and a sleeping kernel module 2013-02-20 6:29 ` Srinivas Ganji @ 2013-02-20 6:33 ` Srinivas Ganji 0 siblings, 0 replies; 10+ messages in thread From: Srinivas Ganji @ 2013-02-20 6:33 UTC (permalink / raw) To: kernelnewbies On Wed, Feb 20, 2013 at 11:59 AM, Srinivas Ganji < srinivasganji.kernel@gmail.com> wrote: > > On Tue, Feb 19, 2013 at 5:02 PM, Kevin Wilson <wkevils@gmail.com> wrote: > >> Hi, >> >> Thanks about the info about ps. >> This raises two new questions: >> 1) The following code is a very basic kernel module (based on my >> previous code, removing somethings). >> I do not understand something: >> I call >> /* sleep for a millisecond */ >> msleep(1); >> printk("calling do_exit\n"); >> msleep(60000); >> >> In my understanding, after 1 millisecond, it should have been >> available to the scheduler, and after returning to the line after >> msleep(1), it should print "calling do_exit". However, >> I see no such log message. Any ideas why ? can something be >> added to enable this ? >> >> 2)How can I create a kernel thread so that it will be in >> TASK_INTERRUPTIBLE state ? there must be a way, >> since I see many kernel threads where ps shows "S" in the >> status coumn. >> >> >> struct task_struct *task; >> >> int thread_function(void *data) >> { >> int exit_sig = SIGKILL; >> >> printk("in %s\n",__func__); >> /* sleep for a millisecond */ >> msleep(1); >> printk("calling do_exit\n"); >> msleep(60000); >> do_exit(exit_sig); >> >> return 0; >> } >> >> static int kernel_init(void) >> { >> printk("in kernel_init\n"); >> task = kthread_create(thread_function,NULL,"MY_KERNEL_THREAD"); >> return 0; >> } >> >> static void kernel_exit(void) >> { >> printk("in kernel_exit\n"); >> kthread_stop(task); >> } >> >> >> module_init(kernel_init); >> module_exit(kernel_exit); >> >> >> rgs >> Kevin >> >> > After creating the kernel thread, you can use wake_up_process(task) call > which will run your thread function. > > Generally, when we create a kernel thread using kthread_create, > the process is created in an unrunnable state. It will not start running until explicitly woken up via wake_up_process(). The kthread_create() followed by wake_up_process() is done by a single call kthread_run(). I hope this helps you. Regards Srinivas G. > > >> _______________________________________________ >> Kernelnewbies mailing list >> Kernelnewbies at kernelnewbies.org >> http://lists.kernelnewbies.org/mailman/listinfo/kernelnewbies >> > > -------------- next part -------------- An HTML attachment was scrubbed... URL: http://lists.kernelnewbies.org/pipermail/kernelnewbies/attachments/20130220/4cf6e7d6/attachment.html ^ permalink raw reply [flat|nested] 10+ messages in thread
* SIGKILL and a sleeping kernel module 2013-02-19 9:16 ` Srivatsa S. Bhat 2013-02-19 11:32 ` Kevin Wilson @ 2013-02-19 19:54 ` Anatol Pomozov 1 sibling, 0 replies; 10+ messages in thread From: Anatol Pomozov @ 2013-02-19 19:54 UTC (permalink / raw) To: kernelnewbies Hi On Tue, Feb 19, 2013 at 1:16 AM, Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com> wrote: > On 02/19/2013 02:07 PM, Kevin Wilson wrote: >> Hi all, >> I am trying to send a SIGKILL to a kernel module which is sleeping. >> I added a printk after the sleep command. >> Sending a SIGLKILL (by kill -9 SIGLKILL pidOfKernelThread) does **not** >> yield the message from printk("calling do_exit\n"); >> which is immediately after the msleep() command, as I expected. >> >> Moreover, ps before and after the kill show 'D' in the STAT column >> (STATUS), which means that the process is sleeping (If I am not >> wrong). >> >> Any ideas why ? > > There are 2 ways in which a task can sleep - interruptible sleep and > uninterruptible sleep. Interruptible sleep means, the task can get > interrupted by a signal. A task doing uninterruptible sleep doesn't > get woken up by any signal. The 'D' state indicates that the task is > doing uninterruptible sleep, that's why your signals aren't working. There is one more sleeping state: killable sleep. It is like uninterruptable sleep that can be interrupted only with SIGKILL. http://lwn.net/Articles/288056/ > > Regards, > Srivatsa S. Bhat > >> below is the code: >> >> #include<linux/init.h> >> #include<linux/module.h> >> #include<linux/kernel.h> >> #include<linux/kthread.h> >> #include<linux/sched.h> >> #include <linux/delay.h> >> >> struct task_struct *task; >> >> int thread_function(void *data) >> { >> int exit_sig = SIGKILL; >> >> allow_signal(SIGKILL); >> >> printk("in %s\n",__func__); >> // sleep for a second >> msleep(60000); >> printk("calling do_exit\n"); >> do_exit(exit_sig); >> >> return 0; >> } >> >> static int kernel_init(void) >> { >> task = kthread_create(thread_function,NULL,"MY_KERNEL_THREAD"); >> return 0; >> } >> >> static void kernel_exit(void) >> { >> printk("in kernel_exit\n"); >> kthread_stop(task); >> } >> >> >> module_init(kernel_init); >> module_exit(kernel_exit); >> >> MODULE_AUTHOR("Tester"); >> MODULE_DESCRIPTION("test"); >> MODULE_LICENSE("GPL"); >> >> rgs, >> Kevin >> > > > _______________________________________________ > Kernelnewbies mailing list > Kernelnewbies at kernelnewbies.org > http://lists.kernelnewbies.org/mailman/listinfo/kernelnewbies ^ permalink raw reply [flat|nested] 10+ messages in thread
* SIGKILL and a sleeping kernel module 2013-02-19 8:37 SIGKILL and a sleeping kernel module Kevin Wilson 2013-02-19 9:11 ` Silviu Popescu 2013-02-19 9:16 ` Srivatsa S. Bhat @ 2013-02-19 10:33 ` Valdis.Kletnieks at vt.edu 2 siblings, 0 replies; 10+ messages in thread From: Valdis.Kletnieks at vt.edu @ 2013-02-19 10:33 UTC (permalink / raw) To: kernelnewbies On Tue, 19 Feb 2013 10:37:28 +0200, Kevin Wilson said: > Hi all, > I am trying to send a SIGKILL to a kernel module which is sleeping. > I added a printk after the sleep command. > Sending a SIGLKILL (by kill -9 SIGLKILL pidOfKernelThread) does **not** > yield the message from printk("calling do_exit\n"); > which is immediately after the msleep() command, as I expected. Others have mentioned the various types of sleeping in the kernel, but overlooked a minor detail. If a task is in the kernel in a non-interruptible state, signals are queued and delivered once that status is cleared (which often doesn't happen until a syscall is about to return to userspace). The reason this detail is important for would-be kernel hackers: If one kernel thread manages to BUG() or oops() or otherwise die or wedge up while holding a lock, other processes can end up blocking while waiting for the lock. The problem is that the other processes are usually in non-interruptible state when they try to take the lock. The end result is that you end up with processes that are blocked in the kernel, and you can't kill -9 them - you're basically stuck with them until you reboot. This is why your system will often limp along and slowly become more and more wedged up after a BUG(). Also - the fact that /bin/ps shows a D or S does *not* in fact mean the process is in a sleep state inside the kernel. That's *usually* the case, but it's quite possible for the code to be actively executing and burning lots of CPU (often because it's stuck in a loop that's failing to make forward progress). The result there is that ps shows a D/S but your CPU starts getting *very* warm.... -------------- next part -------------- A non-text attachment was scrubbed... Name: not available Type: application/pgp-signature Size: 865 bytes Desc: not available Url : http://lists.kernelnewbies.org/pipermail/kernelnewbies/attachments/20130219/7ecb86c2/attachment.bin ^ permalink raw reply [flat|nested] 10+ messages in thread
end of thread, other threads:[~2013-02-20 6:33 UTC | newest]
Thread overview: 10+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2013-02-19 8:37 SIGKILL and a sleeping kernel module Kevin Wilson
2013-02-19 9:11 ` Silviu Popescu
2013-02-19 9:16 ` Srivatsa S. Bhat
2013-02-19 11:32 ` Kevin Wilson
[not found] ` <5123643C.1000907@linux.vnet.ibm.com>
2013-02-19 12:00 ` Kevin Wilson
2013-02-19 18:55 ` Mulyadi Santosa
2013-02-20 6:29 ` Srinivas Ganji
2013-02-20 6:33 ` Srinivas Ganji
2013-02-19 19:54 ` Anatol Pomozov
2013-02-19 10:33 ` Valdis.Kletnieks at vt.edu
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.