linux内核中socket的实现

首先来看整个与socket相关的操作提供了一个统一的接口sys_socketcall. 

下面就是它的代码片段: 

Java代码  

1. asmlinkage long sys_socketcall(int call, unsigned long __user *args)  
2. {  
3.     unsigned long a[6];  
4.     unsigned long a0, a1;  
5.     int err;  
6. ..........................................  
7.   
8.     a0 = a[0];  
9.     a1 = a[1];  
10.   
11.     switch (call) {  
12.     case SYS_SOCKET:  
13.         err = sys_socket(a0, a1, a[2]);  
14.         break;  
15.     case SYS_BIND:  
16.         err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);  
17.         break;  
18.     case SYS_CONNECT:  
19.         err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);  
20.         break;  
21.     case SYS_LISTEN:  
22.         err = sys_listen(a0, a1);  
23.         break;  
24.     case SYS_ACCEPT:  
25.         err =  
26.             do_accept(a0, (struct sockaddr __user *)a1,  
27.                   (int __user *)a[2], 0);  
28.         break;  
29.     case SYS_GETSOCKNAME:  
30.         err =  
31.             sys_getsockname(a0, (struct sockaddr __user *)a1,  
32.                     (int __user *)a[2]);  
33.         break;  
34. .....................................  
35.     return err;  
36. }  

可以看到代码比较简单,就是通过传递进来的call类型,来调用相应的socket相关的函数. 

这里你可能注意到了,那就是一般文件句柄相关的操作,比如write,read,aio,poll这些并没有看到(也就是file_operations).这是因为socket上面其实还有一层vfs层,内核把socket当做一个文件系统来处理,并实现了相应的vfs方法.因此下面我们先来了解下vfs.然后会描述下进程如何通过vfs存取句柄. 

vfs其实就相当于对下层的文件系统和上层应用之间的粘合层,它定义了文件系统需要实现的相关的操作,然后下层的文件系统只需要实现这些方法就可以了,也就是说在内核其他部分和上层应用看来,所有的文件系统没有任何区别. 

下面的这张图就是从用户空间调用write的大体流程: 



vfs中有4种主要的数据结构: 

1 超级块对象,代表一个已安装的文件系统.super_block 

2 索引节点对象,代表一个文件.inode 

3 目录项对象,代表一个目录项.dentry 

4 文件对象,表示一个被进程打开的文件.file 

其中每种对象都包含一个操作对象.依次为super_operations,inode_operations,dentry_operations以及file_operations.各自操作不同的层次.然后我们的文件系统只需要实现这些方法,然后注册到内核就可以了. 

接下来我们来看和vfs相应的结构: 

第一个就是file_system_type结构,这个结构表示了一个文件系统: 

Java代码  

1. struct file_system_type {  
2.     const char *name;  
3.     int fs_flags;  
4. ///最关键的函数,得到文件系统的超级块.  
5.     int (*get_sb) (struct file_system_type *, int,  
6.                const char *, void *, struct vfsmount *);  
7.     void (*kill_sb) (struct super_block *);  
8. ...........................................  
9. };  

然后是vfsmount结构,它表示了一个安装点,换句话说也就是一个文件系统实例. 

第三个是files_struct结构,它主要是为每个进程来维护它所打开的句柄.这里只需要注意一个就是fd_array和fstable中的fd的区别.当进程数比较少也就是小于NR_OPEN_DEFAULT(32)时,句柄就会存放在fd_array中,而当句柄数超过32则就会重新分配数组,然后将fd指针指向它(然后我们通过fd就可以取得相应的file结构). 

而且files_struct是每个进程只有一个的. 

Java代码  

