Chinaunix首页 | 论坛 | 博客
  • 博客访问: 183553
  • 博文数量: 93
  • 博客积分: 832
  • 博客等级: 军士长
  • 技术积分: 640
  • 用 户 组: 普通用户
  • 注册时间: 2010-09-19 02:28
文章分类
文章存档

2012年(41)

2011年(45)

2010年(7)

分类:

2011-07-05 17:07:21

一、前情回顾

上一节《socket地址绑定》中提到,应用程序传递过来的端口在内核中需要检查端口是否可用:


  1. if (sk->sk_prot->get_port(sk, snum)) {  
  2.     inet->saddr = inet->rcv_saddr = 0;  
  3.     err = -EADDRINUSE;  
  4.     goto out_release_sock;  
  5. }  

 

按照前面的例子来分析,这里是调用了tcp_prot结构变量中的get_prot函数指针,该函数位于net/ipv4/Inet_connection_sock.c中;这个函数比较长,也是我们今天要分析的重点;

 

二、端口的管理

1、端口管理数据结构

Linux内核将所有socket使用时的端口通过一个哈希表来管理,该哈希表存放在全局变量tcp_hashinfo中,通过tcp_prot变量的h成员引用,该成员是一个联合类型;对于tcp套接字类型,其引用存放在h. hashinfo成员中;下面是tcp_hashinfo的结构体类型:

 

  1. struct inet_hashinfo {  
  2.        struct inet_ehash_bucket  *ehash;  
  3.        rwlock_t                     *ehash_locks;  
  4.        unsigned int                ehash_size;  
  5.        unsigned int                ehash_locks_mask;  
  6.    
  7.        struct inet_bind_hashbucket    *bhash;//管理端口的哈希表  
  8.        unsigned int                bhash_size;//端口哈希表的大小  
  9.    
  10.        struct hlist_head         listening_hash[INET_LHTABLE_SIZE];  
  11.        rwlock_t                     lhash_lock ____cacheline_aligned;  
  12.        atomic_t                     lhash_users;  
  13.        wait_queue_head_t           lhash_wait;  
  14.        struct kmem_cache                 *bind_bucket_cachep;//哈希表结构高速缓存  
  15. }  
 

端口管理相关的,目前可以只关注加注释的这三个成员,其中bhash为已经哈希表结构,bhash_size为哈希表的大小;所有哈希表中的节点内存都是在bind_bucket_cachep高速缓存中分配;

 

下面看一下inet_bind_hashbucket结构体:

 

  1. struct inet_bind_hashbucket {  
  2.        spinlock_t            lock;  
  3.        struct hlist_head  chain;  
  4. };  
  5. struct hlist_head {  
  6.        struct hlist_node *first;  
  7. };  
  8. struct hlist_node {  
  9.        struct hlist_node *next, **pprev;  
  10. };  
 

inet_bind_hashbucket是哈希桶结构,lock成员是用于操作时对桶进行加锁,chain成员是相同哈希值的节点的链表;示意图如下:

 

2、默认端口的分配

当应用程序没有指定端口时(如socket客户端连接到服务端时,会由内核从可用端口中分配一个给该socket);

看看下面的代码(参见net/ipv4/Inet_connection_sock.c: inet_csk_get_port()函数)

 

  1. if (!snum) {  
  2.     int remaining, rover, low, high;  
  3.    
  4.     inet_get_local_port_range(&low, &high);  
  5.     remaining = (high - low) + 1;  
  6.     rover = net_random() % remaining + low;  
  7.    
  8.     do {  
  9.         head = &hashinfo->bhash[inet_bhashfn(rover, hashinfo->bhash_size)];  
  10.         spin_lock(&head->lock);  
  11.         inet_bind_bucket_for_each(tb, node, &head->chain)  
  12.             if (tb->ib_net == net && tb->port == rover)  
  13.                 goto next;  
  14.         break;  
  15.     next:  
  16.         spin_unlock(&head->lock);  
  17.         if (++rover > high)  
  18.             rover = low;  
  19.     } while (--remaining > 0);  
  20.    
  21.     ret = 1;  
  22.     if (remaining <= 0)  
  23.         goto fail;  
  24.    
  25.     snum = rover;  
  26. }  
 

