嵌入式 Linux环境进程间通信（二）：有名管道（FIFO）

来源：互联网发布：华为云计算部门在哪里编辑：程序博客网时间：2024/06/05 00:36

1 有名管道相关的关键概念

管道应用的一个重大限制是它没有名字，因此，只能用于具有亲缘关系的进程间通信，在有名管道（named pipe或FIFO）提出后，该限制得到了克服。

FIFO不同于管道之处在于它提供一个路径名与之关联，以FIFO的文件形式存在于文件系统中。这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信（能够访问该路径的进程以及FIFO的创建进程之间），因此，通过FIFO不相关的进程也能交换数据。

值得注意的是，FIFO严格遵循先进先出（first in first out），对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾。

它们不支持诸如lseek()等文件定位操作。

2 有名管道的创建

使用mkfifo()函数来创建

包含头文件：

#include <sys/types.h>

#include <sys/stat.h>

函数原型：

int mkfifo(const char * pathname, mode_t mode)

参数：

pathname是一个普通的路径名，也就是创建后FIFO的名字；

mode指出FIFO文件的操作权限，与打开普通文件的open()函数中的mode 参数相同。

常用的mode:

O_CREAT：如果文件不存在，则创建之；

O_EXCL：确保此次调用会创建文件；

如果mkfifo的第一个参数是一个已经存在的路径名时，会返回EEXIST错误，所以一般典型的调用代码首先会检查是否返回该错误，如果确实返回该错误，那么只要调用打开FIFO的函数就可以了。一般文件的I/O函数都可以用于FIFO，如close、read、write等等。

返回值：

创建成功，则返回0；

失败则返回-1；

错误类型：

EEXIST 路径名已存在（最常用的判断）

ENAMETOOLONG/ ENOENT/ENOSPC/ ENOTDIR/ EROFS

3 有名管道的打开规则

有名管道比管道多了一个打开操作：open()，以供读取或者写入

包含头文件：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

函数原型：

int open(const char *pathname, int flags);

int open(const char *pathname, int flags, mode_t mode);

参数：

1> pathname：指出文件名

2> flags：至少包含一下一种访问权限：O_RDONLY ( read only ), O_WRONLY( write only ), or O_RDWR( read/write ).

falgs需要与一些文件状态标识进行“ 或 ”操作

FIFO常用的文件状态标识：O_NONBLOCK or O_NDELAY

即表示非阻塞（如果不设置，则默认为阻塞），含义看下文解释。

3> mode：一般取0即可；

返回值：

如果打开成功，则返回一个新的文件描述符；

如果打开失败，则返回-1，并设置响应的errno

FIFO常用到的错误：

ENXIO：当设置flags为O_NONBLOCK | O_WRONLY时，文件为FIFO，并且进程没有文件打开以供写；

FIFO的打开规则：

如果当前打开操作是为读而打开FIFO时，若已经有相应进程为写而打开该FIFO，则当前打开操作将成功返回；否则，可能阻塞直到有相应进程为写而打开该FIFO（当前打开操作设置了阻塞标志）；或者，成功返回（当前打开操作没有设置阻塞标志）。

如果当前打开操作是为写而打开FIFO时，如果已经有相应进程为读而打开该FIFO，则当前打开操作将成功返回；否则，可能阻塞直到有相应进程为读而打开该FIFO（当前打开操作设置了阻塞标志）；或者，返回ENXIO错误（当前打开操作没有设置阻塞标志）。

对FIFO打开规则的验证（主要验证写打开对读打开的依赖性）

