程序博客网 > 鱼油哪个牌子好,知乎

socket 与 vfs

来源：互联网 发布：鱼油哪个牌子好,知乎 编辑：程序博客网 时间：2024/05/22 23:58
首先来看整个与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实现的怎么



bind的实现: 



先来介绍几个地址结构. 

struct sockaddr 其实相当于一个基类的地址结构,其他的结构都能够直接转到sockaddr.举个例子比如当sa_family为PF_INET时,sa_data就包含了端口号和ip地址(in_addr结构). 
Java代码  收藏代码
  1. struct sockaddr {  
  2.     sa_family_t sa_family;  /* address family, AF_xxx   */  
  3.     char        sa_data[14];    /* 14 bytes of protocol address */  
  4. };  


接下来就是sockaddr_in ,它表示了所有的ipv4的地址结构.可以看到他也就相当于sockaddr 的一个子类. 
Java代码  收藏代码
  1. struct sockaddr_in {  
  2.   sa_family_t       sin_family; /* Address family       */  
  3.   __be16        sin_port;   /* Port number          */  
  4.   struct in_addr    sin_addr;   /* Internet address     */  
  5.   /* Pad to size of `struct sockaddr'. */  
  6.   unsigned char     __pad[__SOCK_SIZE__ - sizeof(short int) -  
  7.             sizeof(unsigned short int) - sizeof(struct in_addr)];  
  8. };  


这里还有一个内核比较新的地质结构sockaddr_storage,他可以容纳所有类型的套接口结构,比如ipv4,ipv6..可以看到它是强制对齐的,相比于sockaddr. 

Java代码  收藏代码
  1. struct __kernel_sockaddr_storage {  
  2.     unsigned short  ss_family;      /* address family */  
  3. ///每个协议实现自己的地址结构.  
  4.     char        __data[_K_SS_MAXSIZE - sizeof(unsigned short)];  
  5.                 /* space to achieve desired size, */  
  6.                 /* _SS_MAXSIZE value minus size of ss_family */  
  7. } __attribute__ ((aligned(_K_SS_ALIGNSIZE)));   /* force desired alignment */  


接下来看几个和bind相关的数据结构: 

第一个是inet_hashinfo,它主要用来管理 tcp的bind hash bucket(在tcp的初始化函数中会将tcp_hashinfo初始化.然后在tcp_prot中会将tcp_hashinfo付给结构体h,然后相应的我们就可以通过sock中的sock_common域来存取这个值).后面我们会分析这个流程. 

Java代码  收藏代码
  1. struct inet_hashinfo {  
  2.     /* This is for sockets with full identity only.  Sockets here will 
  3.      * always be without wildcards and will have the following invariant: 
  4.      * 
  5.      *          TCP_ESTABLISHED <= sk->sk_state < TCP_CLOSE 
  6.      * 
  7.      * TIME_WAIT sockets use a separate chain (twchain). 
  8.      */  
  9. ///下面会分析这个结构.  
  10.     struct inet_ehash_bucket    *ehash;  
  11.     rwlock_t            *ehash_locks;  
  12.     unsigned int            ehash_size;  
  13.     unsigned int            ehash_locks_mask;  
  14.   
  15.     /* Ok, let's try this, I give up, we do need a local binding 
  16.      * TCP hash as well as the others for fast bind/connect. 
  17.      */  
  18. ///表示所有的已经在使用的端口号的信息.这里bhash也就是一个hash链表,而链表的元素是inet_bind_bucket,紧接着我们会分析这个结构.  
  19.     struct inet_bind_hashbucket *bhash;  
  20.   
  21.     unsigned int            bhash_size;  
  22.     /* Note : 4 bytes padding on 64 bit arches */  
  23.   
  24.     /* All sockets in TCP_LISTEN state will be in here.  This is the only 
  25.      * table where wildcard'd TCP sockets can exist.  Hash function here 
  26.      * is just local port number. 
  27.      */  
  28. ///listening_hash表示所有的处于listen状态的socket.  
  29.     struct hlist_head       listening_hash[INET_LHTABLE_SIZE];  
  30.   
  31.     /* All the above members are written once at bootup and 
  32.      * never written again _or_ are predominantly read-access. 
  33.      * 
  34.      * Now align to a new cache line as all the following members 
  35.      * are often dirty. 
  36.      */  
  37.     rwlock_t            lhash_lock ____cacheline_aligned;  
  38.     atomic_t            lhash_users;  
  39.     wait_queue_head_t       lhash_wait;  
  40.     struct kmem_cache           *bind_bucket_cachep;  
  41. };  


struct inet_ehash_bucket管理所有的tcp状态在TCP_ESTABLISHED和TCP_CLOSE之间的socket.这里要注意,twchain表示处于TIME_WAIT的socket. 

Java代码  收藏代码
  1. struct inet_ehash_bucket {  
  2.     struct hlist_head chain;  
  3.     struct hlist_head twchain;  
  4. };  



inet_bind_bucket结构就是每个使用的端口的信息,最终会把它链接到bhash链表中. 

Java代码  收藏代码
  1. struct inet_bind_bucket {  
  2.     struct net      *ib_net;  
  3. ///端口号  
  4.     unsigned short      port;  
  5. ///表示这个端口是否能够被重复使用.  
  6.     signed short        fastreuse;  
  7. ///指向下一个端口的inet_bind_bucket 结构.  
  8.     struct hlist_node   node;  
  9. ///也就是使用这个端口的socket链表  
  10.     struct hlist_head   owners;  
  11. };  


最后一个结构是tcp_hashinfo他在 tcp_init中被初始化,而tcp_init是在inet_init中被初始化的.然后tcp_hashinfo会被赋值给tcp_proto和sock的sk_prot域. 

Java代码  收藏代码
  1. struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {  
  2.     .lhash_lock  = __RW_LOCK_UNLOCKED(tcp_hashinfo.lhash_lock),  
  3.     .lhash_users = ATOMIC_INIT(0),  
  4.     .lhash_wait  = __WAIT_QUEUE_HEAD_INITIALIZER(tcp_hashinfo.lhash_wait),  
  5. };  


然后来看bind的实现,bind对应的系统调用是sys_bind: 

Java代码  收藏代码
  1. asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)  
  2. {  
  3.     struct socket *sock;  
  4.     struct sockaddr_storage address;  
  5.     int err, fput_needed;  
  6.   
  7. ///通过fd查找相应的socket,如果不存在则返回错误.  
  8.     sock = sockfd_lookup_light(fd, &err, &fput_needed);  
  9.     if (sock) {  
  10. ///用户空间和内核的地址拷贝.  
  11.         err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address);  
  12.         if (err >= 0) {  
  13.             err = security_socket_bind(sock,  
  14.                            (struct sockaddr *)&address,  
  15.                            addrlen);  
  16.             if (!err)  
  17. ///调用inet_bind方法.  
  18.                 err = sock->ops->bind(sock,  
  19.                               (struct sockaddr *)  
  20.                               &address, addrlen);  
  21.         }  
  22. ///将socket对应的file结构的引用计数.  
  23.         fput_light(sock->file, fput_needed);  
  24.     }  
  25.     return err;  
  26. }  