这里,随机端口的范围是32768~61000;上面代码的逻辑如下:

1)  [32768, 61000]中随机取一个端口rover

2)  计算该端口的hash值,然后从全局变量tcp_hashinfo的哈希表bhash中取出相同哈希值的链表head

3)  遍历链表head,检查每个节点的网络设备是否和当前网络设置相同,同时检查节点的端口是否和rover相同;

4)  如果相同,表明端口被占用,继续下一个端口;如果和链表head中的节点都不相同,则跳出循环,继续后面的逻辑;

 

inet_bind_bucket_foreach宏利用《创建socket》一文中提到的container_of宏来实现 的,大家可以自己看看;

 

3、端口重用

当应用程序指定端口时,参考下面的源代码:


  1. else {  
  2.     head = &hashinfo->bhash[inet_bhashfn(snum, hashinfo->bhash_size)];  
  3.     spin_lock(&head->lock);  
  4.     inet_bind_bucket_for_each(tb, node, &head->chain)  
  5.         if (tb->ib_net == net && tb->port == snum)  
  6.             goto tb_found;  
  7. }  
 

 

此时同样会检查该端口有没有被占用;如果被占用,会检查端口重用(跳转到tb_found):


  1. tb_found:  
  2.        if (!hlist_empty(&tb->owners)) {  
  3.               if (tb->fastreuse > 0 &&  
  4.                   sk->sk_reuse && sk->sk_state != TCP_LISTEN) {  
  5.                      goto success;  
  6.               } else {  
  7.                      ret = 1;  
  8.                      if (inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb))  
  9.                             goto fail_unlock;  
  10.               }  
  11.        }  
 

1)    端口节点结构


  1. struct inet_bind_bucket {  
  2.        struct net             *ib_net;//端口所对应的网络设置  
  3.        unsigned short            port;//端口号  
  4.        signed short         fastreuse;//是否可重用  
  5.        struct hlist_node  node;//作为bhash中chain链表的节点  
  6.        struct hlist_head  owners;//绑定在该端口上的socket链表  
  7. };  
 

 

前面提到的哈希桶结构中的chain链表中的每个节点,其宿主结构体是inet_bind_bucket,该结构体通过成员node链入链表;


2)    检查端口是否可重用

这里涉及到两个属性,一个是socketsk_reuse,另一个是inet_bind_bucketfastreuse

sk_reuse可以通过setsockopt()库函数进行设置,其值为01,当为1时,表示当一个socket进入TCP_TIME_WAIT状态(连接关闭已经完成)后,它所占用的端口马上能够被重用,这在调试服务器时比较有用,重启程序不用进行等待;而fastreuse代表该端口是否允许被重用:

l 当该端口第一次被使用时(owners为空),如果sk_reuse1socket状态不为TCP_LISTEN,则设置fastreuse1,否则设置为0

l 当该端口同时被其他socket使用时(owners不为空),如果当前端口能被重用,但是当前socketsk_reuse0或其状态为TCP_LISTEN,则将fastreuse设置为0,标记为不能重用;


3)    当不能重用时,再次检查冲突

