深入理解Linux网络(一):内核如何接收网络包

news2024/11/13 15:25:08

深入理解Linux网络(一):内核如何接收网络包

  • 一、网络收包总览
  • 二、Linux启动
    • 1、创建 ksoftirqd 内核进程
    • 2、网络子系统初始化
    • 3、协议栈注册
    • 4、网卡初始化
      • NAPI
    • 5、启动网卡
  • 三、接收数据
    • 1、硬中断处理
    • 2、ksoftirqd 内核线程处理软中断
    • 3、网络协议栈处理
    • 4、IP 协议层处理

一、网络收包总览

在这里插入图片描述
网卡本身就是一个单片机装载了射频收发模块,任务就是不停地收发无线电波并解析为基带数据传输到总线,内核有通知就会去接收。

⽹络驱动会以 DMA 的⽅式把⽹卡上收到的帧写到内存⾥。再向 CPU 发起⼀个中断,以通知 CPU 有数据到达。当 CPU 收到中断请求后,会去调⽤⽹络驱动注册的中断处理函数。
⽹卡的中断处理函数发出软中断请求,并释放 CPU。
ksoftirqd 检测到有软中断请求到达,调⽤ poll 开始轮询收包,收到后交由各级协议栈处理。对于 udp 包来说,会被放到⽤户socket 的接收队列中。
在这里插入图片描述

二、Linux启动

内核在接收⽹卡数据包之前,需要提前创建好ksoftirqd内核线程,注册好各个协议对应的处理函数,初始化⽹卡设备⼦系统。

1、创建 ksoftirqd 内核进程

Linux 的软中断都是在专⻔的内核线程(ksoftirqd)中进⾏的。
关于解收包进程,该进程数量不是 1个,⽽是 N 个,其中 N 等于你的机器的核数。
系统初始化的时候在 kernel/smpboot.c中调⽤了 smpboot_register_percpu_thread, 该
函数进⼀步会执⾏到 spawn_ksoftirqd(位于kernel/softirq.c)来创建出 softirqd 进程。
在这里插入图片描述

//file: kernel/softirq.c
static struct smp_hotplug_thread softirq_threads = {
 .store = &ksoftirqd,
 .thread_should_run = ksoftirqd_should_run,
 .thread_fn = run_ksoftirqd,
 .thread_comm = "ksoftirqd/%u",
};

static __init int spawn_ksoftirqd(void)
{
 register_cpu_notifier(&cpu_nfb);
 BUG_ON(smpboot_register_percpu_thread(&softirq_threads));
 return 0;
}
early_initcall(spawn_ksoftirqd);

当 ksoftirqd 被创建出来以后,它就会进⼊⾃⼰的线程循环函数 ksoftirqd_should_run和
run_ksoftirqd 了。不停地判断有没有软中断需要被处理。
注意:软中断不止有网络软中断。

//file: include/linux/interrupt.h
enum
{
 HI_SOFTIRQ=0,
 TIMER_SOFTIRQ,
 NET_TX_SOFTIRQ,
 NET_RX_SOFTIRQ,
 BLOCK_SOFTIRQ,
 BLOCK_IOPOLL_SOFTIRQ,
 TASKLET_SOFTIRQ,
 SCHED_SOFTIRQ,
 HRTIMER_SOFTIRQ,
 RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */
 NR_SOFTIRQS
};

2、网络子系统初始化

在这里插入图片描述
linux 内核通过调⽤ subsys_initcall 来初始化各个⼦系统,其中就有⽹络⼦系统
net_dev_init 函数。

//file: net/core/dev.c
static int __init net_dev_init(void)
{
 ......
 for_each_possible_cpu(i) {
   struct softnet_data *sd = &per_cpu(softnet_data, i);
   memset(sd, 0, sizeof(*sd));
   skb_queue_head_init(&sd->input_pkt_queue);
   skb_queue_head_init(&sd->process_queue);
   sd->completion_queue = NULL;
   INIT_LIST_HEAD(&sd->poll_list);
   ......
 }
 ......
 open_softirq(NET_TX_SOFTIRQ, net_tx_action);
 open_softirq(NET_RX_SOFTIRQ, net_rx_action);
}
subsys_initcall(net_dev_init);

这个函数为每个 CPU 都申请⼀个 softnet_data 数据结构,其中 poll_list 等待驱动程序将其 poll 函数注册进来。
NET_TX_SOFTIRQ 的处理函数为 net_tx_action,NET_RX_SOFTIRQ 的为 net_rx_action。
open_softirq 的注册的⽅式记录在 softirq_vec 变量中。后⾯ ksoftirqd 线程收到软中断的时候,会⽤这个变量来找到每⼀种软中断对应的处理函数。