[cpp] view plaincopy

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#define FIFO_SERVER "/tmp/fifoserver"
int handle_client(char*);
int main()
{
int r_rd;
int w_fd;
pid_t pid;
//创建FIFO，并检查是否已有同名的FIFO文件
if((mkfifo(FIFO_SERVER,O_CREAT|O_EXCL)<0)&&(errno!=EEXIST))
{
printf("cannot create fifoserver\n");
}
//创建成功
handle_client(FIFO_SERVER);
}
int handle_client(char* arg)
{
int ret;
ret=w_open(arg);
switch(ret)
{
case 0:
{
printf("open %s error\n",arg);
printf("no process has the fifo open for reading\n");
return -1;
}
case -1:
{
printf("something wrong with open the fifo except for ENXIO");
return -1;
}
case 1:
{
printf("open server ok\n");
return 1;
}
default:
{
printf("w_no_r return ----\n");
return 0;
}
}
unlink(FIFO_SERVER);
}
//返回0，表示打开失败，因为没有文件
//返回-1，表示打开失败，但是因为别的原因
//返回1，表示打开成功
int w_open(char*arg)
{
if(open(arg,O_WRONLY|O_NONBLOCK,0)==-1)
{
if(errno==ENXIO)
{
return 0;
}
else
{
return -1;
}
}
return 1;
}

4 有名管道的读写规则

从FIFO中读取数据：

约定：

如果一个进程为了从FIFO中读取数据而阻塞打开FIFO（open()时不设置O_NONBLOCK ），那么称该进程内的读操作为设置了阻塞标志的读操作。

如果有进程写打开FIFO，且当前FIFO内没有数据

1> 则对于设置了阻塞标志的读操作来说，将一直阻塞

2> 对于没有设置阻塞标志读操作来说则返回-1，当前errno值为EAGAIN，提醒以后再试。

对于设置了阻塞标志的读操作说，造成阻塞的原因有两种：

1> 当前FIFO内有数据，但有其它进程在读这些数据；

2> FIFO内没有数据。

解阻塞的原因则是FIFO中有新的数据写入，不论信写入数据量的大小，也不论读操作请求多少数据量。

读打开的阻塞标志只对本进程第一个读操作施加作用，如果本进程内有多个读操作序列，则在第一个读操作被唤醒并完成读操作后，其它将要执行的读操作将不再阻塞，即使在执行读操作时，FIFO中没有数据也一样（此时，读操作返回0）。

如果没有进程写打开FIFO，则设置了阻塞标志的读操作会阻塞。

注：如果FIFO中有数据，则设置了阻塞标志的读操作不会因为FIFO中的字节数小于请求读的字节数而阻塞，此时，读操作会返回FIFO中现有的数据量。

使用read()方法从FIFO中读取数据

包含头文件：

#include <unistd.h>

函数原型：

ssize_t read(int fd, void *buf, size_t count);

功能：

从文件描述符fd中读取count字节到buf中；

参数：

如果count==0，则函数返回0；如果count大于buf的size，结果不确定？？

返回值：

如果读取成功，则返回读取的字节数；

（当申请的字节数多余fd中可读的字节数时，返回的值小于count）

如果读取失败，则返回-1；

FIFO中可能出现的错误：

EAGAIN or EWOULDBLOCK：The file descriptor fd refers to a socket and has been marked nonblocking (O_NONBLOCK), and the read would block.

向FIFO中写入数据：

约定：如果一个进程为了向FIFO中写入数据而阻塞打开FIFO（open()时不设置O_NONBLOCK ），那么称该进程内的写操作为设置了阻塞标志的写操作。

对于设置了阻塞标志的写操作：

1> 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。

如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳要写入的字节数时，才开始进行一次性写操作。

2> 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求写的数据后返回。

对于没有设置阻塞标志的写操作：

1> 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。（不保证所有数据都能写入）

2> 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。

如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；

如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写；

要注意几种不同情况下的区别！

使用write()方法向FIFO写入数据；

包含头文件：

#include <unistd.h>

函数原型：

ssize_t write(int fd, const void *buf, size_t count);

返回值：

如果成功，则返回写入的字节数；

如果失败，返回-1，并设置相应的errno；

可能出现的错误：

EAGAIN or EWOULDBLOCK：The file descriptor fd refers to a socket and has been marked nonblocking (O_NONBLOCK), and the write would block.

对FIFO读写规则的验证：

下面提供了两个对FIFO的读写程序，适当调节程序中的很少地方或者程序的命令行参数就可以对各种FIFO读写规则进行验证。

程序1：写FIFO的程序

