linux 内核tcp接收数据的实现

最新推荐文章于 2024-10-04 12:27:46 发布
最新推荐文章于 2024-10-04 12:27:46 发布
阅读量2.1k 收藏 4
点赞数
相比于发送数据，接收数据更复杂一些。接收数据这里和3层的接口是tcp_v4_rcv(我前面的blog有介绍3层和4层的接口的实现).而4层和用户空间，也就是系统调用是socket_recvmsg(其他的读取函数也都会调用这个函数).而这个系统调用会调用__sock_recvmsg.下面我们就先来看下这个函数。 

它的主要功能是初始化sock_iocb,以便与将来数据从内核空间拷贝到用户空间。然后调用 
recvmsg这个虚函数(tcp协议的话也就是tcp_recvmsg). 

Java代码   收藏代码
  1. static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,  
  2.                  struct msghdr *msg, size_t size, int flags)  
  3. {  
  4.     int err;  
  5.     struct sock_iocb *si = kiocb_to_siocb(iocb);  
  6. ///初始化si。  
  7.     si->sock = sock;  
  8.     si->scm = NULL;  
  9.     si->msg = msg;  
  10.     si->size = size;  
  11.     si->flags = flags;  
  12.   
  13.     err = security_socket_recvmsg(sock, msg, size, flags);  
  14.     if (err)  
  15.         return err;  
  16. //调用tcp_recvmsg  
  17.     return sock->ops->recvmsg(iocb, sock, msg, size, flags);  
  18. }  


内核对待数据的接收分为2部分，一部分是当用户是阻塞的读取数据时，这时如果有数据则是直接拷贝到用户空间。而另一方面，如果是非阻塞，则会先把数据拷贝到接收队列。 

而在内核中这个队列分为3种形式。分别是： 

1 sock域结构的 sk_backlog队列。 

2 tcp_sock的ucopy.prequeue队列。 

3 sock结构的 receive_queue队列。 

我们先来看两个主要的结构体，然后再来解释这3各队列的区别，首先是ucopy结构. 

这个结构表示将要直接复制到用户空间的数据。 

Java代码   收藏代码
  1. /* Data for direct copy to user */  
  2.     struct {  
  3. ///prequeue队列。  
  4.         struct sk_buff_head prequeue;  
  5. ///表示当前所处的进程，其实也就是skb的接受者。  
  6.         struct task_struct  *task;  
  7. ///数据区  
  8.         struct iovec        *iov;  
  9. ///prequeue队列总的所占用的内存大小  
  10.         int         memory;  
  11. ///这个域表示用户所请求的长度(要注意这个值是可变的，随着拷贝给用户的数据而减少)  
  12.         int         len;  
  13. ........................  
  14.     } ucopy;  


接下来是sock的sock_lock结构. 

内核的注释很详细，这个锁主要是用来对软中断和进程上下文之间提供一个同步。 

Java代码   收藏代码
  1. /* This is the per-socket lock.  The spinlock provides a synchronization 
  2.  * between user contexts and software interrupt processing, whereas the 
  3.  * mini-semaphore synchronizes multiple users amongst themselves. 
  4.  */  
  5. typedef struct {  
  6. ///自选锁  
  7.     spinlock_t      slock;  
  8. ///如果有用户进程在使用这个sock 则owned为1,否则为0  
  9.     int         owned;  
  10. ///等待队列，也就是当sock被锁住后，等待使用这个sock对象。  
  11.     wait_queue_head_t   wq;  
  12.     /* 
  13.      * We express the mutex-alike socket_lock semantics 
  14.      * to the lock validator by explicitly managing 
  15.      * the slock as a lock variant (in addition to 
  16.      * the slock itself): 
  17.      */  
  18. #ifdef CONFIG_DEBUG_LOCK_ALLOC  
  19.     struct lockdep_map dep_map;  
  20. #endif  
  21. } socket_lock_t;  


然后来看3个队列的区别。 

首先sk_backlog队列是当当前的sock在进程上下文中被使用时，如果这个时候有数据到来，则将数据拷贝到sk_backlog. 

prequeue则是数据buffer第一站一般都是这里，如果prequeue已满，则会拷贝数据到receive_queue队列种。 

最后一个receive_queue也就是进程上下文第一个取buffer的队列。(后面介绍tcp_recvmsg时会再介绍这3个队列). 

这里为什么要有prequeue呢,直接放到receive_queue不就好了.这里我是认receive_queue的处理比较繁琐(看tcp_rcv_established的实现就知道了,分为slow path和fast path),而软中断每次只能处理一个数据包(在一个cpu上),因此为了软中断能尽快完成,我们就可以先将数据放到prequeue中(tcp_prequeue),然后软中断就直接返回.而处理prequeue就放到进程上下文去处理了. 

最后在分析tcp_v4_rcv和tcp_recvmsg之前，我们要知道tcp_v4_rcv还是处于软中断上下文，而tcp_recvmsg是处于进程上下文，因此比如socket_lock_t才会提供一个owned来锁住对应的sock。而我们也就是需要这3个队列来进行软中断上下文和进程上下文之间的通信。最终当数据拷贝到对应队列，则软中断调用返回。这里要注意的是相同的函数在软中断上下文和进程上下文种调用是不同的，我们下面就会看到(比如tcp_rcv_established函数) 

