TCP内核源码分析笔记

[注]: 在内核2.6.32以后对应函数为inet_csk_accept().

• 描述: 通过在规定时间内，判断tcp_sock->accept_queue队列非空，代表有新的连接进入．
  
• 返回值: (struct sock *)newsk;
  
• 代码关键路径:
  

   1:  struct sock *tcp_accept(struct sock *sk, int flags, int *err)
   2:  {
   3:      ....
   4:      /* Find already established connection */
   5:      if (!tp->accept_queue) {/* accept队列为空，说明还没有收到新连接 */
   6:          long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);/* 如果套口是非阻塞的，或者在一定时间内没有新连接，则返回 */
   7:  
   8:          if (!timeo)/* 超时时间到，没有新连接，退出 */
   9:              goto out;
  10:  
  11:          /* 运行到这里，说明有新连接到来，则等待新的传输控制块 */
  12:          error = wait_for_connect(sk, timeo);
  13:          if (error)
  14:              goto out;
  15:      }
  16:  
  17:      req = tp->accept_queue;
  18:      if ((tp->accept_queue = req->dl_next) == NULL)
  19:          tp->accept_queue_tail = NULL;
  20:  
  21:      newsk = req->sk;
  22:      sk_acceptq_removed(sk);
  23:      tcp_openreq_fastfree(req);
  24:      ....
  25:  
  26:      return newsk;
  27:  }
  

• 由tcp_v4_connect()->tcp_connect()->tcp_transmit_skb()发送，并置为TCP_SYN_SENT.
  
• 代码关键路径:
  

   1:  /* 构造并发送SYN段 */
   2:  int tcp_connect(struct sock *sk)
   3:  {
   4:      struct tcp_sock *tp = tcp_sk(sk);
   5:      struct sk_buff *buff;
   6:  
   7:      tcp_connect_init(sk);/* 初始化传输控制块中与连接相关的成员 */
   8:  
   9:      /* 为SYN段分配报文并进行初始化 */
  10:      buff = alloc_skb(MAX_TCP_HEADER + 15, sk->sk_allocation);
  11:      if (unlikely(buff == NULL))
  12:          return -ENOBUFS;
  13:  
  14:      /* Reserve space for headers. */
  15:      skb_reserve(buff, MAX_TCP_HEADER);
  16:  
  17:      TCP_SKB_CB(buff)->flags = TCPCB_FLAG_SYN;
  18:      TCP_ECN_send_syn(sk, tp, buff);
  19:      TCP_SKB_CB(buff)->sacked = 0;
  20:      skb_shinfo(buff)->tso_segs = 1;
  21:      skb_shinfo(buff)->tso_size = 0;
  22:      buff->csum = 0;
  23:      TCP_SKB_CB(buff)->seq = tp->write_seq++;
  24:      TCP_SKB_CB(buff)->end_seq = tp->write_seq;
  25:      tp->snd_nxt = tp->write_seq;
  26:      tp->pushed_seq = tp->write_seq;
  27:      tcp_ca_init(tp);
  28:  
  29:      /* Send it off. */
  30:      TCP_SKB_CB(buff)->when = tcp_time_stamp;
  31:      tp->retrans_stamp = TCP_SKB_CB(buff)->when;
  32:  
  33:      /* 将报文添加到发送队列上 */
  34:      __skb_queue_tail(&sk->sk_write_queue, buff);
  35:      sk_charge_skb(sk, buff);
  36:      tp->packets_out += tcp_skb_pcount(buff);
  37:      /* 发送SYN段 */
  38:      tcp_transmit_skb(sk, skb_clone(buff, GFP_KERNEL));
  39:      TCP_INC_STATS(TCP_MIB_ACTIVEOPENS);
  40:  
  41:      /* Timer for repeating the SYN until an answer. */
  42:      /* 启动重传定时器 */
  43:      tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto);
  44:      return 0;
  45:  }
  46:  
  

• 由tcp_v4_do_rcv()->tcp_rcv_state_process()->tcp_v4_conn_request()->tcp_v4_send_synack().
  