1. struct files_struct {  
2.   /* 
3.    * read mostly part 
4.    */  
5.     atomic_t count;  
6.     struct fdtable *fdt;  
7.     struct fdtable fdtab;  
8.   /* 
9.    * written part on a separate cache line in SMP 
10.    */  
11.     spinlock_t file_lock ____cacheline_aligned_in_smp;  
12.     int next_fd;  
13.     struct embedded_fd_set close_on_exec_init;  
14.     struct embedded_fd_set open_fds_init;  
15. ///所打开的所有文件  
16.     struct file * fd_array[NR_OPEN_DEFAULT];  
17. };  
18.   
19.   
20. struct fdtable {  
21.     unsigned int max_fds;  
22.     struct file ** fd;      /* current fd array */  
23.     fd_set *close_on_exec;  
24.     fd_set *open_fds;  
25.     struct rcu_head rcu;  
26.     struct fdtable *next;  
27. };  

还有两个一个是fs_struct,一个是namespace也都是进程相关的.这里就不一一介绍了. 

我这里vfs介绍只是个大概,需要详细了解的,可以去看ulk的vfs相关章节和linux内核设计与实现的相关章节. 

因此下面的图表示了进程和socket的关系: 




上面的这张图有些老了,新的内核中的inode节点中已经没有u这个联合体了,对应的是会有一个包含socket和inode的一个结构体,然后我们通过inode,而inode中专门有个i_mode域来判断相应的inode类型,比如socket就是 S_IFSOCK.就可以直接计算出相应的socket的地址,然后就可以存取socket了.后面我们会介绍. 

内核中标售socket有两个数据结构,一个是socket,另一个是sock,其中socket是一个general BSD socket, 它也就是应用程序和4层协议之间的一个接口,屏蔽掉了相关的4层协议部分.而在内核中,socket所需要使用的相关的4层协议的信息全部是保存在sock结构当中的,而socket和sock这两个结构都有保存对方的指针,因此可以很容易的存取对方.

还有一个就是ops域,这个域保存了所有的相关的4层协议的操作函数.. 

而在sock中有一个sk_common保存了一个skc_prot域,这个域保存的是相应的协议簇的操作函数的集合. 


后面介绍到socket创建的时候,我们会分析proto_ops和proto的区别.其实proto相当于对proto_ops的一层封装,最终会在proto中调用proto_ops. 

Java代码  

1. /** 
2.  *  struct socket - general BSD socket 
3.  *  @state: socket state (%SS_CONNECTED, etc) 
4.  *  @type: socket type (%SOCK_STREAM, etc) 
5.  *  @flags: socket flags (%SOCK_ASYNC_NOSPACE, etc) 
6.  *  @ops: protocol specific socket operations 
7.  *  @fasync_list: Asynchronous wake up list 
8.  *  @file: File back pointer for gc 
9.  *  @sk: internal networking protocol agnostic socket representation 
10.  *  @wait: wait queue for several uses 
11.  */  
12. struct socket {  
13.     socket_state        state;  
14.     short           type;  
15.     unsigned long       flags;  
16.     const struct proto_ops  *ops;  
17.     struct fasync_struct    *fasync_list;  
18.     struct file     *file;  
19.     struct sock     *sk;  
20.     wait_queue_head_t   wait;  
21. };  
22.   
23. struct sock_common {  
24.     unsigned short      skc_family;  
25.     volatile unsigned char  skc_state;  
26.     unsigned char       skc_reuse;  
27.     int         skc_bound_dev_if;  
28.     struct hlist_node   skc_node;  
29.     struct hlist_node   skc_bind_node;  
30.     atomic_t        skc_refcnt;  
31.     unsigned int        skc_hash;  
32.     struct proto        *skc_prot;  
33. #ifdef CONFIG_NET_NS  
34.     struct net      *skc_net;  
35. #endif  
36. };  
37.   
38. struct proto_ops {  
39.     int     family;  
40.     struct module   *owner;  
41.     int     (*release)   (struct socket *sock);  
42.     int     (*bind)      (struct socket *sock,  
43.                       struct sockaddr *myaddr,  
44.                       int sockaddr_len);  
45.     int     (*connect)   (struct socket *sock,  
46.                       struct sockaddr *vaddr,  
47.                       int sockaddr_len, int flags);  
48. ...................................................  
49. };  

然后我们来看sock_init的实现,在这个函数中,将socket注册为一个伪文件系统,并安装相应的mount点: 

Java代码  