[cpp] view plaincopy

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include "BYHFileOperation.h"
#define FIFO_SERVER "/home/stuy1001593/fifoserver"
void printMkfifoErrorInfo(int err);
int main()
{
char w_buf[4*1024*2]={0};
int real_wnum;
//创建FIFO，并检查路径名是否存在
int nRet=mkfifo(FIFO_SERVER,O_CREAT|O_EXCL);
if(nRet<0)
{
int tempErrno=errno;
printMkfifoErrorInfo(tempErrno);
if(errno==EEXIST)
{
printf("文件%s已存在\n", FIFO_SERVER);
}
else
{
exit(-1);
}
}
//设置非阻塞标志的只写操作
//int open_flag=O_WRONLY|O_NONBLOCK;
int open_flag=O_WRONLY;
int fd=BYHFileOperation::Open(FIFO_SERVER, open_flag);
if(fd==-1)
{
if(errno==ENXIO)
{
printf("进程没有文件打开，以供写入\n");
}
exit(-1);
}
//写入小于PIPE_BUFF的数据
real_wnum=write(fd, w_buf, 2048);
if(real_wnum==-1)
{
if(errno==EAGAIN)
{
printf("写入到FIFO中时发生错误，FIFO空闲缓存区没有足够的空间，稍后再试\n");
}
exit(-1);
}
else
{
printf("向FIFO空闲缓存中写入了%dByte\n",real_wnum);
}
//写入大于PIPE_BUFF的数据
real_wnum=write(fd, w_buf, 5000);
//5000用于测试写入字节大于4096时的非原子性
//real_wnum=write(fd,w_buf,4096);
//4096用于测试写入字节不大于4096时的原子性
if(real_wnum==-1)
{
if(errno==EAGAIN)
{
printf("写入到FIFO中时发生错误，FIFO空闲缓存区没有足够的空间，稍后再试\n");
}
exit(-1);
}
else
{
printf("向FIFO空闲缓存中写入了%dByte\n",real_wnum);
}
}

程序2：与程序1一起测试写FIFO的规则，第一个命令行参数是请求从FIFO读出的字节数

[cpp] view plaincopy

#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#define FIFO_SERVER "/tmp/fifoserver"
int main()
{
char r_buf[4096*2]={0};
//FIFO文件描述符
int fd;
int r_size=1024;
int ret_size;
//以非阻塞方式打开FIFO Server（FIFO发送者）
fd=open(FIFO_SERVER,O_RDONLY|O_NONBLOCK,0);
//以阻塞方式打开FIFO
//fd=open(FIFO_SERVER,O_RDONLY,0);
if(fd==-1)
{
printf("打开FIFO文件%s失败\n", FIFO_SERVER);
exit(0);
}
while(true)
{
//从FIFO中读取到r_buf中
ret_size=read(fd, r_buf, r_size);
//读取失败
if(ret_size==-1)
{
if(errno==EAGAIN)
{
printf("FIFO缓存中没有数据可读，请稍后再试\n");
sleep(1);
}
}
printf("从FIFO缓存中读取%dBytes\n",ret_size);
sleep(1);
}
pause();
//删除FIFO文件
unlink(FIFO_SERVER);
}

程序应用说明：

把读程序编译成两个不同版本：

1>阻塞读版本

2>非阻塞读版本nbr

把写程序编译成两个四个版本：

1> 非阻塞且请求写的字节数大于PIPE_BUF版本：nbwg

2> 非阻塞且请求写的字节数不大于PIPE_BUF版本：版本nbw

3> 阻塞且请求写的字节数大于PIPE_BUF版本：bwg

4> 阻塞且请求写的字节数不大于PIPE_BUF版本：版本bw

小结：

FIFO可以说是管道的推广，克服了管道无名字的限制，使得无亲缘关系的进程同样可以采用先进先出的通信机制进行通信。

管道和FIFO的数据是字节流，应用程序之间必须事先确定特定的传输"协议"，采用传播具有特定意义的消息。

要灵活应用管道及FIFO，理解它们的读写规则是关键。

0 0