लिनक्स पाइप युक्तियाँ और चालें

पाइप - यह क्या है?

cmd1 | cmd2 | .... | cmdN 

 $ grep -i “error” ./log | wc -l 43 

तर्क

साधारण डिबग

 $ strace -f bash -c '/bin/echo foo | grep bar' .... getpid() = 13726 <– PID   ... pipe([3, 4]) <–      .... clone(....) = 13727 <–      (echo) ... [pid 13727] execve("/bin/echo", ["/bin/echo", "foo"], [/* 61 vars */] ..... [pid 13726] clone(....) = 13728 <–     (grep)      ... [pid 13728] stat("/home/aikikode/bin/grep", ... 

 1242 pipeline: pipeline '|' newline_list pipeline 1243 { $$ = command_connect ($1, $4, '|'); } 1244 | pipeline BAR_AND newline_list pipeline 1245 { 1246 /* Make cmd1 |& cmd2 equivalent to cmd1 2>&1 | cmd2 */ 1247 COMMAND *tc; 1248 REDIRECTEE rd, sd; 1249 REDIRECT *r; 1250 1251 tc = $1->type == cm_simple ? (COMMAND *)$1->value.Simple : $1; 1252 sd.dest = 2; 1253 rd.dest = 1; 1254 r = make_redirection (sd, r_duplicating_output, rd, 0); 1255 if (tc->redirects) 1256 { 1257 register REDIRECT *t; 1258 for (t = tc->redirects; t->next; t = t->next) 1259 ; 1260 t->next = r; 1261 } 1262 else 1263 tc->redirects = r; 1264 1265 $$ = command_connect ($1, $4, '|'); 1266 } 1267 | command 1268 { $$ = $1; } 1269 ; 

 194 COMMAND * 195 command_connect (com1, com2, connector) 196 COMMAND *com1, *com2; 197 int connector; 198 { 199 CONNECTION *temp; 200 201 temp = (CONNECTION *)xmalloc (sizeof (CONNECTION)); 202 temp->connector = connector; 203 temp->first = com1; 204 temp->second = com2; 205 return (make_command (cm_connection, (SIMPLE_COM *)temp)); 206 } 

 2325 case '|': ... 2331 exec_result = execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close); 

 2112 prev = pipe_in; 2113 cmd = command; 2114 2115 while (cmd && cmd->type == cm_connection && 2116 cmd->value.Connection && cmd->value.Connection->connector == '|') 2117 { 2118 /*      */ 2119 if (pipe (fildes) < 0) 2120 { /*   */ } ....... /*     ,      prev —   ,     fildes[1] —   ,     pipe() */ 2178 execute_command_internal (cmd->value.Connection->first, asynchronous, 2179 prev, fildes[1], fd_bitmap); 2180 2181 if (prev >= 0) 2182 close (prev); 2183 2184 prev = fildes[0]; /*        */ 2185 close (fildes[1]); ....... 2190 cmd = cmd->value.Connection->second; /* “”      */ 2191 } 

 /*       .       /proc/sys/fs/pipe-max-size */ 35 unsigned int pipe_max_size = 1048576; /*    ,   POSIX     , .. 4 */ 40 unsigned int pipe_min_size = PAGE_SIZE; 869 int create_pipe_files(struct file **res, int flags) 870 { 871 int err; 872 struct inode *inode = get_pipe_inode(); 873 struct file *f; 874 struct path path; 875 static struct qstr name = {. name = “” }; /*  dentry  dcache */ 881 path.dentry = d_alloc_pseudo(pipe_mnt->mnt_sb, &name); /*     file.    FMODE_WRITE,     O_WRONLY, ..             .   O_NONBLOCK   . */ 889 f = alloc_file(&path, FMODE_WRITE, &pipefifo_fops); 893 f->f_flags = O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT)); /*      file   (. FMODE_READ   O_RDONLY) */ 896 res[0] = alloc_file(&path, FMODE_READ, &pipefifo_fops); 902 res[0]->f_flags = O_RDONLY | (flags & O_NONBLOCK); 903 res[1] = f; 904 return 0; 917 } 918 919 static int __do_pipe_flags(int *fd, struct file **files, int flags) 920 { 921 int error; 922 int fdw, fdr; /*   file     (.  ) */ 927 error = create_pipe_files(files, flags); /*     */ 931 fdr = get_unused_fd_flags(flags); 936 fdw = get_unused_fd_flags(flags); 941 audit_fd_pair(fdr, fdw); 942 fd[0] = fdr; 943 fd[1] = fdw; 944 return 0; 952 } /*    int pipe2(int pipefd[2], int flags)... */ 969 SYSCALL_DEFINE2(pipe2, int __user *, fildes, int, flags) 970 { 971 struct file *files[2]; 972 int fd[2]; /*    /     */ 975 __do_pipe_flags(fd, files, flags); /*     kernel space  user space */ 977 copy_to_user(fildes, fd, sizeof(fd)); /*       */ 984 fd_install(fd[0], files[0]); 985 fd_install(fd[1], files[1]); 989 } /* ... int pipe(int pipefd[2]),        pipe2   ; */ 991 SYSCALL_DEFINE1(pipe, int __user *, fildes) 992 { 993 return sys_pipe2(fildes, 0); 994 } 

  8 #define PIPE_BUF PAGE_SIZE 

 fcntl(fd, F_SETPIPE_SZ, <size>) 