1. ///相应的mount对象  
2. static struct vfsmount *sock_mnt __read_mostly;  
3. ///文件系统对象.  
4. static struct file_system_type sock_fs_type = {  
5.     .name =     "sockfs",  
6.     .get_sb =   sockfs_get_sb,  
7.     .kill_sb =  kill_anon_super,  
8. };  
9.   
10. static int __init sock_init(void)  
11. {  
12.     /* 
13.      *      Initialize sock SLAB cache. 
14.      */  
15.   
16.     sk_init();  
17.   
18.     /* 
19.      *      Initialize skbuff SLAB cache 
20.      */  
21.     skb_init();  
22.   
23. ///初始化一个inodecache.  
24.     init_inodecache();  
25. ///注册文件系统到内核.  
26.     register_filesystem(&sock_fs_type);  
27. ///安装mount点.  
28.     sock_mnt = kern_mount(&sock_fs_type);  
29.   
30. #ifdef CONFIG_NETFILTER  
31.     netfilter_init();  
32. #endif  
33.     return 0;  
34. }  

我们知道每次创建一个socket,都是要依赖于当前的protocol family类型的(后面会分析sys_socket的源码的时候会看到).而在内核中,每种类型的protocol family都会有一个相对应的net_proto_family结构,然后将这个结构注册到内核的net_families数组中,这样我们创建socket的时候,就可以调用这个数组来创建socket. 


我们先来看sock_register的源码,也就是如何将一个net_proto_family注册到相应的数组: 

Java代码  

1. static const struct net_proto_family *net_families[NPROTO] __read_mostly;  
2.   
3. int sock_register(const struct net_proto_family *ops)  
4. {  
5.     int err;  
6.   
7.     if (ops->family >= NPROTO) {  
8.         printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family,  
9.                NPROTO);  
10.         return -ENOBUFS;  
11.     }  
12.   
13.     spin_lock(&net_family_lock);  
14. ///代码非常简单,就是根据类型,然后放到相应的位置.  
15.     if (net_families[ops->family])  
16.         err = -EEXIST;  
17.     else {  
18.         net_families[ops->family] = ops;  
19.         err = 0;  
20.     }  
21.     spin_unlock(&net_family_lock);  
22.   
23.     printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);  
24.     return err;  
25. }  

我们知道每个协议簇和相应的套接口都对应有好多种组合,因此在协议簇的实现中保存了一个相应的结构来保存这些组合,然后后面就首先通过family然后确定到某个结构,再根据套接口的类型来得到这个结构,并赋值给sock. 

这里要注意我们只分析af_inet的实现,其他的协议簇都差不多: 


我们来看这个的实现: 

Java代码  

