Chinaunix首页 | 论坛 | 博客
  • 博客访问: 488943
  • 博文数量: 239
  • 博客积分: 60
  • 博客等级: 民兵
  • 技术积分: 1044
  • 用 户 组: 普通用户
  • 注册时间: 2009-03-22 18:25
文章分类

全部博文(239)

文章存档

2019年(9)

2018年(64)

2017年(2)

2016年(26)

2015年(30)

2014年(41)

2013年(65)

2012年(2)

分类: LINUX

2013-06-18 12:22:20

    之前在项目测试的时候,如果第三次握手发完裸ack(没有数据)之后不发送数据的时候,连接状态一直为SYN_RCV,而且服务端重传synack,当时很不解,后来看了下源码,才发现些端倪。当时测试的内核是2.6.18-194(centos5.5)。
    第三次握手会调用函数tcp_v4_hnd_req:
  1. static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
  2. {
  3.     ......
  4.     struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
  5.                          iph->saddr, iph->daddr);//查找半连接队列,返回req
  6.     if (req)
  7.         return tcp_check_req(sk, skb, req, prev);//ack的处理
  8.     ......
  9. }
    我们看函数tcp_check_req
  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.        ......
  6.         /* If TCP_DEFER_ACCEPT is set, drop bare ACK. */
  7.         if (inet_csk(sk)->icsk_accept_queue.rskq_defer_accept &&
  8.          TCP_SKB_CB(skb)->end_seq == tcp_rsk(req)->rcv_isn + 1) {//如果选项设置了,并且是裸
  9.                                                                    ack,丢弃该ack;选项值得默
  10.                                                                    认为1
  11.             inet_rsk(req)->acked = 1;
  12.             return NULL;
  13.         }
  14.         child = inet_csk(sk)->icsk_af_ops->syn_recv_sock(sk, skb,
  15.                                  req, NULL);//如果非裸ack或没设置选项则建立连接(req从半连接
  16.                                               队列到连接队列及tcp状态变为ESTABLISHED)
  17.         ......
  18. }

我们在用户层写socket程序时,可以通过setsockopt来设置TCP_DEFER_ACCEPT选项:

  1. val = 5;
  2. setsockopt(srv_socket->fd, SOL_TCP, TCP_DEFER_ACCEPT, &val, sizeof(val)) ;
  3. 里面 val 的单位是秒,注意如果打开这个功能,kernel 在 val 秒之内还没有收到数据,不会继续唤醒进程,而是直接丢弃连接。
在内核空间会调用:
  1. static int do_tcp_setsockopt(struct sock *sk, int level,
  2.         int optname, char __user *optval, int optlen)
  3. {
  4.     struct tcp_sock *tp = tcp_sk(sk);
  5.     struct inet_connection_sock *icsk = inet_csk(sk);
  6.     int val;
        ......
  7.      if (get_user(val, (int __user *)optval))//拷贝用户空间数据
              return -EFAULT;
  8.     ......
  9.     case TCP_DEFER_ACCEPT:
  10.         icsk->icsk_accept_queue.rskq_defer_accept = 0;
  11.         if (val > 0) {//如果setsockopt中设置val为0,则不开始TCP_DEFER_ACCEPT选项
  12.             /* Translate value in seconds to number of
  13.              * retransmits */
  14.             while (icsk->icsk_accept_queue.rskq_defer_accept < 32 &&
  15.              val > ((TCP_TIMEOUT_INIT / HZ) <<
  16.                  icsk->icsk_accept_queue.rskq_defer_accept))//根据设置的val决定重传次数,譬
  17.                                                 如val=10,重传次数为3;后面我们可以看到,只有
  18.                                                 /proc/sys/net/ipv4/tcp_synack_retries的
  19.                                                 值小于等于通过val算出的重传次数时,这个val才
  20.                                                 起作用
  21.                 icsk->icsk_accept_queue.rskq_defer_accept++;
  22.             icsk->icsk_accept_queue.rskq_defer_accept++;
  23.         }
  24.         break;
  25.     ......
  26. }
