求解linux cat命令的实现机制！cat设备节点文件，没任何输出（之前已写入）

d82616520

pipe设备：实现一个循环缓冲区阻塞读写

pipe0为设备节点

应用程序：
int main(int argc, char **argv)
{
int fd;
int err;
char wb[1000] = "today is good day!";
char wb1[1000] = "what's the problem";
char rb[1000] ;
fd = open("/dev/pipe0", O_RDWR);//读写打开设备
if (fd < 0)
{
printf("can't open!\n");
}
printf("fd is : %d\n ",fd);
printf("%s\n", wb);
printf("%s\n", wb1);
   write(fd, &wb, 20);//写二次
  write(fd, &wb1, 20);
   err=read(fd, &rb, 20);//读数据
  printf("err is :%d\n", err);
   printf("%s\n", rb);//打印所读到数据
  
return 0;
}
应用程序Linux下运行结果：
root@book-desktop:/work/pipe# ./pipetest
fd is : 3
  today is good day!
what's the problem
err is :20
today is good day!
root@book-desktop:/work/pipe#
root@book-desktop:/work/pipe#
root@book-desktop:/work/pipe# cat /dev/pipe0

^C
root@book-desktop:/work/pipe#
cat pipe0怎么什么都没有，是无数据还是阻塞，为什么？求大神讲解下cat的机制啊?

nswcfd

应该跟cat没啥关系，cat的读写肯定都是block io。

可以strace确认一下，是block在open上，还是block在read上。

可以找一下fifo/pipe的实现，依稀记得，它对应的kernel buffer不是固定不变的，好像跟reader/writer的引用计数有关系。

如果你的程序不退出，在return 0之前加个pause，也许就能被外面的cat读到了。【不确定，自己做实验试试吧】

1. static int fifo_open(struct inode *inode, struct file *filp)
   
2. {
   
3.         pipe = inode->i_pipe;
   
4.         if (!pipe) {
   
5.                 pipe = alloc_pipe_info(inode);
   
6.                 inode->i_pipe = pipe;
   
7.         }
   
8.         switch (filp->f_mode) {
   
9.         case 3:
   
10.         /*
    
11.          *  O_RDWR
    
12.          *  POSIX.1 leaves this case "undefined" when O_NONBLOCK is set.
    
13.          *  This implementation will NEVER block on a O_RDWR open, since
    
14.          *  the process can at least talk to itself.
    
15.          */
    
16.                 filp->f_op = &rdwr_fifo_fops;
    
17.                 pipe->readers++;
    
18.                 pipe->writers++;
    
19. }               
    
20. const struct file_operations rdwr_fifo_fops = {
    
21.         .release        = pipe_rdwr_release,
    
22. };
    
23. static int pipe_rdwr_release(struct inode *inode, struct file *filp)
    
24. {
    
25.         int decr, decw;
    
26.         decr = (filp->f_mode & FMODE_READ) != 0;
    
27.         decw = (filp->f_mode & FMODE_WRITE) != 0;
    
28.         return pipe_release(inode, decr, decw);
    
29. }
    
30. static int pipe_release(struct inode *inode, int decr, int decw)
    
31. {
    
32.         pipe->readers -= decr;
    
33.         pipe->writers -= decw;
    
34.         if (!pipe->readers && !pipe->writers) {
    
35.                 free_pipe_info(inode);
    
36.         }
    
37. }

复制代码