Linux内核网络udp数据包发送

Posted 2021-08-09 Linux阅码场

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Linux内核网络udp数据包发送相关的知识，希望对你有一定的参考价值。

1. 前言

本文首先从宏观上概述了数据包发送的流程，接着分析了协议层注册进内核以及被socket的过程，最后介绍了通过 socket 发送网络数据的过程。

2. 数据包发送宏观视角

从宏观上看，一个数据包从用户程序到达硬件网卡的整个过程如下：

使用系统调用（如 sendto，sendmsg 等）写数据
数据穿过socket 子系统，进入socket 协议族（protocol family）系统
协议族处理：数据穿过协议层，这一过程（在许多情况下）会将数据（data）转换成数据包（packet）
穿过协议层，packet 到达设备无关层（device agnostic layer）
使用 XPS（如果启用）或散列函数选择发送队列
调用网卡驱动的发送函数
数据传送到网卡的 qdisc（queue discipline，排队规则）
qdisc 会直接发送数据（如果可以），或者将其放到队列，下次触发NET_TX 类型软中断（softirq）的时候再发送
数据从 qdisc 传送给驱动程序
驱动程序创建所需的DMA 映射，以便网卡从 RAM 读取数据
驱动向网卡发送信号，通知数据可以发送了
网卡从 RAM 中获取数据并发送
发送完成后，设备触发一个硬中断（IRQ），表示发送完成
硬中断处理函数被唤醒执行。对许多设备来说，这会触发 NET_RX 类型的软中断，然后 NAPI poll 循环开始收包
poll 函数会调用驱动程序的相应函数，解除 DMA 映射，释放数据

3. 协议层注册

协议层分析我们将关注 IP 和 UDP 层，其他协议层可参考这个过程。我们首先来看协议族是如何注册到内核，并被 socket 子系统使用的。

当用户程序像下面这样创建 UDP socket 时会发生什么？

sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)

内核初始化的很早阶段就执行了 inet_init 函数，这个函数会注册 AF_INET 协议族，以及该协议族内的各协议栈（TCP，UDP，ICMP 和 RAW），并调用初始化函数使协议栈准备好处理网络数据。inet_init 定义在net/ipv4/af_inet.c 。

AF_INET 协议族导出一个包含 create 方法的 struct net_proto_family 类型实例。当从用户程序创建 socket 时，内核会调用此方法：

static const struct net_proto_family inet_family_ops = {
    .family = PF_INET,
    .create = inet_create,
    .owner  = THIS_MODULE,
};

inet_create 根据传递的 socket 参数，在已注册的协议中查找对应的协议：

/* Look for the requested type/protocol pair. */
lookup_protocol:
        err = -ESOCKTNOSUPPORT;
        rcu_read_lock();
        list_for_each_entry_rcu(answer, &inetsw[sock->type], list) {

                err = 0;
                /* Check the non-wild match. */
                if (protocol == answer->protocol) {
                        if (protocol != IPPROTO_IP)
                                break;
                } else {
                        /* Check for the two wild cases. */
                        if (IPPROTO_IP == protocol) {
                                protocol = answer->protocol;
                                break;
                        }
                        if (IPPROTO_IP == answer->protocol)
                                break;
                }
                err = -EPROTONOSUPPORT;
        }

然后，将该协议的回调方法（集合）赋给这个新创建的 socket：

sock->ops = answer->ops;

可以在 af_inet.c 中看到所有协议的初始化参数。下面是TCP 和 UDP的初始化参数：

/* Upon startup we insert all the elements in inetsw_array[] into
 * the linked list inetsw.
 */
static struct inet_protosw inetsw_array[] =
{
        {
                .type =       SOCK_STREAM,
                .protocol =   IPPROTO_TCP,
                .prot =       &tcp_prot,
                .ops =        &inet_stream_ops,
                .no_check =   0,
                .flags =      INET_PROTOSW_PERMANENT |
                              INET_PROTOSW_ICSK,
        },

