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

时间：2021-08-29 08:53:24

管道是一种"无名","无形文件,只可以近亲进程使用,不可以再任意两个进程通信使用,所以只能实现"有名","有形"的文件来实现就可以克服其缺点,这里的有名:一个文件应该有文件名,使得任何进程可以通过文件名或者路径找到该文件,有形指的是文件的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. 

  2. 	    inode->i_ino == EXT2_ACL_DATA_INO)
    3. 

  3. 		/* Nothing to do */ ;
    4. 

  4. 	else if (S_ISREG(inode->i_mode)) {
    5. 

  5. 		inode->i_op = &ext2_file_inode_operations;
    6. 

  6. 		inode->i_fop = &ext2_file_operations;
    7. 

  7. 		inode->i_mapping->a_ops = &ext2_aops;
    8. 

  8. 	} else if (S_ISDIR(inode->i_mode)) {
    9. 

  9. 		inode->i_op = &ext2_dir_inode_operations;
    10. 

  10. 		inode->i_fop = &ext2_dir_operations;
    11. 

  11. 	} else if (S_ISLNK(inode->i_mode)) {
    12. 

  12. 		if (!inode->i_blocks)
    13. 

  13. 			inode->i_op = &ext2_fast_symlink_inode_operations;
    14. 

  14. 		else {
    15. 

  15. 			inode->i_op = &page_symlink_inode_operations;
    16. 

  16. 			inode->i_mapping->a_ops = &ext2_aops;
    17. 

  17. 		}
    18. 

  18. 	} else 
    19. 

  19. 		init_special_inode(inode, inode->i_mode,
    20. 

  20. 				   le32_to_cpu(raw_inode->i_block[0]));
    21.
接下来查看init_special_inode
    

    2. 

  2. void init_special_inode(struct inode *inode, umode_t mode, int rdev)
    3. 

  3. {
    4. 

  4. 	inode->i_mode = mode;
    5. 

  5. 	if (S_ISCHR(mode)) {
    6. 

  6. 		inode->i_fop = &def_chr_fops;
    7. 

  7. 		inode->i_rdev = to_kdev_t(rdev);
    8. 

  8. 	} else if (S_ISBLK(mode)) {
    9. 

  9. 		inode->i_fop = &def_blk_fops;
    10. 

  10. 		inode->i_rdev = to_kdev_t(rdev);
    11. 

  11. 		inode->i_bdev = bdget(rdev);
    12. 

  12. 	} else if (S_ISFIFO(mode))//是fifo文件,设置文件操作为def_fifo_fops
    13. 

  13. 		inode->i_fop = &def_fifo_fops;
    14. 

  14. 	else if (S_ISSOCK(mode))
    15. 

  15. 		inode->i_fop = &bad_sock_fops;
    16. 

  16. 	else
    17. 

  17. 		printk(KERN_DEBUG "init_special_inode: bogus imode (%o)\n", mode);
    18. 

  18. }
    19. 


    

    2. 

  2. /*
    3. 

  3.  * Dummy default file-operations: the only thing this does
    4. 

  4.  * is contain the open that then fills in the correct operations
    5. 

  5.  * depending on the access mode of the file...
    6. 

  6.  */
    7. 

  7. struct file_operations def_fifo_fops = {
    8. 

  8. 	open:		fifo_open,	/* will set read or write pipe_fops */
    9. 

  9. };
    10.
