มีขีด จำกัด สูงสุดของจำนวนกระบวนการซอมบี้ที่คุณมีหรือไม่?


17

ฉันเคยทำงานกับระบบ HP-UX และผู้ดูแลระบบเก่าบอกฉันว่ามีจำนวน จำกัด ของกระบวนการซอมบี้ที่คุณมีในระบบฉันเชื่อว่า 1024

  • นี่เป็นเพดานจริงหรือเปล่า? ฉันคิดว่าคุณสามารถมีซอมบี้จำนวนเท่าใดก็ได้ราวกับว่าคุณมีกระบวนการจำนวนมาก ... ?
  • มันแตกต่างจาก distro ไป distro หรือไม่?
  • จะเกิดอะไรขึ้นถ้าเรามีขีด จำกัด สูงสุดและพยายามสร้างซอมบี้ตัวใหม่

1
ตามบทความบล็อกนี้ข้อ จำกัด เพียงอย่างเดียวของ Linux คือจำนวนของ PID ซึ่งมีผลต่อซอมบี้โดยบังเอิญ
bahamat

2
ulimit -uคำตอบทั้งสองข้างล่างนี้กล่าวถึง ผมสับสนในขณะที่เป็นman ulimitมีฉันประจำ C -uที่มีการกล่าวถึงไม่มี ulimit ที่กล่าวถึงในความเป็นจริงเป็นเครื่องมือทุบตีในตัวและมีการอธิบายไว้ใน manpage ทุบตี
Emanuel Berg

คำตอบ:


11

ฉันไม่ได้มี HP-UX ให้ฉันและฉันไม่เคยเป็นแฟนตัวยงของ HP-UX

ปรากฏว่าบน Linux ขีด จำกัด ต่อกระบวนการหรืออาจ จำกัด ต่อผู้ใช้ในจำนวนกระบวนการลูกที่มีอยู่ คุณสามารถดูได้ด้วยlimitZsh ในตัว (ดูเหมือนจะคล้ายกับulimit -uทุบตี):

1002 % limit
cputime         unlimited
filesize        unlimited
datasize        unlimited
stacksize       8MB
coredumpsize    0kB
memoryuse       unlimited
maxproc         16136
  ...

นั่นคือแล็ปท็อป Arch linux

ฉันเขียนโปรแกรมเล็ก ๆ เพื่อทดสอบขีด จำกัด นั้น:

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

volatile int sigchld_cnt = 0;

voida
sigchld_hdlr(int signo)
{
        ++sigchld_cnt;
}

int
main(int ac, char **av)
{
        int looping = 1;
        int child_cnt = 0;
        int status;

        signal(SIGCHLD, sigchld_hdlr);

        printf("Parent PID %d\n", getpid());

        while (looping)
        {
                switch (fork())
                {
                case 0:
                        _exit(0);
                        break;
                case -1:
                        fprintf(stderr, "Problem with fork(), %d children: %s\n",
                                child_cnt, strerror(errno));
                        looping = 0;
                        break;
                default:
                        ++child_cnt;
                        break;
                }
        }

        fprintf(stderr, "Sleeping, forked %d child processes\n", child_cnt);
        fprintf(stderr, "Received %d sigchild\n", sigchld_cnt);
        sleep(10);

        looping = 1;
        do {
                int x = wait(&status);

                if (x != -1)
                        --child_cnt;
                else if (errno != EINTR) {
                        fprintf(stderr, "wait() problem %d children left: \%s\n",
                                child_cnt, strerror(errno));
                        looping = 0;
                }
        } while (looping);

        printf("%d children left, %d SIGCHLD\n", child_cnt, sigchld_cnt);

        return 0;
}

มันยากที่จะประหลาดใจที่จะ "รวบรวม" ซอมบี้ทั้งหมดโดยเรียกwait(2)เวลาเพียงพอ นอกจากนี้จำนวนสัญญาณ SIGCHLD ที่ได้รับนั้นไม่เหมือนกันกับจำนวนของกระบวนการย่อย ๆ ที่มีเด็ก ๆ : ฉันเชื่อว่าบางครั้งเคอร์เนล linux จะส่ง 1 SIGCHLD สำหรับกระบวนการลูกที่ออกมาจำนวนหนึ่ง

อย่างไรก็ตามในแล็ปท็อป Arch linux ของฉันฉันได้รับกระบวนการลูก 16088 ทางแยกและนั่นจะต้องเป็นจำนวนซอมบี้เนื่องจากโปรแกรมไม่ทำงาน wait(2)เรียกระบบในตัวจัดการสัญญาณ

เมื่อวันที่ 12 Slackware เซิร์ฟเวอร์ของฉันฉันจะได้รับ 6076 maxproc 6079กระบวนการที่เด็กซึ่งใกล้เคียงกับค่าของ ID ผู้ใช้ของฉันมี 2 กระบวนการอื่นกำลังทำงานอยู่sshdและ Zsh พร้อมด้วยอินสแตนซ์แรกที่ไม่ใช่ซอมบี้ของโปรแกรมด้านบนที่สร้าง 6079

