For catastrophe testing scenarios on out server environment we're looking for an easy way to make a process stuck in D (uninterruptible sleep) state.

Any easy ways? An example C sample code would be a plus :)

Edit - the first answer is semi-correct, as the process is shown to be in D state, but it still receives signals and can be killed


3 Answers 3


From https://blogs.oracle.com/ksplice/entry/disown_zombie_children_and_the

A process is put in an uninterruptible sleep (STAT D) when it needs to wait on something (typically I/O) and shouldn't be handling signals while waiting. This means you can't kill it, because all kill does is send it signals. This might happen in the real world if you unplug your NFS server while other machines have open network connections to it.

We can create our own uninterruptible processes of limited duration by taking advantage of the vfork system call. vfork is like fork, except the address space is not copied from the parent into the child, in anticipation of an exec which would just throw out the copied data. Conveniently for us, when you vfork the parent waits uninterruptibly (by way of wait_on_completion) on the child's exec or exit:

jesstess@aja:~$ cat uninterruptible.c 
int main() {
    return 0;
jesstess@aja:~$ gcc -o uninterruptible uninterruptible.c
jesstess@aja:~$ echo $$
jesstess@aja:~$ ./uninterruptible
and in another shell:

jesstess@aja:~$ ps -o ppid,pid,stat,cmd $(pgrep -f uninterruptible)

13291  1972 D+   ./uninterruptible
 1972  1973 S+   ./uninterruptible

We see the child (PID 1973, PPID 1972) in an interruptible sleep and the parent (PID 1972, PPID 13291 -- the shell) in an uninterruptible sleep while it waits for 60 seconds on the child.

One neat (mischievous?) thing about this script is that processes in an uninterruptible sleep contribute to the load average for a machine. So you could run this script 100 times to temporarily give a machine a load average elevated by 100, as reported by uptime.

  • Exactly what is was looking for! Thank you very much!
    – er453r
    Jun 8, 2014 at 20:26
  • 3
    the sad thing is that the process is in D state, but I am able to kill it with kill :/
    – er453r
    Jun 9, 2014 at 12:05
  • @er453r - sorry, man. I don't know much about it honestly - the answer was just a copy/paste which is why I set it as community wiki content. I read your question, was curious myself, then did some googling and turned up what I thought was some pretty interesting information. That's what you see above. But the votes and the rest don't contribute to my own reputation because it's wikied, and because I kind of stole it. Maybe there's more info on that page that could explain why?
    – mikeserv
    Jun 9, 2014 at 12:08
  • Thanks - I've read it just as you posted it. I've already searched the internet for this, but every one tries to get rid of this processes, not create them :P Generally, stack exchange is always the last resort for me :)
    – er453r
    Jun 9, 2014 at 12:29
  • Yea, I can still kill this as well :-/ Nov 7, 2018 at 19:48

I had the same problem and resolved it by creating a kernel module that gets stuck in D state.

As I don't have any experience in modules, I took the code from this turorial with some modifications found someplace esle.

The result is a device on /dev/memory that gets stuck on read but can be waken up writting on it (it needs two writes, I don't know why but I don't care).

To use it just:

# make
# make mknod
# make install
# cat /dev/memory   # this gets blocked

To unblock, from another terminal:

# echo -n a > /dev/memory
# echo -n a > /dev/memory


obj-m += memory.o

    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

    sudo insmod memory.ko

    sudo rmmod memory

    sudo mknod /dev/memory c 60 0
    sudo chmod 666 /dev/memory

Code for memory.c:

/* Necessary includes for device drivers */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/slab.h> /* kmalloc() */
#include <linux/fs.h> /* everything... */
#include <linux/errno.h> /* error codes */
#include <linux/types.h> /* size_t */
#include <linux/proc_fs.h>
#include <linux/fcntl.h> /* O_ACCMODE */
#include <asm/uaccess.h> /* copy_from/to_user */
#include <linux/sched.h>


/* Declaration of memory.c functions */
int memory_open(struct inode *inode, struct file *filp);
int memory_release(struct inode *inode, struct file *filp);
ssize_t memory_read(struct file *filp, char *buf, size_t count, loff_t *f_pos);
ssize_t memory_write(struct file *filp, char *buf, size_t count, loff_t *f_pos);
void memory_exit(void);
int memory_init(void);

/* Structure that declares the usual file */
/* access functions */
ssize_t memory_write( struct file *filp, char *buf, size_t count, loff_t *f_pos);
ssize_t memory_read(struct file *filp, char *buf, size_t count, loff_t *f_pos);
int memory_open(struct inode *inode, struct file *filp);
int memory_release(struct inode *inode, struct file *filp);
struct file_operations memory_fops = {
    .read = memory_read,
    .write = memory_write,
    .open = memory_open,
    .release = memory_release

/* Declaration of the init and exit functions */

/* Global variables of the driver */
/* Major number */
int memory_major = 60;
/* Buffer to store data */
char *memory_buffer;

int memory_init(void) {
    int result;

    /* Registering device */
    result = register_chrdev(memory_major, "memory", &memory_fops);
    if (result < 0) {
                "<1>memory: cannot obtain major number %d\n", memory_major);
        return result;

    /* Allocating memory for the buffer */
    memory_buffer = kmalloc(1, GFP_KERNEL); 
    if (!memory_buffer) { 
        result = -ENOMEM;
        goto fail; 
    memset(memory_buffer, 0, 1);

    printk("<1>Inserting memory module\n"); 
    return 0;

    return result;

void memory_exit(void) {
    /* Freeing the major number */
    unregister_chrdev(memory_major, "memory");

    /* Freeing buffer memory */
    if (memory_buffer) {

    printk("<1>Removing memory module\n");


int memory_open(struct inode *inode, struct file *filp) {

    /* Success */
    return 0;

int memory_release(struct inode *inode, struct file *filp) {

    /* Success */
    return 0;
static volatile int flag = 0;

ssize_t memory_read(struct file *filp, char *buf, 
        size_t count, loff_t *f_pos) { 

    printk("<1>going to sleep\n");
    flag = 0;
    //wait_event_interruptible(wq, flag != 0);
    wait_event(wq, flag != 0);

    printk("<1>Reading from memory module\n");
    /* Transfering data to user space */ 

    /* Changing reading position as best suits */ 
    if (*f_pos == 0) { 
        return 1; 
    } else { 
        return 0; 

ssize_t memory_write( struct file *filp, char *buf,
        size_t count, loff_t *f_pos) {

    char *tmp;

    printk("<1>wake someone up\n");
    flag = 1;

    printk("<1>Writting to memory module\n");
    return 1;

Basically, you can't. Read this article, titled: TASK_KILLABLE: New process state in Linux.


Linux® kernel 2.6.25 introduced a new process state for putting processes to sleep called TASK_KILLABLE, which offers an alternative to the efficient but potentially unkillable TASK_UNINTERRUPTIBLE and the easy-to-awaken but safer TASK_INTERRUPTIBLE.

This SO Q&A titled: What is an uninterruptable process? also explains it.

I discovered this in this very interesting book titled: The Linux Programming Interface: A Linux and UNIX System Programming Handbook.

  • 1
    That doesn't mean you can't produce an unkillable process. It just means that the number of system calls that are unkillable is dropping as those calls switch to using the new TASK_KILLABLE state. Jan 17, 2019 at 13:47

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.