内核是通过函数inet_csk_reqsk_queue_prune进行重传synack:
  1. void inet_csk_reqsk_queue_prune(struct sock *parent,
  2.                 const unsigned long interval,
  3.                 const unsigned long timeout,
  4.                 const unsigned long max_rto)
  5. {
  6.     struct inet_connection_sock *icsk = inet_csk(parent);
  7.     struct request_sock_queue *queue = &icsk->icsk_accept_queue;
  8.     struct listen_sock *lopt = queue->listen_opt;
  9.     int max_retries = icsk->icsk_syn_retries ? : sysctl_tcp_synack_retries;//默认synack
  10.                                                                              重传次数为5
  11.     int thresh = max_retries;
  12.     unsigned long now = jiffies;
  13.     struct request_sock **reqp, *req;
  14.     int i, budget;
  15.     ......
  16.     if (queue->rskq_defer_accept)
  17.         max_retries = queue->rskq_defer_accept;//设定支持选项时候的重传次数

  18.     budget = 2 * (lopt->nr_table_entries / (timeout / interval));
  19.     i = lopt->clock_hand;

  20.     do {
  21.         reqp=&lopt->syn_table[i];
  22.         while ((req = *reqp) != NULL) {
  23.             if (time_after_eq(now, req->expires)) {
  24.                 if ((req->retrans < thresh ||
  25.                  (inet_rsk(req)->acked && req->retrans < max_retries))
  26.                  && !req->rsk_ops->rtx_syn_ack(parent, req, NULL)) {//如果重传次数小于设定
  27.                  的重传次数,就重传synack;这里可以看出两个并列的判断条件:req->retrans < thres
  28.                  h和(inet_rsk(req)->acked && req->retrans < max_retries),第一个是当前req
  29.                  的重传次数小于设定的最大重传次数,这里是5;第二个则是TCP_DEFER_ACCEPT;inet_rs
  30.                  k(req)->acked则是在函数tcp_check_req中设定的,上面讨论过了,而max_retries则
  31.                  为通过val计算的值,默认为1。这个重传次数决定了synack包的重传次数及最长超时时间,
  32.                  显然两者中较大者起到决定性的作用。譬如,默认重传为2,通过val计算出的max_retries
  33.                  值为3,则将发送3次重传的synack及超时时间为12秒后,关闭连接
  34.                     unsigned long timeo;

  35.                     if (req->retrans++ == 0)
  36.                         lopt->qlen_young--;
  37.                     timeo = min((timeout << req->retrans), max_rto);
  38.                     req->expires = now + timeo;//每重传一次,超时值就按初始值
  39.                                                  timeout(TCP_TIMEOUT_INIT)比值为2的等比
  40.                                                  数列增加,如3 6 12 24 48 96
  41.                     reqp = &req->dl_next;
  42.                     continue;//继续循环
  43.                 }

  44.                 /* Drop this request */
  45.                 如果超时,如超过例子中的96秒,就将req从半连接队列里删除,丢弃连接
  46.                 inet_csk_reqsk_queue_unlink(parent, req, reqp);
  47.                 reqsk_queue_removed(queue, req);
  48.                 reqsk_free(req);
  49.                 continue;
  50.             }
  51.             reqp = &req->dl_next;
  52.         }

  53.         i = (i + 1) & (lopt->nr_table_entries - 1);

  54.     } while (--budget > 0);

  55.     lopt->clock_hand = i;

  56.     if (lopt->qlen)
  57.         inet_csk_reset_keepalive_timer(parent, interval);
  58. }

那么TCP_DEFER_ACCEPT选项有什么好处呢,我们知道服务端处于监听时,客户端connect;服务端会收到syn包,并发送synack;当客户端收到synack并发送裸ack时,服务端accept创建一个新的句柄,这是不支持TCP_DEFER_ACCEPT选项下的流程。如果支持TCP_DEFER_ACCEPT,收到裸ack时,不会建立连接,操作系统不会Accept,也不会创建IO句柄。操作系统应该在若干秒后,会释放相关的链接;但没有同时关闭相应的端口,所以客户端会一直以为处于链接状态,如果Connect后面马上有后续的发送数据,那么服务器会调用Accept接收这个连接。

函数inet_csk_reqsk_queue_prune是通过tcp_synack_timer,是它在定时器中起作用的

  1. static void tcp_synack_timer(struct sock *sk)
  2. {
  3.     inet_csk_reqsk_queue_prune(sk, TCP_SYNQ_INTERVAL,
  4.                  TCP_TIMEOUT_INIT, TCP_RTO_MAX);
  5. }
关于定时器,在后续的分析中。
阅读(563) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~