//file: kernel/softirq.c
void open_softirq(int nr, void (*action)(struct softirq_action*))
{
 softirq_vec[nr].action = action;
}

3、协议栈注册

IP协议的实现函数是 ip_rcv()
TCP协议的实现函数是 tcp_rcv()
UDP协议的实现函数是 udp_rcv()
Linux 内核中的 fs_initcall 和 subsys_initcall 类似,都是初始化模块的⼊⼝。 fs_initcall 调⽤ inet_init 后开始⽹络协议栈注册。inet_init 将这些函数注册到了 inet_protos 和 ptype_base 数据结构中。
在这里插入图片描述

//file: net/ipv4/af_inet.c
static struct packet_type ip_packet_type __read_mostly = {
 .type = cpu_to_be16(ETH_P_IP),
 .func = ip_rcv,
};
static const struct net_protocol udp_protocol = {
 .handler = udp_rcv,
 .err_handler = udp_err,
 .no_policy = 1,
 .netns_ok = 1,
};
static const struct net_protocol tcp_protocol = {
 .early_demux = tcp_v4_early_demux,
 .handler = tcp_v4_rcv,
 .err_handler = tcp_v4_err,
 .no_policy = 1,
 .netns_ok = 1,
};
static int __init inet_init(void)
{
 ......
 if (inet_add_protocol(&icmp_protocol, IPPROTO_ICMP) < 0)
   pr_crit("%s: Cannot add ICMP protocol\n", __func__);
 if (inet_add_protocol(&udp_protocol, IPPROTO_UDP) < 0)
   pr_crit("%s: Cannot add UDP protocol\n", __func__);
 if (inet_add_protocol(&tcp_protocol, IPPROTO_TCP) < 0)
   pr_crit("%s: Cannot add TCP protocol\n", __func__);
 ......
 dev_add_pack(&ip_packet_type);
}

udp_protocol 结构体中的 handler 是 udp_rcv,tcp_protocol 结构体中的 handler 是tcp_v4_rcv,通过 inet_add_protocol 被初始化了进来。

int inet_add_protocol(const struct net_protocol *prot, unsigned char protocol)
{
 if (!prot->netns_ok) {
   pr_err("Protocol %u is not namespace aware, cannot register.\n", protocol);
   return -EINVAL;
 }
 return !cmpxchg((const struct net_protocol **)&inet_protos[protocol], NULL, prot) ? 0 : -1;
}

inet_add_protocol 函数将 tcp 和 udp 对应的处理函数都注册到了 inet_protos 数组中了。再看 dev_add_pack(&ip_packet_type); 这⼀⾏,ip_packet_type 结构体中的 type 是协议名,func 是 ip_rcv 函数,在dev_add_pack 中会被注册到 ptype_base 哈希表中。

//file: net/core/dev.c
void dev_add_pack(struct packet_type *pt)
{
 struct list_head *head = ptype_head(pt);
 ......
}
static inline struct list_head *ptype_head(const struct packet_type *pt)
{
 if (pt->type == htons(ETH_P_ALL))
   return &ptype_all;
 else
   return &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK];
}

inet_protos 记录着 udp,tcp 的处理函数地址,ptype_base 存储着 ip_rcv() 函数的处理地址。
后⾯我们会看到软中断中会通过 ptype_base 找到 ip_rcv 函数地址,进⽽将 ip 包正确地送到 ip_rcv() 中执⾏。在 ip_rcv 中将会通过 inet_protos 找到 tcp 或者 udp 的处理函数,再⽽把包转发给 udp_rcv() 或 tcp_v4_rcv() 函数。

注意:如果看⼀下 ip_rcv 和 udp_rcv 等函数的代码能看到很多协议的处理过程。
例如,ip_rcv 中会处理 netfilter 和 iptable 过滤,如果你有很多或者很复杂的 netfilter 或 iptables 规则,这些规则都是在软中断的上下⽂中执⾏的,会加⼤⽹络延迟
再例如,udp_rcv 中会判断 socket 接收队列是否满了。对应的相关内核参数是
net.core.rmem_max 和net.core.rmem_default。
建议好好研究 inet_init 这个函数的代码

4、网卡初始化

注意:先说好一件事,每个驱动的具体实现都不一样,这部分知道个原理即可。
每⼀个驱动程序(不仅仅只是⽹卡驱动)会使⽤ module_init 向内核注册⼀个初始化函数,当驱动被加载时,内核会调⽤这个函数。
例如 igb ⽹卡驱动的代码位于:drivers/net/ethernet/intel/igb/igb_main.c

