TCP/IP源码学习(47)——socket与VFS的关联

TCP/IP源码学习(47)——socket与VFS的关联(1) 

摘自：http://blog.chinaunix.net/uid-23629988-id-3080166.html

作者：gfree.wind@gmail.com
博客：blog.focus-linux.net   linuxfocus.blog.chinaunix.net 

 

本文的copyleft归gfree.wind@gmail.com所有，使用GPL发布，可以自由拷贝，转载。但转载请保持文档的完整性，注明原作者及原链接，严禁用于任何商业用途。

======================================================================================================

今天学习一下socket与VFS之间的关系。

对于socket编程，我们都知道socket也是一个文件描述符，那么socket与VFS之间究竟是如何关联的呢？

首先，创建socket的函数，socket.c的函数SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol) 在成功创建了socket以后，通过函数sock_map_fd，将创建的struct socket结构映射为一个文件描述符。

1.     /* sock为成功创建的struct socket *sock类型， 而retval为映射后的文件描述符 */
2.     retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
   
3.     if (retval < 0)
   
4.         goto out_release;

进入sock_map_fd

1. int sock_map_fd(struct socket *sock, int flags)
   
2. {
   
3.     struct file *newfile;
   
4.     /* 将sock映射为一个文件描述符fd */
5.     int fd = sock_alloc_file(sock, &newfile, flags);
   

     /* 映射成功后，将fd加入到当前进程的文件描述符表中 */

1.     if (likely(fd >= 0))
   
2.         fd_install(fd, newfile);
   
3. 
   
4.     return fd;
   
5. }

进入sock_alloc_file，

1. static int sock_alloc_file(struct socket *sock, struct file **f, int flags)
   
2. {
   
3.     struct qstr name = { .name = "" };
   
4.     struct path path;
   
5.     struct file *file;
   
6.     int fd;
   

      

     /* 

     该函数名字稍微有点晦涩。看上去像是获得fd_flags，但是实际上是获得fd。

     我个人觉得名字叫做get_unused_fd_with_flags更好一些，这样还是突出是获得fd

     */

1.     fd = get_unused_fd_flags(flags);
   
2.     if (unlikely(fd < 0))
   
3.         return fd;
   

     /* 

     申请新的dentry，用socket对应的inode——该inode实际上是与socket同时申请下来的，参见 struct socket_      alloc结构 ，

     初始化该dentry。

     sock_mnt为一个全局变量，为sockfs的文件系统挂载点。

     */

1.     path.dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name);
   
2.     if (unlikely(!path.dentry)) {
   
3.         put_unused_fd(fd);
   
4.         return -ENOMEM;
   
5.     }
   
6.     path.mnt = mntget(sock_mnt);
   

    

     /* 

     将sockfs的dentry操作函数，和文件操作函数分别绑定到dentry和inode上。

     这样即完成VFS的统一调用。

     */

1.     path.dentry->d_op = &sockfs_dentry_operations;
   
2.     d_instantiate(path.dentry, SOCK_INODE(sock));
   
3.     SOCK_INODE(sock)->i_fop = &socket_file_ops;
   

      

     /* 申请file，并将前面的dentry path与file关联起来 */

1.     file = alloc_file(&path, FMODE_READ | FMODE_WRITE,
   
2.          &socket_file_ops);
   
3.     if (unlikely(!file)) {
   
4.         /* drop dentry, keep inode */
   
5.         atomic_inc(&path.dentry->d_inode->i_count);
   
6.         path_put(&path);
   
7.         put_unused_fd(fd);
   
8.         return -ENFILE;
   
9.     }
   
10. 
    
11.     sock->file = file;
    
12.     file->f_flags = O_RDWR | (flags & O_NONBLOCK);
    
13.     file->f_pos = 0;
    
14.     file->private_data = sock;
    
15. 
    
16.     *f = file;
    
17.     return fd;
    
18. }

进入 get_unused_fd_flags->alloc_fd

1. */
   
2. int alloc_fd(unsigned start, unsigned flags)
   
3. {
   
4.     struct files_struct *files = current->files;
   
5.     unsigned int fd;
   
6.     int error;
   
7.     struct fdtable *fdt;
   

     

1.     spin_lock(&files->file_lock);
   
2. repeat:
   
3.     /* 得到该进程的文件描述符表 */
4.     fdt = files_fdtable(files);
   
5.     /* 从start开始查找 */
6.     fd = start;
   
7.     /* 
8.     files->next_fd为上一次查找确定的下一个可用空闲的文件描述符。
9.     那么这次可以直接使用next_fd
10.     */
11.     if (fd < files->next_fd)
    
12.         fd = files->next_fd;
    

     /* 当fd小于目前进程支持的最大的描述符号，那么可以通过fds_bits位图，从fd位开始查找，

     找到下一个0位，即下一个空闲描述符。

     */

1.     if (fd < fdt->max_fds)
   
2.         fd = find_next_zero_bit(fdt->open_fds->fds_bits,
   
3.                      fdt->max_fds, fd);

1.     /* 如需要则扩展文件描述符表 */
2.     error = expand_files(files, fd);
   
3.     if (error < 0)
   
4.         goto out;
   
5. 
   
6.     /*
   
7.      * If we needed to expand the fs array we
   
8.      * might have blocked - try again.
   
9.      */
   
10.     if (error)
    
11.         goto repeat;
    

     

     /* 

     设置next_fd，用于下次加速查找空闲的fd。

     当start大于next_fd时，不会设置next_fd以避免文件描述符的不连续

     */

1.     if (start <= files->next_fd)
   
2.         files->next_fd = fd + 1;
   

     /* 将fd添加到已打开的文件描述符表中 */

1.     FD_SET(fd, fdt->open_fds);
   
2.     if (flags & O_CLOEXEC)
   
3.         FD_SET(fd, fdt->close_on_exec);
   
4.     else
   
5.         FD_CLR(fd, fdt->close_on_exec);
   
6.     error = fd;
   
7. #if 1
   
8.     /* Sanity check */
   
9.     if (rcu_dereference_raw(fdt->fd[fd]) != NULL) {
   
10.         printk(KERN_WARNING "alloc_fd: slot %d not NULL!\n", fd);
    
11.         rcu_assign_pointer(fdt->fd[fd], NULL);
    
12.     }
    
13. #endif
    
14. 
    
15. out:
    
16.     spin_unlock(&files->file_lock);
    
17.     return error;
    
18. }