ok，现在来看tcp_v4_rcv的源码。这个函数是在软中断上下文中被调用的,我们这里来看下她的代码片断： 


Java代码   收藏代码
  1.     int tcp_v4_rcv(struct sk_buff *skb)  
  2. {  
  3. ///一些用到的变量  
  4.     const struct iphdr *iph;  
  5.     struct tcphdr *th;  
  6.     struct sock *sk;  
  7.     int ret;  
  8.     struct net *net = dev_net(skb->dev);  
  9. ............................  
  10.   
  11. //通过四元组得到对应的sock。  
  12.     sk = __inet_lookup_skb(&tcp_hashinfo, skb, th->source, th->dest);  
  13.     if (!sk)  
  14.         goto no_tcp_socket;  
  15.   
  16. process:  
  17.   
  18. ///如果是time_wait状态，则进入相关处理(这次不会分析time_wait状态，以后分析tcp的断开状态变迁时，会详细分析这个).  
  19.     if (sk->sk_state == TCP_TIME_WAIT)  
  20.         goto do_time_wait;  
  21. .................................  
  22. ///加下半部的锁  
  23.     bh_lock_sock_nested(sk);  
  24.     ret = 0;  
  25. ///这个宏很简单就是判断(sk)->sk_lock.owned.也就是当进程上下文在使用这个sock时为1.  
  26.     if (!sock_owned_by_user(sk)) {  
  27. 。........................  
  28.         {  
  29. ///先将buffer放到prequeue队列中。如果成功则返回1.  
  30.             if (!tcp_prequeue(sk, skb))  
  31. ///假设失败，则直接调用tcp_v4_do_rcv处理这个skb(其实也就是直接放到receive_queue中).  
  32.                 ret = tcp_v4_do_rcv(sk, skb);  
  33.         }  
  34.     } else  
  35. ///当有进程在使用这个sock则放buf到sk_backlog中。  
  36.         sk_add_backlog(sk, skb);  
  37. //解锁。  
  38.     bh_unlock_sock(sk);  
  39.   
  40.     sock_put(sk);  
  41.   
  42.     return ret;  
  43. ...................................................  


上面的流程很简单，我们接下来来看几个跳过的函数，第一个是tcp_prequeue。 

这里我们可以看到sysctl_tcp_low_latency可以决定我们是否使用prequeue队列. 

Java代码   收藏代码
  1. static inline int tcp_prequeue(struct sock *sk, struct sk_buff *skb)  
  2. {  
  3.     struct tcp_sock *tp = tcp_sk(sk);  
  4.   
  5. ///如果启用tcp_low_latency或者ucopy.task为空则返回0.ucopy.task为空一般是表示进程空间有进程在等待sock的数据的到来，因此我们需要直接复制数据到receive队列。并唤醒它。  
  6.     if (sysctl_tcp_low_latency || !tp->ucopy.task)  
  7.         return 0;  
  8. ///加数据包到prequeue队列。  
  9.     __skb_queue_tail(&tp->ucopy.prequeue, skb);  
  10. ///update内存大小。  
  11.     tp->ucopy.memory += skb->truesize;  
  12. ///如果prequeue已满，则将处理prequeue队列。  
  13.     if (tp->ucopy.memory > sk->sk_rcvbuf) {  
  14.         struct sk_buff *skb1;  
  15.   
  16.         BUG_ON(sock_owned_by_user(sk));  
  17. ///遍历prequeue队列。  
  18.         while ((skb1 = __skb_dequeue(&tp->ucopy.prequeue)) != NULL) {  
  19. ///这个函数最终也会调用tcp_v4_do_rcv(也就是加入到receive队列中).  
  20.             sk_backlog_rcv(sk, skb1);  
  21.             NET_INC_STATS_BH(sock_net(sk),  
  22.                      LINUX_MIB_TCPPREQUEUEDROPPED);  
  23.         }  
  24. ///清空内存。  
  25.         tp->ucopy.memory = 0;  
  26.     } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {  
  27. ///这里表示这个数据包是prequeue的第一个包。然后唤醒等待队列。  
  28.         wake_up_interruptible_poll(sk->sk_sleep,  
  29.                        POLLIN | POLLRDNORM | POLLRDBAND);  
  30.   
  31. ///这里的定时器以后会详细介绍。  
  32.         if (!inet_csk_ack_scheduled(sk))  
  33.             inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,  
  34.                           (3 * tcp_rto_min(sk)) / 4,  
  35.                           TCP_RTO_MAX);  
  36.     }  
  37.     return 1;  
  38. }  



我们这里只关注TCP_ESTABLISHED状态，来看tcp_v4_do_rcv:它主要是通过判断相应的tcp状态来进入相关的处理函数。 


Java代码   收藏代码
  1. int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb)  
  2. {  
  3.     struct sock *rsk;  
  4. ...................................  
  5.     if (sk->sk_state == TCP_ESTABLISHED) { /* Fast path */  
  6.         TCP_CHECK_TIMER(sk);  
  7. ///处理数据包。  
  8.         if (tcp_rcv_established(sk, skb, tcp_hdr(skb), skb->len)) {  
  9.             rsk = sk;  
  10.             goto reset;  
  11.         }  
  12.         TCP_CHECK_TIMER(sk);  
  13.         return 0;  
  14.     }  
  15.   
  16.     ........................................  
  17. }  



