Linux网络协议栈 -- socket创建（1）

原文地址：http://blog.csdn.net/zhaqiwen/article/details/7725430

内核版本：2.6.12 

一、系统总入口

Linux 内核为所有的与 socket 有关的操作的 API，提供了一个统一的系统调用入口，其代码在net/socket.c中： 

asmlinkage long sys_socketcall(int call, unsigned long __user *args) {         unsigned long a[6];         unsigned long a0,a1;         int err;          if(call<1||call>SYS_RECVMSG)                 return -EINVAL;          /* copy_from_user should be SMP safe. */         if (copy_from_user(a, args, nargs[call]))                 return -EFAULT;                          a0=a[0];         a1=a[1];                  switch(call)          {                 case SYS_SOCKET:                          err = sys_socket(a0,a1,a[2]);                         break;                 case SYS_BIND:                         err = sys_bind(a0,(struct sockaddr __user *)a1, a[2]);                         break;                 case SYS_CONNECT:                         err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);                         break;                 case SYS_LISTEN:                         err = sys_listen(a0,a1);                         break;                 case SYS_ACCEPT:                         err = sys_accept(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);                         break;                 case SYS_GETSOCKNAME:                         err = sys_getsockname(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);                         break;                 case SYS_GETPEERNAME:                         err = sys_getpeername(a0, (struct sockaddr __user *)a1, (int __user *)a[2]);                         break;                 case SYS_SOCKETPAIR:                         err = sys_socketpair(a0,a1, a[2], (int __user *)a[3]);                         break;                 case SYS_SEND:                         err = sys_send(a0, (void __user *)a1, a[2], a[3]);                         break;                 case SYS_SENDTO:                         err = sys_sendto(a0,(void __user *)a1, a[2], a[3],                                          (struct sockaddr __user *)a[4], a[5]);                         break;                 case SYS_RECV:                         err = sys_recv(a0, (void __user *)a1, a[2], a[3]);                         break;                 case SYS_RECVFROM:                         err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],                                             (struct sockaddr __user *)a[4], (int __user *)a[5]);                         break;                 case SYS_SHUTDOWN:                         err = sys_shutdown(a0,a1);                         break;                 case SYS_SETSOCKOPT:                         err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);                         break;                 case SYS_GETSOCKOPT:                         err = sys_getsockopt(a0, a1, a[2], (char __user *)a[3], (int __user *)a[4]);                         break;                 case SYS_SENDMSG:                         err = sys_sendmsg(a0, (struct msghdr __user *) a1, a[2]);                         break;                 case SYS_RECVMSG:                         err = sys_recvmsg(a0, (struct msghdr __user *) a1, a[2]);                         break;                 default:                         err = -EINVAL;                         break;         }         return err; }

首先调用 copy_from_user将用户态参数拷贝至数组 a。但是问题在于，每个被调用的 API 的参数不尽相同，那么每次拷贝的字节在小如果断定？ 来看其第三个参数 nargs[call]，其中 call 是操作码，后面有个大大的 switch...case 就是判断它。对应的操作码定义在 include/linux/net.h：

#define SYS_SOCKET        1                /* sys_socket(2)                */ #define SYS_BIND        2                /* sys_bind(2)                        */ #define SYS_CONNECT        3                /* sys_connect(2)                */ #define SYS_LISTEN        4                /* sys_listen(2)                */ #define SYS_ACCEPT        5                /* sys_accept(2)                */ #define SYS_GETSOCKNAME        6                /* sys_getsockname(2)                */ #define SYS_GETPEERNAME        7                /* sys_getpeername(2)                */ #define SYS_SOCKETPAIR        8                /* sys_socketpair(2)                */ #define SYS_SEND        9                /* sys_send(2)                        */ #define SYS_RECV        10                /* sys_recv(2)                        */ #define SYS_SENDTO        11                /* sys_sendto(2)                */ #define SYS_RECVFROM        12                /* sys_recvfrom(2)                */ #define SYS_SHUTDOWN        13                /* sys_shutdown(2)                */ #define SYS_SETSOCKOPT        14                /* sys_setsockopt(2)                */ #define SYS_GETSOCKOPT        15                /* sys_getsockopt(2)                */ #define SYS_SENDMSG        16                /* sys_sendmsg(2)                */ #define SYS_RECVMSG        17                /* sys_recvmsg(2)                */[/code] 

而数组 nargs则根据操作码的不同，计算对应的参数的空间大小：

/* Argument list sizes for sys_socketcall */ #define AL(x) ((x) * sizeof(unsigned long)) static unsigned char nargs[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),                                  AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),                                  AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)}; #undef AL

当拷贝完成参数后，就进入一个 switch...case...判断操作码，跳转至对应的系统接口。 

二、 sys_socket 函数

操作码 SYS_SOCKET 是由 sys_socket()实现的： 

asmlinkage long sys_socket(int family, int type, int protocol) {         int retval;         struct socket *sock;          retval = sock_create(family, type, protocol, &sock);         if (retval < 0)                 goto out;          retval = sock_map_fd(sock);         if (retval < 0)                 goto out_release;  out:         /* It may be already another descriptor 8) Not kernel problem. */         return retval;  out_release:         sock_release(sock);         return retval; }

