Linux 套接字与文件系统的关系--------套接字文件系统

我就是我 2022-08-09 14:44 265阅读 0赞

[Linux套接字与虚拟文件系统（1）：初始化和创建][Linux_1]

**引言**  
 在Unix的世界里，万物皆文件，通过虚拟文件系统VFS，程序可以用标准的Unix系统调用对不同的文件系统，甚至不同介质上的文件系统进行读写操作。对于网络套接字socket也是如此，除了专属的Berkeley Sockets API，还支持一些标准的文件IO系统调用如read(v)、write(v)和close等。那么为什么socket也支持文件IO系统调用呢？在Linux上，这是通过套接口伪文件系统sockfs来实现的，因为sockfs实现了VFS中的4种主要对象：超级块super block、索引节点inode、 目录项对象dentry和文件对象file，当执行文件IO系统调用时，VFS就将请求转发给sockfs，而sockfs就调用特定的协议实现，层次结构如下图：

![sockfs_schema.PNG][]

本文以linux 2.6.34实现为基础，本篇阐述初始化和 [Socket创建][Socket]两部分的实现，下篇阐述 [Socket操作和销毁][Socket 1]两部分的实现。  
  
**初始化**

--------------------

在内核引导时初始化网络子系统，进而调用sock\_init，该函数主要步骤如下：创建inode缓存，注册和装载sockfs，定义在net/socket.c中。

1 ![None.gif][] static  int  \_\_init  **sock\_init** ( void )  
 2 ![ExpandedBlockStart.gif][] \{  
3![InBlock.gif][] ![dot.gif][]  
4![InBlock.gif][] init\_inodecache();  
5![InBlock.gif][] register\_filesystem(&sock\_fs\_type);  
6![InBlock.gif][] sock\_mnt = kern\_mount(&sock\_fs\_type);  
7![InBlock.gif][] ![dot.gif][]  
8![ExpandedBlockEnd.gif][]\}

**创建inode缓存**  
init\_inodecache为socket\_alloc对象创建SLAB缓存，名称为sock\_inode\_cachep，socket\_alloc定义在include/net/sock.h中。

1 ![ExpandedBlockStart.gif][] struct  socket\_alloc  \{  
2![InBlock.gif][]struct socket socket;  
3![InBlock.gif][]struct inode vfs\_inode;  
4![ExpandedBlockEnd.gif][]\} ;

socket\_alloc由socket和inode结构2部分组成，这样就方便了在套接字与inode对象间双向定位。  
  
**注册sockfs**  
调用VFS的函数register\_filesystem实现注册，sock\_fs\_type定义在net/socket.c中。

1 ![ExpandedBlockStart.gif][] static  struct  file\_system\_type  **sock\_fs\_type**  =  \{  
2![InBlock.gif][] .name ="sockfs",  
3![InBlock.gif][] .get\_sb =sockfs\_get\_sb,  
4![InBlock.gif][] .kill\_sb = kill\_anon\_super,  
5![ExpandedBlockEnd.gif][]\} ;

sock\_fs\_type包含了文件系统sockfs的名称、创建和销毁super block的函数，其中sockfs\_get\_sb实现在net/socket.c中。

1 ![None.gif][] static  int  **sockfs\_get\_sb** ( struct  file\_system\_type  \* fs\_type, int  flags,  const  char  \* dev\_name,  void  \* data, struct  vfsmount  \* mnt)  
 2 ![ExpandedBlockStart.gif][] \{  
3![InBlock.gif][]return get\_sb\_pseudo(fs\_type, "socket:", &sockfs\_ops, SOCKFS\_MAGIC, mnt);  
4![ExpandedBlockEnd.gif][]\}

它在kern\_mount内被执行，通过调用get\_sb\_pseudo创建了一个super block(包含一个对应dentry及一个关联inode)：操作对象为sockfs\_ops，根目录名称为socket:，对应的根索引节点编号为1。  
 sockfs\_ops定义在net/socket.c中。

1 ![ExpandedBlockStart.gif][] static  const  struct  super\_operations  **sockfs\_ops**  =  \{  
2![InBlock.gif][] .alloc\_inode = sock\_alloc\_inode,  
3![InBlock.gif][] .destroy\_inode = sock\_destroy\_inode,  
4![InBlock.gif][] .statfs = simple\_statfs,  
5![ExpandedBlockEnd.gif][]\} ;

sock\_alloc\_inode用于分配inode对象，将在socket创建过程中被调用；sock\_destroy\_inode用于释放inode对象，将在socket销毁过程中被调用；simple\_statfs用于获取sockfs文件系统的状态信息。  
  
 装载sockfs  
 由kern\_mount函数实现装载一个伪文件系统（当然，它没有装载点），返回一个static vfsmount对象sock\_mnt。  
  
 经过以上步骤后，所创建的VFS对象关系如下图：

