Linux内核分析 - 网络[十二]：UDP模块 - 收发

最新推荐文章于 2024-04-28 09:12:01 发布

yo-yo

最新推荐文章于 2024-04-28 09:12:01 发布

阅读量1.8w

点赞数 5

分类专栏：内核协议栈 Linux内核协议栈文章标签： linux内核网络 socket struct dst

本文链接：https://blog.csdn.net/qy532846454/article/details/6993695

版权

内核协议栈同时被 2 个专栏收录

23 篇文章 29 订阅

订阅专栏

Linux内核协议栈

23 篇文章 121 订阅

订阅专栏

内核版本：2.6.34

UDP报文接收
UDP报文的接收可以分为两个部分：协议栈收到udp报文，插入相应队列中；用户调用recvfrom()或recv()系统调用从队列中取出报文，这里的队列就是sk->sk_receive_queue，它是报文中转的纽带，两部分的联系如下图所示。

第一部分：协议栈如何收取udp报文的。
udp模块的注册在inet_init()中，当收到的是udp报文，会调用udp_protocol中的handler函数udp_rcv()。

if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
 printk(KERN_CRIT "inet_init: Cannot add UDP protocol\n");

udp_rcv() -> __udp4_lib_rcv() 完成udp报文接收，初始化udp的校验和，并不验证校验和的正确性。

if (udp4_csum_init(skb, uh, proto))
 goto csum_error;

在udptable中以套接字的[saddr, sport, daddr, dport]查找相应的sk，在上一篇中已详细讲过”sk的查找”，这里报文的source源端口相当于源主机的端口，dest目的端口相当于本地端口。

sk = __udp4_lib_lookup_skb(skb, uh->source, uh->dest, udptable);

如果udptable中存在相应的sk，即有socket在接收，则通过udp_queue_rcv_skb()将报文skb入队列，该函数稍后分析，总之，报文会被放到sk->sk_receive_queue队列上，然后sock_put()减少sk的引用计算，并返回。之后的接收工作的完成将有赖于用户的操作。

if (sk != NULL) {
 int ret = udp_queue_rcv_skb(sk, skb);
 sock_put(sk);
if (ret > 0)
  return -ret;
 return 0;
}

当没有在udptable中找到sk时，则本机没有socket会接收它，因此要发送icmp不可达报文，在此之前，还要验证校验和udp_lib_checksum_complete()，如果校验和错误，则直接丢弃报文；如果校验和正确，则会增加mib中的统计，并发送icmp端口不可达报文，然后丢弃该报文。

if (udp_lib_checksum_complete(skb))
 goto csum_error;
UDP_INC_STATS_BH(net, UDP_MIB_NOPORTS, proto == IPPROTO_UDPLITE);
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
kfree_skb(skb);

udp_queue_rcv_skb() 报文入队列
sock_woned_by_user()判断sk->sk_lock.owned的值，如果等于1，表示sk处于占用状态，此时不能向sk接收队列中添加skb，执行else if部分，sk_add_backlog()将skb添加到sk->sk_backlog队列上；如果等于0，表示sk没被占用，执行if部分，__udp_queue_rcv_skb()将skb添加到sk->sk_receive_queue队列上。

bh_lock_sock(sk);
if (!sock_owned_by_user(sk))
 rc = __udp_queue_rcv_skb(sk, skb);
else if (sk_add_backlog(sk, skb)) {
 bh_unlock_sock(sk);
 goto drop;
}
bh_unlock_sock(sk);

      那么何时sk会被占用？何时sk->sk_backlog上的skb被处理的？
      创建socket时，sys_socket() -> inet_create() -> sk_alloc() -> sock_lock_init() -> sock_lock_init_class_and_name()初始化sk->sk_lock_owned=0。
      比如当销毁socket时，udp_destroy_sock()会调用lock_sock()对sk加锁，操作完后，调用release_sock()对sk解锁。

void udp_destroy_sock(struct sock *sk)
{
 lock_sock(sk);
 udp_flush_pending_frames(sk);
 release_sock(sk);
}