//file: drivers/net/ethernet/intel/igb/igb_main.c
static struct pci_driver igb_driver = {
 .name = igb_driver_name,
 .id_table = igb_pci_tbl,
 .probe = igb_probe,
 .remove = igb_remove,
 ......
};
static int __init igb_init_module(void)
{
 ......
 ret = pci_register_driver(&igb_driver);
 return ret;
}

驱动的 pci_register_driver 调⽤完成后,Linux 内核就知道了该驱动的相关信息,⽐如 igb ⽹卡驱动的 igb_driver_name 和 igb_probe 函数地址等等(这些函数地址都在该驱动的结构体中)。
当⽹卡设备被识别以后,内核会调⽤其驱动的 probe ⽅法(igb_driver 的 probe ⽅法是 igb_probe)。
驱动 probe ⽅法执⾏的⽬的就是让设备 ready ,对于 igb ⽹卡,其 igb_probe 位于 drivers/net/ethernet/intel/igb/igb_main.c 下。主要执⾏的操作如下:
在这里插入图片描述
igb ⽹卡驱动实现了 ethtool 所需要的接⼝,也在这⾥注册完成函数地址的注册。
当 ethtool 发起⼀个系统调⽤之后,内核会找到对应操作的回调函数。对于 igb ⽹卡来说,其实现函数都在 drivers/net/ethernet/intel/igb/igb_ethtool.c 下。网卡驱动中提供了能让 ethtool 查看⽹卡收发包统计、能修改⽹卡⾃适应模式、能调整 RX 队列的数量和⼤⼩等功能的接口。

第6步注册的 igb_netdev_ops 中包含的是 igb_open 等函数,该函数在⽹卡被启动的时候会被调⽤。

//file: 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,
 .ndo_change_mtu = igb_change_mtu,
 .ndo_do_ioctl = igb_ioctl,......

NAPI

第 7 步中,在 igb_probe 初始化过程中,还调⽤到了 igb_alloc_q_vector 。igb_alloc_q_vector 注册了⼀个 NAPI 机制所必须的 poll 函数,对于 igb ⽹卡驱动来说,这个函数就是 igb_poll ,如下代码所示。

static int igb_alloc_q_vector(struct igb_adapter *adapter,
 int v_count, int v_idx,
 int txr_count, int txr_idx,
 int rxr_count, int rxr_idx)
{
 ......
 /* initialize NAPI */
 netif_napi_add(adapter->netdev, &q_vector->napi, igb_poll, 64);
}

5、启动网卡

之前⾯⽹卡驱动初始化时,我们提到了驱动向内核注册了 structure net_device_ops 变量,它包含着⽹卡启⽤、发包、设置 mac 地址等回调函数(函数指针)。当启⽤⼀个⽹卡时(例如,通过 ifconfig eth0 up),net_device_ops 中的 igb_open ⽅法会被调⽤。它通常会做以下事情:
在这里插入图片描述
NAPI 的机制非常重要!!!

//file: drivers/net/ethernet/intel/igb/igb_main.c
static int __igb_open(struct net_device *netdev, bool resuming)
{
 /* allocate transmit descriptors */
 err = igb_setup_all_tx_resources(adapter);
 /* allocate receive descriptors */
 err = igb_setup_all_rx_resources(adapter);
 
 /* 注册中断处理函数 */
 err = igb_request_irq(adapter);
 if (err)
   goto err_req_irq;
 /* 启⽤NAPI */
 for (i = 0; i < adapter->num_q_vectors; i++)
   napi_enable(&(adapter->q_vector[i]->napi));
 ......
}

在上⾯ __igb_open 函数调⽤了 igb_setup_all_tx_resources ,和 igb_setup_all_rx_resources。在 igb_setup_all_rx_resources 这⼀步操作中,分配了 RingBuffer,并建⽴内存和Rx队列的映射关系。(Rx Tx 队列的数量和⼤⼩可以通过 ethtool 进⾏配置)。我们再接着看中断函数注册 igb_request_irq :

