Return to pipe CVS log

Up to [MW Coherent from dump] / coherent / a / usr / man / COHERENT

Annotation of coherent/a/usr/man/COHERENT/pipe, revision 1.1.1.1

1.1       root        1: 
                      2: 
                      3: pipe()                 COHERENT System Call                pipe()
                      4: 
                      5: 
                      6: 
                      7: 
                      8: Open a pipe
                      9: 
                     10: iinntt ppiippee(_f_d)
                     11: iinntt _f_d[22];
                     12: 
                     13: A pipe is  an interprocess communication mechanism.  pipe creates
                     14: a pipe, typically to construct pipelines in the shell sh.
                     15: 
                     16: pipe fills  in fd[0] and fd[1] with read  and write file descrip-
                     17: tors, respectively.   The file descriptors allow  the transfer of
                     18: data from one or more writers  to one or more readers.  Pipes are
                     19: buffered to  5,120 bytes.  If  more than 5,120  bytes are written
                     20: into the  pipe, the write  call will not return  until the reader
                     21: has removed sufficient data for the write to complete.  If a read
                     22: occurs on  an empty  pipe, its  completion awaits the  writing of
                     23: data.
                     24: 
                     25: When all writing processe close their write file descriptors, the
                     26: reader receives  an end  of file indication.   A write on  a pipe
                     27: with  no remaining  readers  generates a  SIGPIPE  signal to  the
                     28: caller.
                     29: 
                     30: pipe is  generally called just before fork.   Once the parent and
                     31: child processes  are created, the unused  file descriptors should
                     32: be closed in each process.
                     33: 
                     34: ***** Example *****
                     35: 
                     36: The following  example prints  the word  Waiting until a  line of
                     37: data  is entered.   It illustrates  how to  use pipe,  fstat, and
                     38: fork.
                     39: 
                     40: 
                     41: #include <stdio.h>
                     42: #include <sys/stat.h>
                     43: 
                     44: 
                     45: 
                     46: main()
                     47: {
                     48:         struct stat s;
                     49:         char buff[10];
                     50:         int fd[2];
                     51: 
                     52: 
                     53: 
                     54:         if(pipe(fd) == -1) {
                     55:                 fprintf(stderr, "Cannot open pipe");
                     56:                 exit(1);
                     57:         }
                     58: 
                     59: 
                     60: 
                     61: 
                     62: 
                     63: 
                     64: COHERENT Lexicon                                           Page 1
                     65: 
                     66: 
                     67: 
                     68: 
                     69: pipe()                 COHERENT System Call                pipe()
                     70: 
                     71: 
                     72: 
                     73:         if(!fork()) { /* child process */
                     74:                 buff[0] = getchar(); /* wait for the keyboard */
                     75:                 write(fd[1], buff, 1); /* childs copy of buff */
                     76:                 exit(0);
                     77:         }
                     78: 
                     79: 
                     80: 
                     81:         for(;;) { /* parent process. */
                     82:                 fstat(fd[0], &s);
                     83:                 if(s.st_size) { /* char in the pipe */
                     84:                         read(fd[0], buff, 1); /* parents copy */
                     85:                         printf("Got data\n");
                     86:                         exit(0);
                     87:                 }
                     88: 
                     89: 
                     90: 
                     91:                 printf("Waiting\n");
                     92:         }
                     93: }
                     94: 
                     95: 
                     96: ***** See Also *****
                     97: 
                     98: close(),  COHERENT system calls,  mknod(), read(),  sh, signal(),
                     99: write()
                    100: 
                    101: ***** Diagnostics *****
                    102: 
                    103: pipe  returns zero  on successful  calls, or -1  if it  could not
                    104: create the pipe.
                    105: 
                    106: If it  is necessary to create  a pipe between tasks  that are not
                    107: parent and  child, use /etc/mknod to create  a named pipe.  These
                    108: named pipes can be opened and used by different programs for com-
                    109: munication.  Remember to  give them the correct owner and permis-
                    110: sions.
                    111: 
                    112: 
                    113: 
                    114: 
                    115: 
                    116: 
                    117: 
                    118: 
                    119: 
                    120: 
                    121: 
                    122: 
                    123: 
                    124: 
                    125: 
                    126: 
                    127: 
                    128: 
                    129: 
                    130: COHERENT Lexicon                                           Page 2
                    131: 
                    132: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.