1. ///可以看到这是一个数组,每个元素都是一个链表,也就是每种类型的socket就是一个链表.而这个链表所包含的是不同4层协议的inetsw.可是在inet中,现在每种类型的socket只对应一个4层协议.这里只是为了以后扩展.  
2. static struct list_head inetsw[SOCK_MAX];  
3.   
4. ///相应的socket的对应的信息的结构.  
5. struct inet_protosw {  
6.     struct list_head list;  
7.   
8. ///需要这两个key才能定位一个inet_protosw.  
9.     unsigned short   type;     /* This is the 2nd argument to socket(2). */  
10.     unsigned short   protocol; /* This is the L4 protocol number.  */  
11.   
12. ///相应的基于ipv4的4层协议的操作集合.  
13.     struct proto     *prot;  
14. ///相应的协议簇的操作信息.  
15.     const struct proto_ops *ops;  
16.     
17.     int              capability; /* Which (if any) capability do 
18.                       * we need to use this socket 
19.                       * interface? 
20.                                       */  
21.     char             no_check;   /* checksum on rcv/xmit/none? */  
22.     unsigned char    flags;      /* See INET_PROTOSW_* below.  */  
23. };  
24.   
25. void inet_register_protosw(struct inet_protosw *p)  
26. {  
27.     struct list_head *lh;  
28.     struct inet_protosw *answer;  
29.     int protocol = p->protocol;  
30.     struct list_head *last_perm;  
31. .............................................  
32.     answer = NULL;  
33.     last_perm = &inetsw[p->type];  
34. ///这个操作也很简单,就是将inet_protosw根据套接口类型插入到全局链表数组.  
35.     list_for_each(lh, &inetsw[p->type]) {  
36.         answer = list_entry(lh, struct inet_protosw, list);  
37.   
38.         /* Check only the non-wild match. */  
39.         if (INET_PROTOSW_PERMANENT & answer->flags) {  
40.             if (protocol == answer->protocol)  
41.                 break;  
42.             last_perm = lh;  
43.         }  
44.   
45.         answer = NULL;  
46.     }  
47.     if (answer)  
48.         goto out_permanent;  
49. ///插入链表.  
50.     list_add_rcu(&p->list, last_perm);  
51. ..............................  

接下来来分析inet_init的源码. 

Java代码  

1. ///表示了所有的可能的当前协议簇和套接口类型的组合.  
2. static struct inet_protosw inetsw_array[] =  
3. {  
4.     {  
5.         .type =       SOCK_STREAM,  
6.         .protocol =   IPPROTO_TCP,  
7.         .prot =       &tcp_prot,  
8.         .ops =        &inet_stream_ops,  
9.         .capability = -1,  
10.         .no_check =   0,  
11.         .flags =      INET_PROTOSW_PERMANENT |  
12.                   INET_PROTOSW_ICSK,  
13.     },  
14.   
15.     {  
16.         .type =       SOCK_DGRAM,  
17.         .protocol =   IPPROTO_UDP,  
18.         .prot =       &udp_prot,  
19.         .ops =        &inet_dgram_ops,  
20.         .capability = -1,  
21.         .no_check =   UDP_CSUM_DEFAULT,  
22.         .flags =      INET_PROTOSW_PERMANENT,  
23.        },  
24.   
25.   
26.        {  
27.            .type =       SOCK_RAW,  
28.            .protocol =   IPPROTO_IP,    /* wild card */  
29.            .prot =       &raw_prot,  
30.            .ops =        &inet_sockraw_ops,  
31.            .capability = CAP_NET_RAW,  
32.            .no_check =   UDP_CSUM_DEFAULT,  
33.            .flags =      INET_PROTOSW_REUSE,  
34.        }  
35. };  
36.   
37. ///协议簇的创建函数.  
38. static struct net_proto_family inet_family_ops = {  
39.     .family = PF_INET,  
40.     .create = inet_create,  
41.     .owner  = THIS_MODULE,  
42. };  
43.   
44. static int __init inet_init(void)  
45. {  
46. .............................................  
47.   
48. ///注册相应的proto到全局链表中.  
49.     rc = proto_register(&tcp_prot, 1);  
50.     if (rc)  
51.         goto out;  
52.   
53.     rc = proto_register(&udp_prot, 1);  
54.     if (rc)  
55.         goto out_unregister_tcp_proto;  
56.   
57.     rc = proto_register(&raw_prot, 1);  
58.     if (rc)  
59.         goto out_unregister_udp_proto;  
60.   
61. ///注册协议簇的操作函数(后面socket创建的时候会用到).  
62.     (void)sock_register(&inet_family_ops);  
63.   
64. .............................................  
65.     /* Register the socket-side information for inet_create. */  
66.     for (r = &inetsw[0]; r < &inetsw[SOCK_MAX]; ++r)  
67.         INIT_LIST_HEAD(r);  
68.   
69. ///将inetsw_array插入到相应的数组链表.  
70.     for (q = inetsw_array; q < &inetsw_array[INETSW_ARRAY_LEN]; ++q)  
71.         inet_register_protosw(q);  
72. ...........................................  
73.   
74. }  

接下来我们来通过分析创建socket的函数sys_socket,来更加好的理解socket的实现. 

Java代码  

1. asmlinkage long sys_socket(int family, int type, int protocol)  
2. {  
3. ...............................................  
4. ///主要是两个函数,一个是创建socket  
5.     retval = sock_create(family, type, protocol, &sock);  
6.     if (retval < 0)  
7.         goto out;  
8. ///这个是相应的文件系统的操作.  
9.     retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));  
10. ....................................  
11. }  

