सी ब्लॉक पर यूनिक्स पाइप पढ़ने पर

Question

मैं कक्षा के लिए पाइपलाइनों के साथ एक खोल लागू करने के लिए संघर्ष कर रहा हूं। पाइप लाइन में

typedef struct { 
    char** cmd; 
    int in[2]; 
    int out[2]; 
} cmdio; 

cmdio cmds[MAX_PIPE + 1]; 

आदेश पढ़ सकते हैं और cmds में संग्रहीत हैं।

cmdio[i].in इनपुट पाइप के फ़ाइल डिस्क्रिप्टर की जोड़ी pipe() द्वारा लौटा दी गई है। पहले कमांड के लिए, जो टर्मिनल इनपुट से पढ़ता है, यह सिर्फ {fileno (stdin), -1} है। cmdin[i].out आउटपुट पाइप/टर्मिनल आउटपुट के लिए समान है। cmdio[i].incmd[i-1].out जैसा ही है। उदाहरण के लिए: process_command अंदर अब

for (cmdi = 0; cmds[cmdi].cmd != NULL; cmdi++) { 
    process_command(&cmds[cmdi]); 
} 

,:

$ ls -l | sort | wc 

CMD: ls -l 
IN: 0 -1 
OUT: 3 4 

CMD: sort 
IN: 3 4 
OUT: 5 6 

CMD: wc 
IN: 5 6 
OUT: -1 1 

हम process_command करने के लिए प्रत्येक आदेश है, जो चीजों के एक नंबर करता है पारित

if (!(pid_fork = fork())) { 
    dup2(cmd->in[0], fileno(stdin)); 
    dup2(cmd->out[1], fileno(stdout));  
    if (cmd->in[1] >= 0) { 
     if (close(cmd->in[1])) { 
      perror(NULL); 
     } 
    } 
    if (cmd->out[0] >= 0) { 
     if (close(cmd->out[0])) { 
      perror(NULL); 
     } 
    } 
    execvp(cmd->cmd[0], cmd->cmd); 
    exit(-1); 
} 

समस्या से पढ़ कि है पाइप ब्लॉक हमेशा के लिए:

COMMAND $ ls | wc 
Created pipe, in: 5 out: 6 
Foreground pid: 9042, command: ls, Exited, info: 0 
[blocked running read() within wc] 

हैं, तो execvp साथ प्रक्रिया का आदान प्रदान करने के बजाय, मैं सिर्फ ऐसा करते हैं:

if (!(pid_fork = fork())) { 
    dup2(cmd->in[0], fileno(stdin)); 
    dup2(cmd->out[1], fileno(stdout)); 
    if (cmd->in[1] >= 0) { 
     if (close(cmd->in[1])) { 
      perror(NULL); 
     } 
    } 
    if (cmd->out[0] >= 0) { 
     if (close(cmd->out[0])) { 
      perror(NULL); 
     } 
    } 

    char buf[6]; 
    read(fileno(stdin), buf, 5); 
    buf[5] = '\0'; 

    printf("%s\n", buf); 
    exit(0); 
} 

यह काम करने के लिए होता है:

COMMAND $ cmd1 | cmd2 | cmd3 | cmd4 | cmd5 
Pipe creada, in: 11 out: 12 
Pipe creada, in: 13 out: 14 
Pipe creada, in: 15 out: 16 
Pipe creada, in: 17 out: 18 
hola! 
Foreground pid: 9251, command: cmd1, Exited, info: 0 
Foreground pid: 9252, command: cmd2, Exited, info: 0 
Foreground pid: 9253, command: cmd3, Exited, info: 0 
Foreground pid: 9254, command: cmd4, Exited, info: 0 
hola! 
Foreground pid: 9255, command: cmd5, Exited, info: 0 

क्या हो सकता है समस्या?

Answer 1

आपके पास पर्याप्त बंद नहीं है। कोड में:

if (!(pid_fork = fork())) { 
    dup2(cmd->in[0], fileno(stdin)); 
    dup2(cmd->out[1], fileno(stdout));  
    if (cmd->in[1] >= 0) { 
     if (close(cmd->in[1])) { 
      perror(NULL); 
     } 
    } 
    if (cmd->out[0] >= 0) { 
     if (close(cmd->out[0])) { 
      perror(NULL); 
     } 
    } 
    close(cmd->in[0]); // Or your error checked version, but I'd use a function 
    close(cmd->out[1]);  
    execvp(cmd->cmd[0], cmd->cmd); 
    exit(-1); 
} 

कार्यक्रमों परिष्करण नहीं कर रहे हैं क्योंकि वहाँ:

if (!(pid_fork = fork())) { 
    dup2(cmd->in[0], fileno(stdin)); 
    dup2(cmd->out[1], fileno(stdout));  
    if (cmd->in[1] >= 0) { 
     if (close(cmd->in[1])) { 
      perror(NULL); 
     } 
    } 
    if (cmd->out[0] >= 0) { 
     if (close(cmd->out[0])) { 
      perror(NULL); 
     } 
    } 
    execvp(cmd->cmd[0], cmd->cmd); 
    exit(-1); 
} 

के बाद आप stdin और stdout (fileno() के माध्यम से) के लिए पाइप दोहराया गया है, तो आप पाइप बंद करने की आवश्यकता फ़ाइल का एक लेखन अंत अभी भी खुला है। साथ ही, यह न भूलें कि यदि पैरेंट प्रक्रिया (खोल) पाइप बनाता है, तो इसे पाइप के दोनों सिरों को बंद करना होगा। पाइप के साथ नलसाजी सीखना शुरू करते समय पर्याप्त पाइप बंद नहीं करना शायद सबसे आम गलती है।

Answer 2

ठीक है, मैंने अंततः इसे हल किया।

माता पिता प्रक्रिया पर, बस पूरे बच्चे कांटा के बाद, मैं डाल:

f (cmd->in[0] != fileno(stdin)) { 
    close(cmd->in[0]); 
    close(cmd->in[1]); 
} 

और देखा। मैंने पहले ऐसा कुछ किया था लेकिन मैंने गलत टाइप किया और close(cmd->out[0]); इसके बजाए किया। तो यह बात है। यह अब समझ में आता है।