sockfd_lookup_light主要是查找fd对应的socket 

Java代码  收藏代码
  1. static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)  
  2. {  
  3.     struct file *file;  
  4.     struct socket *sock;  
  5.   
  6.     *err = -EBADF;  
  7. ///通过fd得到对应的file结构  
  8.     file = fget_light(fd, fput_needed);  
  9.     if (file) {  
  10. ///我们在sock_map_fd通过sock_attach_fd中已经把file的private域赋值为socket,因此这里就直接返回socket.  
  11.         sock = sock_from_file(file, err);  
  12.         if (sock)  
  13.             return sock;  
  14.         fput_light(file, *fput_needed);  
  15.     }  
  16.     return NULL;  
  17. }  


然后来看inet_bind的实现. 
Java代码  收藏代码
  1. int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)  
  2. {  
  3. ///取得绑定地址.以及相关的socket和inet_sock.  
  4.     struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;  
  5.     struct sock *sk = sock->sk;  
  6.     struct inet_sock *inet = inet_sk(sk);  
  7.     unsigned short snum;  
  8.     int chk_addr_ret;  
  9.     int err;  
  10.   
  11.     /* If the socket has its own bind function then use it. (RAW) */  
  12.     if (sk->sk_prot->bind) {  
  13.         err = sk->sk_prot->bind(sk, uaddr, addr_len);  
  14.         goto out;  
  15.     }  
  16.     err = -EINVAL;  
  17.     if (addr_len < sizeof(struct sockaddr_in))  
  18.         goto out;  
  19. ///得到地址类型,比如广播地址之类的.  
  20.     chk_addr_ret = inet_addr_type(sock_net(sk), addr->sin_addr.s_addr);  
  21.   
  22.     err = -EADDRNOTAVAIL;  
  23.   
  24. ///主要是判断绑定的地址不是本地时的一些条件判断.  
  25.     if (!sysctl_ip_nonlocal_bind &&  
  26.         !inet->freebind &&  
  27.         addr->sin_addr.s_addr != htonl(INADDR_ANY) &&  
  28.         chk_addr_ret != RTN_LOCAL &&  
  29.         chk_addr_ret != RTN_MULTICAST &&  
  30.         chk_addr_ret != RTN_BROADCAST)  
  31.         goto out;  
  32. ///得到端口号.  
  33.     snum = ntohs(addr->sin_port);  
  34.     err = -EACCES;  
  35. ///主要是端口号小于prot_sock(1024)必须得有root权限.如果没有则退出.capable就是用来判断权限的.  
  36.     if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))  
  37.         goto out;  
  38.   
  39.     /*      We keep a pair of addresses. rcv_saddr is the one 
  40.      *      used by hash lookups, and saddr is used for transmit. 
  41.      * 
  42.      *      In the BSD API these are the same except where it 
  43.      *      would be illegal to use them (multicast/broadcast) in 
  44.      *      which case the sending device address is used. 
  45.      */  
  46.     lock_sock(sk);  
  47.   
  48.     /* Check these errors (active socket, double bind). */  
  49.     err = -EINVAL;  
  50. ///检测状态是否为close.如果是close状态,说明这个socket前面已经bind过了.而num只有当raw socket时才会不为0  
  51.     if (sk->sk_state != TCP_CLOSE || inet->num)  
  52.         goto out_release_sock;  
  53.   
  54. ///设置相应的地址.rcv_saddr是通过hash查找的源地址,而saddr是ip层使用的源地址(ip头的源地址).  
  55.     inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr;  
  56. ///如果是多播或者广播,设置saddr.  
  57.     if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)  
  58.         inet->saddr = 0;  /* Use device */  
  59.   
  60. ///这里get_port用来发现我们绑定的端口,是否被允许使用.而get_port在tcp中,被实例化为inet_csk_get_port,接近着我们会分析它的实现.  
  61.     if (sk->sk_prot->get_port(sk, snum)) {  
  62.         inet->saddr = inet->rcv_saddr = 0;  
  63.         err = -EADDRINUSE;  
  64.         goto out_release_sock;  
  65.     }  
  66. ///这两个锁不太理解.不知道谁能解释下.  
  67.     if (inet->rcv_saddr)  
  68.         sk->sk_userlocks |= SOCK_BINDADDR_LOCK;  
  69.     if (snum)  
  70.         sk->sk_userlocks |= SOCK_BINDPORT_LOCK;  
  71. ///设置源端口  
  72.     inet->sport = htons(inet->num);  
  73. ///目的地址和目的端口,暂时设为0  
  74.     inet->daddr = 0;  
  75.     inet->dport = 0;  
  76.     sk_dst_reset(sk);  
  77.     err = 0;  
  78. out_release_sock:  
  79.     release_sock(sk);  
  80. out:  
  81.     return err;  
  82. }  


这里我先来介绍下inet_csk_get_port的流程. 

当绑定的port为0时,这时也就是说需要kernel来分配一个新的port. 
1 首先得到系统的port范围. 

2  随机分配一个port. 

3 从bhash中得到当前随机分配的端口的链表(也就是inet_bind_bucket链表). 

4 遍历这个链表(链表为空的话,也说明这个port没有被使用),如果这个端口已经被使用,则将端口号加一,继续循环,直到找到当前没有被使用的port,也就是没有在bhash中存在的port. 

5 新建一个inet_bind_bucket,并插入到bhash中. 

当指定port时. 

1 从bhash中根据hash值(port计算的)取得当前指定端口对应的inet_bind_bucket结构. 

2 如果bhash中存在,则说明,这个端口已经在使用,因此需要判断这个端口是否允许被reuse. 

3 如果不存在,则步骤和上面的第5部一样. 