sock_create的具体流程我们就不分析了,我们只需要知道最终他会通过传递进来的family的值,来取得相应的family中注册的creat函数.然后会调用这个函数来完成socket的创建.而在上面的代码分析中,我们知道在af_inet中,注册的create函数是inet_create函数,因此我们来看这个函数的实现: 

Java代码  

1. static int inet_create(struct net *net, struct socket *sock, int protocol)  
2. {  
3.     struct sock *sk;  
4.     struct inet_protosw *answer;  
5.     struct inet_sock *inet;  
6.     struct proto *answer_prot;  
7.     unsigned char answer_flags;  
8.     char answer_no_check;  
9.     int try_loading_module = 0;  
10.     int err;  
11. ...........................................................  
12. ///首先给socket状态赋值.  
13.   
14.     sock->state = SS_UNCONNECTED;  
15.   
16.     /* Look for the requested type/protocol pair. */  
17. lookup_protocol:  
18.     err = -ESOCKTNOSUPPORT;  
19.     rcu_read_lock();  
20. ///通过type和protocl的值,来查找到相应的inet_protosw结构.  
21.     list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {  
22.   
23.         err = 0;  
24.         /* Check the non-wild match. */  
25.         if (protocol == answer->protocol) {  
26.             if (protocol != IPPROTO_IP)  
27.                 break;  
28.         } else {  
29.             /* Check for the two wild cases. */  
30.             if (IPPROTO_IP == protocol) {  
31.                 protocol = answer->protocol;  
32.                 break;  
33.             }  
34.             if (IPPROTO_IP == answer->protocol)  
35.                 break;  
36.         }  
37.         err = -EPROTONOSUPPORT;  
38.     }  
39.   
40.     ..........................................  
41.   
42. ///开始给socket赋值.这里我们可以看到最终socket的ops域所得到的值就是相应的协议簇的操作集合(比如inet_stream_ops这些)..  
43.     sock->ops = answer->ops;  
44.     answer_prot = answer->prot;  
45.     answer_no_check = answer->no_check;  
46.     answer_flags = answer->flags;  
47.     rcu_read_unlock();  
48.   
49.     WARN_ON(answer_prot->slab == NULL);  
50.   
51.     err = -ENOBUFS;  
52. ///alloc一个sock结构,其中将刚才取得的inet_protosw中的pro 域赋值给sock的sk_prot域和sk_prot_creator.以及family域也被相应的赋值.  
53.     sk = sk_alloc(net, PF_INET, GFP_KERNEL, answer_prot);  
54.     if (sk == NULL)  
55.         goto out;  
56. ....................................................................  
57.   
58. ///这个函数中会初始化相应的socket中的写队列,读队列以及错误队列.并将sk指针和sock连接起来.而且还将初始化相应的定时器.  
59.   
60.     sock_init_data(sock, sk);  
61. ..........................................  
62. ///调用相应的初始化.  
63.   
64.     if (sk->sk_prot->init) {  
65. ///其实也就是相对应4层协议的初始化函数,它会初始化一些协议相关的东西.  
66.         err = sk->sk_prot->init(sk);  
67.         if (err)  
68.             sk_common_release(sk);  
69.     }  
70. out:  
71.     return err;  
72. out_rcu_unlock:  
73.     rcu_read_unlock();  
74.     goto out;  
75. }  

这里举个例子,来看一下tcp_v4_init_sock的实现,也就是tcp的初始化函数. 

Java代码  

1. static int tcp_v4_init_sock(struct sock *sk)  
2. {  
3.     struct inet_connection_sock *icsk = inet_csk(sk);  
4.     struct tcp_sock *tp = tcp_sk(sk);  
5.   
6.     skb_queue_head_init(&tp->out_of_order_queue);  
7. ///初始化定时器,也就是tcp的那3个定时器,write,delay以及keepalive定时器.  
8.     tcp_init_xmit_timers(sk);  
9.     tcp_prequeue_init(tp);  
10. ...................................  
11. ///状态赋值.初始状态.  
12.     sk->sk_state = TCP_CLOSE;  
13.   
14. ..................................  
15.   
16.     return 0;  
17. }  