在分析这段代码之间，首先来看，创建一个 Socket，对内核而言，究竟意味着什么？究竟需要内核干什么事？ 

当用户空间要创建一个 socke 接口时，会调用 API 函数： 
int socket(int domain, int type, int protocol); 
 
函数，其三个参数分别表示协议族、协议类型（面向连接或无连接）以及协议。 
 
对于用户态而言，一个 Scoket，就是一个特殊的，已经打开的文件。为了对 socket抽像出文件的概念，内核中为 socket 定义了一个专门的文件系统类型 sockfs： 

static struct vfsmount *sock_mnt;  static struct file_system_type sock_fs_type = {         .name =                "sockfs",         .get_sb =        sockfs_get_sb,         .kill_sb =        kill_anon_super, };

在模块初始化的时候，安装该文件系统：  
void __init sock_init(void) 
{ 
        …… 
        register_filesystem(&sock_fs_type); 
        sock_mnt = kern_mount(&sock_fs_type);         
}
 
有了文件系统后，对内核而言，创建一个 socket， 就是在 sockfs 文件系统中创建一个文件节点(inode)，并建立起为了实现 socket 功能所  需的一整套数据结构，包括 struct inode 和 struct socket 结构。 struct socket 结构在内核中，就代表了一个"Socket"，当一个 struct socket 数据结构被分配空间后，再将其与一个已打开的文件“建立映射关系”。这样，用户态就可以用抽像的文件的概念来操作socket了——当然，由  于网络的特殊性，至少就目前而言，这种抽像，并不如其它模块的抽像那么完美。 
 

文件系统 struct vfsmount 中有一个成员指针 mnt_sb 指向该文件系统的超级块，而超级块结构 struct super_lock 有一个重要的成员 s_op 指向了超级块的操作函数表，其中有函数指针 alloc_inode()即为在给定的超级块下创建并初始化一 个新的索引节点对像。也就是调用： 

sock_mnt->mnt_sb->s_op->alloc_inode(sock_mnt->mnt_sb);

当然，连同相关的处理细节一起，这一操作被层层封装至一个上层函数 new_inode()。 
 
那如何分配一个 struct socket 结构呢？如前所述，一个 socket 总是与一个inode 密切相关的。当然，在 inode 中，设置一个 socket 成员，是完全可行的，但是  这貌似浪费了空间——毕竟，更多的文件系统没有 socket 这个东东。所以，内核引入了另一个 socket_alloc 结构： 

struct socket_alloc {         struct socket socket;         struct inode vfs_inode; };

显而易见，该结构实现了 inode 和 socket 的封装。已经一个 inode，可以通过宏 SOCKET_I 来获取与之对应的 socket： 

sock = SOCKET_I(inode);  static inline struct socket *SOCKET_I(struct inode *inode) {         return &container_of(inode, struct socket_alloc, vfs_inode)->socket; } 

但是，这样做，也同时意味着，在分配一个 inode 后，必须再分配一个 socket_alloc结构，并实现对应的封装。否则，container_of 又能到哪儿去找到 socket 呢？现在来简要地看一个这个流程——这是文件系统安装中的一个重要步骤：

struct vfsmount *kern_mount(struct file_system_type *type) {         return do_kern_mount(type->name, 0, type->name, NULL); } struct vfsmount * do_kern_mount(const char *fstype, int flags, const char *name, void *data) {         struct file_system_type *type = get_fs_type(fstype);         struct super_block *sb = ERR_PTR(-ENOMEM);                 ……                 sb = type->get_sb(type, flags, name, data);                 ……                mnt->mnt_sb = sb;                …… } 

do_kern_mount 函数中，先根据注册的文件系统类型，调用 get_fs_type 获取之，也就是我们之前注册的 sock_fs_type，然后调用它的 get_sb 成员函数指针，获取相应的超级块 sb。最后，调置文件系统的超级块成员指针，使之指向对应的值。 这里 get_sb函数指针，指向之前初始化的 sockfs_get_sb()函数。 

static struct super_block *sockfs_get_sb(struct file_system_type *fs_type,         int flags, const char *dev_name, void *data) {         return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC); } 

注意其第三个参数 sockfs_ops，它封装了 sockfs 的功能函数表： 

static struct super_operations sockfs_ops = {         .alloc_inode =        sock_alloc_inode,         .destroy_inode =sock_destroy_inode,         .statfs =        simple_statfs, }; struct super_block * get_sb_pseudo(struct file_system_type *fs_type, char *name,         struct super_operations *ops, unsigned long magic) {         struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);                 ……                          s->s_op = ops ? ops : &default_ops; }

这里就是先获取/分配一个超级块，然后初始化超级块的各成员，包括 s_op，我们前面提到过它，它封装了对应的功能函数表。这里 s_op 自然就指向了 sockfs_ops。那前面提到的 new_inode()函数分配 inode 时调用的：

sock_mnt->mnt_sb->s_op->alloc_inode(sock_mnt->mnt_sb);