static int igb_request_irq(struct igb_adapter *adapter)
{
 if (adapter->msix_entries) {
   err = igb_request_msix(adapter);
 if (!err)
   goto request_done;
 ......
 }
}
static int igb_request_msix(struct igb_adapter *adapter)
{
 ......
 for (i = 0; i < adapter->num_q_vectors; i++) {
   ...
   err = request_irq(adapter->msix_entries[vector].vector, igb_msix_ring, 0, q_vector->name,
 }

在上⾯的代码中跟踪函数调⽤, __igb_open => igb_request_irq => igb_request_msix , 在 igb_request_msix 中我们看到了,对于多队列的⽹卡,为每⼀个队列都注册了中断,其对应的中断处理函数是 igb_msix_ring(该函数也在 drivers/net/ethernet/intel/igb/igb_main.c 下)。 我们也可以看到,msix ⽅式下,每个 RX 队列有独⽴的 MSI-X 中断,从⽹卡硬件中断的层⾯就可以设置让收到的包被不同的 CPU 处理。(可以通过 irqbalance ,或者修改 /proc/irq/IRQ_NUMBER/smp_affinity 能够修改和 CPU 的绑定⾏为)。
当做好以上准备⼯作后金额可以接收数据包了!

三、接收数据

1、硬中断处理

⾸先当数据帧从⽹线到达⽹卡上的时候,第⼀站是⽹卡的接收队列。⽹卡在分配给⾃⼰的 RingBuffer 中寻找可⽤的内存位置,找到后 DMA 引擎会把数据 DMA 到⽹卡之前关联的内存⾥,这个时候 CPU 都是⽆感的。当 DMA 操作完成以后,⽹卡会向 CPU 发起⼀个硬中断,通知 CPU 有数据到达。
在这里插入图片描述
注意:当RingBuffer满的时候,新来的数据包将给丢弃。
ifconfig查看⽹卡的时候,可以⾥⾯有个overruns,表示因为环形队列满被丢弃的包。如果发现有丢包,可能需要通过 ethtool命令来加⼤环形队列的⻓度。

⽹卡的硬中断注册的处理函数是igb_msix_ring:

//file: drivers/net/ethernet/intel/igb/igb_main.c
static irqreturn_t igb_msix_ring(int irq, void *data)
{
 struct igb_q_vector *q_vector = data;
 /* Write the ITR value calculated from the previous interrupt. */
 igb_write_itr(q_vector);
 napi_schedule(&q_vector->napi);
 return IRQ_HANDLED;
}

igb_write_itr 只是记录⼀下硬件中断频率(据说⽬的是在减少对 CPU 的中断频率时⽤到)。顺着 napi_schedule 调⽤⼀路跟踪下去, __napi_schedule => ____napi_schedule:

/* Called with irq disabled */
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);
}

这⾥我们看到, list_add_tail 修改了 CPU 变量 softnet_data ⾥的 poll_list ,将驱动 napi_struct 传过来的 poll_list 添加了进来。
其中 softnet_data 中的 poll_list 是⼀个双向列表,其中的设备都带有输⼊帧等着被处理。紧接着 __raise_softirq_irqoff 触发了⼀个软中断 NET_RX_SOFTIRQ, 这个所谓的触发过程只是对⼀个变量进⾏了⼀次或运算⽽已。

void __raise_softirq_irqoff(unsigned int nr)
{
 trace_softirq_raise(nr);
 or_softirq_pending(1UL << nr);
}

Linux 在硬中断⾥只完成简单必要的⼯作,剩下的⼤部分的处理都是转交给软中断的。通过上⾯代码可以看到,硬中断处理过程真的是⾮常短。只是记录了⼀个寄存器,修改了⼀下下 CPU 的 poll_list,然后发出个软中断。就这么简单,硬中断⼯作就算是完成了。

2、ksoftirqd 内核线程处理软中断

在这里插入图片描述
内核线程初始化的时候,我们介绍了 ksoftirqd 中两个线程函数 ksoftirqd_should_run 和 run_ksoftirqd 。其中 ksoftirqd_should_run 代码如下:

static int ksoftirqd_should_run(unsigned int cpu)
{
 return local_softirq_pending();
}
#define local_softirq_pending() \
 __IRQ_STAT(smp_processor_id(), __softirq_pending)

这⾥看到和硬中断中调⽤了同⼀个函数 local_softirq_pending 。使⽤⽅式不同的是硬中断位置是为了写⼊标记,这⾥仅仅只是读取。如果硬中断中设置了 NET_RX_SOFTIRQ ,这⾥⾃然能读取的到。接下来会真正进⼊线程函数中 run_ksoftirqd 处理:

static void run_ksoftirqd(unsigned int cpu)
{
 local_irq_disable();
 if (local_softirq_pending()) {
   __do_softirq();
   rcu_note_context_switch(cpu);
   local_irq_enable();
   cond_resched();
   return;
 }
 local_irq_enable();
}

在 __do_softirq 中,判断根据当前 CPU 的软中断类型,调⽤其注册的 action ⽅法。

asmlinkage void __do_softirq(void)
{
 do {
   if (pending & 1) {
     unsigned int vec_nr = h - softirq_vec;
     int prev_count = preempt_count();
     ...
     trace_softirq_entry(vec_nr);
     h->action(h);
     trace_softirq_exit(vec_nr);
     ...
   }
   h++;
   pending >>= 1;
 } while (pending);
}