上面我们看到有两个新的结构inet_connection_sock以及tcp_sock.我们接下来就来看这两个结构. 

inet_connection_sock也就是所有面向连接的协议的socket的相关信息.它的第一个域是inet_sock,因此我们可以很方便的进行转换.而tcp_sock 相当与inet_connection_sock得一个子类,保存有所有tcp相关的socket的信息.它的第一个域就是inet_connection_sock. 

可以看到其实tcp_socket类似于inet_sock(前面的blog有介绍),都是保存了本层的相关的信息. 

这里就不列出这两个结构了,内核中这两个结构的注释都是很详细的.. 



在看sock_map_fd实现之前,我们先来看内核中socket类型的inode节点的实现: 

这里看到,我们只要拥有了inode节点,通过containof宏我们就可以计算出socket的地址,从而就可以得到整个socket的信息了. 

Java代码  

1. struct socket_alloc {  
2.     struct socket socket;  
3.     struct inode vfs_inode;  
4. };  

而inode节点的赋值是在sock_alloc中实现的,而这个函数是在__sock_create中被调用的,也就是在init_cteate被调用之前. 

Java代码  

1. static struct socket *sock_alloc(void)  
2. {  
3.     struct inode *inode;  
4.     struct socket *sock;  
5.   
6. ///新建一个inode,sock_mnt就是sock_init中被安装的mount点.  
7.     inode = new_inode(sock_mnt->mnt_sb);  
8.     if (!inode)  
9.         return NULL;  
10. ///然后组合inode和socket结构.  
11.     sock = SOCKET_I(inode);  
12. ///设置inode类型.  
13.     inode->i_mode = S_IFSOCK | S_IRWXUGO;  
14.     inode->i_uid = current->fsuid;  
15.     inode->i_gid = current->fsgid;  
16. ///将sockets_in_use(也就是当前创建的socket)加一.  
17.     get_cpu_var(sockets_in_use)++;  
18.     put_cpu_var(sockets_in_use);  
19.     return sock;  
20. }  

然后我们来看sock_map_fd的实现.我们首先要知道,socket是没有open函数的,因此要通过vfs层的调用,必须要在create的时候,映射一个file结构,从而将句柄与这个file关联起来. 

Java代码  

1. int sock_map_fd(struct socket *sock, int flags)  
2. {  
3.     struct file *newfile;  
4. ///找到一个可用的fd,并找到一个可用的file结构并返回.  
5.     int fd = sock_alloc_fd(&newfile, flags);  
6.   
7.     if (likely(fd >= 0)) {  
8. ///初始化这个file结构.  
9.         int err = sock_attach_fd(sock, newfile, flags);  
10.   
11.         if (unlikely(err < 0)) {  
12.             put_filp(newfile);  
13.             put_unused_fd(fd);  
14.             return err;  
15.         }  
16. ///将句柄和文件指针关联起来.  
17.         fd_install(fd, newfile);  
18.     }  
19.     return fd;  
20. }  

sock_alloc_fd实现比较简单,这里就不分析了. 


就来看下sock_attach_fd的实现.: 


这里要注意,内核通过把socket指针赋值给file的private_data,这样就可以通过句柄,在fdtable中得到file对象,然后轻松取得socket对象. 

Java代码  

