blp 4th edition-Chapter 13-Inter Process Communication:Pipes

 Pipe：connecting a data flow from one process to another

进程管道：Process Pipes

FILE * popen(const char command,const char *open_mode);

command：the name of the program to run

open_mode:must be "r" or "w"

int pclose(FILE * stream_to_close);

#include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> int main() { FILE *read_fp; char buffer[BUFSIZ + 1]; int chars_read; memset(buffer, '/0', sizeof(buffer)); read_fp = popen("ps ax", "r"); if (read_fp != NULL) { chars_read = fread(buffer, sizeof(char), BUFSIZ/10, read_fp); while (chars_read > 0) { buffer[chars_read - 1] = '/0'; printf("Reading %d:-/n %s/n", BUFSIZ/10, buffer); chars_read = fread(buffer, sizeof(char), BUFSIZ/10, read_fp); } pclose(read_fp); exit(EXIT_SUCCESS); } exit(EXIT_FAILURE); }

1.popen首先invoke shell：sh 然后将command传递给sh执行，所以popen可以用来执行复杂的shell 命令如cat popen*.c | wc -l

而其他的如execl can be much more complex to invoke,becaut the calling process has to perfom its own shell expansion

2.但popen调用起来花费较大。

 

---

Pipe 系统调用

 

int pipe(int file_descriptor[2]);

从file_descriptor[1] 写 从file_descriptor[0]读

因为是文件描述符，所以用read和write来读写，而不是fwrite fread

通常我们可以用fork创建新的process，然后在两个process之间传递数据

比如下面的例子

#include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> int main() { int data_processed; int file_pipes[2]; const char some_data[] = "123"; char buffer[BUFSIZ + 1]; pid_t fork_result; memset(buffer, '/0', sizeof(buffer)); if (pipe(file_pipes) == 0) { fork_result = fork(); if (fork_result == -1) { fprintf(stderr, "Fork failure"); exit(EXIT_FAILURE); } // We've made sure the fork worked, so if fork_result equals zero, we're in the child process. if (fork_result == 0) { data_processed = read(file_pipes[0], buffer, BUFSIZ); printf("Read %d bytes: %s/n", data_processed, buffer); exit(EXIT_SUCCESS); } // Otherwise, we must be the parent process. else { data_processed = write(file_pipes[1], some_data,strlen(some_data)); printf("Wrote %d bytes/n", data_processed); } } exit(EXIT_SUCCESS); }

值得注意的是，上面的程序中child process 和parent process运行的是同一段程序，所以child procss拥有file_pipes的拷贝

如果child process调用了一个exec call那么运行的新的程序，我们需要把file_pipes作为一个参数传递过去。

 

有一个常用的技巧是先close STDIN 然后调用dup函数 在close 管道

就可以调用很多专门用于处理标准输入的函数了 并且当程序结束时会自动关闭STDIN

另外在parent process和child process中要养成close不需要的pipe file descriptor的好习惯

#include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> int main() { int data_processed; int file_pipes[2]; const char some_data[] = "123"; pid_t fork_result; if (pipe(file_pipes) == 0) { fork_result = fork(); if (fork_result == (pid_t)-1) { fprintf(stderr, "Fork failure"); exit(EXIT_FAILURE); } if (fork_result == (pid_t)0) { close(0); dup(file_pipes[0]); close(file_pipes[0]); close(file_pipes[1]); execlp("od", "od", "-c", (char *)0); exit(EXIT_FAILURE); } else { close(file_pipes[0]); data_processed = write(file_pipes[1], some_data, strlen(some_data)); close(file_pipes[1]); printf("%d - wrote %d bytes/n", (int)getpid(), data_processed); } } exit(EXIT_SUCCESS); }

 

---

Named Pipes:FIFOs

 

pipe一般用于同一祖先的后代process之间的通信，而FIFOs可以让不关联的process之间通信，FIFOs是文件的一种，我们可以像操作文件一样操作FIFOs

可以调用命令mkfifo filename 或者 mknod filename p

int mkfifo(const char *filename,mode_t mode);

int mknod(const char *filename,mode_t mode ｜ S_IFIFO,(dev_t) 0);