这⾥需要注意⼀个细节,硬中断中设置软中断标记,和 ksoftirq 的判断是否有软中断到达,都是基于 smp_processor_id() 的。这意味着只要硬中断在哪个 CPU 上被响应,那么软中断也是在这个 CPU 上处理的。所以说,如果你发现你的 Linux 软中断 CPU 消耗都集中在⼀个核上的话,做法是要把调整硬中断的 CPU 亲和性,来将硬中断打散到不同的 CPU 核上去。
我们再来把精⼒集中到这个核⼼函数 net_rx_action 上来。

//file:net/core/dev.c
static void net_rx_action(struct softirq_action *h)
{
 struct softnet_data *sd = &__get_cpu_var(softnet_data);
 unsigned long time_limit = jiffies + 2;
 int budget = netdev_budget;
 void *have;
 local_irq_disable();
 while (!list_empty(&sd->poll_list)) {
   ......
   n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list);
   work = 0;
   if (test_bit(NAPI_STATE_SCHED, &n->state)) {
     work = n->poll(n, weight);
     trace_napi_poll(n);
   }
 budget -= work;net_rx_action
 }
}

注意:在硬中断中添加设备到 poll_list,会不会重复添加呢?答案是不会的,在软中断处理函数 net_rx_action 这⾥⼀进来就调⽤ local_irq_disable 把所有的硬中断都给关了,不会让硬中断重复添加 poll_list 的机会。在硬中断的处理函数中本身也有类似的判断机制,打磨了⼏⼗年的内核考虑在细节考虑上还是很完善的。

函数开头的 time_limit 和 budget 是⽤来控制 net_rx_action 函数主动退出的,⽬的是保证⽹络包的接收不霸占 CPU 不放。 等下次⽹卡再有硬中断过来的时候再处理剩下的接收数据包。其中 budget 可以通过内核参数调整。 这个函数中剩下的核⼼逻辑是获取到当前 CPU 变量 softnet_data,对其 poll_list 进⾏遍历, 然后执⾏到⽹卡驱动注册到的 poll 函数。对于 igb ⽹卡来说,就是 igb 驱动⾥的 igb_poll 函数了。

/**
* igb_poll - NAPI Rx polling callback
* @napi: napi polling structure
* @budget: count of how many packets we should handle
**/
static int igb_poll(struct napi_struct *napi, int budget)
{
 ...
 if (q_vector->tx.ring)
   clean_complete = igb_clean_tx_irq(q_vector);
 if (q_vector->rx.ring)
   clean_complete &= igb_clean_rx_irq(q_vector, budget);
 ...
}

在读取操作中, igb_poll 的重点⼯作是对 igb_clean_rx_irq 的调⽤。

static bool igb_clean_rx_irq(struct igb_q_vector *q_vector, const int budget)
{
 ...
 do {
   /* retrieve a buffer from the ring */
   skb = igb_fetch_rx_buffer(rx_ring, rx_desc, skb);
   /* fetch next buffer in frame if non-eop */
   if (igb_is_non_eop(rx_ring, rx_desc))
     continue;
 }
 /* verify the packet layout is correct */
 if (igb_cleanup_headers(rx_ring, rx_desc, skb)) {
   skb = NULL;
   continue;
 }
 /* populate checksum, timestamp, VLAN, and protocol */
 igb_process_skb_fields(rx_ring, rx_desc, skb);
 napi_gro_receive(&q_vector->napi, skb);
}

igb_fetch_rx_buffer 和 igb_is_non_eop 的作⽤就是把数据帧从 RingBuffer 上取下来。
为什么需要两个函数呢?因为有可能帧要占多个 RingBuffer,所以是在⼀个循环中获取的,直到帧尾部。获取下来的⼀个数据帧⽤⼀个 sk_buff 来表示。收取完数据以后,对其进⾏⼀些校验,然后开始设置 sbk 变量的 timestamp, VLAN id, protocol 等字段。接下来进⼊到 napi_gro_receive 中:

//file: net/core/dev.c
gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb)
{
 skb_gro_reset_offset(skb);
 return napi_skb_finish(dev_gro_receive(napi, skb), skb);
}

dev_gro_receive 这个函数代表的是⽹卡 GRO 特性,可以简单理解成把相关的⼩包合并成⼀个⼤包就⾏,⽬的是减少传送给⽹络栈的包数,这有助于减少 CPU 的使⽤量。我们暂且忽略,直接看 napi_skb_finish , 这个函数主要就是调⽤了 netif_receive_skb 。

