在文章《linux基础编程：进程通信之信号》中，我们看到信号作为进程之间的通信方式。但是传送的信息之限于一个信号值。而本文将会介绍Linux支持的最初Unix IPC之一：管道和命名管道，它允许进程之间交换更多的数据，管道指的是从一个进程连接数据流到另一个进程。它具有以下特点：
- 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；
- 只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；
- 单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
- 数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。
本文详细介绍管道相关信息。
管道
基于标准库popen和pclose的进程管道
#include <stdio.h>
FILE *popen(const char *command, const char *type);
int pclose(FILE *stream);
static void check_image(char * imagename)
{
FILE * fp;
char command[120];
char buf[200];
bool ret;
sprintf(command, "cksum %s", imagename);
fp = popen(command, "r");
if(fp == NULL) return;
fgets(buf, 200, fp);
fprintf(stdout, "Check Image: %s... Done\n", buf);
fclose(fp);
return;
}
基于系统调用pipe的进程管道
#include <unistd.h>
int pipe(int pipefd[2]);
利用pipe创建的管道包含两个文件描述符fd[0]以及fd[1]，需要注意的是，该处是文件描述符而不是文件流，对该文件描述符进行读写必须采用read和write系统调用，管道的两端是固定了任务的。即一端只能用于读，由描述字fd[0]表示，称其为管道读端；另一端则只能用于写，由描述字fd[1]来表示，称其为管道写端。如果试图从管道写端读取数据，或者向管道读端写入数据都将导致错误发生。结构如下图：
从管道中读取数据：
- 如果管道的写端不存在，则认为已经读到了数据的末尾，读函数返回的读出字节数为0；
- 当管道的写端存在时，如果请求的字节数目大于PIPE_BUF，则返回管道中现有的数据字节数，如果请求的字节数目不大于PIPE_BUF，则返回管道中现有数据字节数（此时，管道中数据量小于请求的数据量）；或者返回请求的字节数（此时，管道中数据量不小于请求的数据量）。注：（PIPE_BUF在include/linux/limits.h中定义，不同的内核版本可能会有所不同。Posix.1要求PIPE_BUF至少为512字节，red hat 7.2中为4096）。
- 向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。如果读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞。
- 注：只有在管道的读端存在时，向管道中写入数据才有意义。否则，向管道中写入数据的进程将收到内核传来的SIFPIPE信号，应用程序可以处理该信号，也可以忽略（默认动作则是应用程序终止）。
- 只支持单向数据流；
- 只能用于具有亲缘关系的进程之间；
- 没有名字；
- 管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
- 管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
int main()
{
pid_t pid = 0;
int fds[2], nwr = 0;
char buf[128];
pipe(fds);
pid = fork();
if(pid < 0)
{
printf("Fork error.\n");
return -1;
}else if(pid == 0)
{
printf("This is child process, pid = %d\n", getpid());
//part A
printf("Child:waiting for message...\n");
nwr = read(fds[0], buf, sizeof(buf))
printf("Child:received\"%s\"\n", buf);
//part B
printf("Child:send reply\n");
strcpy(buf, "Reply from child");
nwr = write(fds[1], buf, sizeof(buf));
printf("Child:send %d bytes to parent.\n", nwr);
}else{
printf("This is parent process, pid = %d\n", getpid());
printf("Parent:sending message...\n");
strcpy(buf, "Message from parent");
nwr = write(fds[1], buf, sizeof(buf));
printf("Parent:send %d bytes to child.\n", nwr);
//part C
printf("Parent:waiting for reply from child...\n");
nwr = read(fds[0], buf, sizeof(buf));
printf("Parent:received \"%s\" from child\n", buf);
}
return 0;
}
命名管道
管道应用的一个重大限制是它没有名字，因此，只能用于具有亲缘关系的进程间通信，在有名管道（named pipe或FIFO）提出后，该限制得到了克服。FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信（能够访问该路径的进程以及FIFO的创建进程之间），因此，通过FIFO不相关的进程也能交换数据。值得注意的是，FIFO严格遵循先进先出（first in first out），对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。
对命名管道的操作和对文件操作相似，包括创建，打开，读写，和关闭操作。
命名管道的创建
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
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);
}
}
res=open(FIFO_NAME,open_mode);
命名管道的打开
打开的FIFO的限制是：由于FIFO是单向数据传输，程序不能以O_RDWR方式打开FIFO同时进行读写操作，只能是O_RDONLY或者O_WRONLY方式，打开函数如下:
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int open(const char *pathname, int flags);
flags=O_RDONLY：open将会调用阻塞，除非有另外一个进程以写的方式打开同一个FIFO，否则一直等待。
flags=O_WRONLY：open将会调用阻塞，除非有另外一个进程以读的方式打开同一个FIFO，否则一直等待。
flags=O_RDONLY|O_NONBLOCK：如果此时没有其他进程以写的方式打开FIFO，此时open也会成功返回，此时FIFO被读打开，而不会返回错误。
flags=O_WRONLY|O_NONBLOCK：立即返回，如果此时没有其他进程以读的方式打开，open会失败打开，此时FIFO没有被打开，返回-1。
命名管道创建和打开测试程序：
#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;
if(argc < 2){
fprintf(stderr,"Usage:%s<some combination of \
O_RDONLY,O_WRONLY,O_NONBLOCK\n",*argv);
exit(EXIT_FAILURE);
}
argv++;
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;
argv++;
if(*argv){
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){
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 with %d\n",getpid(),open_mode);
res=open(FIFO_NAME,open_mode);
printf("process %d result %d\n",getpid(),res);
sleep(5);
if(res!=-1)close(res);
printf("process %d finished\n",getpid());
exit(EXIT_SUCCESS);
}
命名管道的读写
对命名管道的读写需要利用系统调用read函数：
#include <unistd.h>
ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);在读取管道时，是否采用O_NONBLOCK非阻塞标志对管道的读有影响：
- 对一个空的，阻塞的FIFO文件的read调用将会等待，直到有数据可以读时才继续执行。
- 对一个空的，非阻塞的FIFO的read系统调用将会立即返回0字节。
在写管道时，需要考虑FIFO可以存在的数据长度是有限制的，在limits.h文件中由#definde PIPE_BUF语句定义，通常是4096字节。
对于设置了阻塞标志的写操作：
- 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳要写入的字节数时，才开始进行一次性写操作。
- 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求写的数据后返回。
- 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。
- 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写；
命名管道的关闭
#include <unistd.h>
int close(int fd);
总结
管道常用于两个方面：在shell中时常会用到管道（作为输入输入的重定向），在这种应用方式下，管道的创建对于用户来说是透明的；用于具有亲缘关系的进程间通信，用户自己创建管道，并完成读写操作。FIFO可以说是管道的推广，克服了管道无名字的限制，使得无亲缘关系的进程同样可以采用先进先出的通信机制进行通信。管道和FIFO的数据是字节流，应用程序之间必须事先确定特定的传输"协议"，采用传播具有特定意义的消息。要灵活应用管道及FIFO，理解它们的读写规则是关键。
4330
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