实际上，lock_sock()设置sk->sk_lock.owned=1；而release_sock()设置sk->sk_lock.owned=0，并处理sk_backlog队列上的报文，release_sock() -> __release_sock()，对于sk_backlog队列上的每个报文，调用sk_backlog_rcv() -> sk->sk_backlog_rcv()。同样是在socket的创建中，sk->sk_backlog_rcv = sk->sk_prot->backlog_rcv()即__udp_queue_rcv_skb()，这个函数的作用上面已经讲过，将skb添加到sk_receive_queue，这样，所有的sk_backlog上的报文转移到了sk_receive_queue上。简单来说，sk_backlog队列的作用就是，锁定时报文临时存放在此，解锁时，报文移到sk_receive_queue队列。

第二部分：用户如何收取报文
      用户可以调用sys_recvfrom()或sys_recv()来接收报文，所不同的是，sys_recvfrom()可能通过参数获得报文的来源地址，而sys_recv()则不可以，但对接收报文并没有影响。在用户调用recvfrom()或recv()接收报文前，发给该socket的报文都会被添加到sk->sk_receive_queue上，recvfrom()和recv()要做的就是从sk_receive_queue上取出报文，拷贝到用户空间，供用户使用。
      sys_recv() -> sys_recvfrom()
      sys_recvfrom() -> sk->ops->recvmsg()
                            ==> sock_common_recvmsg() -> sk->sk_prot->recvmsg()
                            ==> udp_recvmsg()

sys_recvfrom()
调用sock_recvmsg()接收udp报文，存放在msg中，如果接收到报文，从内核到用户空间拷贝报文的源地址到addr中，addr是recvfrom()调用的传入参数，表示报文源的地址。而报文的内容是在udp_recvmsg()中从内核拷贝到用户空间的。

err = sock_recvmsg(sock, &msg, size, flags);
if (err >= 0 && addr != NULL) {
 err2 = move_addr_to_user((struct sockaddr *)&address,
    msg.msg_namelen, addr, addr_len);
 if (err2 < 0)
  err = err2;
}

udp_recvmsg() 接收udp报文
      这个函数有三个关键操作：
        1. 取到数据包 -- __skb_recv_datagram()
        2. 拷贝数据 -- skb_copy_datagram_iovec()或skb_copy_and csum_datagram_iovec()
        3. 必要时计算校验和 – skb_copy_and_csum_datagram_iovec()

__skb_recv_datagram()，它会从sk->sk_receive_queue上取出一个skb，前面已经分析到，内核收到发往该socket的报文会放在sk->sk_receive_queue。

skb = __skb_recv_datagram(sk, flags | (noblock ? MSG_DONTWAIT : 0), &peeked, &err);

如果没有报文，有两种情况：使用了非阻塞接收，且用户接收时还没有报文到来；使用阻塞接收，但之前没有报文，且在sk->sk_rcvtimeo时间内都没有报文到来。没有报文，返回错误值。

if (!skb)
 goto out;

len是recvfrom()传入buf的大小，ulen是报文内容的长度，如果ulen > len，那么只需要使用buf的ulen长度就可以了；如果len < ulen，那么buf不够报文填充，只能对报文截断，取前len个字节。

ulen = skb->len - sizeof(struct udphdr);
if (len > ulen)
 len = ulen;
else if (len < ulen)
 msg->msg_flags |= MSG_TRUNC;

如果报文被截断或使用UDP-Lite，那么需要提前验证校验和，udp_lib_checksum_complete()完成校验和计算，函数在下面具体分析。

if (len < ulen || UDP_SKB_CB(skb)->partial_cov) {
 if (udp_lib_checksum_complete(skb))
  goto csum_copy_err;
}