![sockfs_vfsobj_init.png][]

对于根目录项，不用进行路径转换，因此dentry的d\_op为空（未画出）；对于伪文件系统，操作索引对象没有意义，所以inode的i\_op为空（未画出）。  
  
**Socket创建**

--------------------

系统调用socket、accept和socketpair是用户空间创建socket的几种方法，其核心调用链如下图：

![sockfs_sock_create_calltree.PNG][]

从上图可知共同的核心就3个过程：先构造inode，再构造对应的file，最后安装file到当前进程中（即关联映射到一个未用的文件描述符）,下面就这3个过程进行详细说明。  
  
 构造inode  
 由sock\_alloc函数实现，定义在net/socket.c中。

1 ![None.gif][] static  struct  socket  \* **sock\_alloc** ( void )  
  2 ![ExpandedBlockStart.gif][] \{  
 3![InBlock.gif][]struct inode \*inode;  
 4![InBlock.gif][]struct socket \*sock;  
 5![InBlock.gif][]  
 6![InBlock.gif][] inode = new\_inode(sock\_mnt\->mnt\_sb);  
 7![InBlock.gif][] ![dot.gif][]  
 8![InBlock.gif][] sock =SOCKET\_I(inode);  
 9![InBlock.gif][] ![dot.gif][]  
10![InBlock.gif][] inode\->i\_mode =S\_IFSOCK | S\_IRWXUGO;  
11![InBlock.gif][] inode\->i\_uid = current\_fsuid();  
12![InBlock.gif][] inode\->i\_gid = current\_fsgid();  
13![InBlock.gif][] ![dot.gif][]  
14![InBlock.gif][]return sock;  
15![ExpandedBlockEnd.gif][]\}

先调用new\_inode创建inode对象，再设置它的类型为S\_IFSOCK，由此可知inode对应的文件类型为套接字。new\_inode是文件系统的一个接口函数，用于创建一个inode对象，定义在fs/inode.c中，它调用了sockfs超级块的操作对象即sockfs\_ops的sock\_alloc\_inode方法，由于sock\_alloc\_inode实际创建的是socket\_alloc复合对象，因此要使用SOCKET\_I宏从inode中取出关联的socket对象用于返回。  
  
构造file  
 有了inode对象后，接下来就要构造对应的file对象了，由sock\_alloc\_file实现，定义在net/socket.c中。

1 ![None.gif][] static  int  **sock\_alloc\_file** ( struct  socket  \* sock,  struct  file  \*\* f,  int  flags)  
  2 ![ExpandedBlockStart.gif][] \{  
 3![ExpandedSubBlockStart.gif][]struct qstr name =\{ .name ="" \};  
 4![InBlock.gif][]struct path path;  
 5![InBlock.gif][]struct file \*file;  
 6![InBlock.gif][]int fd;  
 7![InBlock.gif][]  
 8![InBlock.gif][] fd = get\_unused\_fd\_flags(flags);  
 9![InBlock.gif][] ![dot.gif][]  
10![InBlock.gif][] path.dentry = d\_alloc(sock\_mnt\->mnt\_sb\->s\_root, &name);  
11![InBlock.gif][] ![dot.gif][]  
12![InBlock.gif][] path.mnt = mntget(sock\_mnt);  
13![InBlock.gif][]  
14![InBlock.gif][]path.dentry\->d\_op =&sockfs\_dentry\_operations;  
15![InBlock.gif][]d\_instantiate(path.dentry, SOCK\_INODE(sock));  
16![InBlock.gif][]SOCK\_INODE(sock)\->i\_fop =&socket\_file\_ops;  
17![InBlock.gif][]  
18![InBlock.gif][] file = alloc\_file(&path, FMODE\_READ | FMODE\_WRITE, &socket\_file\_ops);  
19![InBlock.gif][] ![dot.gif][]  
20![InBlock.gif][]sock\->file = file;  
21![InBlock.gif][] file\->f\_flags = O\_RDWR | (flags & O\_NONBLOCK);  
22![InBlock.gif][] file\->f\_pos =0;  
23![InBlock.gif][]file\->private\_data = sock;  
24![InBlock.gif][]  
25![InBlock.gif][]\*f = file;  
26![InBlock.gif][]return fd;  
27![ExpandedBlockEnd.gif][]\}

sock为 [上一过程][Link 1] 返回的套接字对象，该函数主要做了以下几件事：  
 1 ）得到空闲的文件描述符fd，实际上就是fd数组的索引，准备作为返回值。  
 2 ）先初始化路径path：其目录项的父目录项为超级块对应的根目录，名称为空，操作对象为sockfs\_dentry\_operations，对应的索引节点对象为sock套接字关联的索引节点对象，即SOCK\_INODE(sock)；装载点为sock\_mnt。   
 sockfs\_dentry\_operations定义在net/socket.c中。