टिप्स और ट्रिक्स

1. दोनों stdout और stderr को पाइप पर पुनर्निर्देशित करना

   
   

    ls -d ./Documents ./non-existent_file ./other_non-existent_file 2>&1 | egrep “Doc|other” ls: cannot access ./other_non-existent_file: No such file or directory ./Documents 

   या आप अक्षरों के संयोजन का उपयोग कर सकते हैं '| &' (आप इसके बारे में डॉक्यूमेंट से शेल (मैन बैश) और ऊपर के स्रोतों से, जहाँ हमने याक पार्सर बैश पर देखा था) के बारे में जान सकते हैं:
   

    ls -d ./Documents ./non-existent_file ./other_non-existent_file |& egrep “Doc|other” ls: cannot access ./other_non-existent_file: No such file or directory ./Documents 

   
   

2. अनुप्रेषित _only_ stderr से पाइप

   
   

    $ ls -d ./Documents ./non-existent_file ./other_non-existent_file 2>&1 >/dev/null | egrep “Doc|other” ls: cannot access ./other_non-existent_file: No such file or directory 

   अपने आप को पैर में गोली मारो
   स्टडआउट और स्टेडर पुनर्निर्देशन आदेश का पालन करना महत्वपूर्ण है। उदाहरण के लिए, संयोजन>> / देव / अशक्त 2> और 1 out दोनों stdout और stderr को / dev / null में पुनर्निर्देशित करेगा।
   
   

3. सही पाइपलाइन समाप्ति कोड प्राप्त करना

   
   डिफ़ॉल्ट रूप से, पाइपलाइन समाप्ति कोड पाइपलाइन में अंतिम कमांड का समाप्ति कोड है। उदाहरण के लिए, मूल कमांड लें, जो एक गैर-शून्य कोड के साथ समाप्त होती है:
   

    $ ls -d ./non-existent_file 2>/dev/null; echo $? 2 

   और इसे पाइप में डालें:
   

    $ ls -d ./non-existent_file 2>/dev/null | wc; echo $? 0 0 0 0 

   अब पाइपलाइन समाप्ति कोड wc कमांड समाप्ति कोड है, अर्थात 0।
   
   आमतौर पर, हमें यह जानना होगा कि क्या पाइपलाइन के निष्पादन के दौरान कोई त्रुटि हुई है। ऐसा करने के लिए, pipefail विकल्प सेट करें, जो शेल को बताता है कि पाइपलाइन समाप्ति कोड पाइपलाइन कमांड या शून्य में से किसी एक के पहले गैर-शून्य समाप्ति कोड के साथ मेल खाएगा यदि सभी कमांड सही तरीके से पूरा हो:
   

    $ set -o pipefail $ ls -d ./non-existent_file 2>/dev/null | wc; echo $? 0 0 0 2 

   अपने आप को पैर में गोली मारो
   "हानिरहित" आदेशों को ध्यान में रखें जो गैर-शून्य वापस कर सकते हैं। यह न केवल कन्वेयर के साथ काम करने के लिए लागू होता है। उदाहरण के लिए, grep उदाहरण पर विचार करें:
   

    $ egrep “^foo=[0-9]+” ./config | awk '{print “new_”$0;}' 

   यहां हम प्रत्येक पंक्ति की शुरुआत में 'new_' को प्राप्त करने वाली सभी लाइनों को प्रिंट करते हैं, या वांछित प्रारूप की कोई भी रेखा नहीं मिलने पर कुछ भी प्रिंट नहीं करते हैं। समस्या यह है कि अगर कोई मेल नहीं मिला, तो grep कोड 1 के साथ समाप्त हो जाता है, इसलिए यदि हमारी स्क्रिप्ट में pipefail विकल्प सेट है, तो यह उदाहरण कोड 1 के साथ समाप्त हो जाएगा:
   

    $ set -o pipefail $ egrep “^foo=[0-9]+” ./config | awk '{print “new_”$0;}' >/dev/null; echo $? 1 

   जटिल डिजाइन और लंबे कन्वेयर के साथ बड़ी स्क्रिप्ट में, इस बिंदु को अनदेखा किया जा सकता है, जिससे गलत परिणाम हो सकते हैं।
   
   