Java代码  收藏代码
  1. int inet_csk_get_port(struct sock *sk, unsigned short snum)  
  2. {  
  3.     struct inet_hashinfo *hashinfo = sk->sk_prot->h.hashinfo;  
  4.     struct inet_bind_hashbucket *head;  
  5.     struct hlist_node *node;  
  6.     struct inet_bind_bucket *tb;  
  7.     int ret;  
  8.     struct net *net = sock_net(sk);  
  9.   
  10.     local_bh_disable();  
  11.     if (!snum) {  
  12. ///端口为0,也就是需要内核来分配端口.  
  13.         int remaining, rover, low, high;  
  14. ///得到端口范围.  
  15.         inet_get_local_port_range(&low, &high);  
  16.         remaining = (high - low) + 1;  
  17.         rover = net_random() % remaining + low;  
  18.   
  19. ///循环来得到一个当前没有使用的端口.  
  20.         do {  
  21. ///通过端口为key,来得到相应的inet_bind_bucket  
  22.             head = &hashinfo->bhash[inet_bhashfn(net, rover,  
  23.                     hashinfo->bhash_size)];  
  24.             spin_lock(&head->lock);  
  25.             inet_bind_bucket_for_each(tb, node, &head->chain)  
  26.                 if (tb->ib_net == net && tb->port == rover)  
  27. ///说明这个端口已被使用,因此需要将端口加1,重新查找.  
  28.                     goto next;  
  29.             break;  
  30.         next:  
  31.             spin_unlock(&head->lock);  
  32. ///如果端口大于最大值,则将它赋值为最小值(这是因为我们这个端口是随机值,因此有可能很多端口就被跳过了),重新查找.  
  33.             if (++rover > high)  
  34.                 rover = low;  
  35.         } while (--remaining > 0);  
  36.   
  37.         /* Exhausted local port range during search?  It is not 
  38.          * possible for us to be holding one of the bind hash 
  39.          * locks if this test triggers, because if 'remaining' 
  40.          * drops to zero, we broke out of the do/while loop at 
  41.          * the top level, not from the 'break;' statement. 
  42.          */  
  43.         ret = 1;  
  44.         if (remaining <= 0)  
  45.             goto fail;  
  46. ///将要分配的端口号.  
  47.         snum = rover;  
  48.     } else {  
  49. ///指定端口号的情况.和上面的方法差不多,只不过只需要一次.  
  50.         head = &hashinfo->bhash[inet_bhashfn(net, snum,  
  51.                 hashinfo->bhash_size)];  
  52.         spin_lock(&head->lock);  
  53.         inet_bind_bucket_for_each(tb, node, &head->chain)  
  54.             if (tb->ib_net == net && tb->port == snum)  
  55.                 goto tb_found;  
  56.     }  
  57.     tb = NULL;  
  58.     goto tb_not_found;  
  59. tb_found:  
  60. ///用来处理端口号已经被使用的情况.他被使用的socket不为空的情况.  
  61.     if (!hlist_empty(&tb->owners)) {  
  62. ///fastreuse大于0说明其他的socket允许另外的socket也使用这个端口,而reuse表示当前的端口也允许和其他的端口分享这个port.并且socket的状态必须是TCP_LISTEN,才能做这个判断.  
  63.         if (tb->fastreuse > 0 &&  
  64.             sk->sk_reuse && sk->sk_state != TCP_LISTEN) {  
  65.             goto success;  
  66.         } else {  
  67.             ret = 1;  
  68. ///如果出错,调用inet_csk_bind_conflict.主要是有可能一些使用这个端口的socket,有可能使用不同的ip地址.此时,我们是可以使用这个端口的.  
  69.             if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb))  
  70.                 goto fail_unlock;  
  71.         }  
  72.     }  
  73. tb_not_found:  
  74.     ret = 1;  
  75. ///重新分配一个inet_bind_bucket,并链接到bhash.  
  76.     if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,  
  77.                     net, head, snum)) == NULL)  
  78.         goto fail_unlock;  
  79.     if (hlist_empty(&tb->owners)) {  
  80. ///设置当前端口的fastreuse,这个域也只能是处于listen的socket才能设置.  
  81.         if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)  
  82.             tb->fastreuse = 1;  
  83.         else  
  84.             tb->fastreuse = 0;  
  85.     } else if (tb->fastreuse &&  
  86.            (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))  
  87.         tb->fastreuse = 0;  
  88. success:  
  89. ///将这个socket加到这个端口的ower中.  
  90.     if (!inet_csk(sk)->icsk_bind_hash)  
  91.         inet_bind_hash(sk, tb, snum);  
  92.     WARN_ON(inet_csk(sk)->icsk_bind_hash != tb);  
  93.     ret = 0;  
  94.   
  95. fail_unlock:  
  96.     spin_unlock(&head->lock);  
  97. fail:  
  98.     local_bh_enable();  
  99.     return ret;  
  100. }  



在看listen的代码之前.我们也先来看相关的数据结构: 

其中inet_connection_sock我们先前已经介绍过了,它包含了一个icsk_accept_queue的域,这个域是一个request_sock_queue类型,.我们就先来看这个结构: 

request_sock_queue也就表示一个request_sock队列.这里我们知道,tcp中分为半连接队列(处于SYN_RECVD状态)和已完成连接队列(处于established状态).这两个一个是刚接到syn,等待三次握手完成,一个是已经完成三次握手,等待accept来读取. 

这里每个syn分节到来都会新建一个request_sock结构,并将它加入到listen_sock的request_sock hash表中.然后3次握手完毕后,将它放入到request_sock_queue的rskq_accept_head和rskq_accept_tail队列中.这样当accept的时候就直接从这个队列中读取了. 


Java代码  收藏代码
  1. struct request_sock_queue {  
  2. ///一个指向头,一个指向结尾.  
  3.     struct request_sock *rskq_accept_head;  
  4.     struct request_sock *rskq_accept_tail;  
  5.     rwlock_t        syn_wait_lock;  
  6.     u8          rskq_defer_accept;  
  7.     /* 3 bytes hole, try to pack */  
  8. ///相应的listen_socket结构.  
  9.     struct listen_sock  *listen_opt;  
  10. };  


listen_sock 表示一个处于listening状态的socket. 

Java代码  收藏代码
  1. struct listen_sock {  
  2. ///log_2 of maximal queued SYNs/REQUESTs ,这里不太理解这个域的作用.  
  3.     u8          max_qlen_log;  
  4.     /* 3 bytes hole, try to use */  
  5. ///当前的半连接队列的长度.  
  6.     int         qlen;  
  7. ///也是指当前的半开连接队列长度,不过这个值会当重传syn/ack的时候(这里要注意是这个syn/ack第一次重传的时候才会减一)自动减一.  
  8.     int         qlen_young;  
  9.     int         clock_hand;  
  10.     u32         hash_rnd;  
  11. ///这个值表示了当前的syn_backlog(半开连接队列)的最大值  
  12.     u32         nr_table_entries;  
  13. ///半连接队列.  
  14.     struct request_sock *syn_table[0];  
  15. };  