因此我们这里重点要看的函数就是tcp_rcv_established,当它在软中断上下文中被调用时，主要的目的是将skb加入到receive_queue队列中。因此这里我们只看这一部分，等下面分析tcp_recvmsg时，我们再来看进程上下文才会处理的一部分。 

Java代码   收藏代码
  1. ///程序如何到达这里，我们在分析tcp_recvmsg时会再次分析tcp_rcv_established,那个时候会介绍这个。  
  2. if (!eaten) {  
  3. ///进行checksum  
  4.     if (tcp_checksum_complete_user(sk, skb))  
  5.       
  6.                 goto csum_error;  
  7. ..................................................  
  8.   
  9.                 __skb_pull(skb, tcp_header_len);  
  10.   
  11. ///最重要的在这里，我们可以看到直接将skb加入到sk_receive队列中。  
  12.             __skb_queue_tail(&sk->sk_receive_queue, skb);  
  13.                 skb_set_owner_r(skb, sk);  
  14. ///更新rcv_nxt,也就是表示下一个接收序列起始号。  
  15.                 tp->rcv_nxt =             TCP_SKB_CB(skb)->end_seq;  
  16.             }  
  17. ............................................  



接下来来看tcp_rcvmsg函数。 

通过上面我们知道有找个队列可供我们取得skbuf，那么具体的次序是什么呢，我这里摘抄内核的注释，它讲的非常清楚： 

引用
Look: we have the following (pseudo)queues: 
1. packets in flight 
2. backlog 
3. prequeue 
4. receive_queue 
Each queue can be processed only if the next ones are empty. At this point we have empty receive_queue.But prequeue _can_ be not empty after 2nd iteration, when we jumped to start of loop because backlog 
processing added something to receive_queue. We cannot release_sock(), because backlog containd packets arrived _after_ prequeued ones. 

Shortly, algorithm is clear --- to process all the queues in order. We could make it more directly,requeueing packets from backlog to prequeue, if is not empty. It is more elegant, but eats cycles,


由于这个函数比较复杂，因此我们分段来分析这个函数。 
首先是处理包之前的一些合法性判断，以及取得一些有用的值。 

Java代码   收藏代码
  1. int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,  
  2.         size_t len, int nonblock, int flags, int *addr_len)  
  3. {  
  4. ...................................  
  5.   
  6. ///锁住当前的socket。  
  7.     lock_sock(sk);  
  8.   
  9.     TCP_CHECK_TIMER(sk);  
  10.   
  11.     err = -ENOTCONN;  
  12.     if (sk->sk_state == TCP_LISTEN)  
  13.         goto out;  
  14.   
  15.   
  16. ///得到超时时间(前面已经介绍过了).如果非阻塞则为0.  
  17.     timeo = sock_rcvtimeo(sk, nonblock);  
  18.   
  19.     /* Urgent data needs to be handled specially. */  
  20.     if (flags & MSG_OOB)  
  21.         goto recv_urg;  
  22.   
  23. ///取得当前tcp字节流中的未读数据的起始序列号。  
  24.     seq = &tp->copied_seq;  
  25.     if (flags & MSG_PEEK) {  
  26.         peek_seq = tp->copied_seq;  
  27.         seq = &peek_seq;  
  28.     }  
  29.   
  30. ///主要是用来处理MSG_WAITALL套接字选项。这个选项是用来标记是否等待所有的数据到达才返回的。  
  31.     target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);  
  32. }  


在上面我们看到了lock_sock，这个函数是用来锁住当前的sock， 我们来看它的详细实现,它最终会调用lock_sock_nested： 

Java代码   收藏代码
  1. void lock_sock_nested(struct sock *sk, int subclass)  
  2. {  
  3.     might_sleep();  
  4. ///首先加锁。  
  5.     spin_lock_bh(&sk->sk_lock.slock);  
  6. ///如果owned为1,也就是有其他进程在使用这个sock。此时调用__lock_sock(这个函数用来休眠进程，进入等待队列)。  
  7.     if (sk->sk_lock.owned)  
  8.         __lock_sock(sk);  
  9. ///当sock可以使用了，则设置owned为1,标记被当前进程所使用。  
  10.     sk->sk_lock.owned = 1;  
  11. ///解锁。  
  12.     spin_unlock(&sk->sk_lock.slock);  
  13.     /* 
  14.      * The sk_lock has mutex_lock() semantics here: 
  15.      */  
  16.     mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);  
  17.     local_bh_enable();  
  18. }  


我们再来看__lock_sock如何来处理的。 

Java代码   收藏代码
  1. static void __lock_sock(struct sock *sk)  
  2. {  
  3.     DEFINE_WAIT(wait);  
  4.   
  5.     for (;;) {  
  6. ///加入等待队列，可以看到加入的等待队列是sl_lock.wq，也就是我们上面介绍过得。而这个等待队列的唤醒我们下面会介绍。  
  7.         prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,  
  8.                     TASK_UNINTERRUPTIBLE);  
  9. ///解锁。  
  10.         spin_unlock_bh(&sk->sk_lock.slock);  
  11. ///让出cpu，进入休眠。  
  12.         schedule();  
  13.         spin_lock_bh(&sk->sk_lock.slock);  
  14. ///如果轮到我们处理这个sock，则跳出循环。  
  15.         if (!sock_owned_by_user(sk))  
  16.             break;  
  17.     }  
  18.     finish_wait(&sk->sk_lock.wq, &wait);  
  19. }  