//file: net/core/dev.c
static gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff *skb)
{
 switch (ret) {
   case GRO_NORMAL:
     if (netif_receive_skb(skb))
       ret = GRO_DROP;
       break;
 ......
}

在 netif_receive_skb 中,数据包将被送到协议栈中。

3、网络协议栈处理

netif_receive_skb 函数会根据包的协议,假如是 udp 包,会将包依次送到 ip_rcv(),udp_rcv() 协议处理函数中进⾏处理。
在这里插入图片描述

//file: net/core/dev.c
int netif_receive_skb(struct sk_buff *skb)
{
 //RPS处理逻辑,先忽略
 ......
 return __netif_receive_skb(skb);
}
static int __netif_receive_skb(struct sk_buff *skb)
{
 ...... 
 ret = __netif_receive_skb_core(skb, false);
}
static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc)
{
 ......
 //pcap逻辑,这⾥会将数据送⼊抓包点。tcpdump就是从这个⼊⼝获取包的
 list_for_each_entry_rcu(ptype, &ptype_all, list) {
   if (!ptype->dev || ptype->dev == skb->dev) {
     if (pt_prev)
     ret = deliver_skb(skb, pt_prev, orig_dev);
     pt_prev = ptype;
   }
 }
 ......
 list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) {
   if (ptype->type == type && (ptype->dev == null_or_dev || ptype->dev == skb->dev || ptype->dev == orig_dev)) {
     if (pt_prev)
       ret = deliver_skb(skb, pt_prev, orig_dev);
       pt_prev = ptype;
     }
 }
}

在 __netif_receive_skb_core 中就有 tcpdump 的抓包点。接着 __netif_receive_skb_core 取出
protocol,它会从数据包中取出协议信息,然后遍历注册在这个协议上的回调函数列表。 ptype_base 是⼀个 hash table,在协议注册⼩节我们提到过。ip_rcv 函数地址就是存在这个 hash table 中的。

//file: net/core/dev.c
static inline int deliver_skb(struct sk_buff *skb,
 struct packet_type *pt_prev,
 struct net_device *orig_dev)
{
 ......
 return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
}

pt_prev->func 这⼀⾏就调⽤到了协议层注册的处理函数了。对于 ip 包来讲,就会进⼊到 ip_rcv (如果是arp包的话,会进⼊到arp_rcv)。

4、IP 协议层处理

我们再来⼤致看⼀下 linux 在 ip 协议层都做了什么,包⼜是怎么样进⼀步被送到 udp 或 tcp 协议处理函数中的。

//file: net/ipv4/ip_input.c
int ip_rcv(struct sk_buff *skb, struct net_device *dev, struct
  packet_type *pt, struct net_device *orig_dev)
{
 ......
 return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING, skb, dev, NULL, ip_rcv_finish);
}

这⾥ NF_HOOK 是⼀个钩⼦函数,当执⾏完注册的钩⼦后就会执⾏到最后⼀个参数指向的函数 ip_rcv_finish 。

static int ip_rcv_finish(struct sk_buff *skb)
{
 ......
 if (!skb_dst(skb)) {
   int err = ip_route_input_noref(skb, iph->daddr, iph->saddr, iph->tos, skb->dev);
   ...
 }
 ......
 return dst_input(skb);
}

跟踪 ip_route_input_noref 后看到它⼜调⽤了 ip_route_input_mc 。 在
ip_route_input_mc 中,函数 ip_local_deliver 被赋值给了 dst.input , 如下:

//file: net/ipv4/route.c
static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr, u8 tos, struct net_device *dev, int our)
{
 if (our) {
   rth->dst.input= ip_local_deliver;
   rth->rt_flags |= RTCF_LOCAL;
 }
}

所以回到 ip_rcv_finish 中的 return dst_input(skb) 。

/* Input packet from network to transport. */
static inline int dst_input(struct sk_buff *skb)
{
 return skb_dst(skb)->input(skb);
}

skb_dst(skb)->input 调⽤的 input ⽅法就是路由⼦系统赋的 ip_local_deliver。

//file: net/ipv4/ip_input.c
int ip_local_deliver(struct sk_buff *skb)
{
 /*
 * Reassemble IP fragments.
 */
 if (ip_is_fragment(ip_hdr(skb))) {
   if (ip_defrag(skb, IP_DEFRAG_LOCAL_DELIVER))
     return 0;
 }
 return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN, skb, skb->dev, NULL, ip_local_deliver_finish);
}

static int ip_local_deliver_finish(struct sk_buff *skb)
{
 ......
 int protocol = ip_hdr(skb)->protocol;
 const struct net_protocol *ipprot;
 ipprot = rcu_dereference(inet_protos[protocol]);
 if (ipprot != NULL) {
   ret = ipprot->handler(skb);
 }
}