在传输数据之前，我们可以调用open函数来打开一个FIFOs，一般open_mode可以为O_RDONLY O_WRONLY　O_NONBLOCK

在下面的程序中我们来检测不同的组合

#include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <fcntl.h> #include <sys/types.h> #include <sys/stat.h> #define FIFO_NAME "/tmp/my_fifo" int main(int argc,char * argv[]) { int res; int open_mode=0; int i; if(argc<2){ fprintf(stderr,"Usage: %s <some combination of/ O_RDONLY,O_WRONLY,O_NONBLOCK>/n",*argv); exit(EXIT_FAILURE); } for(i=1;i<argc;i++){ if(strncmp(*++argv,"O_RDONLY",8)==0) open_mode|=O_RDONLY; if(strncmp(*argv,"O_WRONLY",8)==0) open_mode|=O_WRONLY; if(strncmp(*argv,"O_NONBLOCK",10)==0) open_mode|=O_NONBLOCK; } if(access(FIFO_NAME,F_OK)==-1){ /*The file do not exist,we will create it*/ res=mkfifo(FIFO_NAME,0777); if(res!=0){ fprintf(stderr,"Could not create fifo %s/n",FIFO_NAME); exit(EXIT_FAILURE); } } printf("Process %d open FIFO/n",getpid()); res=open(FIFO_NAME,open_mode); printf("Process %d result %d/n",getpid(),res); sleep(5);/*sleep to test different combination of open_mode*/ if(res!=-1) (void)close(res); printf("Process %d finished/n",getpid()); exit(EXIT_SUCCESS); }

当我们运行上面的程序，并且以O_RDONLY打开FIFOs时，程序将block等待 另外一个程序以O_WRONLY打开FIFOs

如果以O_RDONLY ｜ O_NONBLOCK打开时，程序不会block

 

系统定义了PIPE_BUF用来限制FIFO中任何时刻数据的大小，linux上通常是4096

下面的程序用FIFOs来IPC 一个生产者，一个消费者

#include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <fcntl.h> #include <limits.h> #include <sys/types.h> #include <sys/stat.h> #define FIFO_NAME "/tmp/my_fifo" #define BUFFER_SIZE PIPE_BUF #define TEN_MEG (1024 * 1024 * 10) int main() { int pipe_fd; int res; int open_mode = O_WRONLY; int bytes_sent = 0; char buffer[BUFFER_SIZE + 1]; if (access(FIFO_NAME, F_OK) == -1) { res = mkfifo(FIFO_NAME, 0777); if (res != 0) { fprintf(stderr, "Could not create fifo %s/n", FIFO_NAME); exit(EXIT_FAILURE); } } printf("Process %d opening FIFO O_WRONLY/n", getpid()); pipe_fd = open(FIFO_NAME, open_mode); printf("Process %d result %d/n", getpid(), pipe_fd); if (pipe_fd != -1) { while(bytes_sent < TEN_MEG) { res = write(pipe_fd, buffer, BUFFER_SIZE); if (res == -1) { fprintf(stderr, "Write error on pipe/n"); exit(EXIT_FAILURE); } bytes_sent += res; } (void)close(pipe_fd); } else { exit(EXIT_FAILURE); } printf("Process %d finished/n", getpid()); exit(EXIT_SUCCESS); }

#include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <fcntl.h> #include <limits.h> #include <sys/types.h> #include <sys/stat.h> #define FIFO_NAME "/tmp/my_fifo" #define BUFFER_SIZE PIPE_BUF int main() { int pipe_fd; int res; int open_mode = O_RDONLY; char buffer[BUFFER_SIZE + 1]; int bytes_read = 0; memset(buffer, '/0', sizeof(buffer)); printf("Process %d opening FIFO O_RDONLY/n", getpid()); pipe_fd = open(FIFO_NAME, open_mode); printf("Process %d result %d/n", getpid(), pipe_fd); if (pipe_fd != -1) { do { res = read(pipe_fd, buffer, BUFFER_SIZE); bytes_read += res; } while (res > 0); (void)close(pipe_fd); } else { exit(EXIT_FAILURE); } printf("Process %d finished, %d bytes read/n", getpid(), bytes_read); exit(EXIT_SUCCESS); }