1. ///目录项的操作集合  
2. static struct dentry_operations sockfs_dentry_operations = {  
3.     .d_delete = sockfs_delete_dentry,  
4.     .d_dname  = sockfs_dname,  
5. };  
6. ///文件的操作集合.这些函数最终调用的还是socket的ops域中的函数.而我们上面已经提过最终他们调用sock域的proto中的函数.  
7. static const struct file_operations socket_file_ops = {  
8.     .owner =    THIS_MODULE,  
9.     .llseek =   no_llseek,  
10.     .aio_read = sock_aio_read,  
11.     .aio_write =    sock_aio_write,  
12.     .poll =     sock_poll,  
13.     .unlocked_ioctl = sock_ioctl,  
14. #ifdef CONFIG_COMPAT  
15.     .compat_ioctl = compat_sock_ioctl,  
16. #endif  
17.     .mmap =     sock_mmap,  
18.     .open =     sock_no_open,   /* special open code to disallow open via /proc */  
19.     .release =  sock_close,  
20.     .fasync =   sock_fasync,  
21.     .sendpage = sock_sendpage,  
22.     .splice_write = generic_splice_sendpage,  
23.     .splice_read =  sock_splice_read,  
24. };  
25.   
26. static int sock_attach_fd(struct socket *sock, struct file *file, int flags)  
27. {  
28.     struct dentry *dentry;  
29.     struct qstr name = { .name = "" };  
30. ///根据装载点的mnt_sb(super block)的root域来创建一个目录项.  
31.     dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name);  
32.     if (unlikely(!dentry))  
33.         return -ENOMEM;  
34. ///将sockfs的目录项操作集合赋值.  
35.     dentry->d_op = &sockfs_dentry_operations;  
36.     /* 
37.      * We dont want to push this dentry into global dentry hash table. 
38.      * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED 
39.      * This permits a working /proc/$pid/fd/XXX on sockets 
40.      */  
41.     dentry->d_flags &= ~DCACHE_UNHASHED;  
42. ///将inode和目录项关联起来.  
43.     d_instantiate(dentry, SOCK_INODE(sock));  
44.   
45.     sock->file = file;  
46. ///初始化文件对象,主要就是将socket_file_ops赋值给file结构的f_op域.  
47.     init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE,  
48.           &socket_file_ops);  
49.     SOCK_INODE(sock)->i_fop = &socket_file_ops;  
50.     file->f_flags = O_RDWR | (flags & O_NONBLOCK);  
51.     file->f_pos = 0;  
52. ///将sock赋值给private_data,这样我们就能通过file轻松获得socket结构(在后面会用到).  
53.     file->private_data = sock;  
54.   
55.     return 0;  
56. }  

下面就是sys_socket的流程图: 


 


最终来总结一下.内核中,socket是作为一个伪文件系统来实现的,它在初始化时注册到内核,而每个进程的files_struct域保存了所有的句柄,包括socket的.一般的文件操作的话,内核直接调用vfs层的方法,然后会自动调用socket实现的相关方法.内核通过inode结构的imode域就可以知道当前的句柄所关联的是不是socket类型,这时遇到socket独有的操作,就通过containof方法,来计算出socket的地址,从而就可以进行相关的操作. 


最后我们要注意的是,内核在调用相关操作都是直接调用socket的ops域,然后在ops域中调用相应的sock结构体中的sock_common域的skc_prot的操作集中的相对应的函数. 

举个例子,假设现在我们使用tcp协议然后调用bind方法,内核会先调用sys_bind方法: 

Java代码  

1. asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)  
2. {  
3. ................................................  
4.             if (!err)  
5.                 err = sock->ops->bind(sock,  
6.                               (struct sockaddr *)  
7.                               &address, addrlen);  
8. ...................................................  
9. }  

可以看到它调用的是ops域的bind方法.而这时我们的ops域是inet_stream_ops,来看它的bind方法: 

Java代码  

1. int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)  
2. {  
3. ..............................................  
4.   
5.     /* If the socket has its own bind function then use it. (RAW) */  
6.     if (sk->sk_prot->bind) {  
7.         err = sk->sk_prot->bind(sk, uaddr, addr_len);  
8.         goto out;  
9.     }  
10. ................................................  
11. }  

它最终调用的是sock结构的sk_prot域(也就是sock_common的skc_prot域)的bind方法,而此时我们的skc_prot的值是tcp_prot,因此最终会调用tcp_prot的bind方法. 

下面就是示意图: 



PS:随便抱怨下,linux kernel的socket实现也太复杂了..不知道其他的操作系统的socket实现的怎么样..