如果报文不用验证校验和，那么执行if部分，调用skb_copy_datagram_iovec()直接拷贝报文到buf中就可以了；如果报文需要验证校验和，那么执行else部分，调用skb_copy_and_csum_datagram_iovec()拷贝报文到buf，并在拷贝过程中计算校验和。这也是为什么在内核收到udp报文时为什么先验证校验和再处理的原因，udp报文可能很大，校验和的计算可能很耗时，将其放在拷贝过程中可以节约开销，当然它的代价是一些校验和错误的报文也会被添加到socket的接收队列上，直到用户真正接收时它们才会被丢弃。

if (skb_csum_unnecessary(skb))
 err = skb_copy_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov, len);
else {
 err = skb_copy_and_csum_datagram_iovec(skb, sizeof(struct udphdr), msg->msg_iov);
 if (err == -EINVAL)
  goto csum_copy_err;
}

拷贝地址到msg->msg_name中，在sys_recvfrom()中msg->msg_name=&address，然后address会从内核拷贝给用户空间的addr。

if (sin) {
 sin->sin_family = AF_INET;
 sin->sin_port = udp_hdr(skb)->source;
 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
 memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
}

      下面来重点看核心操作的三个函数：
__skb_recv_datagram()   从sk_receive_queue上取一个skb
      核心代码段如下，skb_peek()从sk->sk_receive_queue中取出一个skb，如果有的话，则返回skb，作为用户此次接收的报文，当然还有对skb的后续处理，但该函数只是取出一个skb；如果还没有的话，则使用wait_for_packet()等待报文到来，其中参数timeo代表等待的时间，如果使用非阻塞接收的话，timeo会设置为0(即当前没有skb的话则直接返回，不进行等待)，否则设置为sk->sk_rcvtimeo。

do {
 ……
 skb = skb_peek(&sk->sk_receive_queue);
 if (skb) {
  *peeked = skb->peeked;
  if (flags & MSG_PEEK) {
   skb->peeked = 1;
   atomic_inc(&skb->users);
  } else
   __skb_unlink(skb, &sk->sk_receive_queue);
 }
 if (skb)
  return skb;
……
} while (!wait_for_packet(sk, err, &timeo));

skb_copy_datagram_iovec()   拷贝skb内容到msg中
      拷贝可以分三部分：线性地址空间的拷贝，聚合/发散地址空间的拷贝，非线性地址空间的拷贝。第二部分需要硬件的支持，这里讨论另两部分。
      在skb的buff中的是线性地址空间，在skb的frag_list上的是非线性地址空间；当没有分片发生的，用线性地址空间就足够了，但是当报文过长而分片时，第一个分片会使用线性地址空间，其余的分片将被链到skb的frag_list上，即非线性地址空间，具体可以参考”ipv4模块”中分片部分。
      拷贝报文内容时，就要将线性和非线性空间的内容都拷贝过去。下面是拷贝线性地址空间的代码段，start是报文的线性部分长度(skb->len-skb->datalen)，copy是线性地址空间的大小，offset是相对skb的偏移(即此次拷贝从哪里开始)，以udp报文为例，这几个值如下图所示。memcpy_toiovec()拷贝内核到to中，要注意的是它改变了to的成员变量。

int start = skb_headlen(skb);
int i, copy = start - offset;
if (copy > 0) {
 if (copy > len)
  copy = len;
 if (memcpy_toiovec(to, skb->data + offset, copy))
  goto fault;
 if ((len -= copy) == 0)
  return 0;
 offset += copy;
}

下面是拷贝非线性地址空间的代码段，遍历skb的frag_list链表，对上面的每个分片，拷贝内容到to中，这里start, end的值不重要，重要的是它们的差值end-start，表示了当前分片frag_iter的长度，使用skb_copy_datagram_iovec()拷贝当前分片内容，即把每个分片都作为单独报文来处理。不过对于分片，感觉只有拷贝的第一部分和第二部分，在IP层分片重组时，并没有将分片链在分片的frag_list上的情况，而都链在头分片的frag_list上。

skb_walk_frags(skb, frag_iter) {
 int end;
 end = start + frag_iter->len;
 if ((copy = end - offset) > 0) {
  if (copy > len)
   copy = len;
  if (skb_copy_datagram_iovec(frag_iter,
    offset - start, to, copy))
   goto fault;
  if ((len -= copy) == 0)
   return 0;
  offset += copy;
 }
 start = end;
}