如协议注册⼩节看到 inet_protos 中保存着 tcp_v4_rcv() 和 udp_rcv() 的函数地址。这⾥将会根据包中的协议类型选择进⾏分发,在这⾥ skb 包将会进⼀步被派送到更上层的协议中,udp 和 tcp。

整理回顾:

  1. ⽹卡将数据帧 DMA 到内存的 RingBuffer 中,然后向 CPU 发起中断通知
  2. CPU 响应中断请求,调⽤⽹卡启动时注册的中断处理函数
  3. 中断处理函数⼏乎没⼲啥,就发起了软中断请求
  4. 内核线程 ksoftirqd 线程发现有软中断请求到来,先关闭硬中断
  5. ksoftirqd 线程开始调⽤驱动的 poll 函数收包
  6. poll 函数将收到的包送到协议栈注册的 ip_rcv 函数中
  7. ip_rcv 函数再将包送到 udp_rcv 函数中(对于 tcp 包就送到 tcp_rcv )

最后,再次推荐一下飞哥的《深入理解Linux网络–修炼底层内功》,希望大家有所收获。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1941119.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

数据库基础与安装MYSQL数据库

一、数据库管理系统DBMS 数据库技术是计算机科学的核心技术之一&#xff0c;具有完备的理论基础。使用数据库可以高效且条理分明地存储数据&#xff0c;使人们能够更加迅速、方便地管理数据 1.可以结构化存储大量的数据信息&#xff0c;方便用户进行有效的检索和访问 2.可以…

24届电子信息应届硕士生秋招+春招心得与感悟

背景&#xff1a; 研二下学期在深圳某互联网独角兽公司实习过四个月 岗位为测试实习生 求职的方向为互联网-测试岗 24届电子信息硕士 24秋招&#xff08;2023.9-2023.12&#xff09; 其实早在7月份部分互联网公司和大厂已经开始提前批了&#xff0c;因为我不是科班出身&…

Step-DPO 论文——数学大语言模型理解

论文题目&#xff1a;STEP-DPO: STEP-WISE PREFERENCE OPTIMIZATION FOR LONG-CHAIN REASONING OF LLMS 翻译为中文就是&#xff1a;“LLMs长链推理的逐步偏好优化” 论文由港中文贾佳亚团队推出&#xff0c;基于推理步骤的大模型优化策略&#xff0c;能够像老师教学生一样优…

【BUG】已解决:requests.exceptions.ProxyError: HTTPSConnectionPool

已解决&#xff1a;requests.exceptions.ProxyError: HTTPSConnectionPool 目录 已解决&#xff1a;requests.exceptions.ProxyError: HTTPSConnectionPool 【常见模块错误】 原因分析 解决方案 欢迎来到英杰社区https://bbs.csdn.net/topics/617804998 欢迎来到我的主页&am…

OCC 创建方管(拉伸操作)

目录 一、OCC 拉伸操作 二、例子 1、使BRepBuilderAPI_MakeFace 2、使用BRepPrimAPI_MakeRevol 3、垂直路径扫掠 一、OCC 拉伸操作 BRepPrimAPI_MakeSweep Class Reference - Open CASCADE Technology Documentation OCC提供几种图形的构建是由基本图形的旋转&#xff0c;…

使用Python快速比较和替换键值对

问题背景 您需要在多个文件中替换所有特定字符串的实例。例如&#xff0c;您有一个包含 60728 个键值对的映射词典&#xff0c;需要处理多达 50 个文件&#xff0c;每个文件大约有 250000 行&#xff0c;并且需要在每行中替换多个键。 解决方案 方法一&#xff1a;使用正则表…

【区块链 + 智慧政务】山东荣成:区块链政务诚信管理系统 | FISCO BCOS应用案例

2018 年 9 月&#xff0c;荣成市政府与山东观海数据技术有限公司合作&#xff0c;基于 FISCO BCOS 区块链技术推动智慧城市建设&#xff0c; 其中&#xff0c;信用管理是智慧城市核心之一。 荣成市区块链政务诚信管理系统&#xff0c;建设信用信息征集、评价、披露和应用于一体…

CloudCampus的三种部署模式

CloudCampus的三种部署模式 本地部署 客户购买控制器 自己运营 软件永久license sns &#xff0c;将软件补丁、软件升级&#xff08;含升级版本的新特性&#xff09;、远程支持等打包在一起组成SnS年费 msp自建云部署 msp 购买控制器 msp运营 …

美业SaaS门店收银系统怎么管理订单?博弈美业系统App实操|美业系统Java源码

- 打开博弈美业 - 首页点击订单管理 - 选择想查询的相应订单即可 美业门店管理系统Java源码、美业店务系统演示视频请私信

HTTP协议详解:从零开始的Web通信之旅