最后来看下request_sock,它保存了tcp双方传输所必需的一些域,比如窗口大小,对端速率,对端数据包序列号等等这些值. 
Java代码  收藏代码
  1. struct request_sock {  
  2.     struct request_sock     *dl_next; /* Must be first member! */  
  3. ///mss值.  
  4.     u16             mss;  
  5.     u8              retrans;  
  6.     u8              cookie_ts; /* syncookie: encode tcpopts in timestamp */  
  7.     /* The following two fields can be easily recomputed I think -AK */  
  8.     u32             window_clamp; /* window clamp at creation time */  
  9. ///窗口大小.  
  10.     u32             rcv_wnd;      /* rcv_wnd offered first time */  
  11.     u32             ts_recent;  
  12.     unsigned long           expires;  
  13. ///这个域包含了发送ack的操作集合.  
  14.     const struct request_sock_ops   *rsk_ops;  
  15.     struct sock         *sk;  
  16.     u32             secid;  
  17.     u32             peer_secid;  
  18. };  



listen的对应的系统调用是sys_listen,它首先通过sockfd_lookup_light查找到相应的socket,然后调用inet_listen,大体流程和bind差不多,只不过中间调用的是inet_listen罢了. 

这里还有一个概念那就是backlog,在linux中,backlog的大小指的是已完成连接队列的大小.而不是和半连接队列之和.而半开连接的大小一般是和backlog差不多大小. 

而半开连接队列的最大长度是根据backlog计算的,我们后面会介绍这个. 

因此我们直接来看inet_listen的实现,这个函数主要是进行一些合法性判断,然后调用inet_csk_listen_start来对相关域进行处理: 


Java代码  收藏代码
  1. int inet_listen(struct socket *sock, int backlog)  
  2. {  
  3.     struct sock *sk = sock->sk;  
  4.     unsigned char old_state;  
  5.     int err;  
  6.   
  7.     lock_sock(sk);  
  8.   
  9.     err = -EINVAL;  
  10. ///判断状态(非连接状态)以及socket类型.  
  11.     if (sock->state != SS_UNCONNECTED || sock->type != SOCK_STREAM)  
  12.         goto out;  
  13.   
  14.     old_state = sk->sk_state;  
  15. ///状态必须为close或者listen.  
  16.     if (!((1 << old_state) & (TCPF_CLOSE | TCPF_LISTEN)))  
  17.         goto out;  
  18.   
  19.     /* Really, if the socket is already in listen state 
  20.      * we can only allow the backlog to be adjusted. 
  21.      */  
  22. ///非listen状态,需要我们处理.  
  23.     if (old_state != TCP_LISTEN) {  
  24.         err = inet_csk_listen_start(sk, backlog);  
  25.         if (err)  
  26.             goto out;  
  27.     }  
  28. ///将backlog赋值给sk_max_ack_backlog,也就是完全连接队列最大值.  
  29.     sk->sk_max_ack_backlog = backlog;  
  30.     err = 0;  
  31.   
  32. out:  
  33.     release_sock(sk);  
  34.     return err;  
  35. }  


然后来看inet_csk_listen_start的实现. 

它的主要工作是新分配一个listen socket,将它加入到inet_connection_sock的icsk_accept_queue域的listen_opt中.然后对当前使用端口进行判断.最终返回: 


Java代码  收藏代码
  1. int inet_csk_listen_start(struct sock *sk, const int nr_table_entries)  
  2. {  
  3.     struct inet_sock *inet = inet_sk(sk);  
  4.     struct inet_connection_sock *icsk = inet_csk(sk);  
  5. ///新分配一个listen socket.  
  6.     int rc = reqsk_queue_alloc(&icsk->icsk_accept_queue, nr_table_entries);  
  7.   
  8.     if (rc != 0)  
  9.         return rc;  
  10. ///先将这两个ack_backlog赋值为0.  
  11.     sk->sk_max_ack_backlog = 0;  
  12.     sk->sk_ack_backlog = 0;  
  13.     inet_csk_delack_init(sk);  
  14.   
  15.     /* There is race window here: we announce ourselves listening, 
  16.      * but this transition is still not validated by get_port(). 
  17.      * It is OK, because this socket enters to hash table only 
  18.      * after validation is complete. 
  19.      */  
  20. ///设置状态.  
  21.     sk->sk_state = TCP_LISTEN;  
  22. ///get_port上面已经分析过了.这里之所以还要再次判断一下端口,是为了防止多线程,也就是另一个线程在我们调用listen之前改变了这个端口的信息.  
  23.     if (!sk->sk_prot->get_port(sk, inet->num)) {  
  24. //端口可用的情况,将端口值付给sport,并加入到inet_hashinfo(上面已经分析过)的listening_hash hash链表中.  
  25.         inet->sport = htons(inet->num);  
  26.   
  27.         sk_dst_reset(sk);  
  28. ///这里调用__inet_hash实现的.  
  29.         sk->sk_prot->hash(sk);  
  30.   
  31.         return 0;  
  32.     }  
  33. ///不可用,则返回错误.  
  34.     sk->sk_state = TCP_CLOSE;  
  35.     __reqsk_queue_destroy(&icsk->icsk_accept_queue);  
  36.     return -EADDRINUSE;  
  37. }  


最后我们来看下reqsk_queue_alloc的实现: 


Java代码  收藏代码
  1. ///半开连接的最大长度.  
  2. int sysctl_max_syn_backlog = 256;  
  3.   
  4. int reqsk_queue_alloc(struct request_sock_queue *queue,  
  5.               unsigned int nr_table_entries)  
  6. {  
  7.     size_t lopt_size = sizeof(struct listen_sock);  
  8.     struct listen_sock *lopt;  
  9. ///在当前的nr_table_entries(也就是listen传进来的backlog)和sysctl_max_syn_backlog取一个较小的值.  
  10.     nr_table_entries = min_t(u32, nr_table_entries, sysctl_max_syn_backlog);  
  11.   
  12. ///也就是说nr_table_entries不能小于8.  
  13.     nr_table_entries = max_t(u32, nr_table_entries, 8);  
  14.   
  15. ///其实也就是使nr_table_entries更接近于2的次幂  
  16.     nr_table_entries = roundup_pow_of_two(nr_table_entries + 1);  
  17. ///最终所要分配的listen_sock 的大小.  
  18.     lopt_size += nr_table_entries * sizeof(struct request_sock *);  
  19.     if (lopt_size > PAGE_SIZE)  
  20.         lopt = __vmalloc(lopt_size,  
  21.             GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO,  
  22.             PAGE_KERNEL);  
  23.     else  
  24.         lopt = kzalloc(lopt_size, GFP_KERNEL);  
  25.     if (lopt == NULL)  
  26.         return -ENOMEM;  
  27. ///计算max_qlen_log的值,他最小要为3,最大为对nr_table_entries求以2为低的log..  
  28.     for (lopt->max_qlen_log = 3;  
  29.          (1 << lopt->max_qlen_log) < nr_table_entries;  
  30.          lopt->max_qlen_log++);  
  31.   
  32.     get_random_bytes(&lopt->hash_rnd, sizeof(lopt->hash_rnd));  
  33.     rwlock_init(&queue->syn_wait_lock);  
  34.     queue->rskq_accept_head = NULL;  
  35. ///给nr_table_entries赋值.  
  36.     lopt->nr_table_entries = nr_table_entries;  
  37.   
  38.     write_lock_bh(&queue->syn_wait_lock);  
  39. ///将listen_socket赋值给queue->listen_opt  
  40.     queue->listen_opt = lopt;  
  41.     write_unlock_bh(&queue->syn_wait_lock);  
  42.   
  43.     return 0;  
  44. }  