此时会调用inet_csk(sk)->icsk_af_ops->bind_conflict(sk, tb)再次检查端口是否冲突;回想《创建socket》一文中提到,创建socket成功后,要使用相应的协议来初始化socket,对于tcp协议来说,其初始化方法是net/ipv4/Tcp_ipv4.c:tcp_v4_init_sock(),其中就做了如下一步的设置:


  1. icsk->icsk_af_ops = &ipv4_specific;  
  2.    
  3. struct inet_connection_sock_af_ops ipv4_specific = {  
  4.        .queue_xmit    = ip_queue_xmit,  
  5.        .send_check          = tcp_v4_send_check,  
  6.        .rebuild_header      = inet_sk_rebuild_header,  
  7.        .conn_request        = tcp_v4_conn_request,  
  8.        .syn_recv_sock     = tcp_v4_syn_recv_sock,  
  9.        .remember_stamp        = tcp_v4_remember_stamp,  
  10.        .net_header_len     = sizeof(struct iphdr),  
  11.        .setsockopt      = ip_setsockopt,  
  12.        .getsockopt     = ip_getsockopt,  
  13.        .addr2sockaddr      = inet_csk_addr2sockaddr,  
  14.        .sockaddr_len        = sizeof(struct sockaddr_in),  
  15.        .bind_conflict          = inet_csk_bind_conflict,  
  16. #ifdef CONFIG_COMPAT  
  17.        .compat_setsockopt = compat_ip_setsockopt,  
  18.        .compat_getsockopt = compat_ip_getsockopt,  
  19. #endif  
  20. };  
 

 

下面看看这里再次检查冲突的代码:


  1. int inet_csk_bind_conflict(const struct sock *sk,  
  2.                         const struct inet_bind_bucket *tb)  
  3. {  
  4.        const __be32 sk_rcv_saddr = inet_rcv_saddr(sk);  
  5.        struct sock *sk2;  
  6.        struct hlist_node *node;  
  7.        int reuse = sk->sk_reuse;  
  8.    
  9.        sk_for_each_bound(sk2, node, &tb->owners) {  
  10.               if (sk != sk2 &&  
  11.                   !inet_v6_ipv6only(sk2) &&  
  12.                   (!sk->sk_bound_dev_if ||  
  13.                    !sk2->sk_bound_dev_if ||  
  14.                    sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {  
  15.                      if (!reuse || !sk2->sk_reuse ||  
  16.                          sk2->sk_state == TCP_LISTEN) {  
  17.                             const __be32 sk2_rcv_saddr = inet_rcv_saddr(sk2);  
  18.                             if (!sk2_rcv_saddr || !sk_rcv_saddr ||  
  19.                                 sk2_rcv_saddr == sk_rcv_saddr)  
  20.                                    break;  
  21.                      }  
  22.               }  
  23.        }  
  24.        return node != NULL;  
  25. }  
 

上面函数的逻辑是:从owners中遍历绑定在该端口上的socket,如果某socket跟当前的socket不是同一个,并且是绑定在同一个网络设备接口上的,并且它们两个之中至少有一个的sk_reuse表示自己的端口不能被重用或该socket已经是TCP_LISTEN状态了,并且它们两个之中至少有一个没有指定接收IP地址,或者两个都指定接收地址,但是接收地址是相同的,则冲突产生,否则不冲突。

也就是说,不使用同一个接收地址的socket可以共用端口号,绑定在不同的网络设备接口上的socket可以共用端口号,或者两个socket都表示自己可以被重用,并且还不在TCP_LISTEN状态,则可以重用端口号。

 

4、新建inet_bind_bucket

当在bhash中没有找到指定的端口时,需要创建新的桶节点,然后挂入bhash中:


  1. tb_not_found:  
  2.        ret = 1;  
  3.        if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep,  
  4.                                    net, head, snum)) == NULL)  
  5.               goto fail_unlock;  
  6.        if (hlist_empty(&tb->owners)) {  
  7.               if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)  
  8.                      tb->fastreuse = 1;  
  9.               else  
  10.                      tb->fastreuse = 0;  
  11.        } else if (tb->fastreuse &&  
  12.                  (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))  
  13.               tb->fastreuse = 0;  
  14. success:  
  15.        if (!inet_csk(sk)->icsk_bind_hash)  
  16.               inet_bind_hash(sk, tb, snum);  
 


有兴趣的可以自己看看这段代码的实现,这里就不再展开了。

阅读(496) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册