1、网络发包总览
网络发包总流程图如下：
从上图中可以看到用户数据被拷贝到内核态，然后经过协议栈处理后进入RingBuffer。随后网卡驱动真正的将数据发送了出去。当发送完成的时候，是通过硬中断来通知CPU，然后清理RingBuffer。
下面从源码的角度给出一个流程图。
2、网卡启动准备
现在服务器上的网卡一般都是支持多队列的。每一个队列是由一个RingBuffer表示的，开启了多队列以后的网卡就会对应有多个RingBuffer。网卡启动时的最重要任务之一就是分配和初始化RingBuffer.
在网卡启动时，会调用__igb_open函数，RingBuffer就是在这里分配的。
cpp
static int __igb_open(struct net_device *netdev, bool resuming)
{
struct igb_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
struct pci_dev *pdev = adapter->pdev;
//分配传输描述符数组
err = igb_setup_all_tx_resources(adapter);
//分配接收描述符数组
err = igb_setup_all_rx_resources(adapter);
//中断注册，igb_msix_ring就是在这里进行注册的
err = igb_request_irq(adapter);
//开启全部队列
netif_tx_start_all_queues(netdev);
..
}
cpp
static int igb_setup_all_tx_resources(struct igb_adapter *adapter)
{
struct pci_dev *pdev = adapter->pdev;
int i, err = 0;
for (i = 0; i < adapter->num_tx_queues; i++) {
//有几个队列就构造几个RingBuffer
err = igb_setup_tx_resources(adapter->tx_ring[i]);
if (err) {
dev_err(&pdev->dev,
"Allocation for Tx Queue %u failed\n", i);
for (i--; i >= 0; i--)
igb_free_tx_resources(adapter->tx_ring[i]);
break;
}
}
return err;
}
cpp
int igb_setup_tx_resources(struct igb_ring *tx_ring)
{
//申请igb_tx_buffer数组内存
size = sizeof(struct igb_tx_buffer) * tx_ring->count;
tx_ring->tx_buffer_info = vmalloc(size);
if (!tx_ring->tx_buffer_info)
goto err;
//申请e1000_adv_tx_desc DMA数组内存
tx_ring->size = tx_ring->count * sizeof(union e1000_adv_tx_desc);
tx_ring->size = ALIGN(tx_ring->size, 4096);
tx_ring->desc = dma_alloc_coherent(dev, tx_ring->size,
&tx_ring->dma, GFP_KERNEL);
//初始化队列成员
tx_ring->next_to_use = 0;
tx_ring->next_to_clean = 0;
...
}上面__igb_open调用igb_setup_all_tx_resources分配所有传输的RingBuffer，调用igb_setup_all_rx_resources创建所有的接收RingBuffer。真正的RingBuffer构建是在igb_setup_tx_resources完成的。从上述源码可以看到一个传输RingBuffer的内部包含两个环形数组：igb_tx_buffer数组是内核使用；e1000_adv_tx_desc数组是硬件网卡使用。这两个数组在发送的时候，相同位置的指针都将指向同一个skb。这样内核和硬件就能共同访问同样的数据了，内核往skb写数据，网卡硬件负责发送。
硬中断的处理函数igb_msix_ring也是在__igb_open中注册的。
3、数据从用户进程到网卡的详细过程
3.1 send系统调用实现
send系统调用源码位于net/socket.c中，其内部实际使用的是sendto系统调用。该函数主要干了两件事：在内核中将真正的socket找出来，在这个对象里记录了各种协议栈的函数地址；构造一个struct msghdr对象，把用户传入的数据copy进去。之后就调用inet_sendmsg了。大致流程如下图：
源码如下：
cpp
SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
unsigned int, flags)
{
return sys_sendto(fd, buff, len, flags, NULL, 0);
}
SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
unsigned int, flags, struct sockaddr __user *, addr,
int, addr_len)
{
struct socket *sock;
struct msghdr msg;
err = import_single_range(WRITE, buff, len, &iov, &msg.msg_iter);
if (unlikely(err))
return err;
//1.根据fd找到socket
sock = sockfd_lookup_light(fd, &err, &fput_needed);
//2.构造msghdr
msg.msg_name = NULL;
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;
}
if (sock->file->f_flags & O_NONBLOCK)
flags |= MSG_DONTWAIT;
msg.msg_flags = flags;
//3.发送数据
err = sock_sendmsg(sock, &msg);
}从源码可以看到，send只是sendto封装出来的。在sendto系统调用里，首先根据用户传进来的句柄号来查找真正的socket对象，接着将用户请求的buf、len、flag等参数打包成一个msghdr对象。接着调用了sock_sendmsg==>sock_sendmsg_nosec,在sock_sendmsg_nosec中进入协议栈。
cpp
static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg)
{
//实际调用的是inet_sendmsg
int ret = sock->ops->sendmsg(sock, msg, msg_data_left(msg));
BUG_ON(ret == -EIOCBQUEUED);
return ret;
}3.2 传输层处理
传输层发送流程大致如下：
3.2.1 传输层拷贝
cpp
int inet_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
{
...
return sk->sk_prot->sendmsg(sk, msg, size);
}对于TCP的socket来说，sk->sk_prot->sendmsg实际上是指向tcp_sendmsg(对于UDP的socket来说实际上是udp_sendmsg)。
由于这个函数比较长，下面分开进行理解。
cpp
int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
{
// 开始发送数据
copied = 0;
restart:
mss_now = tcp_send_mss(sk, &size_goal, flags); // 获取当前 MSS 和目标大小
while (msg_data_left(msg)) {
int copy = 0;
int max = size_goal;
skb = tcp_write_queue_tail(sk); // 获取发送队列尾部的 sk_buff
if (tcp_send_head(sk)) {
if (skb->ip_summed == CHECKSUM_NONE)
max = mss_now;
copy = max - skb->len;
}
if (copy <= 0 || !tcp_skb_can_collapse_to(skb)) {
bool first_skb;
new_segment:
// 分配新的 sk_buff
if (!sk_stream_memory_free(sk))
goto wait_for_sndbuf;
if (process_backlog && sk_flush_backlog(sk)) {
process_backlog = false;
goto restart;
}
first_skb = skb_queue_empty(&sk->sk_write_queue);
//申请skb
skb = sk_stream_alloc_skb(sk,
select_size(sk, sg, first_skb),
sk->sk_allocation,
first_skb);
if (!skb)
goto wait_for_memory;
process_backlog = true;
if (sk_check_csum_caps(sk))
skb->ip_summed = CHECKSUM_PARTIAL;
//把skb挂到socket的发送队列末尾
skb_entail(sk, skb);
copy = size_goal;
max = size_goal;
if (tp->repair)
TCP_SKB_CB(skb)->sacked |= TCPCB_REPAIRED;
}
if (copy > msg_data_left(msg))
copy = msg_data_left(msg);
//如果skb有空余空间，则将msg存储的数据copy到skb中
if (skb_availroom(skb) > 0) {
copy = min_t(int, copy, skb_availroom(skb));
//将用户空间的数据拷贝到内核空间,同时计算教育和
err = skb_add_data_nocache(sk, skb, &msg->msg_iter, copy);
if (err)
goto do_fault;
}
...
//更新seq
tp->write_seq += copy;
TCP_SKB_CB(skb)->end_seq += copy;
tcp_skb_pcount_set(skb, 0);
wait_for_sndbuf:
set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
wait_for_memory:
if (copied)
tcp_push(sk, flags & ~MSG_MORE, mss_now,
TCP_NAGLE_PUSH, size_goal);
//socket发送缓存不足时，如果是阻塞套接字会陷入等待
err = sk_stream_wait_memory(sk, &timeo);
if (err != 0)
goto do_error;
mss_now = tcp_send_mss(sk, &size_goal, flags);
}
out:
if (copied) {
tcp_tx_timestamp(sk, sockc.tsflags, tcp_write_queue_tail(sk));
tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
}
out_nopush:
release_sock(sk);
//返回已复制的长度
return copied + copied_syn;
}上面的源码主要是将用户层的数据拷贝到socket的发送缓存队列末尾，如果socket缓存空间不够，而socket又是阻塞模式的就会陷入等待直到超时或者条件满足。在这个copy步骤中，如果用户层发送的数据长度超过mss，则会进行多次分割copy。
cpp
int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
{
while (msg_data_left(msg)) {
//发送判断
if (forced_push(tp)) {
tcp_mark_push(tp, skb);
__tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
} else if (skb == tcp_send_head(sk))
tcp_push_one(sk, mss_now);
continue;
}
...
}在发送只有满足forced_push(tp)或skb == tcp_send_head(sk)成立时，内核才会启动发送数据包。其中forced_push(tp)判断的时未发送的数据是否超过最大窗口的一半，skb == tcp_send_head(sk)判断的是队列最末尾的skb是不是待发送的skb。
条件不满足的话只是将用户数据拷贝到socket的发送队列。
3.2.2 传输层发送
tcp_write_xmit 是 Linux 内核 TCP 协议栈中用于处理数据包发送的核心函数。它负责从 TCP 套接字的发送队列中取出数据包，并在满足特定条件时通过 IP 层发送它们。这个函数处理了多种情况，包括 MTU 探测、拥塞窗口测试、发送窗口测试、Nagle 算法、TSO（TCP Segmentation Offload）处理等。
cpp
static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
int push_one, gfp_t gfp)
{
struct tcp_sock *tp = tcp_sk(sk); // 获取 TCP 特定的 sock 结构
struct sk_buff *skb; // 指向待发送的 sk_buff 结构
unsigned int tso_segs, sent_pkts; // TSO 分段数，已发送数据包数
int cwnd_quota; // 拥塞窗口配额
int result; // 用于存储函数返回值
bool is_cwnd_limited = false, is_rwnd_limited = false; // 拥塞窗口和发送窗口限制标志
u32 max_segs; // 最大分段数
sent_pkts = 0; // 初始化已发送数据包数
if (!push_one) {
// 执行 MTU 探测
result = tcp_mtu_probe(sk);
if (!result) {
return false; // 如果探测失败，返回 false
} else if (result > 0) {
sent_pkts = 1; // 如果探测成功，增加已发送数据包数
}
}
max_segs = tcp_tso_segs(sk, mss_now); // 计算 TSO 分段数
while ((skb = tcp_send_head(sk))) { // 循环处理发送队列头部的数据包
unsigned int limit; // 发送限制
tso_segs = tcp_init_tso_segs(skb, mss_now); // 初始化 TSO 分段数
BUG_ON(!tso_segs); // 确保 TSO 分段数有效
if (unlikely(tp->repair) && tp->repair_queue == TCP_SEND_QUEUE) {
// 如果需要修复，跳过网络传输
skb_mstamp_get(&skb->skb_mstamp);
goto repair;
}
// 测试拥塞窗口是否足够
cwnd_quota = tcp_cwnd_test(tp, skb);
if (!cwnd_quota) {
if (push_one == 2) {
// 强制发送一个丢包探测数据包
cwnd_quota = 1;
} else {
break; // 如果拥塞窗口不足，退出循环
}
}
// 测试发送窗口是否足够
if (unlikely(!tcp_snd_wnd_test(tp, skb, mss_now))) {
is_rwnd_limited = true; // 标记发送窗口限制
break;
}
// 处理 Nagle 算法
if (tso_segs == 1) {
if (unlikely(!tcp_nagle_test(tp, skb, mss_now,
(tcp_skb_is_last(sk, skb) ?
nonagle : TCP_NAGLE_PUSH)))) {
break; // 如果 Nagle 算法不允许发送，退出循环
}
} else {
// 如果 TSO 分段数大于 1，检查是否应该推迟发送
if (!push_one &&
tcp_tso_should_defer(sk, skb, &is_cwnd_limited,
max_segs)) {
break; // 如果应该推迟，退出循环
}
}
// 计算最大发送大小
limit = mss_now;
if (tso_segs > 1 && !tcp_urg_mode(tp)) {
limit = tcp_mss_split_point(sk, skb, mss_now,
min_t(unsigned int,
cwnd_quota,
max_segs),
nonagle);
}
// 如果数据包大小超过限制，尝试分片
if (skb->len > limit &&
unlikely(tso_fragment(sk, skb, limit, mss_now, gfp))) {
break; // 如果分片失败，退出循环
}
// 如果设置了 TCP_TSQ_DEFERRED 标志，清除它
if (test_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags))
clear_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags);
// 检查发送队列大小是否过小
if (tcp_small_queue_check(sk, skb, 0)) {
break; // 如果队列太小，退出循环
}
// 通过 IP 层发送数据包
if (unlikely(tcp_transmit_skb(sk, skb, 1, gfp))) {
break; // 如果发送失败，退出循环
}
repair:
// 更新发送头部，标记数据包已发送
tcp_event_new_data_sent(sk, skb);
// 更新最小序列号
tcp_minshall_update(tp, mss_now, skb);
// 增加已发送数据包数
sent_pkts += tcp_skb_pcount(skb);
if (push_one) {
break; // 如果设置了 push_one，退出循环
}
}
// 如果发送窗口限制，启动计时器
if (is_rwnd_limited)
tcp_chrono_start(sk, TCP_CHRONO_RWND_LIMITED);
else
tcp_chrono_stop(sk, TCP_CHRONO_RWND_LIMITED);
// 如果已发送数据包，更新拥塞窗口和发送窗口
if (likely(sent_pkts)) {
if (tcp_in_cwnd_reduction(sk))
tp->prr_out += sent_pkts;
// 安排发送丢包探测
if (push_one != 2)
tcp_schedule_loss_probe(sk);
is_cwnd_limited |= (tcp_packets_in_flight(tp) >= tp->snd_cwnd);
tcp_cwnd_validate(sk, is_cwnd_limited);
return false; // 返回 false，表示没有更多数据包需要发送
}
return !tp->packets_out && tcp_send_head(sk); // 如果没有数据包发送，返回 true
}
cpp
static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
gfp_t gfp_mask)
{
const struct inet_connection_sock *icsk = inet_csk(sk);
struct inet_sock *inet;
struct tcp_sock *tp;
struct tcp_skb_cb *tcb;
struct tcp_out_options opts;
unsigned int tcp_options_size, tcp_header_size;
struct tcp_md5sig_key *md5;
struct tcphdr *th;
int err;
/* 确保传入的 sk_buff 有效，并且至少有一个 TCP 段被发送 */
BUG_ON(!skb || !tcp_skb_pcount(skb));
tp = tcp_sk(sk); /* 获取 TCP 特定的 sock 结构 */
/* 如果需要克隆 sk_buff，进行时间戳获取和速率计算 */
if (clone_it) {
skb_mstamp_get(&skb->skb_mstamp);
TCP_SKB_CB(skb)->tx.in_flight = TCP_SKB_CB(skb)->end_seq
- tp->snd_una;
tcp_rate_skb_sent(sk, skb);
/* 克隆 sk_buff，为发送做准备 */
if (unlikely(skb_cloned(skb)))
skb = pskb_copy(skb, gfp_mask);
else
skb = skb_clone(skb, gfp_mask);
if (unlikely(!skb))
return -ENOBUFS;
}
/* 获取 inet_sock 和 tcp_skb_cb 结构 */
inet = inet_sk(sk);
tcb = TCP_SKB_CB(skb);
memset(&opts, 0, sizeof(opts)); /* 初始化 TCP 选项 */
/* 根据是否为 SYN 包计算 TCP 选项的大小 */
if (unlikely(tcb->tcp_flags & TCPHDR_SYN))
tcp_options_size = tcp_syn_options(sk, skb, &opts, &md5);
else
tcp_options_size = tcp_established_options(sk, skb, &opts,
&md5);
tcp_header_size = tcp_options_size + sizeof(struct tcphdr); /* TCP 头部总大小 */
/* 如果没有数据包在队列中，允许 XPS 选择另一个队列 */
skb->ooo_okay = sk_wmem_alloc_get(sk) < SKB_TRUESIZE(1);
/* 如果使用了内存预留来分配这个 sk_buff，这可能会导致回环时的丢包 */
skb->pfmemalloc = 0;
/* 为 TCP 头部腾出空间 */
skb_push(skb, tcp_header_size);
skb_reset_transport_header(skb);
/* 将 sk_buff 标记为孤儿，以便它不会影响原始 socket */
skb_orphan(skb);
skb->sk = sk; /* 设置 sk_buff 所属的 socket */
skb->destructor = skb_is_tcp_pure_ack(skb) ? __sock_wfree : tcp_wfree; /* 设置销毁函数 */
skb_set_hash_from_sk(skb, sk); /* 设置哈希值 */
atomic_add(skb->truesize, &sk->sk_wmem_alloc); /* 更新内存分配统计 */
/* 设置目的确认为挂起状态 */
skb_set_dst_pending_confirm(skb, sk->sk_dst_pending_confirm);
//封装TCP头
th = (struct tcphdr *)skb->data;
th->source = inet->inet_sport; /* 设置源端口 */
th->dest = inet->inet_dport; /* 设置目的端口 */
th->seq = htonl(tcb->seq); /* 设置序列号 */
th->ack_seq = htonl(tp->rcv_nxt); /* 设置确认序列号 */
*(((__be16 *)th) + 6) = htons(((tcp_header_size >> 2) << 12) |
tcb->tcp_flags); /* 设置数据偏移和控制标志 */
th->check = 0; /* 清除校验和 */
th->urg_ptr = 0; /* 清除紧急指针 */
/* 如果处于紧急模式，设置紧急指针 */
if (unlikely(tcp_urg_mode(tp) && before(tcb->seq, tp->snd_up))) {
if (before(tp->snd_up, tcb->seq + 0x10000)) {
th->urg_ptr = htons(tp->snd_up - tcb->seq);
th->urg = 1;
} else if (after(tcb->seq + 0xFFFF, tp->snd_nxt)) {
th->urg_ptr = htons(0xFFFF);
th->urg = 1;
}
}
/* 写入 TCP 选项 */
tcp_options_write((__be32 *)(th + 1), tp, &opts);
skb_shinfo(skb)->gso_type = sk->sk_gso_type; /* 设置 GSO 类型 */
/* 设置窗口大小并处理 ECN */
if (likely(!(tcb->tcp_flags & TCPHDR_SYN))) {
th->window = htons(tcp_select_window(sk));
tcp_ecn_send(sk, skb, th, tcp_header_size);
} else {
/* RFC1323: SYN & SYN/ACK 段的窗口不进行缩放 */
th->window = htons(min(tp->rcv_wnd, 65535U));
}
#ifdef CONFIG_TCP_MD5SIG
/* 如果启用了 MD5 签名，计算 MD5 哈希 */
if (md5) {
sk_nocaps_add(sk, NETIF_F_GSO_MASK);
tp->af_specific->calc_md5_hash(opts.hash_location,
md5, sk, skb);
}
#endif
/* 调用地址族特定的发送检查函数 */
icsk->icsk_af_ops->send_check(sk, skb);
/* 如果发送了 ACK，记录事件 */
if (likely(tcb->tcp_flags & TCPHDR_ACK))
tcp_event_ack_sent(sk, tcp_skb_pcount(skb));
/* 如果发送了数据，记录事件 */
if (skb->len != tcp_header_size) {
tcp_event_data_sent(tp, sk);
tp->data_segs_out += tcp_skb_pcount(skb);
}
/* 更新统计信息 */
if (after(tcb->end_seq, tp->snd_nxt) || tcb->seq == tcb->end_seq)
TCP_ADD_STATS(sock_net(sk), TCP_MIB_OUTSEGS,
tcp_skb_pcount(skb));
tp->segs_out += tcp_skb_pcount(skb); /* 更新段输出计数 */
/* 设置 GSO 分段信息 */
skb_shinfo(skb)->gso_segs = tcp_skb_pcount(skb);
skb_shinfo(skb)->gso_size = tcp_skb_mss(skb);
/* 清除时间戳 */
skb->tstamp = 0;
/* 清理 IP 栈的控制块 */
memset(skb->cb, 0, max(sizeof(struct inet_skb_parm),
sizeof(struct inet6_skb_parm)));
//调用网络层发送接口
err = icsk->icsk_af_ops->queue_xmit(sk, skb, &inet->cork.fl);
/* 处理发送结果 */
if (likely(err <= 0))
return err;
/* 进入拥塞控制恢复模式 */
tcp_enter_cwr(sk);
/* 评估网络传输结果 */
return net_xmit_eval(err);
}tcp_transmit_skb的第一件事是克隆一个新的skb,这是因为最后到达网卡发送完成的时候，这个skb会被释放掉，而TCP支持丢失重传，所以传给网卡的是skb的一个拷贝，等收到ACK再真正删除。第二件事就是修改skb中的TCP头。这里的skb内部其实包含了网络协议所有的头，在网络协议栈不同层次传输时只需要移动指针即可，避免了频繁的内存申请和拷贝，提高了效率。第三步就是将数据交给网络层了。icsk->icsk_af_ops->queue_xmit实际是调用了ip_queue_xmit函数。
3.3 网络层发送处理
在网络层主要处理路由项查找、IP设置、netfilter过滤、skb切分(大于MTU的话)等工作。处理完这些工作之后交给更下一层的邻居子系统来处理。
cpp
int ip_queue_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl)
{
struct inet_sock *inet = inet_sk(sk);
struct net *net = sock_net(sk);
struct ip_options_rcu *inet_opt;
struct flowi4 *fl4;
struct rtable *rt;
struct iphdr *iph;
int res;
/* 如果数据包已经被路由，跳过路由选择 */
rcu_read_lock();
inet_opt = rcu_dereference(inet->inet_opt);
fl4 = &fl->u.ip4;
rt = skb_rtable(skb);
if (rt)
goto packet_routed;
//检查socket是否有缓存的路由表
rt = (struct rtable *)__sk_dst_check(sk, 0);
if (!rt) {
__be32 daddr;
/* 如果我们有选项，使用正确的目的地地址 */
daddr = inet->inet_daddr;
if (inet_opt && inet_opt->opt.srr)
daddr = inet_opt->opt.faddr;
/* 如果路由选择失败，传输层的重传机制会不断尝试查找路由项直到路由出现或连接超时 */
rt = ip_route_output_ports(net, fl4, sk,
daddr, inet->inet_saddr,
inet->inet_dport,
inet->inet_sport,
sk->sk_protocol,
RT_CONN_FLAGS(sk),
sk->sk_bound_dev_if);
if (IS_ERR(rt))
goto no_route;
sk_setup_caps(sk, &rt->dst);
}
//为skb设置路由表
skb_dst_set_noref(skb, &rt->dst);
packet_routed:
if (inet_opt && inet_opt->opt.is_strictroute && rt->rt_uses_gateway)
goto no_route;
/* 确定我们要发送的位置，分配并构建 IP 头部 */
skb_push(skb, sizeof(struct iphdr) + (inet_opt ? inet_opt->opt.optlen : 0));
skb_reset_network_header(skb);
iph = ip_hdr(skb);
*((__be16 *)iph) = htons((4 << 12) | (5 << 8) | (inet->tos & 0xff));
if (ip_dont_fragment(sk, &rt->dst) && !skb->ignore_df)
iph->frag_off = htons(IP_DF);
else
iph->frag_off = 0;
iph->ttl = ip_select_ttl(inet, &rt->dst);
iph->protocol = sk->sk_protocol;
ip_copy_addrs(iph, fl4);
...
//发送
res = ip_local_out(net, sk, skb);
...
}ip_queue_xmit函数进行了路由项查找，在路由表查到某个网络应该通过哪个网卡、哪个网关发送出去之后，就缓存到socket上，避免重复查询。接着把路由表地址也缓存到skb中。然后按照规范填充IP头，再通过ip_finish_output进入下一步处理。
cpp
int ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb)
{
int err;
//执行netfilter过滤
err = __ip_local_out(net, sk, skb);
if (likely(err == 1))
//开始发送数据
err = dst_output(net, sk, skb);
return err;
}在调用ip_local_out=>__ip_local_out=>nf_hook(NFPROTO_IPV4, NF_INET_LOCAL_OUT的过程中会执行netfilter过滤。
cpp
static inline int dst_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
return skb_dst(skb)->output(net, sk, skb);
}此函数找到skb的路由表（dst条目），然后调用路由表的output方法。指向的是ip_output方法。
cpp
int ip_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
struct net_device *dev = skb_dst(skb)->dev;
//统计
IP_UPD_PO_STATS(net, IPSTATS_MIB_OUT, skb->len);
skb->dev = dev;
skb->protocol = htons(ETH_P_IP);
//再次交给netfilter，完毕回调ip_finish_output
return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING,
net, sk, skb, NULL, dev,
ip_finish_output,
!(IPCB(skb)->flags & IPSKB_REROUTED));
}
cpp
static int ip_finish_output(struct net *net, struct sock *sk, struct sk_buff *skb)
{
unsigned int mtu;
int ret;
...
/* 获取数据包的目的 MTU（最大传输单元） */
mtu = ip_skb_dst_mtu(sk, skb);
if (skb_is_gso(skb))
return ip_finish_output_gso(net, sk, skb, mtu);
/* 检查数据包长度是否大于 MTU 或者需要分片 */
if (skb->len > mtu || (IPCB(skb)->flags & IPSKB_FRAG_PMTU))
return ip_fragment(net, sk, skb, mtu, ip_finish_output2);
/* 如果不需要分片，直接调用 ip_finish_output2 发送数据包 */
return ip_finish_output2(net, sk, skb);
}
cpp
static int ip_finish_output2(struct net *net, struct sock *sk, struct sk_buff *skb)
{
struct dst_entry *dst = skb_dst(skb); // 获取数据包的路由条目
struct rtable *rt = (struct rtable *)dst; // 转换路由条目
struct net_device *dev = dst->dev; // 获取网络设备
unsigned int hh_len = LL_RESERVED_SPACE(dev); // 计算硬件头部空间
struct neighbour *neigh; // 邻居发现条目
u32 nexthop; // 下一跳地址
// 统计多播或广播数据包
if (rt->rt_type == RTN_MULTICAST) {
IP_UPD_PO_STATS(net, IPSTATS_MIB_OUTMCAST, skb->len);
} else if (rt->rt_type == RTN_BROADCAST)
IP_UPD_PO_STATS(net, IPSTATS_MIB_OUTBCAST, skb->len);
// 检查数据包头部空间是否足够
if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {
struct sk_buff *skb2;
skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev));
if (!skb2) {
kfree_skb(skb); // 如果分配失败，释放数据包
return -ENOMEM;
}
if (skb->sk)
skb_set_owner_w(skb2, skb->sk); // 设置数据包所有者
consume_skb(skb); // 释放旧的数据包
skb = skb2; // 更新数据包指针
}
// 处理隧道重定向
if (lwtunnel_xmit_redirect(dst->lwtstate)) {
int res = lwtunnel_xmit(skb);
if (res < 0 || res == LWTUNNEL_XMIT_DONE)
return res;
}
// 获取下一跳邻居
rcu_read_lock_bh(); // 锁定 RCU 读锁
//根据下一跳的IP地址查找邻居项，找不到就创建一个
nexthop = (__force u32) rt_nexthop(rt, ip_hdr(skb)->daddr);
neigh = __ipv4_neigh_lookup_noref(dev, nexthop);
if (unlikely(!neigh))
neigh = __neigh_create(&arp_tbl, &nexthop, dev, false);
if (!IS_ERR(neigh)) {
int res;
sock_confirm_neigh(skb, neigh); // 确认邻居
res = neigh_output(neigh, skb); // 发送数据包
rcu_read_unlock_bh(); // 解锁 RCU 读锁
return res;
}
rcu_read_unlock_bh(); // 解锁 RCU 读锁
net_dbg_ratelimited("%s: No header cache and no neighbour!\n", __func__);
kfree_skb(skb); // 释放数据包
return -EINVAL; // 返回错误码
}3.4 邻居子系统
cpp
static inline int neigh_output(struct neighbour *n, struct sk_buff *skb)
{
const struct hh_cache *hh = &n->hh;
if ((n->nud_state & NUD_CONNECTED) && hh->hh_len)
return neigh_hh_output(hh, skb);
else
//
return n->output(n, skb);
}如果是新创建的邻居表项，此时因为目的MAC还未获取，不具备发送IP报文的能力，调用n->output,实际是调用neigh_resolve_output，在这个函数内部有可能发出Arp网络请求。
cpp
int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb) {
int rc = 0; // 初始化返回值，0 表示成功
// 尝试发送邻居事件，如果失败则继续处理
if (!neigh_event_send(neigh, skb)) {
int err; // 用于存储错误代码的变量
struct net_device *dev = neigh->dev; // 获取邻居结构体中的网络设备指针
unsigned int seq; // 用于序列化访问的变量
// 如果网络设备支持缓存并且邻居的硬件头部长度为0，则初始化硬件头部
if (dev->header_ops->cache && !neigh->hh.hh_len)
neigh_hh_init(neigh);
// 循环直到硬件头部正确填充或序列化访问失败
do {
// 调整数据包指针，使其指向网络层头部
__skb_pull(skb, skb_network_offset(skb));
seq = read_seqbegin(&neigh->ha_lock); // 开始序列化访问
// 调用网络设备的硬头部函数来填充数据包的硬件头部
err = dev_hard_header(skb, dev, ntohs(skb->protocol), neigh->ha, NULL, skb->len);
} while (read_seqretry(&neigh->ha_lock, seq)); // 如果序列化访问失败则重试
// 如果硬头部填充成功，则将数据包放入网络设备的发送队列
if (err >= 0)
rc = dev_queue_xmit(skb);
}
...
}
cpp
static inline int neigh_hh_output(const struct hh_cache *hh, struct sk_buff *skb)
{
unsigned int seq;
unsigned int hh_len;
do {
seq = read_seqbegin(&hh->hh_lock); // 开始读取序列，用于乐观并发读取
hh_len = hh->hh_len; // 获取硬件头部长度
if (likely(hh_len <= HH_DATA_MOD)) {
// 如果硬件头部长度小于等于 HH_DATA_MOD，直接复制
memcpy(skb->data - HH_DATA_MOD, hh->hh_data, HH_DATA_MOD);
} else {
unsigned int hh_alen = HH_DATA_ALIGN(hh_len); // 对齐硬件头部长度
// 复制对齐后的硬件头部
memcpy(skb->data - hh_alen, hh->hh_data, hh_alen);
}
} while (read_seqretry(&hh->hh_lock, seq)); // 检查序列是否重试
// 将硬件头部推入数据包
skb_push(skb, hh_len);
return dev_queue_xmit(skb); // 将数据包加入到设备的发送队列
}当获取到硬件MAC地址之后，就可以封装skb的MAC头。最后调用dev_queue_xmit将skb传递给Linux网络设备子系统。
3.5 网络设备子系统
cpp
int dev_queue_xmit(struct sk_buff *skb)
{
return __dev_queue_xmit(skb, NULL);
}
static int __dev_queue_xmit(struct sk_buff *skb, void *accel_priv) {
struct net_device *dev = skb->dev; // 获取数据包关联的网络设备
struct netdev_queue *txq; // 指向网络设备队列的结构体
struct Qdisc *q; // 指向队列规则（qdisc）的结构体
int rc = -ENOMEM; // 初始化返回值为-ENOMEM，表示内存分配失败
skb_reset_mac_header(skb); // 重置数据包的MAC层头部
// 如果数据包需要时间戳，则设置时间戳
if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_SCHED_TSTAMP))
__skb_tstamp_tx(skb, NULL, skb->sk, SCM_TSTAMP_SCHED);
// 禁用软中断，获取RCU读锁
rcu_read_lock_bh();
skb_update_prio(skb); // 更新数据包的优先级
qdisc_pkt_len_init(skb); // 初始化队列规则的长度
// 如果配置了网络分类和动作支持
#ifdef CONFIG_NET_CLS_ACT
skb->tc_at_ingress = 0;
// 如果需要处理出口数据
# ifdef CONFIG_NET_EGRESS
if (static_key_false(&egress_needed)) {
skb = sch_handle_egress(skb, &rc, dev);
if (!skb)
goto out; // 如果处理失败，跳转到out标签
}
# endif
#endif
// 如果设备或队列规则不需要数据包的目的地址，则立即释放
if (dev->priv_flags & IFF_XMIT_DST_RELEASE)
skb_dst_drop(skb);
else
skb_dst_force(skb); // 否则强制设置目的地址
// 选择一个发送队列
txq = netdev_pick_tx(dev, skb, accel_priv);
// 获取此队列关联的排队规则
q = rcu_dereference_bh(txq->qdisc);
trace_net_dev_queue(skb); // 跟踪网络设备队列
// 如果队列规则有enqueue函数，则调用__dev_xmit_skb继续处理
if (q->enqueue) {
rc = __dev_xmit_skb(skb, q, dev, txq);
goto out; // 跳转到out标签
}
// 如果设备没有队列规则，通常是软件设备的情况
if (dev->flags & IFF_UP) {
int cpu = smp_processor_id(); // 获取当前CPU编号
// 如果当前CPU不是队列的锁持有者
if (txq->xmit_lock_owner != cpu) {
...
HARD_TX_LOCK(dev, txq, cpu); // 获取硬件发送锁
// 如果队列没有停止，则发送数据包
if (!netif_xmit_stopped(txq)) {
__this_cpu_inc(xmit_recursion); // 增加递归计数
skb = dev_hard_start_xmit(skb, dev, txq, &rc); // 调用硬件发送函数
__this_cpu_dec(xmit_recursion); // 减少递归计数
if (dev_xmit_complete(rc)) {
HARD_TX_UNLOCK(dev, txq); // 释放硬件发送锁
goto out; // 跳转到out标签
}
}
HARD_TX_UNLOCK(dev, txq); // 释放硬件发送锁
net_crit_ratelimited("Virtual device %s asks to queue packet!\n", dev->name);
}
...
}
cpp
static inline int __dev_xmit_skb(struct sk_buff *skb, struct Qdisc *q,
struct net_device *dev,
struct netdev_queue *txq) {
spinlock_t *root_lock = qdisc_lock(q); // 获取队列规则的锁
struct sk_buff *to_free = NULL; // 用于存储需要释放的数据包
bool contended; // 标记是否在竞争状态
int rc; // 用于存储返回值
qdisc_calculate_pkt_len(skb, q); // 计算数据包的长度
// 如果队列规则正在运行，尝试获取忙锁以序列化竞争
contended = qdisc_is_running(q);
if (unlikely(contended))
spin_lock(&q->busylock); // 获取忙锁
spin_lock(root_lock); // 获取队列规则的主锁
// 如果队列规则被停用，则丢弃数据包
if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) {
__qdisc_drop(skb, &to_free); // 丢弃数据包
rc = NET_XMIT_DROP; // 设置返回值为丢弃
} else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) &&
qdisc_run_begin(q)) { // 如果队列规则允许绕过并且队列为空
// 直接发送数据包，不经过队列
qdisc_bstats_update(q, skb); // 更新队列规则的统计信息
if (sch_direct_xmit(skb, q, dev, txq, root_lock, true)) {
// 如果直接发送成功
if (unlikely(contended)) {
spin_unlock(&q->busylock); // 释放忙锁
contended = false; // 标记不再竞争
}
__qdisc_run(q); // 运行队列规则
} else {
qdisc_run_end(q); // 结束队列规则的运行
}
rc = NET_XMIT_SUCCESS; // 设置返回值为成功
} else {
// 将数据包加入队列
rc = q->enqueue(skb, q, &to_free) & NET_XMIT_MASK;
if (qdisc_run_begin(q)) {
if (unlikely(contended)) {
spin_unlock(&q->busylock); // 释放忙锁
contended = false; // 标记不再竞争
}
__qdisc_run(q); // 运行队列规则
}
}
spin_unlock(root_lock); // 释放队列规则的主锁
if (unlikely(to_free)) // 如果有数据包需要释放
kfree_skb_list(to_free); // 释放数据包
if (unlikely(contended)) // 如果在竞争状态
spin_unlock(&q->busylock); // 释放忙锁
return rc; // 返回结果
}__dev_xmit_skb函数的主要任务是将数据包发送到网络设备。它首先检查队列规则的状态，如果队列规则允许并且队列为空，它将尝试直接发送数据包。否则，它将数据包加入队列。在处理过程中，它还处理了竞争状态，以确保在多核处理器上正确地序列化访问。
cpp
void __qdisc_run(struct Qdisc *q)
{
int quota = dev_tx_weight; // 从设备传输权重获取配额，这个配额限制了处理数据包的数量
int packets; // 用于存储本轮处理的数据包数量
while (qdisc_restart(q, &packets)) { // 循环，直到没有更多数据包可以处理
// 根据可能的发生顺序排序：如果1.我们超出了数据包配额 2.另一个进程需要CPU，则推迟处理
quota -= packets; // 从配额中减去本轮处理的数据包数量
if (quota <= 0 || need_resched()) { // 如果配额用完或者系统需要调度其他进程运行
__netif_schedule(q); // 调度网络设备，以便其他进程可以运行
break; // 跳出循环
}
}
qdisc_run_end(q); // 结束队列规则的运行，执行任何清理工作
}从上述代码可以看到while循环不断的从队列取skb并进行发送。
注意：此时占用的是用户进程的系统态实际(sy)。只有当quota用尽或者需要调度其他进程运行时才触发软中断进行发送。
所以这就是在服务器上查看/proc/softirqs时，一般NET_RX比NET_TX大得多的原因。
cpp
static inline int qdisc_restart(struct Qdisc *q, int *packets)
{
...
//取出一个要发送的skb
skb = dequeue_skb(q, &validate, packets);
if (unlikely(!skb))
return 0;
root_lock = qdisc_lock(q);
dev = qdisc_dev(q);
txq = skb_get_tx_queue(dev, skb);
return sch_direct_xmit(skb, q, dev, txq, root_lock, validate);
}qdisc_restart从队列中取出一个skb，并调用sch_direct_xmit继续发送。
cpp
int sch_direct_xmit(struct sk_buff *skb, struct Qdisc *q,
struct net_device *dev, struct netdev_queue *txq,
spinlock_t *root_lock, bool validate) {
int ret = NETDEV_TX_BUSY; // 初始化返回值为 NETDEV_TX_BUSY，表示设备忙
// 释放 qdisc 锁
spin_unlock(root_lock);
// 在没有锁的情况下验证 skb（GSO, 校验和, ...）
if (validate)
skb = validate_xmit_skb_list(skb, dev); // 验证要发送的 skb
if (likely(skb)) { // 如果 skb 有效
HARD_TX_LOCK(dev, txq, smp_processor_id()); // 获取硬件发送锁
if (!netif_xmit_frozen_or_stopped(txq))
skb = dev_hard_start_xmit(skb, dev, txq, &ret); // 调用驱动程序尝试直接发送 skb
HARD_TX_UNLOCK(dev, txq); // 释放硬件发送锁
} else {
spin_lock(root_lock); // 如果 skb 无效，重新获取 qdisc 锁
return qdisc_qlen(q); // 返回队列长度
}
spin_lock(root_lock); // 重新获取 qdisc 锁
if (dev_xmit_complete(ret)) { // 如果发送完成
// 驱动程序成功发送了 skb 或者 skb 被消耗
ret = qdisc_qlen(q); // 返回队列长度
} else {
// 驱动程序返回 NETDEV_TX_BUSY - 重新排队 skb
if (unlikely(ret != NETDEV_TX_BUSY))
net_warn_ratelimited("BUG %s code %d qlen %d\n",
dev->name, ret, q->q.qlen); // 如果返回值不是 NETDEV_TX_BUSY，发出警告
ret = dev_requeue_skb(skb, q); // 将 skb 重新排队
}
if (ret && netif_xmit_frozen_or_stopped(txq))
ret = 0; // 如果设备被冻结或停止，返回 0
return ret; // 返回最终的返回值
}这个函数主要工作是调用dev_hard_start_xmit驱动函数发送skb，如果发送失败将skb重新加入队列。
3.6 软中断调度
在上面我们看到当用户进程配额用尽时会调用__netif_schedule触发一个软中断。该函数会进入__netif_reschedule发出一个NET_TX_SOFTIRQ类型中断。
软中断由内核进程运行，该进程会进入net_tx_action函数，在该函数能获取发送队列，并也最终调用到驱动程序里的入口函数dev_hard_start_xmit，如下图所示：
cpp
static void __netif_reschedule(struct Qdisc *q)
{
struct softnet_data *sd; // 定义一个指向软网数据结构的指针
unsigned long flags; // 用于保存当前中断状态的标志
local_irq_save(flags); // 保存当前中断状态并禁用本地中断
sd = this_cpu_ptr(&softnet_data); // 获取当前 CPU 的软网数据结构
q->next_sched = NULL; // 将队列规则的下一个调度指针设置为 NULL
*sd->output_queue_tailp = q; // 将队列规则添加到输出队列的尾部
sd->output_queue_tailp = &q->next_sched; // 更新输出队列的尾指针
raise_softirq_irqoff(NET_TX_SOFTIRQ); // 触发网络传输软中断
local_irq_restore(flags); // 恢复之前的中断状态
}在这里设置了将保存了发送队列的q添加到CPU的soft_data的发送队列尾部，然后触发软中断。
cpp
static __latent_entropy void net_tx_action(struct softirq_action *h)
{
struct softnet_data *sd = this_cpu_ptr(&softnet_data); // 获取当前 CPU 的软网数据结构
if (sd->completion_queue) { // 如果有完成队列需要处理
struct sk_buff *clist;
local_irq_disable(); // 禁用本地中断
clist = sd->completion_queue; // 获取完成队列
sd->completion_queue = NULL; // 清空完成队列
local_irq_enable(); // 启用本地中断
while (clist) { // 遍历完成队列
struct sk_buff *skb = clist; // 获取当前数据包
clist = clist->next; // 移动到下一个数据包
WARN_ON(atomic_read(&skb->users)); // 如果数据包的使用者计数器不为0，则发出警告
if (likely(get_kfree_skb_cb(skb)->reason == SKB_REASON_CONSUMED))
trace_consume_skb(skb); // 如果数据包已被消耗，则跟踪
else
trace_kfree_skb(skb, net_tx_action); // 否则，跟踪数据包的释放
if (skb->fclone != SKB_FCLONE_UNAVAILABLE)
__kfree_skb(skb); // 如果数据包不是克隆的，则立即释放
else
__kfree_skb_defer(skb); // 否则，延迟释放
__kfree_skb_flush(); // 刷新所有延迟释放的数据包
}
}
if (sd->output_queue) { // 如果有输出队列需要处理
struct Qdisc *head;
local_irq_disable(); // 禁用本地中断
head = sd->output_queue; // 获取输出队列
sd->output_queue = NULL; // 清空输出队列
sd->output_queue_tailp = &sd->output_queue; // 重置尾指针
local_irq_enable(); // 启用本地中断
while (head) { // 遍历输出队列
struct Qdisc *q = head; // 获取当前队列规则
spinlock_t *root_lock;
head = head->next_sched; // 移动到下一个队列规则
root_lock = qdisc_lock(q); // 获取队列规则的锁
spin_lock(root_lock); // 上锁
/* We need to make sure head->next_sched is read
* before clearing __QDISC_STATE_SCHED
*/
smp_mb__before_atomic(); // 确保内存操作的顺序
clear_bit(__QDISC_STATE_SCHED, &q->state); // 清除调度状态位
qdisc_run(q); // 发送数据
spin_unlock(root_lock); // 释放锁
}
}
}软中断这里会获取soft_data,软中断主要做了两件事：一清理发送完成队列的skb，二将发送队列的数据发送出去。这里发送数据消耗的CPU都显示在si这里，不会消耗用户进程时间。
这里和用户态一样会调用__qdisc_run发送数据。
cpp
static inline void qdisc_run(struct Qdisc *q)
{
if (qdisc_run_begin(q))
__qdisc_run(q);
}然后也是进入qdisc_restart=>sch_direct_xmit,直到进入驱动程序函数dev_hard_start_xmit。
3.7 igb网卡驱动发送
无论是在用户进程的内核态还是对于软中断上下文，都会调用网络设备子系统中的dev_hard_start_xmit函数。在这个函数中会调用到驱动的发送函数igb_xmit_frame。
在驱动函数里，会将skb挂到RingBuffer上，驱动调用完毕，数据包将真正从网卡发送出去。流程图如下：
cpp
struct sk_buff *dev_hard_start_xmit(struct sk_buff *first, struct net_device *dev,
struct netdev_queue *txq, int *ret)
{
struct sk_buff *skb = first; // 初始化 skb 为第一个数据包
int rc = NETDEV_TX_OK; // 初始化返回码为 NETDEV_TX_OK，表示发送成功
while (skb) { // 循环处理所有数据包，直到 skb 为 NULL
struct sk_buff *next = skb->next; // 保存下一个数据包的指针
skb->next = NULL; // 将当前数据包的下一个指针设置为 NULL，因为硬件发送通常一次处理一个数据包
rc = xmit_one(skb, dev, txq, next != NULL); // 调用 xmit_one 函数发送当前数据包
if (unlikely(!dev_xmit_complete(rc))) { // 如果发送不完整（失败）
skb->next = next; // 恢复下一个数据包的指针
goto out; // 跳出循环
}
skb = next; // 移动到下一个数据包
if (netif_xmit_stopped(txq) && skb) { // 如果队列已停止并且还有数据包
rc = NETDEV_TX_BUSY; // 设置返回码为 NETDEV_TX_BUSY，表示设备忙
break; // 跳出循环
}
}
out:
*ret = rc; // 将最终的返回码存储在 ret 指针指向的变量中
return skb; // 返回当前处理的数据包（可能是最后一个数据包或因错误而停止的数据包）
}
cpp
static int xmit_one(struct sk_buff *skb, struct net_device *dev,
struct netdev_queue *txq, bool more)
{
unsigned int len;
int rc;
//tcpdump获取本机发送包工作的地方
if (!list_empty(&ptype_all) || !list_empty(&dev->ptype_all))
dev_queue_xmit_nit(skb, dev);
len = skb->len;
trace_net_dev_start_xmit(skb, dev);
//发送数据包
rc = netdev_start_xmit(skb, dev, txq, more);
trace_net_dev_xmit(skb, rc, dev, len);
return rc;
}
cpp
static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
struct netdev_queue *txq, bool more)
{
//获取设备的回调函数集合
const struct net_device_ops *ops = dev->netdev_ops;
int rc;
//继续发送
rc = __netdev_start_xmit(ops, skb, dev, more);
if (rc == NETDEV_TX_OK)
txq_trans_update(txq);
return rc;
}
cpp
static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
struct sk_buff *skb, struct net_device *dev,
bool more)
{
skb->xmit_more = more ? 1 : 0;
return ops->ndo_start_xmit(skb, dev);
}ndo_start_xmit是网卡驱动要实现的一个函数，是在net_device_ops中定义的。
cpp
drivers/net/ethernet/intel/igb/igb_main.c
static const struct net_device_ops igb_netdev_ops = {
.ndo_open = igb_open, //当网络设备被激活（打开）时调用，通常用于初始化硬件。
.ndo_stop = igb_close, //当网络设备被停用（关闭）时调用，用于停止设备的操作。
.ndo_start_xmit = igb_xmit_frame, //用于发送数据包，调用驱动程序的发送函数。
.ndo_get_stats64 = igb_get_stats64, //获取网络设备的统计信息，如发送和接收的数据包数量等。
.ndo_set_rx_mode = igb_set_rx_mode, //设置接收模式，如混杂模式、多播模式或单播模式。
.ndo_set_mac_address = igb_set_mac, //设置网络设备的 MAC 地址。
.ndo_change_mtu = igb_change_mtu, //更改网络设备的 MTU（最大传输单元）大小。
.ndo_do_ioctl = igb_ioctl, //处理 IOCTL 命令，用于执行设备特定的操作。
.ndo_tx_timeout = igb_tx_timeout, //处理发送超时，当设备在一定时间内没有发送数据包时调用。
.ndo_validate_addr = eth_validate_addr, //验证硬件地址的有效性，通常由以太网设备通用层实现。
...
};对于网络设备层定义的ndo_start_xmit，igb的实现函数是igb_xmit_frame，这个函数是在网卡驱动初始化的时候被赋值的。
cpp
static netdev_tx_t igb_xmit_frame(struct sk_buff *skb,
struct net_device *netdev)
{
struct igb_adapter *adapter = netdev_priv(netdev); // 从网络设备结构体中获取私有数据
...
return igb_xmit_frame_ring(skb, igb_tx_queue_mapping(adapter, skb)); // 调用实际的发送函数
}
cpp
netdev_tx_t igb_xmit_frame_ring(struct sk_buff *skb,
struct igb_ring *tx_ring)
{
struct igb_tx_buffer *first;
int tso;
u32 tx_flags = 0;
unsigned short f;
u16 count = TXD_USE_COUNT(skb_headlen(skb)); // 计算所需的描述符数量
__be16 protocol = vlan_get_protocol(skb); // 获取 VLAN 协议
u8 hdr_len = 0; // 头部长度
// 计算所需的描述符数量，包括数据、填充和上下文描述符
for (f = 0; f < skb_shinfo(skb)->nr_frags; f++)
count += TXD_USE_COUNT(skb_shinfo(skb)->frags[f].size);
if (igb_maybe_stop_tx(tx_ring, count + 3)) { // 检查是否需要停止发送
/* this is a hard error */
return NETDEV_TX_BUSY; // 如果需要停止，则返回忙状态
}
// 获取TX Queue中下一个可用的缓冲区信息
first = &tx_ring->tx_buffer_info[tx_ring->next_to_use];
first->skb = skb;
first->bytecount = skb->len;
first->gso_segs = 1;
if (unlikely(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) { // 检查是否需要硬件时间戳
struct igb_adapter *adapter = netdev_priv(tx_ring->netdev);
if (!test_and_set_bit_lock(__IGB_PTP_TX_IN_PROGRESS, &adapter->state)) {
skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
tx_flags |= IGB_TX_FLAGS_TSTAMP;
adapter->ptp_tx_skb = skb_get(skb);
adapter->ptp_tx_start = jiffies;
if (adapter->hw.mac.type == e1000_82576)
schedule_work(&adapter->ptp_tx_work);
}
}
skb_tx_timestamp(skb); // 记录数据包的时间戳
if (skb_vlan_tag_present(skb)) { // 检查是否存在 VLAN 标签
tx_flags |= IGB_TX_FLAGS_VLAN;
tx_flags |= (skb_vlan_tag_get(skb) << IGB_TX_FLAGS_VLAN_SHIFT);
}
// 记录初始标志和协议
first->tx_flags = tx_flags;
first->protocol = protocol;
tso = igb_tso(tx_ring, first, &hdr_len); // 尝试进行 TSO（TCP Segmentation Offload）
if (tso < 0)
goto out_drop; // 如果 TSO 失败，则丢弃数据包
else if (!tso)
igb_tx_csum(tx_ring, first); // 如果不进行 TSO，则计算校验和
// 准备给设备发送的数据(给Tx Queue建立映射关系)
igb_tx_map(tx_ring, first, hdr_len);
...
}
cpp
static void igb_tx_map(struct igb_ring *tx_ring,
struct igb_tx_buffer *first,
const u8 hdr_len)
{
struct sk_buff *skb = first->skb; // 获取要发送的数据包
struct igb_tx_buffer *tx_buffer;
union e1000_adv_tx_desc *tx_desc; // 传输描述符
struct skb_frag_struct *frag;
dma_addr_t dma; // DMA 地址
unsigned int data_len, size;
u32 tx_flags = first->tx_flags; // 传输标志
u32 cmd_type = igb_tx_cmd_type(skb, tx_flags); // 命令类型
u16 i = tx_ring->next_to_use; // 下一个要使用的描述符索引
tx_desc = IGB_TX_DESC(tx_ring, i); // 获取当前描述符
// 设置描述符的 olinfo_status 字段
igb_tx_olinfo_status(tx_ring, tx_desc, tx_flags, skb->len - hdr_len);
size = skb_headlen(skb); // 数据包头部长度
data_len = skb->data_len; // 数据包数据长度
// 为skb->data构造内存映射，以允许设备通过DMA从RAM中读取数据
dma = dma_map_single(tx_ring->dev, skb->data, size, DMA_TO_DEVICE);
tx_buffer = first; // 初始化 tx_buffer 为第一个缓冲区
//遍历该数据包所有分片，为skb的每个分片生成有效
for (frag = &skb_shinfo(skb)->frags[0];; frag++) { // 遍历所有数据包片段
if (dma_mapping_error(tx_ring->dev, dma)) // 检查 DMA 映射是否出错
goto dma_error;
// 记录长度和 DMA 地址
dma_unmap_len_set(tx_buffer, len, size);
dma_unmap_addr_set(tx_buffer, dma, dma);
tx_desc->read.buffer_addr = cpu_to_le64(dma); // 设置描述符的缓冲区地址
// 处理每个描述符的最大数据长度限制
while (unlikely(size > IGB_MAX_DATA_PER_TXD)) {
tx_desc->read.cmd_type_len = cpu_to_le32(cmd_type ^ IGB_MAX_DATA_PER_TXD);
i++;
tx_desc++;
if (i == tx_ring->count) { // 如果到达描述符环的末尾，回到开始
tx_desc = IGB_TX_DES
i = 0;
}
tx_desc->read.olinfo_status = 0;
dma += IGB_MAX_DATA_PER_TXD;
size -= IGB_MAX_DATA_PER_TXD;
tx_desc->read.buffer_addr = cpu_to_le64(dma);
}
if (likely(!data_len)) // 如果没有更多数据要发送，跳出循环
break;
tx_desc->read.cmd_type_len = cpu_to_le32(cmd_type ^ size);
i++;
tx_desc++;
if (i == tx_ring->count) { // 如果到达描述符环的末尾，回到开始
tx_desc = IGB_TX_DESC(tx_ring, 0);
i = 0;
}
tx_desc->read.olinfo_status = 0;
size = skb_frag_size(frag); // 获取片段大小
data_len -= size;
// 将数据包片段映射到 DMA
dma = skb_frag_dma_map(tx_ring->dev, frag, 0, size, DMA_TO_DEVICE);
tx_buffer = &tx_ring->tx_buffer_info[i]; // 更新 tx_buffer 为当前片段
}
// 设置最后一个描述符的 RS 和 EOP 位
cmd_type |= size | IGB_TXD_DCMD;
tx_desc->read.cmd_type_len = cpu_to_le32(cmd_type);
// 更新网络设备发送统计信息
netdev_tx_sent_queue(txring_txq(tx_ring), first->bytecount);
...
}当所有需要的描述符都已建好，且skb的所有数据都映射到DMA地址后，驱动就进入最后一步，触发真实的发送。
4、RingBuffer内存回收
当数据发送完成时，内存还没有清理。在发送完成时，网卡设备会触发硬中断来释放内存。
cpp
static inline void ____napi_schedule(struct softnet_data *sd,
struct napi_struct *napi)
{
list_add_tail(&napi->poll_list, &sd->poll_list);
__raise_softirq_irqoff(NET_RX_SOFTIRQ);
}在这里可以发现，无论是接收数据还是发送完成通知，从硬中断触发的软中断都是NET_RX_SOFTIRQ。
接着进入软中断的回调函数igb_poll。
cpp
static int igb_poll(struct napi_struct *napi, int budget)
{
struct igb_q_vector *q_vector = container_of(napi,
struct igb_q_vector,
napi);
bool clean_complete = true;
int work_done = 0;
...
if (q_vector->tx.ring)
clean_complete = igb_clean_tx_irq(q_vector, budget);
...
}
cpp
static bool igb_clean_tx_irq(struct igb_q_vector *q_vector, int napi_budget)
{
struct igb_adapter *adapter = q_vector->adapter; // 获取适配器实例
struct igb_ring *tx_ring = q_vector->tx.ring; // 获取发送队列
struct igb_tx_buffer *tx_buffer; // 指向当前处理的 tx_buffer
union e1000_adv_tx_desc *tx_desc; // 指向当前处理的 tx_desc
unsigned int total_bytes = 0, total_packets = 0; // 用于统计发送的总字节和数据包数量
unsigned int budget = q_vector->tx.work_limit; // NAPI 预算
unsigned int i = tx_ring->next_to_clean; // 从哪里开始清理
if (test_bit(__IGB_DOWN, &adapter->state)) // 如果设备已经关闭
return true; // 返回 true 表示没有更多的工作要做
tx_buffer = &tx_ring->tx_buffer_info[i]; // 获取当前要清理的 tx_buffer
tx_desc = IGB_TX_DESC(tx_ring, i); // 获取当前要清理的 tx_desc
i -= tx_ring->count; // 调整索引
do {
union e1000_adv_tx_desc *eop_desc = tx_buffer->next_to_watch; // 获取这个数据包的最后一个描述符
/* if next_to_watch is not set then there is no work pending */
if (!eop_desc) // 如果没有工作待处理，则退出循环
break;
/* prevent any other reads prior to eop_desc */
read_barrier_depends(); // 确保 eop_desc 的读取不会乱序
/* if DD is not set pending work has not been completed */
if (!(eop_desc->wb.status & cpu_to_le32(E1000_TXD_STAT_DD))) // 如果 DD 位未设置，表示工作未完成
break;
/* clear next_to_watch to prevent false hangs */
tx_buffer->next_to_watch = NULL; // 清除 next_to_watch 以避免假挂起
/* update the statistics for this packet */
total_bytes += tx_buffer->bytecount; // 更新发送的总字节数
total_packets += tx_buffer->gso_segs; // 更新发送的总数据包数
//释放skb
napi_consume_skb(tx_buffer->skb, napi_budget);
/* unmap skb header data */
dma_unmap_single(tx_ring->dev, // 取消映射 skb 头部数据
dma_unmap_addr(tx_buffer, dma),
dma_unmap_len(tx_buffer, len),
DMA_TO_DEVICE);
/* clear tx_buffer data */
dma_unmap_len_set(tx_buffer, len, 0); // 清除 tx_buffer 数据
/* clear last DMA location and unmap remaining buffers */
while (tx_desc != eop_desc) { // 清除剩余的 DMA 映射
tx_buffer++;
tx_desc++;
i++;
if (unlikely(!i)) {
i -= tx_ring->count;
tx_buffer = tx_ring->tx_buffer_info;
tx_desc = IGB_TX_DESC(tx_ring, 0);
}
/* unmap any remaining paged data */
if (dma_unmap_len(tx_buffer, len)) {
dma_unmap_page(tx_ring->dev,
dma_unmap_addr(tx_buffer, dma),
dma_unmap_len(tx_buffer, len),
DMA_TO_DEVICE);
dma_unmap_len_set(tx_buffer, len, 0);
}
}
/* move us one more past the eop_desc for start of next pkt */
tx_buffer++; // 移动到下一个数据包
tx_desc++;
i++;
if (unlikely(!i)) {
i -= tx_ring->count;
tx_buffer = tx_ring->tx_buffer_info;
tx_desc = IGB_TX_DESC(tx_ring, 0);
}
/* issue prefetch for next Tx descriptor */
prefetch(tx_desc); // 预取下一个 Tx 描述符
/* update budget accounting */
budget--; // 更新预算
} while (likely(budget)); // 如果预算还有剩余，继续处理
netdev_tx_completed_queue(txring_txq(tx_ring), // 更新网络设备的完成统计
total_packets, total_bytes);
i += tx_ring->count; // 调整索引
tx_ring->next_to_clean = i; // 设置新的清理位置
u64_stats_update_begin(&tx_ring->tx_syncp); // 开始更新统计信息
tx_ring->tx_stats.bytes += total_bytes; // 更新发送的总字节数
tx_ring->tx_stats.packets += total_packets; // 更新发送的总数据包数
u64_stats_update_end(&tx_ring->tx_syncp); // 结束更新统计信息
q_vector->tx.total_bytes += total_bytes; // 更新 q_vector 的总字节数
q_vector->tx.total_packets += total_packets; // 更新 q_vector 的总数据包数
...
}