☰

D状態で終了できないプロセスシミュレーション

tag-icon • tag-icon process process-management benchmark
D状態で終了できないプロセスシミュレーション

サーバー環境の災害テストシナリオのために、プロセスをD（ノンストップスリープ）状態に切り替える簡単な方法を探しています。

簡単な方法がありますか？ Cサンプルコードもあればいいと思います:)

編集する- プロセスはD状態にあるとマークされていますが、まだ信号を受信して​​終了する可能性があるため、最初の答えは不正確です。

答え1

~からhttps://blogs.oracle.com/ksplice/entry/disown_zombie_children_and_the

プロセスは邪魔されない睡眠 (STAT D)何かを待たなければならないとき（通常I/O）そして待っている間、信号を処理しないでください。これはkill、Killが実行する操作がシグナルを送信するだけで、そうすることができないことを意味します。実際には、他のコンピュータがネットワークに接続されている間にNFSサーバーを切断すると、これが発生する可能性があります。

システムコールを活用して、vfork限られた期間中に中断されない独自のプロセスを作成できます。コピーされたデータがスローされると予想されるため、アドレス空間が親から子にコピーされないことを除いてvfork同様です。両親が待っている間私たちに便利forkexecvforkノンストップ（を通じてwait_on_completion）子供のexecまたはexit：

jesstess@aja:~$ cat uninterruptible.c 
int main() {
    vfork();
    sleep(60);
    return 0;
}
jesstess@aja:~$ gcc -o uninterruptible uninterruptible.c
jesstess@aja:~$ echo $$
13291
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

子プロセス（PID 1973, PPID 1972）は中断可能なスリープ状態にあり、親プロセス（PID 1972, PPID 13291--shell ）は子プロセスが60秒間待機している間中断できないスリープ状態にあることがわかります。

このスクリプトの1つのきちんとした（いたずらな）点は、中断されていないスリープ状態のプロセスがシステムの負荷平均に影響を与えることです。したがって、このスクリプトを100回実行して、コンピュータの負荷平均を一時的に100回増やすことができますuptime。

答え2

私は同じ問題があり、D状態になったカーネルモジュールを作成して解決しました。

私はモジュールの経験がないので、最初からこの伝説いくつかの修正が見つかりました。エルのどこかに。

その結果、/dev/memoryにあるデバイスは読み込み中に停止しますが、書き込みを行うと目覚めます（2回の書き込みが必要です。理由はわかりませんが関係ありません）。

ただ使用してください：

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

ブロックを解除するには、他の端末から：

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

ファイル生成：

obj-m += memory.o

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

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

install:
    sudo insmod memory.ko

uninstall:
    sudo rmmod memory

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

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>

MODULE_LICENSE("Dual BSD/GPL");

/* 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 */
module_init(memory_init);
module_exit(memory_exit);

/* 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) {
        printk(
                "<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;

fail: 
    memory_exit(); 
    return result;
}

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

    /* Freeing buffer memory */
    if (memory_buffer) {
        kfree(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 DECLARE_WAIT_QUEUE_HEAD(wq);
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 */ 
    copy_to_user(buf,memory_buffer,1);

    /* Changing reading position as best suits */ 
    if (*f_pos == 0) { 
        *f_pos+=1; 
        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;
    //wake_up_interruptible(&wq);
    wake_up(&wq);

    printk("<1>Writting to memory module\n");
    tmp=buf+count-1;
    copy_from_user(memory_buffer,tmp,1);
    return 1;
}

答え3

デフォルトではできません。次のタイトルの記事を読んでください。TASK_KILLABLE：Linuxの新しいプロセス状態。

抜粋

Linux® カーネル 2.6.25 では、プロセスをスリープ状態にするための TASK_KILLABLE という新しいプロセス状態が導入されました。これは、効率的ですが潜在的にシャットダウンできないTASK_UNINTERRUPTIBLEと目覚めやすく、より安全なTASK_INTERRUPTIBLEの代替手段を提供します。

このSO Q&Aのタイトルは次のとおりです。無中断プロセスとは何ですか？また説明します。

私は次の非常に興味深い本でこれを見つけました。Linuxプログラミングインタフェース：LinuxおよびUNIXシステムプログラミングマニュアル。

関連情報