sys_open->filp_open->dentry_open->fifo_open()
    

    2. 

  2. static int fifo_open(struct inode *inode, struct file *filp)
    3. 

  3. {
    4. 

  4. 	int ret;
    5. 

    6. 

  6. 	ret = -ERESTARTSYS;
    7. 

  7. 	lock_kernel();
    8. 

  8. 	if (down_interruptible(PIPE_SEM(*inode)))
    9. 

  9. 		goto err_nolock_nocleanup;
    10. 

    11. 

  11. 	if (!inode->i_pipe) {//第一次打开fifo文件,该管道的缓冲页面没分配,以后打开会跳过
    12. 

  12. 		ret = -ENOMEM;
    13. 

  13. 		if(!pipe_new(inode))
    14. 

  14. 			goto err_nocleanup;
    15. 

  15. 	}
    16. 

  16. 	filp->f_version = 0;
    17. 

    18. 

  18. 	switch (filp->f_mode) {
    19. 

  19. 	case 1:
    20. 

  20. 	/* //只读
    21. 

  21. 	 *  O_RDONLY
    22. 

  22. 	 *  POSIX.1 says that O_NONBLOCK means return with the FIFO
    23. 

  23. 	 *  opened, even when there is no process writing the FIFO.
    24. 

  24. 	 */
    25. 

  25. 		filp->f_op = &read_fifo_fops;
    26. 

  26. 		PIPE_RCOUNTER(*inode)++;//读端的记录++
    27. 

  27. 		if (PIPE_READERS(*inode)++ == 0)//表示刚打开读端,很可能有写进程睡眠,那就要唤醒写进程
    28. 

  28. 			wake_up_partner(inode);
    29. 

    30. 

  30. 		if (!PIPE_WRITERS(*inode)) {//如果不存在写端
    31. 

  31. 			if ((filp->f_flags & O_NONBLOCK)) {//并且不阻塞
    32. 

  32. 				/* suppress POLLHUP until we have
    33. 

  33. 				 * seen a writer */
    34. 

  34. 				filp->f_version = PIPE_WCOUNTER(*inode);//写端计数
    35. 

  35. 			} else //不存在写端并且阻塞,那就之产生一般,需要睡眠,等待生产者进程将其唤醒
    36. 

  36. 			{
    37. 

  37. 				wait_for_partner(inode, &PIPE_WCOUNTER(*inode));
    38. 

  38. 				if(signal_pending(current))
    39. 

  39. 					goto err_rd;
    40. 

  40. 			}
    41. 

  41. 		}
    42. 

  42. 		break;
    43. 

  43. 	
    44. 

  44. 	case 2:
    45. 

  45. 	/*只写
    46. 

  46. 	 *  O_WRONLY
    47. 

  47. 	 *  POSIX.1 says that O_NONBLOCK means return -1 with
    48. 

  48. 	 *  errno=ENXIO when there is no process reading the FIFO.
    49. 

  49. 	 *///不存在读端并且设置了不阻塞,直接return错误
    50. 

  50. 		ret = -ENXIO;
    51. 

  51. 		if ((filp->f_flags & O_NONBLOCK) && !PIPE_READERS(*inode))
    52. 

  52. 			goto err;
    53. 

    54. 

  54. 		filp->f_op = &write_fifo_fops;//设置专用写操作
    55. 

  55. 		PIPE_WCOUNTER(*inode)++;
    56. 

  56. 		if (!PIPE_WRITERS(*inode)++)//如果写端第一次创建,很可能有读进程在睡眠
    57. 

  57. 			wake_up_partner(inode);//将其唤醒
    58. 

    59. 

  59. 		if (!PIPE_READERS(*inode)) {//如果不存在读端并且阻塞
    60. 

  60. 			wait_for_partner(inode, &PIPE_RCOUNTER(*inode));//休眠等待读进程将其唤醒
    61. 

  61. 			if (signal_pending(current))
    62. 

  62. 				goto err_wr;
    63. 

  63. 		}
    64. 

  64. 		break;
    65. 

  65. 	
    66. 

  66. 	case 3:
    67. 

  67. 	/*可读可写
    68. 

  68. 	 *  O_RDWR
    69. 

  69. 	 *  POSIX.1 leaves this case "undefined" when O_NONBLOCK is set.
    70. 

  70. 	 *  This implementation will NEVER block on a O_RDWR open, since
    71. 

  71. 	 *  the process can at least talk to itself.
    72. 

  72. 	 *///相当于一个进程同时打开命名管道的两端,所以不需要等待,只要任何一端是第一次打开,就唤醒在睡眠的进程
    73. 

  73. 		filp->f_op = &rdwr_fifo_fops;
    74. 

    75. 

  75. 		PIPE_READERS(*inode)++;
    76. 

  76. 		PIPE_WRITERS(*inode)++;
    77. 

  77. 		PIPE_RCOUNTER(*inode)++;
    78. 

  78. 		PIPE_WCOUNTER(*inode)++;
    79. 

  79. 		if (PIPE_READERS(*inode) == 1 || PIPE_WRITERS(*inode) == 1)
    80. 

  80. 			wake_up_partner(inode);
    81. 

  81. 		break;
    82. 

    83. 

  83. 	default:
    84. 

  84. 		ret = -EINVAL;
    85. 

  85. 		goto err;
    86. 

  86. 	}
    87. 

    88. 

  88. 	/* Ok! */
    89. 

  89. 	up(PIPE_SEM(*inode));
    90. 

  90. 	unlock_kernel();
    91. 

  91. 	return 0;
    92. 

    93. 

  93. err_rd:
    94. 

  94. 	if (!--PIPE_READERS(*inode))
    95. 

  95. 		wake_up_interruptible(PIPE_WAIT(*inode));
    96. 

  96. 	ret = -ERESTARTSYS;
    97. 

  97. 	goto err;
    98. 

    99. 

  99. err_wr:
    100. 

  100. 	if (!--PIPE_WRITERS(*inode))
    101. 

  101. 		wake_up_interruptible(PIPE_WAIT(*inode));
    102. 

  102. 	ret = -ERESTARTSYS;
    103. 

  103. 	goto err;
    104. 

    105. 

  105. err:
    106. 

  106. 	if (!PIPE_READERS(*inode) && !PIPE_WRITERS(*inode)) {
    107. 

  107. 		struct pipe_inode_info *info = inode->i_pipe;
    108. 

  108. 		inode->i_pipe = NULL;
    109. 

  109. 		free_page((unsigned long)info->base);
    110. 

  110. 		kfree(info);
    111. 

  111. 	}
    112. 

    113. 

  113. err_nocleanup:
    114. 

  114. 	up(PIPE_SEM(*inode));
    115. 

    116. 

  116. err_nolock_nocleanup:
    117. 

  117. 	unlock_kernel();
    118. 

  118. 	return ret;
    119. 

  119. }
    120.
注意FIFO文件的inode节点存在磁盘,但那只是一个节点,而文件的数据之存在内存缓冲区.与普通管道一样









相关文章