SIGKILL and a sleeping kernel module

SIGKILL and a sleeping kernel module

[Kevin Wilson]

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

SIGKILL and a sleeping kernel module

[Silviu Popescu]

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 

SIGKILL and a sleeping kernel module

[Srivatsa S. Bhat]

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
> 

SIGKILL and a sleeping kernel module

[Valdis.Kletnieks at vt.edu]

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 

SIGKILL and a sleeping kernel module

[Kevin Wilson]

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

SIGKILL and a sleeping kernel module

[Kevin Wilson]

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
>>
>

SIGKILL and a sleeping kernel module

[Mulyadi Santosa]

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

SIGKILL and a sleeping kernel module

[Anatol Pomozov]

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

SIGKILL and a sleeping kernel module

[Srinivas Ganji]

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 

SIGKILL and a sleeping kernel module

[Srinivas Ganji]

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