还是以一个例子来说明，主机收到一个udp报文，内容长度为4000 bytes，MTU是1500，传入buff数组大小也为4000。根据MTU，报文会会被分成三片，分片IP报内容大小依次是1480, 1480, 1040。每个分片都有一个20节字的IP报文，第一个分片还有一个8节字的udp报头。接收时数据拷贝情况如下：

分片一是第一个分片，包含UDP报文，在拷贝时要跳过，因为使用的是udp socket接收，只要报文内容就可以了。三张图片代表了三次调用skb_copy_datagram_iovec()的情况，iov是存储内容的buff，最终结果是三个分片共4000字节拷贝到了iov中。
memcpy_toiovec()函数需要注意，不仅因为它改变了iovec的成员值，还因为最后的iov++。在udp socket的接收recvfrom()中，msg.msg_iov = &iov，而iov定义成struct iovec iov，即传入参数iov实际只有一个的空间，那么在iov++后，iov将指向非法的地址。这里只考虑udp使用时的情况，memcpy_toiovec()调用的前一句是，这里len是接收buff的长度：

if (copy > len)
 copy = len;

而memcpy_toiovec()中又有int copy = min_t(unsigned int, iov->iov_len, len)，这里len是上面传入的copy，iov_len是接收buff长度，这两句保证了函数中copy值与len相等，即完成一次拷贝后，len-=copy会使len==0，虽然iov++指向了非法内存，但由于while(len > 0)已退出，所以不会使用iov做任何事情。其次，函数中的iov++并不会对参数iov产生影响，即函数完成iov还是传入的值。最后，拷贝完后会修改iov_len和iov_base的值，iov_len表示可用长度，iov_base表示起始拷贝位置。

int memcpy_toiovec(struct iovec *iov, unsigned char *kdata, int len)
{
 while (len > 0) {
  if (iov->iov_len) {
   int copy = min_t(unsigned int, iov->iov_len, len);
   if (copy_to_user(iov->iov_base, kdata, copy))
    return -EFAULT;
   kdata += copy;
   len -= copy;
   iov->iov_len -= copy;
   iov->iov_base += copy;
  }
  iov++;
 }
 return 0;
}

skb_copy_and_csum_datagram_iovec() 拷贝skb内容到msg中，同时计算校验和
这个函数提高了校验和计算效率，因为它合并了拷贝与计算操作，这样只要一次遍历操作就可以了。与skb_copy_datagram_iovec()相比，它在每次拷贝skb内容时，计算下这次拷贝内容的校验和。

csum = csum_partial(skb->data, hlen, skb->csum);
if (skb_copy_and_csum_datagram(skb, hlen, iov->iov_base, chunk, &csum))
 goto fault;

UDP报文发送
      发送时有两种调用方式：sys_send()和sys_sendto()，两者的区别在于sys_sendto()需要给入目的地址的参数；而sys_send()调用前需要调用sys_connect()来绑定目的地址信息；两者的后续调用是相同的。如果调用sys_sendto()发送，地址信息在sys_sendto()中从用户空间拷贝到内核空间，而报文内容在udp_sendmsg()中从用户空间拷贝到内核空间。
      sys_send() -> sys_sendto()
      sys_sendto() -> sock_sendmsg() -> __sock_sendmsg() -> sock->ops->sendmsg()
                         ==> inet_sendmsg() -> sk->sk_prot->sendmsg()
                         ==> udp_sendmsg()
      udp_sendmsg()的核心流程如下图所示，只列出了核心的函数调用了参数赋值，大致步骤是：获取信息 -> 获取路由项rt -> 添加数据 -> 发送数据。

