linux内核情景分析之命名管道

管道是一种"无名","无形文件,只可以近亲进程使用,不可以再任意两个进程通信使用,所以只能实现"有名","有形"的文件来实现就可以克服其缺点,这里的有名:一个文件应该有文件名,使得任何进程可以通过文件名或者路径找到该文件,有形指的是文件的inode应该存在与磁盘或者其他文件熊截止上.使得任何进程可以再任何时间都可以建立联系.
命名管道的创建用mknod,当然也可以使用mknod函数创建命名管道.建立了这样的节点,进程就可以通过打开一个文件一样打开整个民命管道.
命名管道与匿名管道的不同之处仅仅在于打开的过程,分析如何通过open系统调用与filfo文件取得联系.进程在内核通过sys_open进入filp_open(),然后在open_namei()调用一个函数path_walk(),根据文件的路径在文件系统中找到代表这文件的inode,将磁盘的inode读取内存,根据文件类型,将inode的i_op和i_fop指针设置为对应的inode_operation与file_operation,但对于FIFO这样特殊的文件则用调用init_special_inode加以初始化,可见文件类型不属于ACL或者数据,不是普通文件,不是目录,不是符号连接,就属于FIFO文件
  1. if (inode->i_ino == EXT2_ACL_IDX_INO ||
  2. 	    inode->i_ino == EXT2_ACL_DATA_INO)
  3. 		/* Nothing to do */ ;
  4. 	else if (S_ISREG(inode->i_mode)) {
  5. 		inode->i_op = &ext2_file_inode_operations;
  6. 		inode->i_fop = &ext2_file_operations;
  7. 		inode->i_mapping->a_ops = &ext2_aops;
  8. 	} else if (S_ISDIR(inode->i_mode)) {
  9. 		inode->i_op = &ext2_dir_inode_operations;
  10. 		inode->i_fop = &ext2_dir_operations;
  11. 	} else if (S_ISLNK(inode->i_mode)) {
  12. 		if (!inode->i_blocks)
  13. 			inode->i_op = &ext2_fast_symlink_inode_operations;
  14. 		else {
  15. 			inode->i_op = &page_symlink_inode_operations;
  16. 			inode->i_mapping->a_ops = &ext2_aops;
  17. 		}
  18. 	} else 
  19. 		init_special_inode(inode, inode->i_mode,
  20. 				   le32_to_cpu(raw_inode->i_block[0]));
接下来查看init_special_inode
  2. void init_special_inode(struct inode *inode, umode_t mode, int rdev)
  3. {
  4. 	inode->i_mode = mode;
  5. 	if (S_ISCHR(mode)) {
  6. 		inode->i_fop = &def_chr_fops;
  7. 		inode->i_rdev = to_kdev_t(rdev);
  8. 	} else if (S_ISBLK(mode)) {
  9. 		inode->i_fop = &def_blk_fops;
  10. 		inode->i_rdev = to_kdev_t(rdev);
  11. 		inode->i_bdev = bdget(rdev);
  12. 	} else if (S_ISFIFO(mode))//是fifo文件,设置文件操作为def_fifo_fops
  13. 		inode->i_fop = &def_fifo_fops;
  14. 	else if (S_ISSOCK(mode))
  15. 		inode->i_fop = &bad_sock_fops;
  16. 	else
  17. 		printk(KERN_DEBUG "init_special_inode: bogus imode (%o)\n", mode);
  18. }

  2. /*
  3.  * Dummy default file-operations: the only thing this does
  4.  * is contain the open that then fills in the correct operations
  5.  * depending on the access mode of the file...
  6.  */
  7. struct file_operations def_fifo_fops = {
  8. 	open:		fifo_open,	/* will set read or write pipe_fops */
  9. };