首先来看下内核如何处理3次握手的半连接队列和accept队列(其实也就是server端的三次握手的状态变换).而半连接队列和accept队列在内核如何表示,我们上次已经介绍过了,这里就不介绍了.


首先我们知道当3层的数据包到达之后会调用4层的协议handle,tcp的话就是tcp_v4_rcv.如何调用可以看我前面的blog:

而在tcp_v4_rcv中,则最终会调用tcp_v4_do_rcv来处理输入数据包.在看tcp_v4_do_rcv之前,我们先来看在tcp_v4_rcv中,内核如何通过4元组(目的,源端口和地址)来查找对应得sock对象.

在分析之前,我们要知道,当一对tcp连接3次握手完毕后,内核将会重新new一个socket,这个socket中的大部分域都是与主socket相同的.而把这个新的socket的状态设置为established,而主socket的状态依旧为listen状态.

而通过前面的blog分析,我们也知道在inet_hashinfo中将处于listening状态的socket和处于 TCP_ESTABLISHED与TCP_CLOSE之间的状态的socket是分开的,一个是ehash,一个是listening_hash.因此通 过对应的4元组查找socket也是分开在这两个hash链表中操作的.

内核是通过调用__inet_lookup来查找socket的:

Java代码  收藏代码
  1. ///在tcp_v4_rcv中的代码片段.  
  2. sk = __inet_lookup(net, &tcp_hashinfo, iph->saddr,  
  3.             th->source, iph->daddr, th->dest, inet_iif(skb));  
  4.   
  5. static inline struct sock *__inet_lookup(struct net *net,  
  6.                      struct inet_hashinfo *hashinfo,  
  7.                      const __be32 saddr, const __be16 sport,  
  8.                      const __be32 daddr, const __be16 dport,  
  9.                      const int dif)  
  10. {  
  11.     u16 hnum = ntohs(dport);  
  12.     struct sock *sk = __inet_lookup_established(net, hashinfo,  
  13.                 saddr, sport, daddr, hnum, dif);  
  14.   
  15.     return sk ? : __inet_lookup_listener(net, hashinfo, daddr, hnum, dif);  
  16. }  


tcp_hashinfo我们前面也已经分析过了,包含了所有tcp所用到的hash信息,比如socket,port等等.这里的查找其实就是在tcp_hashinfo中(其实是它的域ehash或者listening_hash)查找相应的socket.

我们可以看到内核在这里进行了两次查找,首先是在established状态的socket中查找,处于established状态,说明3次握手已经完成,因此这个socket可以通过简单的4元组hash在hashinfo的ehash中查找.

而当在__inet_lookup_established中没有找到时,则将会__inet_lookup_listener中查找.也就是在处于listening状态的socket中查找(这里主要是通过daddr也就是目的地址来进行匹配).


当找到对应的socket以后就会进入数据包的处理,也就是进入tcp_v4_do_rcv函数.


Java代码  收藏代码
  1. int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)  
  2. {  
  3.     struct sock *rsk;  
  4. ..................................................  
  5.   
  6. ///如果为TCP_ESTABLISHED状态,则进入相关处理  
  7.     if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */  
  8.         TCP_CHECK_TIMER(sk);  
  9.         if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {  
  10.             rsk = sk;  
  11.             goto reset;  
  12.         }  
  13.         TCP_CHECK_TIMER(sk);  
  14.         return 0;  
  15.     }  
  16.   
  17. ///进行包头的合法性校验.  
  18.     if (skb->len < tcp_hdrlen(skb) || tcp_checksum_complete(skb))  
  19.         goto csum_err;  
  20. ///进入TCP_LISTEN状态.  
  21.     if (sk->sk_state == TCP_LISTEN) {  
  22.         struct sock *nsk = tcp_v4_hnd_req(sk, skb);  
  23.         if (!nsk)  
  24.             goto discard;  
  25.   
  26.         if (nsk != sk) {  
  27.             if (tcp_child_process(sk, nsk, skb)) {  
  28.                 rsk = nsk;  
  29.                 goto reset;  
  30.             }  
  31.             return 0;  
  32.         }  
  33.     }  
  34.   
  35.     TCP_CHECK_TIMER(sk);  
  36. ///进入其他状态的处理.除了ESTABLISHED和TIME_WAIT状态.  
  37.     if (tcp_rcv_state_process(sk, skb, tcp_hdr(skb), skb->len)) {  
  38.         rsk = sk;  
  39.         goto reset;  
  40.     }  
  41.     TCP_CHECK_TIMER(sk);  
  42.     return 0;  
  43. ......................................................................  
  44. }  


可以看到当进来之后,会通过判断socket的不同状态来进入不同的处理.这里其实就分了3种状态,TCP_ESTABLISHED,TCP_LISTEN和剩余的的状态.

我们这里先不分析TCP_ESTABLISHED.

我们先来看当第一个syn分解到达后,内核会做怎么样处理.首先它会进入tcp_v4_hnd_req函数,这个函数我们后面会处理,这里只需要 知道当为第一个syn分节时,它会返回当前socket.因此此时nsk == sk,所以我们进入tcp_rcv_state_process函数,这个函数处理除了ESTABLISHED和TIME_WAIT状态之外的所有状态.

我们这里只看他的listen状态处理,后面的话也是遇到一个状态,我们看一个状态的处理:


Java代码  收藏代码
  1. int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,  
  2.               struct tcphdr *th, unsigned len)  
  3. {  
  4.     struct tcp_sock *tp = tcp_sk(sk);  
  5. ///取得对应的inet_connection_sock .  
  6.     struct inet_connection_sock *icsk = inet_csk(sk);  
  7.     int queued = 0;  
  8.     tp->rx_opt.saw_tstamp = 0;  
  9.   
  10.     switch (sk->sk_state) {  
  11.     case TCP_LISTEN:  
  12. ///当为ack分节,则返回1,而对应内核会发送一个rst给对端.  
  13.         if (th->ack)  
  14.             return 1;  
  15. ///如果是rst,则忽略这个分组.  
  16.         if (th->rst)  
  17.             goto discard;  
  18. ///是syn分组,因此调用对应的虚函数conn_request,而这个函数在tcpv4中被初始化为tcp_v4_conn_request.  
  19.         if (th->syn) {  
  20.             if (icsk->icsk_af_ops->conn_request(sk, skb) < 0)  
  21.                 return 1;  
  22.             kfree_skb(skb);  
  23.             return 0;  
  24.         }  
  25.         goto discard;  
  26. ............................................................  
  27. }  


可以看到最终会调用tcp_v4_conn_request来处理syn分组,我们接下来就来看这个函数的实现.

先来看几个相关的函数,第一个是reqsk_queue_is_full,他来判断半连接队列是否已满.其实实现很简单,就是判断qlen和max_qlen_log的大小:

Java代码  收藏代码
  1. static inline int reqsk_queue_is_full(const struct request_sock_queue *queue)  
  2. {  
  3.     return queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log;  
  4. }  


第二个是sk_acceptq_is_full,它用来判断accept队列是否已满.这个也是很简单,比较当前的队列大小sk_ack_backlog与最大的队列大小sk_max_ack_backlog.

Java代码  收藏代码
  1. static inline int sk_acceptq_is_full(struct sock *sk)  
  2. {  
  3.     return sk->sk_ack_backlog > sk->sk_max_ack_backlog;  
  4. }  


最后一个是tcp_openreq_init,它用来新建一个inet_request_sock,我们知道每次一个syn到达后,我们都会新建一个inet_request_sock,并加入到半连接队列.

Java代码  收藏代码
  1. static inline void tcp_openreq_init(struct request_sock *req,  
  2.                     struct tcp_options_received *rx_opt,  
  3.                     struct sk_buff *skb)  
  4. {  
  5.     struct inet_request_sock *ireq = inet_rsk(req);  
  6.   
  7.     req->rcv_wnd = 0;        /* So that tcp_send_synack() knows! */  
  8.     req->cookie_ts = 0;  
  9.     tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;  
  10.     req->mss = rx_opt->mss_clamp;  
  11.     req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;  
  12.     ireq->tstamp_ok = rx_opt->tstamp_ok;  
  13.     ireq->sack_ok = rx_opt->sack_ok;  
  14.     ireq->snd_wscale = rx_opt->snd_wscale;  
  15.     ireq->wscale_ok = rx_opt->wscale_ok;  
  16.     ireq->acked = 0;  
  17.     ireq->ecn_ok = 0;  
  18.     ireq->rmt_port = tcp_hdr(skb)->source;  
  19. }  



接下来来看tcp_v4_conn_request的实现,
Java代码  收藏代码
  1. int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)  
  2. {  
  3.     struct inet_request_sock *ireq;  
  4.     struct tcp_options_received tmp_opt;  
  5.     struct request_sock *req;  
  6.     __be32 saddr = ip_hdr(skb)->saddr;  
  7.     __be32 daddr = ip_hdr(skb)->daddr;  
  8. ///这个名字实在是无语,when具体表示什么不太理解,只是知道它是用来计算rtt的.  
  9.     __u32 isn = TCP_SKB_CB(skb)->when;  
  10.     struct dst_entry *dst = NULL;  
  11. #ifdef CONFIG_SYN_COOKIES  
  12.     int want_cookie = 0;  
  13. #else  
  14. #define want_cookie 0 /* Argh, why doesn't gcc optimize this :( */  
  15. #endif  
  16.   
  17. ///如果是广播或者多播,则丢掉这个包.  
  18.     if (skb->rtable->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST))  
  19.         goto drop;  
  20.   
  21. ///判断半连接队列是否已经满掉.如果满掉并且处于非timewait状态,则丢掉这个包(如果设置了SYN Cookie则会继续进行,因为SYN Cookie不需要新分配半连接队列,详细的SYN Cookie请google)  
  22.     if (inet_csk_reqsk_queue_is_full(sk) && !isn) {  
  23. #ifdef CONFIG_SYN_COOKIES  
  24.         if (sysctl_tcp_syncookies) {  
  25.             want_cookie = 1;  
  26.         } else  
  27. #endif  
  28.         goto drop;  
  29.     }  
  30. ///如果accept队列已满,并且qlen_young大于一就丢掉这个包,这里qlen_young大于一表示在syn队列中已经有足够多的(这里不包括重传的syn)请求了.  
  31.     if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)  
  32.         goto drop;  
  33.     req = inet_reqsk_alloc(&tcp_request_sock_ops);  
  34.     if (!req)  
  35.         goto drop;  
  36. ...................................................  
  37.   
  38. ///对tmp_opt进行初始化,而tcp_options_received中包含了tcp的一些选项信息(比如mss,窗口扩大因子等等)  
  39.     tcp_clear_options(&tmp_opt);  
  40.     tmp_opt.mss_clamp = 536;  
  41.     tmp_opt.user_mss  = tcp_sk(sk)->rx_opt.user_mss;  
  42.   
  43. ///对对端的tcp_options_received进行解析,并对本端得tcp_options_received进行初始化.  
  44.     tcp_parse_options(skb, &tmp_opt, 0);  
  45.   
  46. .......................................................  
  47. ///这里对新的req进行初始化.  
  48.   
  49.     tcp_openreq_init(req, &tmp_opt, skb);  
  50. ...............................................  
  51.   
  52. ///这里将tcp_options_received保存到req中.  
  53.     ireq->opt = tcp_v4_save_options(sk, skb);  
  54.     if (!want_cookie)  
  55.         TCP_ECN_create_request(req, tcp_hdr(skb));  
  56.   
  57.     if (want_cookie) {  
  58. #ifdef CONFIG_SYN_COOKIES  
  59.         syn_flood_warning(skb);  
  60.         req->cookie_ts = tmp_opt.tstamp_ok;  
  61. #endif  
  62.         isn = cookie_v4_init_sequence(sk, skb, &req->mss);  
  63.     }else if (!isn) {  
  64. .............................................  
  65. ///计算当前一个合适的isn,并返回.  
  66.         isn = tcp_v4_init_sequence(skb);  
  67.     }  
  68.   
  69. ///赋值发送给对端的isn  
  70.     tcp_rsk(req)->snt_isn = isn;  
  71.   
  72. ///发送syn和ack(如果设置了want_cookie则不会将这个req链接到半连接队列中.  
  73.     if (__tcp_v4_send_synack(sk, req, dst) || want_cookie)  
  74.         goto drop_and_free;  
  75.   
  76. ///将这个req链接到半连接队列中.  
  77.     inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);  
  78.     return 0;  
  79.   
  80. drop_and_release:  
  81.     dst_release(dst);  
  82. drop_and_free:  
  83.     reqsk_free(req);  
  84. drop:  
  85.     return 0;  
  86. }  