ok，再回到tcp_recvmsg.接下来我们来看如何处理数据包。 

下面这一段主要是用来从receive队列中读取数据。 

Java代码   收藏代码
  1. do {  
  2.         u32 offset;  
  3.   
  4. ///是否有urgent数据，如果已经读取了一些数据或者有个未决的sigurg信号，则直接退出循环。  
  5.         if (tp->urg_data && tp->urg_seq == *seq) {  
  6.             if (copied)  
  7.                 break;  
  8.             if (signal_pending(current)) {  
  9.                 copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;  
  10.                 break;  
  11.             }  
  12.         }  
  13.   
  14.   
  15. ///开始处理buf，首先是从receive队列中读取buf。  
  16.         skb_queue_walk(&sk->sk_receive_queue, skb) {  
  17. ///开始遍历receive_queue.  
  18.             if (before(*seq, TCP_SKB_CB(skb)->seq)) {  
  19.                 printk(KERN_INFO "recvmsg bug: copied %X "  
  20.                        "seq %X\n", *seq, TCP_SKB_CB(skb)->seq);  
  21.                 break;  
  22.             }  
  23. ///由于tcp是字节流，因此我们拷贝给用户空间，需要正序的拷贝给用户，这里的第一个seq前面已经描述了，表示当前的总的sock连接中的未读数据的起始序列号，而后一个seq表示当前skb的起始序列号。因此这个差值如果小于skb->len,就表示，当前的skb就是我们需要读取的那个skb(因为它的序列号最小).  
  24.             offset = *seq - TCP_SKB_CB(skb)->seq;  
  25. ///跳过syn。  
  26.             if (tcp_hdr(skb)->syn)  
  27.                 offset--;  
  28. ///找到skb。  
  29.             if (offset < skb->len)  
  30.                 goto found_ok_skb;  
  31.             if (tcp_hdr(skb)->fin)  
  32.                 goto found_fin_ok;  
  33.             WARN_ON(!(flags & MSG_PEEK));  
  34.         }  
  35. ....................................  
  36. }while(len > 0)  



接下来是对tcp状态做一些校验。这里要注意，copied表示的是已经复制到用户空间的skb的大小。而len表示还需要拷贝多少数据。 

Java代码   收藏代码
  1. ///如果复制的值大于等于所需要复制的，并且sk_backlog为空,则跳出循环。这是因为我们每次复制完毕之后，都需要将sk_backlog中的数据复制到receive队列中。  
  2. if (copied >= target && !sk->sk_backlog.tail)  
  3.             break;  
  4.   
  5.         if (copied) {  
  6.             if (sk->sk_err ||  
  7.                 sk->sk_state == TCP_CLOSE ||  
  8.                 (sk->sk_shutdown & RCV_SHUTDOWN) ||  
  9.                 !timeo ||  
  10.                 signal_pending(current))  
  11.                 break;  
  12.         } else {  
  13.   
  14. ///如没有复制到数据(也就是receive为空),则判断是否有错误发生。这里主要是状态的判断和超时的判断。  
  15.             if (sock_flag(sk, SOCK_DONE))  
  16.                 break;  
  17.   
  18.             if (sk->sk_err) {  
  19.                 copied = sock_error(sk);  
  20.                 break;  
  21.             }  
  22.   
  23.             if (sk->sk_shutdown & RCV_SHUTDOWN)  
  24.                 break;  
  25.   
  26.             if (sk->sk_state == TCP_CLOSE) {  
  27.                 if (!sock_flag(sk, SOCK_DONE)) {  
  28.                     copied = -ENOTCONN;  
  29.                     break;  
  30.                 }  
  31.                 break;  
  32.             }  
  33.   
  34.             if (!timeo) {  
  35.                 copied = -EAGAIN;  
  36.                 break;  
  37.             }  
  38.   
  39.             if (signal_pending(current)) {  
  40.                 copied = sock_intr_errno(timeo);  
  41.                 break;  
  42.             }  
  43.         }  



然后就是根据已经复制的数据大小来清理receive队列中的数据，并且发送ACK给对端。然后就是给tcp_socket的ucopy域赋值，主要是iov域和task域。一个是数据区，一个是当前从属的进程。 
Java代码   收藏代码
  1. tcp_cleanup_rbuf(sk, copied);  
  2.   
  3.         if (!sysctl_tcp_low_latency && tp->ucopy.task == user_recv) {  
  4.   
  5. ///循环的第一次的话user_recv为空，因此给ucopy得想关域赋值。  
  6.             if (!user_recv && !(flags & (MSG_TRUNC | MSG_PEEK))) {  
  7. //进程为当前进程。  
  8.                 user_recv = current;  
  9.                 tp->ucopy.task = user_recv;  
  10.                 tp->ucopy.iov = msg->msg_iov;  
  11.             }  
  12. ///长度为还需拷贝的数据的长度。  
  13.             tp->ucopy.len = len;  
  14.   
  15.             WARN_ON(tp->copied_seq != tp->rcv_nxt &&  
  16.                 !(flags & (MSG_PEEK | MSG_TRUNC)));  
  17. ///如果prequeue不为空则跳到 do_prequeue，处理backlog队列。  
  18.             if (!skb_queue_empty(&tp->ucopy.prequeue))  
  19.                 goto do_prequeue;  
  20.   
  21.             /* __ Set realtime policy in scheduler __ */  
  22.         }  
  23. ///已经复制完毕，则开始拷贝back_log队列到receive队列。  
  24.         if (copied >= target) {  
  25.             /* Do not sleep, just process backlog. */  
  26.             release_sock(sk);  
  27.             lock_sock(sk);  
  28.         } else  
  29. ///否则进入休眠，等待数据的到来。  
  30.             sk_wait_data(sk, &timeo);  