在上面的程序中生产者向FIFOs中写入PIPE_BUF大小的数据，然后block，等待消费者从中读取PIPE_BUF大小的数据。

在我1G内存 双核1.8G的机子上，传输10M的数据只需要0.023秒，在linux下，FIFOs can be an efficient way of transferring data between programs

 

下面是用FIFOs实现的Clien/Server程序

clien.h

/* * Define some common variable which will be used by both clien and server */ #include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <fcntl.h> #include <limits.h> #include <sys/types.h> #include <sys/stat.h> #define SERVER_FIFO_NAME "/tmp/serv_fifo" #define CLIENT_FIFO_NAME "/tmp/cli_%d_fifo" #define BUFFER_SIZE 20 struct data_to_pass_st { pid_t client_pid; char some_data[BUFFER_SIZE - 1]; };

server.c

#include "client.h" #include <ctype.h> int main() { int server_fifo_fd, client_fifo_fd; struct data_to_pass_st my_data; int read_res; char client_fifo[256]; char *tmp_char_ptr; mkfifo(SERVER_FIFO_NAME, 0777); server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY); if (server_fifo_fd == -1) { fprintf(stderr, "Server fifo failure/n"); exit(EXIT_FAILURE); } sleep(10); /* lets clients queue for demo purposes */ do { read_res = read(server_fifo_fd, &my_data, sizeof(my_data)); if (read_res > 0) { // In this next stage, we perform some processing on the data just read from the client. // We convert all the characters in some_data to uppercase and combine the CLIENT_FIFO_NAME // with the received client_pid. tmp_char_ptr = my_data.some_data; while (*tmp_char_ptr) { *tmp_char_ptr = toupper(*tmp_char_ptr); tmp_char_ptr++; } sprintf(client_fifo, CLIENT_FIFO_NAME, my_data.client_pid); // Then we send the processed data back, opening the client pipe in write-only, blocking mode. // Finally, we shut down the server FIFO by closing the file and then unlinking the FIFO. client_fifo_fd = open(client_fifo, O_WRONLY); if (client_fifo_fd != -1) { write(client_fifo_fd, &my_data, sizeof(my_data)); close(client_fifo_fd); } } } while (read_res > 0); close(server_fifo_fd); unlink(SERVER_FIFO_NAME); exit(EXIT_SUCCESS); }

client.c

// Here's the client, client.c. The first part of this program opens the server FIFO, // if it already exists, as a file. It then gets its own process ID, which forms some // of the data that will be sent to the server. The client FIFO is created, ready for // the next section. #include "client.h" #include <ctype.h> int main() { int server_fifo_fd, client_fifo_fd; struct data_to_pass_st my_data; int times_to_send; char client_fifo[256]; server_fifo_fd = open(SERVER_FIFO_NAME, O_WRONLY); if (server_fifo_fd == -1) { fprintf(stderr, "Sorry, no server/n"); exit(EXIT_FAILURE); } my_data.client_pid = getpid(); sprintf(client_fifo, CLIENT_FIFO_NAME, my_data.client_pid); if (mkfifo(client_fifo, 0777) == -1) { fprintf(stderr, "Sorry, can't make %s/n", client_fifo); exit(EXIT_FAILURE); } // For each of the five loops, the client data is sent to the server. // Then the client FIFO is opened (read-only, blocking mode) and the data read back. // Finally, the server FIFO is closed and the client FIFO removed from memory. for (times_to_send = 0; times_to_send < 5; times_to_send++) { sprintf(my_data.some_data, "Hello from %d", my_data.client_pid); printf("%d sent %s, ", my_data.client_pid, my_data.some_data); write(server_fifo_fd, &my_data, sizeof(my_data)); client_fifo_fd = open(client_fifo, O_RDONLY); if (client_fifo_fd != -1) { if (read(client_fifo_fd, &my_data, sizeof(my_data)) > 0) { printf("received: %s/n", my_data.some_data); } close(client_fifo_fd); } } close(server_fifo_fd); unlink(client_fifo); exit(EXIT_SUCCESS); }