udp_sock结构体中的pending用于标识当前udp_sock上是否有待发送数据，如果有的话，则直接goto do_append_data继续添加数据；否则先要做些初始化工作，再才添加数据。实际上，pending!=0表示此调用前已经有数据在udp_sock中的，每次调和sendto()发送数据时，pending初始等于0；在添加数据时，设置up->pending = AF_INET。直到最后调用udp_push_pending_frames()将数据发送给IP层或skb_queue_empty(&sk->sk_write_queue)发送链表上为空，这时设置up->pending = 0。因此，这里可以看到，报文发送时pending值的变化：

通常使用sendto()发送都是一次调用对应一个报文，即pending=0->AF_INET->0；但如果调用sendto()时参数用到了MSG_MORE标志，则pending=0->AF_INET，直到调用sendto()时未使用MSG_MORE标志，表示此次发送数据是最后一部分数据时，pending=AF_INET->0。

if (up->pending) {
 lock_sock(sk);
 if (likely(up->pending)) {
  if (unlikely(up->pending != AF_INET)) {
   release_sock(sk);
   return -EINVAL;
  }
  goto do_append_data;
 }
 release_sock(sk);
}

如果pending=0没有待发送数据，执行初始化操作：报文长度、地址信息、路由项。
ulen初始为sendto()传入的数据长度，由于是第一部分数据(如果没有后续数据，则就是报文)，ulen要添加udp报头的8字节。

ulen += sizeof(struct udphdr);

这段代码获取要发送数据的目的地址和端口号。一种情况是调用sendto()发送数据，此时目的的信息以参数传入，存储在msg->msg_name中，因此从中取出daddr和dport；另一种情况是调用connect(), send()发送数据，在connect()调用时绑定了目的的信息，存储在inet中，并且由于是调用了connect()，sk->sk_state会设置为TCP_ESTABLISHED。以后调用send()发送数据时，无需要再给入目的信息参数，因此从inet中取出dadr和dport。而connected表示了该socket是否已绑定目的。

if (msg->msg_name) {
 struct sockaddr_in * usin = (struct sockaddr_in *)msg->msg_name;
 if (msg->msg_namelen < sizeof(*usin))
  return -EINVAL;
 if (usin->sin_family != AF_INET) {
  if (usin->sin_family != AF_UNSPEC)
   return -EAFNOSUPPORT;
 }

 daddr = usin->sin_addr.s_addr;
 dport = usin->sin_port;
 if (dport == 0)
  return -EINVAL;
} else {
 if (sk->sk_state != TCP_ESTABLISHED)
  return -EDESTADDRREQ;
 daddr = inet->inet_daddr;
 dport = inet->inet_dport;
 connected = 1;
}

下一步是获取路由项rt，如果已连接(调用过connect)，则路由信息在connect()时已获取，直接拿就可以了；如果未连接或拿到的路由项已被删除，则需要重新在路由表中查找，还是使用ip_route_output_flow()来查找，如果是连接状态的socket，则要用新找到的rt来更新socket，当然，前提条件是之前的rt已过期。

if (rt == NULL) {
 ……
 err = ip_route_output_flow(net, &rt, &fl, sk, 1);
 ……
 if (connected)
  sk_dst_set(sk, dst_clone(&rt->u.dst));
}

存储信息daddr, dport, saddr, sport到cork.fl中，它们会在生成udp报头和计算udp校验和时用到。up->pending=AF_INET标识了数据添加的开始，下面将开始数据的添加工作。

inet->cork.fl.fl4_dst = daddr;
inet->cork.fl.fl_ip_dport = dport;
inet->cork.fl.fl4_src = saddr;
inet->cork.fl.fl_ip_sport = inet->inet_sport;
up->pending = AF_INET;

如果pending!=0或执行完初始化操作，则直接执行添加数据操作：
up->len表示要发送数据的总长度，包括udp报头，因此每发送一部分数据就要累加它的长度，在发送后up->len被清0。然后调用ip_append_data()添加数据到sk->sk_write_queue，它会处理数据分片等问题，在 ”ICMP模块” 中有详细分析过。