上面的分析中有release_sock函数，这个函数用来release这个sock，也就是对这个sock解除锁定。然后唤醒等待队列。 

这里要注意，sock一共有两个等待队列，一个是sock的sk_sleep等待队列，这个等待队列用来等待数据的到来。一个是ucopy域的等待队列wq，这个表示等待使用这个sock。 

Java代码   收藏代码
  1. void release_sock(struct sock *sk)  
  2. {  
  3.   
  4.     mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);  
  5.   
  6.     spin_lock_bh(&sk->sk_lock.slock);  
  7. ///如果backlog队列不为空，则调用__release_sock处理  
  8.     if (sk->sk_backlog.tail)  
  9.         __release_sock(sk);  
  10. ///处理完毕则给owened赋值为0.释放对这个sock的控制。  
  11.     sk->sk_lock.owned = 0;  
  12. ///唤醒wq上的所有元素。  
  13.     if (waitqueue_active(&sk->sk_lock.wq))  
  14.         wake_up(&sk->sk_lock.wq);  
  15.     spin_unlock_bh(&sk->sk_lock.slock);  
  16. }  


然后来看主要的处理函数__release_sock,它主要是遍历backlog队列，然后处理skb。这里它有两个循环，外部循环是遍历backlog，而内部循环是遍历skb(也就是数据)。 


Java代码   收藏代码
  1. static void __release_sock(struct sock *sk)  
  2. {  
  3.     struct sk_buff *skb = sk->sk_backlog.head;  
  4.   
  5. ///遍历backlog队列。  
  6.     do {  
  7.         sk->sk_backlog.head = sk->sk_backlog.tail = NULL;  
  8.         bh_unlock_sock(sk);  
  9.   
  10.         do {  
  11.             struct sk_buff *next = skb->next;  
  12.   
  13.             skb->next = NULL;  
  14.   
  15. ///这个函数我们知道最终会调tcp_v4_do_rcv.而在tcp_v4_do_rcv中，会把数据复制到receive_queue队列中。  
  16.             sk_backlog_rcv(sk, skb);  
  17.             cond_resched_softirq();  
  18.   
  19.             skb = next;  
  20.         } while (skb != NULL);  
  21.   
  22.         bh_lock_sock(sk);  
  23.     } while ((skb = sk->sk_backlog.head) != NULL);  
  24. }  



而当数据tp->ucopy.prequeue为空，并且所复制的数据不能达到所期望的值，此时我们进入sk_wait_data等待数据的到来。 


Java代码   收藏代码
  1. #define sk_wait_event(__sk, __timeo, condition)         \  
  2.     ({int  __rc;                        \  
  3. ///这个我们通过上面知道，会将数据复制到receive-queue队列。  
  4.     release_sock(__sk);                 \  
  5.     __rc = condition;     
  6. ///当sk_wait_data调用时，rc是用来判断receive_queue是否为空的，          \  
  7.     if (!__rc) {      
  8. ///如果为空则会休眠等待，sk_sleep等待队列的唤醒。                  \  
  9.         *(__timeo) = schedule_timeout(*(__timeo));  \  
  10.         }                           \  
  11.         lock_sock(__sk);                    \  
  12. __rc = condition;               \  
  13.         __rc;                           \  
  14.     })  
  15.   
  16.   
  17.   
  18. int sk_wait_data(struct sock *sk, long *timeo)  
  19. {  
  20.     int rc;  
  21.     DEFINE_WAIT(wait);  
  22. ///加入sk_sleep的等待队列  
  23.     prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);  
  24.     set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);  
  25. ///处理事件  
  26.     rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));  
  27.     clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);  
  28.     finish_wait(sk->sk_sleep, &wait);  
  29.     return rc;  
  30. }  


接下来就是一些域的更新，以及处理prequeue队列： 