而tcp_v4_hnd_req的主要工作是在半连接队列中看是否存在当前的socket,如果存在则说明这个有可能是最终的ack包,因此将会 做一系列的合法性校验(比如重传,rst,syn等等),最终确定这个是ack后会调用对应的新建socket的虚函数syn_recv_sock.

Java代码  收藏代码
  1. static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)  
  2. {  
  3.     struct tcphdr *th = tcp_hdr(skb);  
  4.     const struct iphdr *iph = ip_hdr(skb);  
  5.     struct sock *nsk;  
  6.     struct request_sock **prev;  
  7. ///通过socket,查找对应request_sock  
  8.     struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,  
  9.                                iph->saddr, iph->daddr);  
  10.     if (req)  
  11. ///如果存在则进入req的相关处理.  
  12.         return tcp_check_req(sk, skb, req, prev);  
  13.   
  14. ///不存在,则通过inet_lookup_established查找.这是因为有可能当我们进入这个函数之前,socket的状态被改变了,也就是这个socket的状态已经不是listen了.  
  15.   
  16.     nsk = inet_lookup_established(sock_net(sk), &tcp_hashinfo, iph->saddr,  
  17.             th->source, iph->daddr, th->dest, inet_iif(skb));  
  18.   
  19.     if (nsk) {  
  20.         if (nsk->sk_state != TCP_TIME_WAIT) {  
  21. ///非tw状态返回新的socket.  
  22.             bh_lock_sock(nsk);  
  23.             return nsk;  
  24.         }  
  25. ///如果是timewait状态则返回空.  
  26.         inet_twsk_put(inet_twsk(nsk));  
  27.         return NULL;  
  28.     }  
  29.   
  30. #ifdef CONFIG_SYN_COOKIES  
  31.     if (!th->rst && !th->syn && th->ack)  
  32.         sk = cookie_v4_check(sk, skb, &(IPCB(skb)->opt));  
  33. #endif  
  34.     return sk;  
  35. }  



tcp_check_req最主要工作就是调用虚函数,新建一个socket,并返回.

先来看几个相关的函数,第一个是inet_csk_reqsk_queue_unlink,它主要用来从半连接队列unlink掉一个元素.:

Java代码  收藏代码
  1. static inline void inet_csk_reqsk_queue_unlink(struct sock *sk,  
  2.                            struct request_sock *req,  
  3.                            struct request_sock **prev)  
  4. {  
  5.     reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req, prev);  
  6. }  
  7.   
  8. static inline void reqsk_queue_unlink(struct request_sock_queue *queue,  
  9.                       struct request_sock *req,  
  10.                       struct request_sock **prev_req)  
  11. {  
  12.     write_lock(&queue->syn_wait_lock);  
  13. ///处理链表.  
  14.     *prev_req = req->dl_next;  
  15.     write_unlock(&queue->syn_wait_lock);  
  16. }  


第二个是inet_csk_reqsk_queue_removed,它主要用来修改对应的qlen和qlen_young的值.


Java代码  收藏代码
  1. static inline void inet_csk_reqsk_queue_removed(struct sock *sk,  
  2.                         struct request_sock *req)  
  3. {  
  4.     if (reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req) == 0)  
  5.         inet_csk_delete_keepalive_timer(sk);  
  6. }  
  7.   
  8. static inline int reqsk_queue_removed(struct request_sock_queue *queue,  
  9.                       struct request_sock *req)  
  10. {  
  11.     struct listen_sock *lopt = queue->listen_opt;  
  12. ///如果重传数为0则说明没有重传过,因此qlen_young跟着也减一.  
  13.     if (req->retrans == 0)  
  14.         --lopt->qlen_young;  
  15.   
  16.     return --lopt->qlen;  
  17. }  


最后是inet_csk_reqsk_queue_add,它用来把新的req加入到accept队列中.


Java代码  收藏代码
  1. static inline void inet_csk_reqsk_queue_add(struct sock *sk,  
  2.                         struct request_sock *req,  
  3.                         struct sock *child)  
  4. {  
  5.     reqsk_queue_add(&inet_csk(sk)->icsk_accept_queue, req, sk, child);  
  6. }  
  7.   
  8.   
  9. static inline void reqsk_queue_add(struct request_sock_queue *queue,  
  10.                    struct request_sock *req,  
  11.                    struct sock *parent,  
  12.                    struct sock *child)  
  13. {  
  14.     req->sk = child;  
  15.     sk_acceptq_added(parent);  
  16. ///可以看到刚好就是request_sock_queue的rskq_accept_head与rskq_accept_tail保存accept队列.  
  17.     if (queue->rskq_accept_head == NULL)  
  18.         queue->rskq_accept_head = req;  
  19.     else  
  20.         queue->rskq_accept_tail->dl_next = req;  
  21.   
  22.     queue->rskq_accept_tail = req;  
  23.     req->dl_next = NULL;  
  24. }  


然后再来看tcp_check_req的实现.
Java代码  收藏代码
  1. struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,  
  2.                struct request_sock *req,  
  3.                struct request_sock **prev)  
  4. {  
  5.     const struct tcphdr *th = tcp_hdr(skb);  
  6.     __be32 flg = tcp_flag_word(th) & (TCP_FLAG_RST|TCP_FLAG_SYN|TCP_FLAG_ACK);  
  7.     int paws_reject = 0;  
  8.     struct tcp_options_received tmp_opt;  
  9.     struct sock *child;  
  10.   
  11.     tmp_opt.saw_tstamp = 0;  
  12. ......................................  
  13. ///如果只有rst和syn域则发送一个rst给对端.  
  14. if (flg & (TCP_FLAG_RST|TCP_FLAG_SYN)) {  
  15.         TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_ATTEMPTFAILS);  
  16.         goto embryonic_reset;  
  17.     }  
  18.   
  19. ///如果是重传的syn,则重新发送syn和ack分组.  
  20.     if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn &&  
  21.         flg == TCP_FLAG_SYN &&  
  22.         !paws_reject) {  
  23.         req->rsk_ops->rtx_syn_ack(sk, req);  
  24.         return NULL;  
  25.     }  
  26.   
  27.     ..........................................  
  28.   
  29. ///确定有设置ack分节.  
  30.     if (!(flg & TCP_FLAG_ACK))  
  31.         return NULL;  
  32.   
  33. ///这里主要处理TCP_DEFER_ACCEPT被设置的情况,如果它被设置,则丢掉这个包.(这是因为TCP_DEFER_ACCEPT会等待数据真正发过来才处理的,而不是最后一个ack发过来就处理)  
  34.     if (inet_csk(sk)->icsk_accept_queue.rskq_defer_accept &&  
  35.         TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {  
  36.         inet_rsk(req)->acked = 1;  
  37.         return NULL;  
  38.     }  
  39.   
  40. ///可以创建一个新的socket了.返回一个包含新创建的socket的request结构.  
  41.     child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb, req, NULL);  
  42.     if (child == NULL)  
  43.         goto listen_overflow;  
  44. ..................................  
  45. #endif  
  46. ///创建成功,则在request_sock_queue的listen_opt中unlink掉这个req.也就是从半连接队列中删除这个req.  
  47.     inet_csk_reqsk_queue_unlink(sk, req, prev);  
  48. ///修改对应的 qlen和qlen_young的值.  
  49.     inet_csk_reqsk_queue_removed(sk, req);  
  50. ///最后加入到accept队列中.这里注意最终是将新的socket赋值给对应的req.  
  51.     inet_csk_reqsk_queue_add(sk, req, child);  
  52.     return child;  
  53.   
  54. listen_overflow:  
  55.     if (!sysctl_tcp_abort_on_overflow) {  
  56.         inet_rsk(req)->acked = 1;  
  57.         return NULL;  
  58.     }  
  59.   
  60. embryonic_reset:  
  61.     NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_EMBRYONICRSTS);  
  62.     if (!(flg & TCP_FLAG_RST))  
  63.         req->rsk_ops->send_reset(sk, skb);  
  64.   
  65.     inet_csk_reqsk_queue_drop(sk, req, prev);  
  66.     return NULL;  
  67. }  