up->len += ulen;
getfrag  =  is_udplite ?  udplite_getfrag : ip_generic_getfrag;
err = ip_append_data(sk, getfrag, msg->msg_iov, ulen,
  sizeof(struct udphdr), &ipc, &rt,
  corkreq ? msg->msg_flags|MSG_MORE : msg->msg_flags);

ip_append_data()添加数据正确会返回0，否则udp_flush_pending_frames()丢弃将添加的数据；如果添加数据正确，且没有后续的数据到来(由MSG_MORE来标识)，则udp_push_pending_frames()将数据发送给IP层，下面将详细分析这个函数。最后一种情况是当sk_write_queue上为空时，它触发的条件必须是发送多个报文且sk_write_queue上为空，而实际上在ip_append_data过后sk_write_queue不会为空的，因此正常情况下并不会发生。哪种情况会发生呢？重置pending值为0就是在这里完成的，三个条件语句都会将pending设置为0。

if (err)
 udp_flush_pending_frames(sk);
else if (!corkreq)
 err = udp_push_pending_frames(sk);
else if (unlikely(skb_queue_empty(&sk->sk_write_queue)))
 up->pending = 0;

数据已经处理完成，释放取到的路由项rt，如果有IP选项，也释放它。如果发送数据成功，返回发送的长度len；否则根据错误值err进行错误处理并返回err。

ip_rt_put(rt);
if (free)
 kfree(ipc.opt);
if (!err)
 return len;
if (err == -ENOBUFS || test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
 UDP_INC_STATS_USER(sock_net(sk), UDP_MIB_SNDBUFERRORS, is_udplite);
}
return err;

在 “ICMP模块” 中往IP层发送数据使用的是ip_push_pending_frames()。而在UDP模块中往IP层发送数据使用的是ip_push_pending_frames()。而在UDP模块中往IP层发送数据的udp_push_pending_frames()只是对ip_push_pending_frames()的封装，主要是增加对UDP的报头的处理。同理，udp_flush_pending_frames()也是，只是它更简单，仅仅重置了up->len和up->pending的值，重置后可以开始一个新报文。那么udp_push_pending_frames()封装了哪些处理呢。

udp_push_pending_frames() 发送数据给IP层
设置udp报头，包括源端口source，目的端口dest，报文长度len。

uh = udp_hdr(skb);
uh->source = fl->fl_ip_sport;
uh->dest = fl->fl_ip_dport;
uh->len = htons(up->len);
uh->check = 0;

计算udp报头中的校验和，包括了伪报头、udp报头和报文内容。

if (is_udplite)
 csum  = udplite_csum_outgoing(sk, skb);
else if (sk->sk_no_check == UDP_CSUM_NOXMIT) {   /* UDP csum disabled */
 skb->ip_summed = CHECKSUM_NONE;
 goto send;
} else if (skb->ip_summed == CHECKSUM_PARTIAL) { /* UDP hardware csum */
 udp4_hwcsum_outgoing(sk, skb, fl->fl4_src, fl->fl4_dst, up->len);
 goto send;
} else       /*   `normal' UDP    */
 csum = udp_csum_outgoing(sk, skb);
uh->check = csum_tcpudp_magic(fl->fl4_src, fl->fl4_dst, up->len, sk->sk_protocol, csum);

将报文发送给IP层，这个函数已经分析过了。

err = ip_push_pending_frames(sk);

同样，在发送完报文后，重置len和pending的值，以便开始下一个报文发送。

up->len = 0;
up->pending = 0;

yo-yo

关注

5
点赞
踩
35

收藏

觉得还不错? 一键收藏
1
评论
Linux内核分析 - 网络[十二]：UDP模块 - 收发

内核版本：2.6.34UDP报文接收 UDP报文的接收可以分为两个部分：协议栈收到udp报文，插入相应队列中；用户调用recvfrom()或recv()系统调用从队列中取出报文，这里的队列就是sk->sk_receive_queue，它是报文中转的纽带，两部分的联系如下图所示。第一部分：协议栈如何收取udp报文的。 udp模块的注册在inet_init()
复制链接

扫一扫