fork(2)เรียกระบบล้มเหลวโดยมีข้อผิดพลาด "ทรัพยากรไม่พร้อมใช้งานชั่วคราว" ฉันไม่เห็นหลักฐานอื่น ๆ ว่าทรัพยากรใดไม่พร้อมใช้งาน ฉันจะได้รับตัวเลขที่แตกต่างกันบ้างถ้าฉันรันโปรแกรมพร้อมกันใน xterms ที่ต่างกัน 2 ตัว แต่พวกมันจะรวมกันเป็นจำนวนเดียวกันเหมือนกับว่าฉันรันมันในหนึ่ง xterm ฉันคิดว่ามันเป็นรายการตารางกระบวนการหรือแลกเปลี่ยนหรือทรัพยากรทั่วทั้งระบบและไม่ได้เป็นเพียงข้อ จำกัด โดยพลการ

ฉันไม่ได้ลองทำอะไรอีกเลยในตอนนี้


4

ฉันไม่รู้ว่าขีด จำกัด ของ HP-UX คืออะไร ฉันสามารถบอกคุณได้ว่าการใช้งานเชิงตรรกะคือมีตารางกระบวนการที่มีขนาดสูงสุด จำนวนรายการตารางกระบวนการทั้งหมดถูก จำกัด ทางทฤษฎีโดยช่วงของ ID กระบวนการ แต่การนำไปใช้ส่วนใหญ่จะมีการ จำกัด ขนาดสำหรับตารางที่ให้ผลสูงสุดน้อยกว่ามาก ตัวแปร unix ส่วนใหญ่มีข้อ จำกัด ต่อผู้ใช้ตามจำนวนกระบวนการเช่นกัน คุณสามารถดูข้อ จำกัด โดยการทำงานulimit -uในทุบตี

ฉันไม่ได้คาดหวังว่าระบบยูนิกซ์จะมีข้อ จำกัด ในการแยกซอมบี้มากกว่าจำนวน ID กระบวนการ (ซึ่งรวมถึงกระบวนการจริงและซอมบี้) ดังนั้นเมื่อโปรเซสตายและกลายเป็นซอมบี้นั่นไม่ส่งผลกระทบต่อขีด จำกัด : ทรัพยากร (รายการในตารางโปรเซส) จะถูกจัดสรรเมื่อโปรเซสหยุดการทำงาน


2

ฉันคิดว่าคุณสามารถมีซอมบี้จำนวนเท่าใดก็ได้ราวกับว่าคุณมีกระบวนการจำนวนมาก ... ?

ในที่สุดกระบวนการซอมบี้ก็คือกระบวนการหนึ่ง - ในสถานะพิเศษ - กระบวนการซอมบี้นั้น จำกัด เฉพาะความพร้อมใช้งานและขนาดของตารางกระบวนการเช่นเดียวกับกระบวนการปกติ

มันแตกต่างจาก distro ไป distro หรือไม่?

แน่นอนพารามิเตอร์อื่น ๆ อีกมากมาย คุณไม่ควรส่งต่อขนาดที่เฉพาะเจาะจงหรือถ้ามันใหญ่พอที่จะเก็บกระบวนการซอมบี้จำนวนมาก หากคุณได้รับซอมบี้มากเกินไปทางออกไม่ได้เป็นตารางที่ใหญ่เพราะมันจะเต็มไปด้วยในที่สุด กระบวนการซอมบี้นั้นไม่ได้เลวร้ายเพียงอย่างเดียว แต่การมีกระบวนการซอมบี้ที่สะสมมากเกินไปนั้นเป็นตัวบ่งบอกถึงโปรแกรม "ประพฤติไม่ดี" ที่อนุญาตให้กระบวนการซอมบี้นั้น

จะเกิดอะไรขึ้นถ้าเรามีขีด จำกัด สูงสุดและพยายามสร้างซอมบี้ตัวใหม่

เมื่อตารางกระบวนการเต็ม - กระบวนการปกติและซอมบี้ - กระบวนการใหม่ที่ไม่สม่ำเสมอสามารถสร้างได้แม้ว่าระบบจะมีทรัพยากรเพียงพอ - หน่วยความจำตัวประมวลผล ฯลฯ - ทรัพยากรที่ขาดหายไปเพียงรายการเดียวในตารางกระบวนการ โปรแกรมที่ใช้งานอยู่แล้ว - ผู้ที่ "ประพฤติตนดี" - จะเริ่มต้นล้มเหลวเมื่อต้องการสร้างกระบวนการย่อย โปรแกรมใหม่ไม่สามารถเริ่มต้นได้และแม้แต่การรันคำสั่งเดียวก็ล้มเหลว


Even running single commands would fail.-> นั่นเป็นผลกระทบที่ยิ่งใหญ่
Shiplu Mokaddim
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.