• tcp_v4_send_synack()
  
  • tcp_make_synack(sk, dst, req); * 根据路由、传输控制块、连接请求块中的构建SYN+ACK段 *
    
  • ip_build_and_send_pkt(); * 生成IP数据报并发送出去 *
    

    
    

    
    

    

    图: 服务端接收到SYN段后，发送SYN/ACK处理流程。

    
    

    
    

  • 代码关键路径:
    

     1:  /* 向客户端发送SYN+ACK报文 */
     2:  static int tcp_v4_send_synack(struct sock *sk, struct open_request *req,
     3:                    struct dst_entry *dst)
     4:  {
     5:      int err = -1;
     6:      struct sk_buff * skb;
     7:  
     8:      /* First, grab a route. */
     9:      /* 查找到客户端的路由 */
    10:      if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL)
    11:          goto out;
    12:  
    13:      /* 根据路由、传输控制块、连接请求块中的构建SYN+ACK段 */
    14:      skb = tcp_make_synack(sk, dst, req);
    15:  
    16:      if (skb) {/* 生成SYN+ACK段成功 */
    17:          struct tcphdr *th = skb->h.th;
    18:  
    19:          /* 生成校验码 */
    20:          th->check = tcp_v4_check(th, skb->len,
    21:                       req->af.v4_req.loc_addr,
    22:                       req->af.v4_req.rmt_addr,
    23:                       csum_partial((char *)th, skb->len,
    24:                                skb->csum));
    25:  
    26:          /* 生成IP数据报并发送出去 */
    27:          err = ip_build_and_send_pkt(skb, sk, req->af.v4_req.loc_addr,
    28:                          req->af.v4_req.rmt_addr,
    29:                          req->af.v4_req.opt);
    30:          if (err == NET_XMIT_CN)
    31:              err = 0;
    32:      }
    33:  
    34:  out:
    35:      dst_release(dst);
    36:      return err;
    37:  }
    38:  
    

  
  

• 由tcp_v4_do_rcv()->tcp_rcv_state_process().当前客户端处于TCP_SYN_SENT状态。
  
• tcp_rcv_synsent_state_process(); * tcp_rcv_synsent_state_process处理SYN_SENT状态下接收到的TCP段 *
  
  • tcp_ack(); * 处理接收到的ack报文 *
    
  • tcp_send_ack(); * 在主动连接时，向服务器端发送ACK完成连接，并更新窗口 *
    
    • alloc_skb(); * 构造ack段 *
      
    • tcp_transmit_skb(); * 将ack段发出 *
      
  • tcp_urg(sk, skb, th); * 处理完第二次握手后，还需要处理带外数据 *
    
  • tcp_data_snd_check(sk); * 检测是否有数据需要发送 *
    
    • 检查sk->sk_send_head队列上是否有待发送的数据。
      
    • tcp_write_xmit(); * 将TCP发送队列上的段发送出去 *
      
• 代码关键路径:
  

• 由tcp_v4_do_rcv()->tcp_rcv_state_process().当前服务端处于TCP_SYN_RECV状态变为TCP_ESTABLISHED状态。
  
