TCP/IP源码学习(23)——tcp_sendmsg(2)

2022-01-09 00:01:55

本文的copyleft归gfree.wind@gmail.com所有，使用GPL发布，可以*拷贝，转载。但转载请保持文档的完整性，注明原作者及原链接，严禁用于任何商业用途。
作者：gfree.wind@gmail.com
博客：linuxfocus.blog.chinaunix.net    

继续前面的学习，tcp_sendmsg
  1. int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
  2.         size_t size)
  3. {
  4.     /* 
  5.     省略之前的代码
  6.     */
  7.     while (--iovlen >= 0) {
  8.         size_t seglen = iov->iov_len;
  9.         unsigned char __user *from = iov->iov_base;

  11.         iov++;

  13.         while (seglen > 0) {
    1.           /* 
    2.           省略了之前的代码
    3.           */           
  15.  
  16.             /*
  17.             调整要复制的字节数，使最多只能复制剩下的字节数seglen。
  18.             从后面可以看出，seglen逐渐减少
  19.             */
  20.             /* Try to append data to the end of skb. */
  21.             if (copy > seglen)
  22.                 copy = seglen;

  24.             /* Where to copy to? */
  25.             if (skb_tailroom(skb) > 0) {
  26.                 /* 如果skb还有空间，则复制到skb中去*/
  27.                 /* We have some space in skb head. */
  28.                 /*
  29.                 调整copy的大小，使其不得大于tailroom的空间。
  30.                 */
  31.                 if (copy > skb_tailroom(skb))
  32.                     copy = skb_tailroom(skb);
  33.                 /* 将数据加到skb中去*/
  34.                 if ((err = skb_add_data(skb, from, copy)) != 0)
  35.                     goto do_fault;
  36.             } else {
  37.                 /* skb中没有空闲空间了 */
  38.                 
  39.                 /*
  40.                 这时的数据组织方式，可以参考我的另外一篇博文《tcp/ip源码（19）——Scatter/Gather I                 /O在L3中的应用》
  41.                 */
  42.                 int merge = 0;
  43.                 int i = skb_shinfo(skb)->nr_frags;
  44.                 struct page *page = TCP_PAGE(sk);
  45.                 int off = TCP_OFF(sk);

  47.                 if (skb_can_coalesce(skb, i, page, off) &&
  48.                  off != PAGE_SIZE) {
  49.                     /* We can extend the last page
  50.                      * fragment. */
  51.                     /* 可以将数据加到最后一个page中 */
  52.                     merge = 1;
  53.                 } else if (i == MAX_SKB_FRAGS || !sg) {
  54.                     /* Need to add new fragment and cannot
  55.                      * do this because interface is non-SG,
  56.                      * or because all the page slots are
  57.                      * busy. */
  58.                     /* 
  59.                     到达此处，表明当前的page无法填充数据。
  60.                     这时，数据分片达到最大的frag数量，或者不支持Scatter Gather功能。那么都无法继续                     填充。这时，将tcp置为push标志，尽快发送数据
  61.                     */
  62.                     tcp_mark_push(tp, skb);
  63.                     /* 需要申请一个新的skb */
  64.                     goto new_segment;
  65.                 } else if (page) {
  66.                     if (off == PAGE_SIZE) {
  67.                         /* 
  68.                         之前的page已经写满.所以该page已经不能再继续填充了，
  69.                         因此将sk->sk_sndmsg_page和page置为null
  70.                         */
  1.                         put_page(page);
  2.                         TCP_PAGE(sk) = page = NULL;
  3.                         off = 0;
  4.                     }
  5.                 } else 
  6.                     off = 0; //没有可用page，所以offset为0
                  /* 调整copy的大小，使之不得大于page剩下的空间 */
  1.                 if (copy > PAGE_SIZE - off)
  2.                     copy = PAGE_SIZE - off;
                  /* 判断是否需要等待，直到有许可的内存使用 */
  1.                 if (!sk_wmem_schedule(sk, copy))
  2.                     goto wait_for_memory;

  4.                 if (!page) {
  5.                     /* 如当前没有page，则申请一个新的page */
  6.                     /* Allocate new cache page. */
  7.                     if (!(page = sk_stream_alloc_page(sk)))
  8.                         goto wait_for_memory;
  9.                 }
                 /* 复制数据到当前page */
  1.                 /* Time to copy data. We are close to
  2.                  * the */
  3.                 err = skb_copy_to_page(sk, from, skb, page,
  4.                          off, copy);
  5.                 if (err) {
  6.                     /* If this page was new, give it to the
  7.                      * socket so it does not get leaked.
  8.                      */
  9.                     /* 出错了。则把这个page交给该socket，所以没有内存泄露 */
  10.                     if (!TCP_PAGE(sk)) {
  11.                         TCP_PAGE(sk) = page;
  12.                         TCP_OFF(sk) = 0;
  13.                     }
  14.                     goto do_error;
  15.                 }

  17.                 /* Update the skb. */
  18.                 if (merge) {
  19.                     /* 如果是复制到已有的page上，那么就更新对应的frags的size */
  20.                     skb_shinfo(skb)->frags[i - 1].size +=
  21.                                     copy;
  22.                 } else {
  23.                     /* 这是一个新的page，那么需要填充新的frags的值 */
  24.                     skb_fill_page_desc(skb, i, page, off, copy);
  25.                     /* 增加page的计数，如果该page没有填满，且sock的sk_sndmsg_page没有值，则把当前                      page赋给它 */
  26.                     if (TCP_PAGE(sk)) {
  27.                         get_page(page);
  28.                     } else if (off + copy < PAGE_SIZE) {
  29.                         get_page(page);
  30.                         TCP_PAGE(sk) = page;
  31.                     }
  32.                 }
                 /* 调整偏移 */
  1.                 TCP_OFF(sk) = off + copy;
  2.             }
             
             /* 若没有复制任何数据，则取消PUSH标志 */
  1.             if (!copied)
  2.                 TCP_SKB_CB(skb)->flags &= ~TCPHDR_PSH;
             
             /* 
             调整sequence
             注意这里的sequence number并不是tcp包中的sequence number。这里的sequence是tcp内部使用              的
             */
  1.             tp->write_seq += copy;
  2.             TCP_SKB_CB(skb)->end_seq += copy;
  3.             skb_shinfo(skb)->gso_segs = 0;

  5.             from += copy;
  6.             copied += copy;
  7.             if ((seglen -= copy) == 0 && iovlen == 0)
  8.                 goto out;

  10.             if (skb->len < max || (flags & MSG_OOB))
  11.                 continue;

  13.             if (forced_push(tp)) {
  14.                 /* 强制push， 即强制发送数据*/
  15.                 tcp_mark_push(tp, skb);
  16.                 __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
  17.             } else if (skb == tcp_send_head(sk)) //需要发送该skb
  18.                 tcp_push_one(sk, mss_now); 
  19.             continue;

  1. wait_for_sndbuf:
  2.             set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
  3. wait_for_memory:
  4.             if (copied)
  5.                 tcp_push(sk, flags & ~MSG_MORE, mss_now, TCP_NAGLE_PUSH);

  7.             if ((err = sk_stream_wait_memory(sk, &timeo)) != 0)
  8.                 goto do_error;
             /* 发送MSS */
  1.             mss_now = tcp_send_mss(sk, &size_goal, flags);
  2.         }
  3.     }

  5. out:
  6.     if (copied)
  7.         tcp_push(sk, flags, mss_now, tp->nonagle);
  8.     TCP_CHECK_TIMER(sk);
  9.     release_sock(sk);
  10.     return copied;
     /* 下面的都是错误处理 */
  1. do_fault:
  2.     if (!skb->len) {
  3.         tcp_unlink_write_queue(skb, sk);
  4.         /* It is the one place in all of TCP, except connection
  5.          * reset, where we can be unlinking the send_head.
  6.          */
  7.         tcp_check_send_head(sk, skb);
  8.         sk_wmem_free_skb(sk, skb);
  9.     }

  11. do_error:
  12.     if (copied)
  13.         goto out;
  14. out_err:
  15.     err = sk_stream_error(sk, flags, err);
  16.     TCP_CHECK_TIMER(sk);
  17.     release_sock(sk);
  18.     return err;
  19. }
至此，这个函数基本上学习完毕。这里可以看到TCP发送数据时，buffer的组织形式，如果支持SG的话，自然是用SG。如果不支持，当多个数据发送时，只能使用skb buffer来保存数据。这不仅降低效率，也占用了不必要的空间。
上一篇：leetcode1219 黄金旷工 middle


下一篇：剑指Offer：[第4天 查找算法(简单)]---＞0～n-1中缺失的数字