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
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
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
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
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@kernelnewbies.org http://lists.kernelnewbies.org/mailman/listinfo/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@kernelnewbies.org http://lists.kernelnewbies.org/mailman/listinfo/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@kernelnewbies.org http://lists.kernelnewbies.org/mailman/listinfo/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....
participants (6)
-
Anatol Pomozov -
Kevin Wilson -
Silviu Popescu -
Srinivas Ganji -
Srivatsa S. Bhat -
Valdis.Kletnieks＠vt.edu