• 代码关键路径:
  

    1:  /* 除了ESTABLISHED和TIME_WAIT状态外，其他状态下的TCP段处理都由本函数实现 */ 
    2:  int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
    3:                struct tcphdr *th, unsigned len)
    4:  {
    5:      struct tcp_sock *tp = tcp_sk(sk);
    6:      int queued = 0;
    7:  
    8:      tp->rx_opt.saw_tstamp = 0;
    9:  
   10:      switch (sk->sk_state) {
   11:      .....
   12:      /* SYN_RECV状态的处理 */
   13:      if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp &&/* 解析TCP选项，如果首部中存在时间戳选项 */
   14:          tcp_paws_discard(tp, skb)) {/* PAWS检测失败，则丢弃报文 */
   15:          if (!th->rst) {/* 如果不是RST段 */
   16:              /* 发送DACK给对端，说明接收到的TCP段已经处理过 */
   17:              NET_INC_STATS_BH(LINUX_MIB_PAWSESTABREJECTED);
   18:              tcp_send_dupack(sk, skb);
   19:              goto discard;
   20:          }
   21:          /* Reset is accepted even if it did not pass PAWS. */
   22:      }
   23:  
   24:      /* step 1: check sequence number */
   25:      if (!tcp_sequence(tp, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq)) {/* TCP段序号无效 */
   26:          if (!th->rst)/* 如果TCP段无RST标志，则发送DACK给对方 */
   27:              tcp_send_dupack(sk, skb);
   28:          goto discard;
   29:      }
   30:  
   31:      /* step 2: check RST bit */
   32:      if(th->rst) {/* 如果有RST标志，则重置连接 */
   33:          tcp_reset(sk);
   34:          goto discard;
   35:      }
   36:  
   37:      /* 如果有必要，则更新时间戳 */
   38:      tcp_replace_ts_recent(tp, TCP_SKB_CB(skb)->seq);
   39:  
   40:      /* step 3: check security and precedence [ignored] */
   41:  
   42:      /*  step 4:
   43:       *
   44:       *  Check for a SYN in window.
   45:       */
   46:      if (th->syn && !before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {/* 如果有SYN标志并且序号在接收窗口内 */
   47:          NET_INC_STATS_BH(LINUX_MIB_TCPABORTONSYN);
   48:          tcp_reset(sk);/* 复位连接 */
   49:          return 1;
   50:      }
   51:  
   52:      /* step 5: check the ACK field */
   53:      if (th->ack) {/* 如果有ACK标志 */
   54:          /* 检查ACK是否为正常的第三次握手 */
   55:          int acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH);
   56:  
   57:          switch(sk->sk_state) {
   58:          case TCP_SYN_RECV:
   59:              if (acceptable) {
   60:                  tp->copied_seq = tp->rcv_nxt;
   61:                  mb();
   62:                  /* 正常的第三次握手，设置连接状态为TCP_ESTABLISHED */
   63:                  tcp_set_state(sk, TCP_ESTABLISHED);
   64:                  sk->sk_state_change(sk);
   65:  
   66:                  /* Note, that this wakeup is only for marginal
   67:                   * crossed SYN case. Passively open sockets
   68:                   * are not waked up, because sk->sk_sleep ==
   69:                   * NULL and sk->sk_socket == NULL.
   70:                   */
   71:                  if (sk->sk_socket) {/* 状态已经正常，唤醒那些等待的线程 */
   72:                      sk_wake_async(sk,0,POLL_OUT);
   73:                  }
   74:  
   75:                  /* 初始化传输控制块，如果存在时间戳选项，同时平滑RTT为0，则需计算重传超时时间 */
   76:                  tp->snd_una = TCP_SKB_CB(skb)->ack_seq;
   77:                  tp->snd_wnd = ntohs(th->window) <<
   78:                            tp->rx_opt.snd_wscale;
   79:                  tcp_init_wl(tp, TCP_SKB_CB(skb)->ack_seq,
   80:                          TCP_SKB_CB(skb)->seq);
   81:  
   82:                  /* tcp_ack considers this ACK as duplicate
   83:                   * and does not calculate rtt.
   84:                   * Fix it at least with timestamps.
   85:                   */
   86:                  if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
   87:                      !tp->srtt)
   88:                      tcp_ack_saw_tstamp(tp, 0);
   89:  
   90:                  if (tp->rx_opt.tstamp_ok)
   91:                      tp->advmss -= TCPOLEN_TSTAMP_ALIGNED;
   92:  
   93:                  /* Make sure socket is routed, for
   94:                   * correct metrics.
   95:                   */
   96:                  /* 建立路由，初始化拥塞控制模块 */
   97:                  tp->af_specific->rebuild_header(sk);
   98:  
   99:                  tcp_init_metrics(sk);
  100:  
  101:                  /* Prevent spurious tcp_cwnd_restart() on
  102:                   * first data packet.
  103:                   */
  104:                  tp->lsndtime = tcp_time_stamp;/* 更新最近一次发送数据包的时间 */
  105:  
  106:                  tcp_initialize_rcv_mss(sk);
  107:                  tcp_init_buffer_space(sk);
  108:                  tcp_fast_path_on(tp);/* 计算有关TCP首部预测的标志 */
  109:              } else {
  110:                  return 1;
  111:              }
  112:              break;
  113:          .....
  114:          }
  115:      } else
  116:          goto discard;
  117:      .....
  118:  
  119:      /* step 6: check the URG bit */
  120:      tcp_urg(sk, skb, th);/* 检测带外数据位 */
  121:  
  122:      /* tcp_data could move socket to TIME-WAIT */
  123:      if (sk->sk_state != TCP_CLOSE) {/* 如果tcp_data需要发送数据和ACK则在这里处理 */
  124:          tcp_data_snd_check(sk);
  125:          tcp_ack_snd_check(sk);
  126:      }
  127:  
  128:      if (!queued) { /* 如果段没有加入队列，或者前面的流程需要释放报文，则释放它 */
  129:  discard:
  130:          __kfree_skb(skb);
  131:      }
  132:      return 0;
  133:  }