Java代码   收藏代码
  1.           
  2.   
  3. if (user_recv) {  
  4.             int chunk;  
  5.   
  6.             /* __ Restore normal policy in scheduler __ */  
  7. ///这个判断主要是由于在release_sock中，有可能会将数据直接复制到用户空间了。此时我们需要更新len以及copied域。  
  8.             if ((chunk = len - tp->ucopy.len) != 0) {  
  9.                 NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMBACKLOG, chunk);  
  10.                 len -= chunk;  
  11.                 copied += chunk;  
  12.             }  
  13. ///tp->rcv_nxt == tp->copied_seq主要用来判断是否receive队列中还需要数据要执行吗(下面会说明为什么)。  
  14.             if (tp->rcv_nxt == tp->copied_seq &&  
  15.                 !skb_queue_empty(&tp->ucopy.prequeue)) {  
  16. do_prequeue:  
  17. ///执行prequeue  
  18.                 tcp_prequeue_process(sk);  
  19.   
  20. ///和上面一样，更新len和cpoied域。  
  21.                 if ((chunk = len - tp->ucopy.len) != 0) {  
  22.                     NET_ADD_STATS_USER(sock_net(sk), LINUX_MIB_TCPDIRECTCOPYFROMPREQUEUE, chunk);  
  23.                     len -= chunk;  
  24.                     copied += chunk;  
  25.                 }  
  26.             }  
  27.         }  
  28. ...................................  
  29.         continue;  


在分析tcp_prequeue_process之前，我们先来看下什么情况下release_sock会直接复制数据到用户空间。我们知道它最终会调用tcp_rcv_established函数，因此来看tcp_rcv_established的代码片断 
内核接收到的数据包有可能不是正序的，可是内核传递给用户空间的数据必须是正序的，只有这样才能拷贝给用户空间。 