1 ![ExpandedBlockStart.gif][] static  const  struct  dentry\_operations  **sockfs\_dentry\_operations** =  \{  
2![InBlock.gif][] .d\_dname = sockfs\_dname,  
3![ExpandedBlockEnd.gif][]\} ;

sockfs\_dname会被d\_path调用，用于计算socket对象的目录项名称。  
 3 ）设置索引节点的文件操作对象为socket\_file\_ops，定义在net/socket.c中。

1 ![ExpandedBlockStart.gif][] static  const  struct  file\_operations  **socket\_file\_ops**  =  \{  
2![InBlock.gif][] ![dot.gif][]  
3![InBlock.gif][] .aio\_read = sock\_aio\_read,  
4![InBlock.gif][] .aio\_write = sock\_aio\_write,  
5![InBlock.gif][] ![dot.gif][]  
6![ExpandedSubBlockStart.gif][] .open = sock\_no\_open, /\* special open code to disallow open via /proc \*/  
7![InBlock.gif][] .release = sock\_close,  
8![InBlock.gif][] ![dot.gif][]  
9![ExpandedBlockEnd.gif][]\} ;

4 ）调用alloc\_file，以path和socket\_file\_ops为输入参数，这样返回得到的file便与sock的inode关联上了，并且操作对象为socket\_file\_ops，最后设置到输出参数f中。  
 5 ）建立file与socket的一一映射关系。  
  
 安装file  
 由fd\_install实现，定义在fs/open.c中。

1 ![None.gif][] void  **fd\_install** (unsigned  int  fd,  struct  file  \* file)  
  2 ![ExpandedBlockStart.gif][] \{  
 3![InBlock.gif][]struct files\_struct \*files = current\->files;  
 4![InBlock.gif][]struct fdtable \*fdt;  
 5![InBlock.gif][] spin\_lock(&files\->file\_lock);  
 6![InBlock.gif][]fdt =files\_fdtable(files);  
 7![InBlock.gif][] BUG\_ON(fdt\->fd\[fd\] != NULL);  
 8![InBlock.gif][] rcu\_assign\_pointer(fdt\->fd\[fd\], file);  
 9![InBlock.gif][] spin\_unlock(&files\->file\_lock);  
10![ExpandedBlockEnd.gif][]\}

fd和file分别为上一过程返回的空闲文件描述符和文件对象，使RCU技术来设置file到当前进程的fd数组中。  
  
 经过以上过程后，所创建的VFS对象关系图如下

![sockfs_vfsobj_sock_create.png][]

fd为file\*数组的索引而不是成员字段；vfsmount与 [初始化之VFS对象关系图][VFS] 中的vfsmount是同一个对象，即sock\_mnt；对于伪文件系统，操作索引对象没有意义，所以inode的i\_op为空（未画出）。

[Linux_1]: http://www.cppblog.com/qinqing1984/archive/2015/05/03/210521.html
[sockfs_schema.PNG]: /images/20220731/d1665d93276448c1af8cfdac34621117.png
[Socket]: http://www.cppblog.com/qinqing1984/archive/2015/05/03/210521.html#sock_create
[Socket 1]: http://www.cppblog.com/qinqing1984/archive/2015/05/30/210522.html
[None.gif]: /images/20220731/2f088f7b152143dda922880df64385af.png
[ExpandedBlockStart.gif]: /images/20220731/27a04965d85c4783b92e7a68045398a3.png
[InBlock.gif]: /images/20220731/0db11fa284814172b4abf2d0e98444cd.png
[dot.gif]: /images/20220731/64980fc4824f4a8abdaa2be1e781a872.png
[ExpandedBlockEnd.gif]: /images/20220731/b0b3a403b96a4a86aaf47a7f90f15c9a.png
[sockfs_vfsobj_init.png]: /images/20220731/8ddb37fdf9904410bd5b20fb4bb42dad.png
[sockfs_sock_create_calltree.PNG]: /images/20220731/f65e62f25aac46fcbb0607d02d75378d.png
[ExpandedSubBlockStart.gif]: /images/20220731/e0b77c6a32f349e2b252b15a10349fa1.png
[Link 1]: http://www.cppblog.com/qinqing1984/archive/2015/05/03/210521.html#sock_create_inode
[sockfs_vfsobj_sock_create.png]: /images/20220731/b86b60c07a4c46f882b87895d1ffeeb9.png
[VFS]: http://www.cppblog.com/qinqing1984/archive/2015/05/03/210521.html#vfsobj_init