这个 alloc_inode 函数指针也就是 sockfs_ops的 sock_alloc_inode()函数——转了一大圈，终于指到它了。 来看看 sock_alloc_inode 是如何分配一个 inode 节点的： 

static struct inode *sock_alloc_inode(struct super_block *sb) {         struct socket_alloc *ei;         ei = (struct socket_alloc *)kmem_cache_alloc(sock_inode_cachep, SLAB_KERNEL);         if (!ei)                 return NULL;         init_waitqueue_head(&ei->socket.wait);                  ei->socket.fasync_list = NULL;         ei->socket.state = SS_UNCONNECTED;         ei->socket.flags = 0;         ei->socket.ops = NULL;         ei->socket.sk = NULL;         ei->socket.file = NULL;         ei->socket.flags = 0;          return &ei->vfs_inode; } 

函数先分配了一个用于封装 socket 和 inode 的 ei，然后在高速缓存中为之申请了一块空间。这样，inode 和 socket 就同时都被分配了。接下来初始化 socket 的各个成员，这些成员，在后面都会一一提到。 

/**  struct socket - general BSD socket *  @state: socket state (%SS_CONNECTED, etc) *  @flags: socket flags (%SOCK_ASYNC_NOSPACE, etc) *  @ops: protocol specific socket operations *  @fasync_list: Asynchronous wake up list *  @file: File back pointer for gc *  @sk: internal networking protocol agnostic socket representation *  @wait: wait queue for several uses *  @type: socket type (%SOCK_STREAM, etc) */ struct socket {         socket_state                state;         unsigned long                flags;         struct proto_ops        *ops;         struct fasync_struct        *fasync_list;         struct file                *file;         struct sock                *sk;         wait_queue_head_t        wait;         short                        type; }; 

OK，至目前为止，分配 inode、socket 以及两者如何关联，都已一一分析了。 最后一个关键问题，就是如何把 socket 与一个已打开的文件，建立映射关系。 
 

在内核中，用 struct file结构描述一个已经打开的文件，指向该结构的指针内核中通常用 file或 filp来描述。我们知道，内核中，可以通过全局项 current 来获得当  前进程，它是一个 struct task_struct类型的指针。tastk_struct 有一个成员： 

struct files_struct *files; 

指向一个已打开的文件。当然，由于一个进程可能打开多个文件，所以，struct files_struct 结构有 struct file * fd_array[NR_OPEN_DEFAULT]; 
成员，这是个数组，以文件描述符为下标，即 current->files->fd[fd]，可以找到与当前进程指定文件描述符的文件。 
 

有了这些基础，如果要把一个 socket 与一个已打开的文件建立映射，首先要做的就是为 socket分配一个struct file，并申请分配一个相应的文件描述符fd。因为socket并不支持open方法（前面说socket的文件界面的抽像并不完美，这应该是一个佐证 吧？），所以不能期望用户界面通过调用 open() API来分配一个 struct file，而是通过调用get_empty_filp 来获取：

 

struct file *file = get_empty_filp();
 
同样地： 
int fd; 
fd = get_unused_fd();
获取一个空间的文件描述符 
 
然后，让 current 的 files指针的 fd 数组的 fd 索引项指向该 file： 

void fastcall fd_install(unsigned int fd, struct file * file) {         struct files_struct *files = current->files;         spin_lock(&files->file_lock);         if (unlikely(files->fd[fd] != NULL))                 BUG();         files->fd[fd] = file;         spin_unlock(&files->file_lock); }

OK，做到这一步，有了一个文件描述符 fd 和一个打开的文件 file，它们与当前进程相连，但是好像与创建的socket并无任何瓜葛。要做的映射还是没  有进展。 struct file或文件描述述fd或current都没有任何能够与 inode或者是 socket 相关的东东。这需要一个中间的桥梁，目录项：struct dentry结构。 因为一个文件都有与其对应的目录项： 

struct file {         struct list_head        f_list;         struct dentry                *f_dentry; ……  而一个目录项： struct dentry { ……         struct inode *d_inode;                /* Where the name belongs to - NULL is                                          * negative */ 

d_inode 成员指向了与之对应的 inode节点…… 

而之前已经创建了一个 inode 节点和与之对应的 socket。 所以，现在要做的，就是： “先为当前文件分配一个对应的目录项，再将已创建的 inode节点安装至该目录项” 这样，一个完成的映射关系： 进程、文件描述符、打开文件、目录项、inode节点、socket就完整地串起来了。 

现在可以来看套接字的创建过程了： 

asmlinkage long sys_socket(int family, int type, int protocol) {         int retval;         struct socket *sock;          retval = sock_create(family, type, protocol, &sock);         if (retval < 0)                 goto out;          retval = sock_map_fd(sock);         if (retval < 0)                 goto out_release;  out:         /* It may be already another descriptor 8) Not kernel problem. */         return retval;  out_release:         sock_release(sock);         return retval; }  int sock_create(int family, int type, int protocol, struct socket **res) {         return __sock_create(family, type, protocol, res, 0); }