今天是socket如何挂载到VFS的流程，还剩下一小部分这个流程的代码。下一次会将剩下的代码学习完毕，以及如何从VFS到socket流程

TCP/IP源码学习(48)——socket与VFS的关联(2)  

摘自：http://blog.chinaunix.net/uid-23629988-id-3080166.html

作者：gfree.wind@gmail.com
博客：blog.focus-linux.net   linuxfocus.blog.chinaunix.net 

 

本文的copyleft归gfree.wind@gmail.com所有，使用GPL发布，可以自由拷贝，转载。但转载请保持文档的完整性，注明原作者及原链接，严禁用于任何商业用途。

======================================================================================================

继续昨天的学习。

昨天学习alloc_fd时，还有一个函数expand_files没有进入跟踪。

1. int expand_files(struct files_struct *files, int nr)
   
2. {
   
3.     struct fdtable *fdt;
   
4. 
   
5.     fdt = files_fdtable(files);
   
6. 
   
7.     /*
   
8.      * N.B. For clone tasks sharing a files structure, this test
   
9.      * will limit the total number of files that can be opened.
   
10.      */
    
11.     /* 检查是否超过当前进程限定的最大可打开文件数 */
12.     if (nr >= rlimit(RLIMIT_NOFILE))
    
13.         return -EMFILE;
    
14. 
    
15.     /* Do we need to expand? */
    
16.     /* 
17.     如果nr小于max_fds，即目前的文件表的个数已经超过了nr， 所以无需扩展。
18.     这也说明，文件表只会增大，不会减小。
19.     */
20.     if (nr < fdt->max_fds)
    
21.         return 0;
    
22. 
    
23.     /* Can we expand? */
    
24.     /* 
25.     检查是否超过了系统限定的最大可打开文件数
26.     注意前面的检查为当前进程的打开文件数，此处的检查为系统可打开的文件数——所有进程
27.     */
28.     if (nr >= sysctl_nr_open)
    
29.         return -EMFILE;
    
30. 
    
31.     /* All good, so we try */
    
32.     /* 真正去做expand*/
33.     return expand_fdtable(files, nr);
    
34. }

进入expand_fdtable

1. static int expand_fdtable(struct files_struct *files, int nr)
   
2.     __releases(files->file_lock)
   
3.     __acquires(files->file_lock)
   
4. {
   
5.     struct fdtable *new_fdt, *cur_fdt;
   
6. 
   
7.     spin_unlock(&files->file_lock);
   
8.     /* 申请新的文件表 */
9.     new_fdt = alloc_fdtable(nr);
   
10.     spin_lock(&files->file_lock);
    
11.     if (!new_fdt)
    
12.         return -ENOMEM;
    
13.     /*
    
14.      * extremely unlikely race - sysctl_nr_open decreased between the check in
    
15.      * caller and alloc_fdtable(). Cheaper to catch it here...
    
16.      */
    
17.     /* 如注释所示，由于竞争，有可能在申请nr个数的新文件表时，修改了sysctl_nr_open，导致新的文件表个数     小于我们所需要的。所以，这里需要对new_fdt->max_fds和nr进行判断。如果小于nr，那么expand失败 */
18.     if (unlikely(new_fdt->max_fds <= nr)) {
    
19.         __free_fdtable(new_fdt);
    
20.         return -EMFILE;
    
21.     }
    
22.     /*
    
23.      * Check again since another task may have expanded the fd table while
    
24.      * we dropped the lock
    
25.      */
26.     cur_fdt = files_fdtable(files);
    
27.     /* 如注释所示，有可能另外一个进程已经扩展了文件表，所以这里再次判断 */
28.     if (nr >= cur_fdt->max_fds) {
    
29.         /* 复制文件表 */
30.         /* Continue as planned */
    
31.         copy_fdtable(new_fdt, cur_fdt);
    
32.         rcu_assign_pointer(files->fdt, new_fdt);
    
33.         /* 
34.         对于文件表结构struct files_struct，其成员变量fd_array为一个大小为NR_OPEN_DEFAULT的数             组。这是一种常用的技巧。一般来说，进程的打开的文件不会太多，所以可以直接使用一个比较小的数组，这         样可以提高效率避免二次分配，同时由于数组较小，并不会太浪费空间。当文件个数超过数组大小的时候，再         重新申请内存。*/
35.         if (cur_fdt->max_fds > NR_OPEN_DEFAULT)
    
36.             free_fdtable(cur_fdt);
    
37.     } else {
    
38.         /* Somebody else expanded, so undo our attempt */
    
39.         __free_fdtable(new_fdt);
    
40.     }
    
41.     return 1;
    
42. }

expand_files结束之后，alloc_fd也学习完了，即宏get_unused_fd_flags也就结束了，那么我们就再次回到了函数sock_alloc_file，继续学习其调用的其它函数。

TCP/IP源码学习(47)——socket与VFS的关联(1) 

摘自：http://blog.chinaunix.net/uid-23629988-id-3080166.html