        {
                .type =       SOCK_DGRAM,
                .protocol =   IPPROTO_UDP,
                .prot =       &udp_prot,
                .ops =        &inet_dgram_ops,
                .no_check =   UDP_CSUM_DEFAULT,
                .flags =      INET_PROTOSW_PERMANENT,
       },

            /* .... more protocols ... */

IPPROTO_UDP 协议类型有一个 ops 变量，包含很多信息，包括用于发送和接收数据的回调函数：

const struct proto_ops inet_dgram_ops = {
	.family          = PF_INET,
	.owner           = THIS_MODULE,
	
	/* ... */
	
	.sendmsg     = inet_sendmsg,
	.recvmsg     = inet_recvmsg,
	
	/* ... */
};
EXPORT_SYMBOL(inet_dgram_ops);

struct proto udp_prot = {
	.name        = "UDP",
	.owner           = THIS_MODULE,
	
	/* ... */
	
	.sendmsg     = udp_sendmsg,
	.recvmsg     = udp_recvmsg,
	
	/* ... */
};
EXPORT_SYMBOL(udp_prot);

现在，让我们转向发送 UDP 数据的用户程序，看看 udp_sendmsg 是如何在内核中被调用的。

4. 通过 socket 发送网络数据

用户程序想发送 UDP 网络数据，因此它使用 sendto 系统调用：

ret = sendto(socket, buffer, buflen, 0, &dest, sizeof(dest));

该系统调用穿过Linux 系统调用（system call）层，最后到达net/socket.c中的这个函数：

/*
 * Send a datagram to a given address. We move the address into kernel
 * space and check the user space data area is readable before invoking
 * the protocol.
 */

SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
                unsigned int, flags, struct sockaddr __user *, addr,
                int, addr_len)
{
    /* ... code ... */

    err = sock_sendmsg(sock, &msg, len);

    /* ... code ... */
}

SYSCALL_DEFINE6 宏会展开成一堆宏，后者经过一波复杂操作创建出一个带 6 个参数的系统调用（因此叫 DEFINE6）。作为结果之一，会看到内核中的所有系统调用都带 sys_前缀。

iov.iov_base = buff;
iov.iov_len = len;
msg.msg_name = NULL;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_namelen = 0;
if (addr) {
        err = move_addr_to_kernel(addr, addr_len, &address);
        if (err < 0)
                goto out_put;
        msg.msg_name = (struct sockaddr *)&address;
        msg.msg_namelen = addr_len;
}

4.1 `sock_sendmsg`, `__sock_sendmsg`, `__sock_sendmsg_nosec`

sock_sendmsg 做一些错误检查，然后调用__sock_sendmsg；后者做一些自己的错误检查，然后调用__sock_sendmsg_nosec。__sock_sendmsg_nosec 将数据传递到 socket 子系统的更深处：

static inline int __sock_sendmsg_nosec(struct kiocb *iocb, struct socket *sock,
                                       struct msghdr *msg, size_t size)
{
    struct sock_iocb *si =  ....

    /* other code ... */

    return sock->ops->sendmsg(iocb, sock, msg, size);
}

通过前面介绍的 socket 创建过程，可以知道注册到这里的 sendmsg 方法就是 inet_sendmsg。

4.2 `inet_sendmsg`

从名字可以猜到，这是 AF_INET 协议族提供的通用函数。此函数首先调用 sock_rps_record_flow 来记录最后一个处理该（数据所属的）flow 的 CPU; Receive Packet Steering 会用到这个信息。接下来，调用 socket 的协议类型（本例是 UDP）对应的 sendmsg 方法：

int inet_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg,
                 size_t size)
{
      struct sock *sk = sock->sk;

      sock_rps_record_flow(sk);

      /* We may need to bind the socket. */
      if (!inet_sk(sk)->inet_num && !sk->sk_prot->no_autobind && inet_autobind(sk))
              return -EAGAIN;

      return sk->sk_prot->sendmsg(iocb, sk, msg, size);
}
EXPORT_SYMBOL(inet_sendmsg);