Java代码   收藏代码
  1. else {  
  2.             int eaten = 0;  
  3.             int copied_early = 0;  
  4. ///判断从这里开始。copied_seq表示未读的skb的序列号。而rcv_nxt为我们所期望接收的下一个数据的序列号。这里我们是要保证字节流的正序。而第二个条件len - tcp_header_len <= tp->ucopy.len这个说明用户请求的数据还没有复制够。如果已经复制够了，则会复制数据到receive_queue队列。  
  5.         if (tp->copied_seq == tp->rcv_nxt &&  
  6.                len - tcp_header_len <= tp->ucopy.len) {  
  7. .........................  
  8.   
  9. ///然后判断从属的进程必须等于当前调用进程。并且必须为进程上下文。  
  10.     if (tp->ucopy.task == current &&  
  11.         sock_owned_by_user(sk) && !copied_early) {  
  12.                     __set_current_state(TASK_RUNNING);  
  13. ///开始复制数据到用户空间。  
  14.         if (!tcp_copy_to_iovec(sk, skb, tcp_header_len))  
  15.                         eaten = 1;  
  16.                 }  
  17.       
  18. ...............................  


通过上面的判断条件我们很容易看出前面调用release_sock,为何有时将数据拷贝到用户空间，有时拷贝到receive队列。 


ok，最后我们来看下tcp_prequeue_process的实现。它的实现很简单，就是遍历prequeue,然后处理buf。这里要注意，它会处理完所有的prequeue，也就是会清空prequeue. 

Java代码   收藏代码
  1. static void tcp_prequeue_process(struct sock *sk)  
  2. {  
  3.     struct sk_buff *skb;  
  4.     struct tcp_sock *tp = tcp_sk(sk);  
  5.   
  6.     NET_INC_STATS_USER(sock_net(sk), LINUX_MIB_TCPPREQUEUED);  
  7.   
  8.     /* RX process wants to run with disabled BHs, though it is not 
  9.      * necessary */  
  10.     local_bh_disable();  
  11. ///遍历并处理skb。  
  12.     while ((skb = __skb_dequeue(&tp->ucopy.prequeue)) != NULL)  
  13. ///最终会调用tcp_rcv_established.  
  14.         sk_backlog_rcv(sk, skb);  
  15.     local_bh_enable();  
  16. ///内存清空为0.  
  17.     tp->ucopy.memory = 0;  
  18. }  


最后简要的分析下数据如何复制到用户空间。这里的主要函数是skb_copy_datagram_iovec。最终都是通过这个函数复制到用户空间的。 


我们知道内核存储数据有两种形式如果支持S/G IO的网卡，它会保存数据到skb_shinfo(skb)->frags(详见前面的blog),否则则会保存在skb的data区中。 

因此这里也是分为两部分处理。 

还有一个就是这里遍历frags也是遍历两次，第一次遍历是查找刚好 

Java代码   收藏代码
  1. int skb_copy_datagram_iovec(const struct sk_buff *skb, int offset,  
  2.                 struct iovec *to, int len)  
  3. {  
  4.     int start = skb_headlen(skb);  
  5.     int i, copy = start - offset;  
  6.     struct sk_buff *frag_iter;  
  7. ///支持S/G IO的网卡，第一个数据包也是保存在data域中的。  
  8.     if (copy > 0) {  
  9.         if (copy > len)  
  10.             copy = len;  
  11. ///复制data域。  
  12.         if (memcpy_toiovec(to, skb->data + offset, copy))  
  13.             goto fault;  
  14.         if ((len -= copy) == 0)  
  15.             return 0;  
  16.         offset += copy;  
  17.     }  
  18.   
  19. ///遍历frags，开始复制数据。  
  20.     for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {  
  21.         int end;  
  22.   
  23.         WARN_ON(start > offset + len);  
  24. ///计算复制的字节数  
  25.         end = start + skb_shinfo(skb)->frags[i].size;  
  26. ///判断将要复制的字节数是否足够  
  27.         if ((copy = end - offset) > 0) {  
  28.             int err;  
  29.             u8  *vaddr;  
  30.             skb_frag_t *frag = &skb_shinfo(skb)->frags[i];  
  31.             struct page *page = frag->page;  
  32. ///如果将要复制的数据太大，则缩小它为请求的长度。  
  33.             if (copy > len)  
  34.                 copy = len;  
  35. ///转换物理地址到虚拟地址。  
  36.             vaddr = kmap(page);  
  37. ///复制数据。  
  38.             err = memcpy_toiovec(to, vaddr + frag->page_offset +  
  39.                          offset - start, copy);  
  40.             kunmap(page);  
  41.             if (err)  
  42.                 goto fault;  
  43. ///如果复制完毕则返回0  
  44.             if (!(len -= copy))  
  45.                 return 0;  
  46. ///更新offset域。  
  47.             offset += copy;  
  48.         }  
  49. //更新start域。  
  50.         start = end;  
  51.     }  
  52.   
  53. ///到达这里说明数据还没有宝贝完毕，也就是请求的数据还没拷贝完成。此时我们就需要变化offset域。  
  54.     skb_walk_frags(skb, frag_iter) {  
  55.         int end;  
  56.   
  57.         WARN_ON(start > offset + len);  
  58.   
  59.         end = start + frag_iter->len;  
  60.         if ((copy = end - offset) > 0) {  
  61.             if (copy > len)  
  62.                 copy = len;  
  63. ///改变offset域为offset-start递归重新开始。  
  64.             if (skb_copy_datagram_iovec(frag_iter,  
  65.                             offset - start,  
  66.                             to, copy))  
  67.                 goto fault;  
  68.             if ((len -= copy) == 0)  
  69.                 return 0;  
  70.             offset += copy;  
  71.         }  
  72.         start = end;  
  73.     }  
  74.     if (!len)  
  75.         return 0;  
  76.   
  77. fault:  
  78.     return -EFAULT;  
  79. }  
我恨天
关注
linux内核中TCP接收的实现
网络安全研究
04-24 1233
linux内核中TCP接收的实现入口函数是tcp_v4_rcv 1. 数据包检查处理 一开始做一些数据包详细检查处理，一旦出错，可能导致内核挂掉 int tcp_v4_rcv(struct sk_buff *skb) { const struct iphdr *iph; struct tcphdr *th; struct sock *sk; int ret; struct net *ne...
Linux Socket编程
努力学习游泳的鱼的博客
09-26 835
Socket是网络编程中的一个概念，用于标识网络通讯中的一个进程。在网络通讯中，“IP地址 + TCP或UDP端口号” 可以唯一标识一个进程，这个标识被称为Socket。Linux下的Socket编程涉及多个系统调用，通过这些调用可以实现网络通信。无论是TCP还是UDP协议，Socket编程的基本流程相似，主要包括创建Socket、绑定地址、监听连接、接受连接、发送和接收数据等步骤。通过实例代码，可以更好地理解和掌握这些操作。
深入理解Linux内核网络（一）：内核接收数据包的过程
最新发布
一枚菜鸡
10-04 1126
在应用层执行read调用后就能很方便地接收到来自网络的另一端发送过来的数据，其实在这一行代码下隐藏着非常多的内核组件细节工作。在本节中，将详细讲解数据包如何从内核到应用层，以intel igb网卡为例。部分内容来源于 《深入理解Linux网络》、《Linux内核源码分析TCP实现》
Linux内核 - tcp发送数据从应用到驱动经历的函数调用
bcbobo21cn的专栏
04-04 199
这张是Linux操作系统，tcp发送数据，从应用到驱动，发送一个数据块所调用的函数序列； 同一颜色是调用其中某一个，还是从上到下逐个调用，还不了解； 记得以前看一本Windows驱动开发的书说，Win平台下通过网络发送一个数据，从应用程序开始发出，一直到网卡上把这个数据发出，这其中要经历20多个函数调用数据才到达网卡； 看上去Linux也差不多； ...
Linux测试TCP延迟,最新版Linux中的TCP延迟较高
weixin_42502736的博客
05-13 413
在我的研究小组中,我们最近将我们机器上的操作系统从Red Hat 6.2升级到Debian 8.3,并观察到我们机器之间通过集成Intel 1G NIC的TCP往返时间从大约110μs增加到220μs.起初,我认为这是一个配置问题,所以我将所有sysctl配置(例如tcp_low_latency = 1)从未升级的Red Hat机器复制到Debian机器,并且没有解决问题.接下来,我认为这可能是L...
Linux 4.4.0 内核源码分析 TCP实现
04-15
Linux内核的TCP实现涉及了大量底层数据结构和功能函数。在TCP层数据结构中，比如tcphdr定义了TCP头部的结构，tcp_options_received用于处理接收到的TCP选项，tcp_sock用于存储TCP连接的状态信息。这些结构和函数的...
Linux内核源码剖析：TCP IP实现(上册).pdf
08-19
根据提供的文件标题、描述、标签以及部分内容，我们可以推断出这份文档主要关注的是Linux内核中的TCP/IP协议栈实现分析。接下来将详细阐述这一主题下的关键知识点。 ### 一、Linux内核源码剖析概述 #### 1. Linux...
Linux内核TCP-IP协议栈分析.rar
01-29
在本资料"Linux内核TCP/IP协议栈分析"中，我们将深入探讨这个核心组件的工作原理。 TCP/IP协议栈分为四个主要层次：应用层、传输层、网络层和数据链路层。在Linux内核中，每一层都有相应的模块负责处理相关的协议和...
Linux 4.4.0内核源码分析TCP实现
06-30
为了更好地理解TCP协议是如何被集成到Linux内核中的，我们需要探索`tcp_prot`结构体以及相关的函数调用流程。`tcp_prot`是表示TCP协议的结构体，在内核中它主要负责处理与TCP协议相关的操作，如连接建立、数据传输、...
linux 内核socket相关数据结构介绍
02-21
### Linux 内核 Socket 相关数据结构介绍 ...通过对以上数据结构的学习和理解，开发者能够更准确地把握 Socket 在 Linux 内核中的实现细节，这对于进一步探索 Linux 内核网络子系统的其他方面也具有重要的指导意义。
深入理解TCP协议及其源代码——send和recv背后数据的收发过程
木牛的博客
03-11 1003
函数向被服务端监听的socket发起一个连接请求，即发起一次TCP连接的三次握手。函数的缓冲区分别是buff和ubuf指向的内存空间，我们从源码中看一看这两个缓冲区中的数据是如何被处理的。只管拷贝，真正的发送和接收是由TCP连接负责的。为了实现数据的收发，每个TCP socket在内核中都维护了一个发送缓冲区和一个接收缓冲区，函数把应用缓冲区中的数据拷贝到TCP发送缓冲区中，接下来的发送过程由TCP负责；函数创建一个socket对象，生成一个socket文件描述符，然后通过。可以看到，这两个函数相当复杂。
linux socket中的recv、recvfrom、read、recvmsg、readv比较
数字人生
06-27 2365
函数原型：`ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);- 特点：`recvfrom`和`recv`的主要区别在于`recvfrom`可以接收发送方的地址信息，因此非常适合用于无连接的UDP通信。- 特点：相对于`recv`和`recvfrom`，`read`没有`flags`参数，只进行普通的数据读取操作。
Linux相关TCP参数优化: proc/sys/net/ipv4/ 提高web质量
weixin_30830327的博客
07-27 190
tcp_wmem(3个INTEGER变量)： min, default, max min：为TCP socket预留用于发送缓冲的内存最小值。每个tcp socket都可以在建议以后都可以使用它。默认值为4096(4K)。 default：为TCP socket预留用于发送缓冲的内存数量，默认情况下该值会影响其它协议使用的net.core.wmem_default 值，一般要低于net.cor...
Linux操作系统内核参数调优-2
weixin_41312759的博客
03-10 1862
综上所述，Linux内核参数调优是系统管理员和运维人员必须掌握的技能之一，它不仅能够提升系统的性能，还能够提高系统的稳定性和安全性，是确保Linux系统高效运行的关键步骤。在进行调优时，应该根据具体的应用场景和需求来选择合适的参数进行优化，并且需要在调优后进行充分的测试，以确保调优效果达到预期目标。此外，调优过程中应该谨慎操作，避免过度调优导致系统不稳定。在调优之前，建议先进行基线测试，了解系统在默认配置下的性能表现，然后再根据测试结果逐步调整参数，并持续监控系统的表现，以确保调优措施能够带来预期的效果。
嵌入式Linux网络编程 之 简单的TCP网络编程
kindlyde
08-24 3820
关于TCP：TCP提供的是一种面向连接的、可靠的字节流服务。                                                                        TCP网络通信流程图 补充的API 函数名称：listen() 原型：int listen(int sockfd, int backlog) 功能 : 宣告服务器
TCP实现之：TCP报文接收
qq_17045267的博客
06-17 1480
TCP实现之：TCP报文接收 本章节讲述了内核TCP协议层快速收报的流程，包括从IP层将报文传递给TCP层，一直到用户调用系统调用收到报文数据的过程。之所以说是快速收报过程，是因为本文暂不分析异常网络情况下的报文，例如紧急报文、失序报文等的处理过程。 一、SOCK锁机制 sock中的sk_lock字段是用来对sock加锁的，该字段的类型为socket_lock_t。在对sock中的报文接收队列进行处理（包括报文的读取和添加）时，需要先获取该套接字上的锁，其中socket_lock_t的定义如下： typed
linux内核网络收包过程—TCP协议处理
05-23 2791
目录 socket创建过程 tcp_recvmsg 软中断模块 tcp_v4_rcv sock_def_readable __wake_up_common 总结 socket创建过程 SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol) { return __sys_socket(family, type, protocol); } 系统调用__sys_socket->sock_create->_
深入理解TCP三次握手
小鱼学编程
03-30 2357
我们都知道传输层总TCP是面向连接的，可提供可靠的连接服务，而提到TCP就一定会提到TCP三次握手，今天小鱼就和大家一起学习TCP三次握手，深度剖析了TCP三次握手的种种细节，一文搞定三次握手。
Linux内核TCP/IP协议栈详解与实现
《Linux内核TCP/IP协议栈分析》是一本技术密集型的指南，适合对Linux内核和网络协议感兴趣的开发者、系统管理员或深入学习者阅读，通过这本书，读者可以掌握Linux内核中网络通信的底层实现，从而更好地理解和优化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值