文章目录 一、引言&#xff1a;Web通信的基石 - HTTP协议二、HTTP请求方法2.1 OPTIONS2.2 HEAD2.3 GET2.4 POST2.5 PUT2.6 DELETE2.7 TRACE2.8 CONNECT2.9 注意 三、HTTP工作原理四、HTTP 请求/响应流程4.1、客户端连接到web服务器4.2、发送HTTP请求4.3、服务器接受请求并返回H…

【C++】学习笔记——红黑树

文章目录 十七、红黑树1.红黑树的概念红黑树的性质 2.红黑树节点的定义3.红黑树的插入4.红黑树的验证5.完整代码结果演示6.红黑树与AVL树的比较 未完待续 十七、红黑树 1.红黑树的概念 红黑树&#xff0c;是一种二叉搜索树&#xff0c;但在每个结点上增加一个存储位表示结点的…

XXL-JOB 定时任务在AI大模型中的应用

目录 1. 应用场景 2. 部署 XXL-JOB 3. SpringBoot 集成 XXL-JOB 定时任务代码示例 3.1 添加依赖 3.2 添加配置 3.3 添加执行器到Ioc容器 3.4 添加定时任务 3.5 控制台新增执行器 3.6 控制台添加任务 3.7 控制台开启任务 1. 应用场景 AI 大模型的调用往往是一个高资源…

在 Linux 系统上安装 GCC 编译器(不同发行版)

GCC&#xff08;GNU Compiler Collection&#xff09;是一个功能强大的开源编译器&#xff0c;支持多种编程语言&#xff0c;如 C、C、Fortran 等。在这篇博客中&#xff0c;我们将介绍如何在不同的 Linux 发行版上安装 GCC 编译器。 一、在 Ubuntu 上安装 GCC 1. 更新软件包…

numpy(史上最全)

目录 numpy简介 性能对比 ndarray属性 numpy中的数组&#xff1a; 几个创建的函数&#xff1a; 1) np.ones(shape, dtypeNone, orderC) shape: 形状&#xff0c;使用元组表示 2) np.zeros(shape, dtypefloat, orderC) 3) np.full(shape, fill_value, dtypeNone, orderC)…

阿里国际站运营工具 :一键提升你的全球竞争力!

在当今全球化的商业环境中&#xff0c;阿里巴巴国际站作为全球知名的B2B电子商务平台&#xff0c;为无数企业提供了一个展示产品、拓展国际市场的重要渠道。随着越来越多的企业加入到这个平台&#xff0c;如何在激烈的竞争中脱颖而出&#xff0c;成为了每个外贸人员必须面对的挑…

【BUG】已解决:ModuleNotFoundError: No module named ‘requests‘

ModuleNotFoundError: No module named ‘requests‘ 目录 ModuleNotFoundError: No module named ‘requests‘ 【常见模块错误】 【解决方案】 欢迎来到英杰社区https://bbs.csdn.net/topics/617804998 欢迎来到我的主页&#xff0c;我是博主英杰&#xff0c;211科班出身&a…

java-selenium 截取界面验证码图片并对图片文本进行识别

参考链接 1、需要下载Tesseract工具并配置环境变量&#xff0c;步骤如下 Tesseract-OCR 下载安装和使用_tesseract-ocr下载-CSDN博客 2、需要在IDEA中导入tess4j 包&#xff1b;在pom.xml文件中输入如下内容 <!--导入Tesseract 用于识别验证码--><dependency>&l…

SpringSecurity通用权限管理系统

1、介绍 权限管理是所有后台系统都会涉及的一个重要组成部分&#xff0c;而权限管理的核心流程是相似的&#xff0c;如果每个后台单独开发一套权限管理系统&#xff0c;就是重复造轮子&#xff0c;是人力的极大浪费&#xff0c;本项目就是针对这个问题&#xff0c;提供了一套通…

堆的相关特点

一.建堆的两种方法 给定一个数组&#xff0c;其中数组里面的元素个数是n个如何能够把这个数组建立成为一个堆&#xff0c;今天探讨两种方法&#xff0c;分别是向上调整法和向下调整法&#xff0c;分别探讨他们的时间复杂度 向上调整法&#xff08;以小堆为例&#xff09; 回…

【好玩的经典游戏】Docker环境下部署赛车小游戏

【好玩的经典游戏】Docker环境下部署赛车小游戏 一、小游戏介绍1.1 小游戏简介1.2 项目预览二、本次实践介绍2.1 本地环境规划2.2 本次实践介绍三、本地环境检查3.1 安装Docker环境3.2 检查Docker服务状态3.3 检查Docker版本3.4 检查docker compose 版本四、构建容器镜像4.1 下…