sys_open->filp_open->dentry_open->fifo_open()
  2. static int fifo_open(struct inode *inode, struct file *filp)
  3. {
  4. 	int ret;
  6. 	ret = -ERESTARTSYS;
  7. 	lock_kernel();
  8. 	if (down_interruptible(PIPE_SEM(*inode)))
  9. 		goto err_nolock_nocleanup;
  11. 	if (!inode->i_pipe) {//第一次打开fifo文件,该管道的缓冲页面没分配,以后打开会跳过
  12. 		ret = -ENOMEM;
  13. 		if(!pipe_new(inode))
  14. 			goto err_nocleanup;
  15. 	}
  16. 	filp->f_version = 0;
  18. 	switch (filp->f_mode) {
  19. 	case 1:
  20. 	/* //只读
  21. 	 *  O_RDONLY
  22. 	 *  POSIX.1 says that O_NONBLOCK means return with the FIFO
  23. 	 *  opened, even when there is no process writing the FIFO.
  24. 	 */
  25. 		filp->f_op = &read_fifo_fops;
  26. 		PIPE_RCOUNTER(*inode)++;//读端的记录++
  27. 		if (PIPE_READERS(*inode)++ == 0)//表示刚打开读端,很可能有写进程睡眠,那就要唤醒写进程
  28. 			wake_up_partner(inode);
  30. 		if (!PIPE_WRITERS(*inode)) {//如果不存在写端
  31. 			if ((filp->f_flags & O_NONBLOCK)) {//并且不阻塞
  32. 				/* suppress POLLHUP until we have
  33. 				 * seen a writer */
  34. 				filp->f_version = PIPE_WCOUNTER(*inode);//写端计数
  35. 			} else //不存在写端并且阻塞,那就之产生一般,需要睡眠,等待生产者进程将其唤醒
  36. 			{
  37. 				wait_for_partner(inode, &PIPE_WCOUNTER(*inode));
  38. 				if(signal_pending(current))
  39. 					goto err_rd;
  40. 			}
  41. 		}
  42. 		break;
  43. 	
  44. 	case 2:
  45. 	/*只写
  46. 	 *  O_WRONLY
  47. 	 *  POSIX.1 says that O_NONBLOCK means return -1 with
  48. 	 *  errno=ENXIO when there is no process reading the FIFO.
  49. 	 *///不存在读端并且设置了不阻塞,直接return错误
  50. 		ret = -ENXIO;
  51. 		if ((filp->f_flags & O_NONBLOCK) && !PIPE_READERS(*inode))
  52. 			goto err;
  54. 		filp->f_op = &write_fifo_fops;//设置专用写操作
  55. 		PIPE_WCOUNTER(*inode)++;
  56. 		if (!PIPE_WRITERS(*inode)++)//如果写端第一次创建,很可能有读进程在睡眠
  57. 			wake_up_partner(inode);//将其唤醒
  59. 		if (!PIPE_READERS(*inode)) {//如果不存在读端并且阻塞
  60. 			wait_for_partner(inode, &PIPE_RCOUNTER(*inode));//休眠等待读进程将其唤醒
  61. 			if (signal_pending(current))
  62. 				goto err_wr;
  63. 		}
  64. 		break;
  65. 	
  66. 	case 3:
  67. 	/*可读可写
  68. 	 *  O_RDWR
  69. 	 *  POSIX.1 leaves this case "undefined" when O_NONBLOCK is set.
  70. 	 *  This implementation will NEVER block on a O_RDWR open, since
  71. 	 *  the process can at least talk to itself.
  72. 	 *///相当于一个进程同时打开命名管道的两端,所以不需要等待,只要任何一端是第一次打开,就唤醒在睡眠的进程
  73. 		filp->f_op = &rdwr_fifo_fops;
  75. 		PIPE_READERS(*inode)++;
  76. 		PIPE_WRITERS(*inode)++;
  77. 		PIPE_RCOUNTER(*inode)++;
  78. 		PIPE_WCOUNTER(*inode)++;
  79. 		if (PIPE_READERS(*inode) == 1 || PIPE_WRITERS(*inode) == 1)
  80. 			wake_up_partner(inode);
  81. 		break;
  83. 	default:
  84. 		ret = -EINVAL;
  85. 		goto err;
  86. 	}
  88. 	/* Ok! */
  89. 	up(PIPE_SEM(*inode));
  90. 	unlock_kernel();
  91. 	return 0;
  93. err_rd:
  94. 	if (!--PIPE_READERS(*inode))
  95. 		wake_up_interruptible(PIPE_WAIT(*inode));
  96. 	ret = -ERESTARTSYS;
  97. 	goto err;
  99. err_wr:
  100. 	if (!--PIPE_WRITERS(*inode))
  101. 		wake_up_interruptible(PIPE_WAIT(*inode));
  102. 	ret = -ERESTARTSYS;
  103. 	goto err;
  105. err:
  106. 	if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) {
  107. 		struct pipe_inode_info *info = inode->i_pipe;
  108. 		inode->i_pipe = NULL;
  109. 		free_page((unsigned long)info->base);
  110. 		kfree(info);
  111. 	}
  113. err_nocleanup:
  114. 	up(PIPE_SEM(*inode));
  116. err_nolock_nocleanup:
  117. 	unlock_kernel();
  118. 	return ret;
  119. }
注意FIFO文件的inode节点存在磁盘,但那只是一个节点,而文件的数据之存在内存缓冲区.与普通管道一样











来自为知笔记(Wiz)


posted on 2016-10-27 10:51  笨拙的菜鸟  阅读(734)  评论(0)    收藏  举报

导航