最后我们来看内核如何创建一个新的socket,tcp 协议使用tcp_v4_syn_recv_sock来实现,它做的其实很简单就是新建一个socket,并且设置状态为TCP_SYN_RECV(在 inet_csk_clone中),父socket继续处于listen状态,然后对新的socket进行一些赋值,然后对一些定时器进行初始化.这里定 时器我们全部都略过了,以后会专门来分析tcp中的定时器.


最后从tcp_v4_hnd_req中返回,判断是否与父socket相等,然后调用tcp_child_process函数:

这个函数主要是完成最终的三次握手,将子socket设置为TCP_ESTABLISHED然后根据条件唤醒被accept阻塞的主socket:

Java代码  收藏代码
  1. int tcp_child_process(struct sock *parent, struct sock *child,  
  2.               struct sk_buff *skb)  
  3. {  
  4.     int ret = 0;  
  5.     int state = child->sk_state;  
  6.   
  7.     if (!sock_owned_by_user(child)) {  
  8. ///完成最终的三次握手.  
  9.         ret = tcp_rcv_state_process(child, skb, tcp_hdr(skb),  
  10.                         skb->len);  
  11.         /* Wakeup parent, send SIGIO */  
  12.         if (state == TCP_SYN_RECV && child->sk_state != state)  
  13. ///唤醒阻塞的主socket.  
  14.             parent->sk_data_ready(parent, 0);  
  15.     } else {  
  16.         /* Alas, it is possible again, because we do lookup 
  17.          * in main socket hash table and lock on listening 
  18.          * socket does not protect us more. 
  19.          */  
  20.         sk_add_backlog(child, skb);  
  21.     }  
  22.   
  23.     bh_unlock_sock(child);  
  24.     sock_put(child);  
  25.     return ret;  
  26. }  


最后来分析下在tcp_rcv_state_process中的处理当前的TCP_SYN_RECV状态,它主要是为将要到来的数据传输做一些准备,设置一些相关域.:


Java代码  收藏代码
  1. case TCP_SYN_RECV:  
  2.             if (acceptable) {  
  3.                 tp->copied_seq = tp->rcv_nxt;  
  4.                 smp_mb();  
  5. ///设置状态为TCP_ESTABLISHED.  
  6.                 tcp_set_state(sk, TCP_ESTABLISHED);  
  7.                 sk->sk_state_change(sk);  
  8.   
  9. ///这里的wake应该是针对epoll这类的  
  10.                 if (sk->sk_socket)  
  11.                     sk_wake_async(sk,  
  12.                               SOCK_WAKE_IO, POLL_OUT);  
  13.   
  14. ///设置期望接收的isn号,也就是第一个字节的序列和窗口大小.  
  15.                 tp->snd_una = TCP_SKB_CB(skb)->ack_seq;  
  16.                 tp->snd_wnd = ntohs(th->window) <<  
  17.                           tp->rx_opt.snd_wscale;  
  18.                 tcp_init_wl(tp, TCP_SKB_CB(skb)->ack_seq,  
  19.                         TCP_SKB_CB(skb)->seq);  
  20.   
  21. .........................................................................  
  22.             break; 

0 0
鱼油哪个牌子好,知乎 鱼油哪个牌子好,知乎
原创粉丝点击
热门IT博客
做程序员学什么做程序员学什么
php开源商城源码下载php开源商城源码下载
ubuntu 测试软件
手机强制删除文件软件
日军退子弹 知乎
cforeach 遍历数组
上海培训java
方媛开的淘宝店
农村淘宝电话投诉电话
node开发指南
java的对象是什么
cpu淘宝e5水多深
淘宝古装哪家比较好的
通用财会软件
深圳软件产业基地招聘
耳机测试软件
控制算法
淘宝企业店铺所有权
如何数据分析
手机电影软件哪个最好
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 牙齿乱长怎么办 小孩牙齿缺失怎么办 缺二号牙怎么办 小孩少长一颗牙怎么办 小孩长牙拉肚子怎么办 长肚子怎么办 宝宝长牙拉肚子怎么办 宝宝长牙不舒服怎么办 宝宝长牙不整齐怎么办 新生儿长米牙怎么办 新生儿长麻牙怎么办 婴儿发芽发烧怎么办 满月宝宝不消化怎么办 婴儿大便不消化怎么办 小孩老是消化不良怎么办 怀孕便秘不消化怎么办 消化不良胖怎么办呀 不消化积食便秘怎么办 婴儿拉青屎怎么办 消化不良还便秘怎么办 老是便秘该怎么办 新生儿宝宝腹泻怎么办 小孩拉青便便怎么办 婴儿肚子着凉怎么办 宝宝拉肚子拉绿屎怎么办 总是不消化怎么办 消化不良胃胀怎么办 严重消化不良怎么办 小孩子肠胃不好怎么办 宝宝不高怎么办 哺乳期宝宝拉稀怎么办 大便蔬菜不消化怎么办 大便有不消化怎么办 新生儿十天不大便怎么办 小儿肠胃不好怎么办 老年人不消化怎么办 宝贝消化不良怎么办 喝奶粉不消化怎么办 吃东西消化不良怎么办 两岁消化不良怎么办 宝宝转奶有奶瓣怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里