4. एक पाइपलाइन में चर के मूल्यों को सौंपना

   
   शुरू करने के लिए, हम याद करते हैं कि पाइपलाइन में सभी कमांडों को क्लोन () कहकर प्राप्त की गई अलग-अलग प्रक्रियाओं में निष्पादित किया जाता है। एक नियम के रूप में, यह समस्याओं का कारण नहीं बनता है, चर के मूल्यों को बदलने के मामलों के अपवाद के साथ।
   निम्नलिखित उदाहरण पर विचार करें:
   

    $ a=aaa $ b=bbb $ echo “one two” | read ab 

   हम उम्मीद करते हैं कि अब चर और बी के मान क्रमशः "एक" और "दो" होंगे। वास्तव में, वे "आ" और "बब्ब" रहेंगे। सामान्य तौर पर, इसके बाहर पाइप लाइन में चर के मूल्यों में कोई भी परिवर्तन चर को अपरिवर्तित छोड़ देगा:
   

    $ filefound=0 $ find . -type f -size +100k | while true do read f echo “$f is over 100KB” filefound=1 break #      done $ echo $filefound; 

   यहां तक ​​कि अगर कोई फ़ाइल 100Kb से बड़ी लगती है, तब भी फ़ाइलफ़ाउंड ध्वज का मान 0 होगा।
   इस समस्या के कई समाधान संभव हैं:
   
   • उपयोग करने के लिए

      set -- $var 

     
     यह निर्माण चर चर की सामग्री के अनुसार स्थितीय चर निर्धारित करता है। उदाहरण के लिए, जैसा कि ऊपर दिए गए पहले उदाहरण में है:
     

      $ var=”one two” $ set -- $var $ a=$1 # “one” $ b=$2 # “two” 

     यह ध्यान में रखना होगा कि स्क्रिप्ट में, मूल स्थितीय पैरामीटर जिसके साथ इसे बुलाया गया था, खो जाएगा।
   • पाइपलाइन में एक ही उपप्रकार के चर मूल्य को संसाधित करने के सभी तर्क को स्थानांतरित करें:
     

      $ echo “one” | (read a; echo $a;) one 

   • पाइपलाइन के अंदर चरों को असाइन करने से बचने के लिए तर्क बदलें।
     उदाहरण के लिए, हमारे उदाहरण को खोजने के साथ बदलें:
     

      $ filefound=0 $ for f in $(find . -type f -size +100k) #   ,     do read f echo “$f is over 100KB” filefound=1 break done $ echo $filefound; 

   • (केवल बैश-4.2 और नए के लिए) लास्टपाइप विकल्प का उपयोग करें
     लास्टपाइप विकल्प शेल को मुख्य प्रक्रिया में अंतिम पाइपलाइन कमांड को निष्पादित करने का निर्देश देता है।
     

      $ (shopt -s lastpipe; a=”aaa”; echo “one” | read a; echo $a) one 

     यह महत्वपूर्ण है कि लास्टपाइप विकल्प को कमांड लाइन पर उसी प्रक्रिया में सेट किया जाना चाहिए जहां इसी पाइपलाइन को बुलाया जाएगा, इसलिए ऊपर दिए गए उदाहरण में कोष्ठक की आवश्यकता है। लिपियों में, कोष्ठक वैकल्पिक हैं।

अतिरिक्त जानकारी

• कन्वेयर सिंटैक्स का विस्तृत विवरण: linux.die.net/man/1/bash (पाइपलाइन अनुभाग), या टर्मिनल में 'मैन बैश'।
• पाइपलाइन तर्क: linux.die.net/man/7/pipe या 'मैन 7 पाइप'
• bash शेल स्रोत कोड: ftp.gnu.org/gnu/bash , रिपॉजिटरी: git.savannah.gnu.org/cgit/bash.git
• लिनक्स कर्नेल: www.kernel.org