4.4 TCP Small Queue(TSQ)

  TCP发送的数据经过IP层添加IP包头后,会被发送到IP数据栈和网卡之间的队列中,当网卡能够发送数据时会到这个队列中去取skb。当TCP发送数据过快时,或一个带宽很大或者包速率很大的非TCP数据流会把队列里的所有空间占满,造成数据包丢失和延时的问题。更糟的是,这样很可能会使另一个缓存产生,进而产生一个静止队列(standing queue),造成更严重的延时并使TCP的RTT和拥塞窗口的计算出现问题。Linux3.6.0出现后,Linux内核增加了TCP小队列(TCP Small Queue)的机制,用于解决该问题。TCP小队列对每个TCP数据流中,能够同时参与排队的字节数做出了限制,这个限制是通过net.ipv4.tcp_limit_output_bytes内核选项实现的。当TCP发送的数据超过这个限制时,多余的数据会被放入另外一个队列中,再通过tastlet机制择机发送。下面分析一下TSQ的实现。

  TSQ tasklet是一个每CPU变量,这样可以保证在多核条件下的并发:

 678 struct tsq_tasklet {     
 679     struct tasklet_struct   tasklet;
 680     struct list_head    head; /* queue of tcp sockets */
 681 };
 682 static DEFINE_PER_CPU(struct tsq_tasklet, tsq_tasklet);

  TSQ tasklet的初始化是在内核加载时完成:

3375 void __init tcp_init(void)
3376 {
...
3456     tcp_tasklet_init();
3457 }
 772 void __init tcp_tasklet_init(void)
 773 {   
 774     int i;
 775     
 776     for_each_possible_cpu(i) {
 777         struct tsq_tasklet *tsq = &per_cpu(tsq_tasklet, i);
 778 
 779         INIT_LIST_HEAD(&tsq->head);
 780         tasklet_init(&tsq->tasklet,
 781                  tcp_tasklet_func,
 782                  (unsigned long)tsq); //初始化tasklet任务
 783     }
 784 }       
  tasklet_init函数指定了tcp_tasklet_func函数为处理函数:
 697 static void tcp_tasklet_func(unsigned long data)
 698 {
 699     struct tsq_tasklet *tsq = (struct tsq_tasklet *)data;
 700     LIST_HEAD(list);
 701     unsigned long flags;
 702     struct list_head *q, *n;
 703     struct tcp_sock *tp;
 704     struct sock *sk;
 705 
 706     local_irq_save(flags);
 707     list_splice_init(&tsq->head, &list); //将tsq->head队列中的成员转移到list中
 708     local_irq_restore(flags);
 709 
 710     list_for_each_safe(q, n, &list) { //每一个成员就是一个socket
 711         tp = list_entry(q, struct tcp_sock, tsq_node);
 712         list_del(&tp->tsq_node);
 713 
 714         sk = (struct sock *)tp;
 715         bh_lock_sock(sk);
 716 
 717         if (!sock_owned_by_user(sk)) { //socket没有被进程访问
 718             tcp_tsq_handler(sk); //发送数据
 719         } else { //scoket正在被进程访问
 720             /* defer the work to tcp_release_cb() */
 721             set_bit(TCP_TSQ_DEFERRED, &tp->tsq_flags);
 722         }
 723         bh_unlock_sock(sk);
 724 
 725         clear_bit(TSQ_QUEUED, &tp->tsq_flags);
 726         sk_free(sk);
 727     }
 728 }
  如果scoket没有被进程访问,则直接调用tcp_tsq_handler发送数据;否则设置TCP_TSQ_DEFERRED标记,这样当用户进程调用release_sock函数解锁socket时会调用tcp_release_cb函数:

 741 void tcp_release_cb(struct sock *sk)
 742 {
 743     struct tcp_sock *tp = tcp_sk(sk);
 744     unsigned long flags, nflags;
 745 
 746     /* perform an atomic operation only if at least one flag is set */
 747     do {
 748         flags = tp->tsq_flags;
 749         if (!(flags & TCP_DEFERRED_ALL))
 750             return; 
 751         nflags = flags & ~TCP_DEFERRED_ALL;
 752     } while (cmpxchg(&tp->tsq_flags, flags, nflags) != flags);
 753     
 754     if (flags & (1UL << TCP_TSQ_DEFERRED)) //如果设置了TCP_TSQ_DEFERRED标记
 755         tcp_tsq_handler(sk);
 756     
 757     if (flags & (1UL << TCP_WRITE_TIMER_DEFERRED)) {
 758         tcp_write_timer_handler(sk);
 759         __sock_put(sk);
 760     }   
 761     if (flags & (1UL << TCP_DELACK_TIMER_DEFERRED)) {
 762         tcp_delack_timer_handler(sk);
 763         __sock_put(sk);
 764     }   
 765     if (flags & (1UL << TCP_MTU_REDUCED_DEFERRED)) {
 766         sk->sk_prot->mtu_reduced(sk);
 767         __sock_put(sk);
 768     }   
 769 }   
  可见在进程锁定socket的情况下tcp_tasklet_func函数只是延迟调用了tcp_tsq_handler函数:
 684 static void tcp_tsq_handler(struct sock *sk)
 685 {
 686     if ((1 << sk->sk_state) &
 687         (TCPF_ESTABLISHED | TCPF_FIN_WAIT1 | TCPF_CLOSING |
 688          TCPF_CLOSE_WAIT  | TCPF_LAST_ACK))
 689         tcp_write_xmit(sk, tcp_current_mss(sk), 0, 0, GFP_ATOMIC);
 690 }
  TSQ tasklet的主要功能是在软中断上下文中遍历挂入TSQ队列中的socket,并调用tcp_write_xmit函数发送socket发送队列中的数据。那么socket在什么情况下会被加入到TSQ队列中呢?先来看负责发送TCP包的tcp_transmit_skb函数:
 828 static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
 829                 gfp_t gfp_mask)
 830 {
...
 890     skb->destructor = (sysctl_tcp_limit_output_bytes > 0) ?
 891               tcp_wfree : sock_wfree;
 892     atomic_add(skb->truesize, &sk->sk_wmem_alloc);
 893 
...
  如果net.ipv4.tcp_limit_output_bytes大于0,则skb->destructor会被设置为tcp_wfree函数,sk->sk_wmen_alloc也会被加上skb的真实大小。当skb被释放时tcp_wfree函数就会被调用:

 791 void tcp_wfree(struct sk_buff *skb)
 792 {
 793     struct sock *sk = skb->sk;
 794     struct tcp_sock *tp = tcp_sk(sk);
 795 
 796     if (test_and_clear_bit(TSQ_THROTTLED, &tp->tsq_flags) &&
 797         !test_and_set_bit(TSQ_QUEUED, &tp->tsq_flags)) { //设置TSQ_QUEUED标记,防止重复处理
 798         unsigned long flags;
 799         struct tsq_tasklet *tsq;
 800     
 801         /* Keep a ref on socket.
 802          * This last ref will be released in tcp_tasklet_func()
 803          */
 804         atomic_sub(skb->truesize - 1, &sk->sk_wmem_alloc);
 805 
 806         /* queue this socket to tasklet queue */
 807         local_irq_save(flags);
 808         tsq = &__get_cpu_var(tsq_tasklet); //获取当前CPU对应的tsq_tasklet
 809         list_add(&tp->tsq_node, &tsq->head); //将socket加入到TSQ队列中
 810         tasklet_schedule(&tsq->tasklet); //将需要调度的tasklet挂到tasklet_hi_vec链表,待软中断被调度到时运行
 811         local_irq_restore(flags);
 812     } else {
 813         sock_wfree(skb);
 814     }
 815 }
  如果设置了TSQ_THROTTLED标记tcp_wfree函数才会将socket放入TSQ队列中等待Tasklet发送。TSQ_THROTTLED标记是什么时候设置的呢?来看tcp_write_xmit函数:

1811 static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
1812                int push_one, gfp_t gfp)
1813 {
...
1832     while ((skb = tcp_send_head(sk))) {
1833         unsigned int limit;
...
1867         if (atomic_read(&sk->sk_wmem_alloc) >= sysctl_tcp_limit_output_bytes) {
1868             set_bit(TSQ_THROTTLED, &tp->tsq_flags);
1869             break;
1870         }
...
1884         if (unlikely(tcp_transmit_skb(sk, skb, 1, gfp)))
1885             break;
...
  sk->sk_wmem_alloc在tcp_transmit_skb中用于累加skb的truesize,在skb释放时再减去skb的truesize;由tcp_transmit_skb函数发送出去的skb有两种情况会被释放:1)底层队列已满;2)skb中的数据被网卡发送出去。故sk->sk_wmem_alloc的意义为TCP放入底层队列中尚未被网卡发送的skb所占用的内存大小。sk->sk_wmem_alloc大于sysctl_tcp_limit_output_bytes意味着当前TCP连接放入底层队列中的数据大小达到限制,这时必须使用TSQ机制。

  现在我们来理顺一下TSQ的运行原理:首先设置net.ipv4.tcp_limit_output_bytes内核选项来指定sysctl_tcp_limit_output_bytes的值,在TCP发包系统调用使用tcp_write_xmit来调用tcp_transmit_skb函数发送skb时会进行设置使得skb在释放时会调用tcp_wfree函数,并增加sk->sk_wmem_alloc的值。当sk->sk_wmem_alloc达到限制时,即底层队列允许当前TCP连接放入的数据的总大小达到限制时(此时底层队列未必会满),tcp_write_xmit函数就不允许继续发送skb,而是设置标记使得在由tcp_transmit_skb函数发送的任意skb在释放时会调用tcp_wfree函数,将发送skb的任务放入TSQ tasklet中,然后系统调用返回。此后由TSQ tasklet在软中断上下文中驱动tcp_write_xmit函数发送skb,但放入底层队列中的skb的总大小仍然不能超过限制。一旦底层队列中的skb被陆续释放使得sk->sk_wmem_alloc的值减小到低于限制时,TSQ tasklet就可以即时地发送skb到队列中。这样既可以通过限制一个TCP连接向底层队列放入skb的速度来缓解队列拥堵导致的丢包问题,也能够在队列空间宽松时及时地发送数据,从而减小了TCP延时。

发布了79 篇原创文章 · 获赞 46 · 访问量 23万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览