前言：在Linux网络编程中，网络包接收指的是主机从网络上接收到一个数据包。它可以是来自其他计算机或设备发送的数据包，也可以是回环地址（localhost）上本地发送的数据包。
当一个网络包被接收时，它经过了多个层次的处理：
- 首先，在物理层，网卡会检测到数据包，并将其传递给操作系统内核。
- 然后，在网络协议栈中，内核会对数据包进行解析和处理。它可能会检查目标IP地址、端口号等信息，并根据规则进行路由、过滤或转发操作。
- 最终，当数据包成功被接收并处理后，应用程序可以通过读取套接字（socket）来获取其中的数据内容。通过监听和接收网络包，我们可以实现各种功能，如实时通信、网络监控、报文分析等。
-----------------------------零声白金卡限时活动---------------------------------
我自己学C++，填了一个坑又一个坑，深知新手学习C/C++的重要性和疑难问题，因此特地给C/C++开发的同学精心准备了一份优惠优质学习卡——零声白金卡（https://xxetb.xet.tech/s/3wrN44购买地址），6个项目分别是：基础架构-KV存储项目、spdk文件系统实现项目、Linux内核内存管理实战案例分析、golang云原生、FFmpeg+SDL播放器开发实站QtMP3音乐播放器搜索引擎实战，提供项目源码下载，同时这份资料也包括 C/C++学习路线、简历指导和求职技巧等。
一、网卡接收
当网络包到达网卡时，网卡会将数据包存储到接收缓冲区中。网卡通常使用DMA（Direct Memory Access）来直接将数据复制到主内存，减少CPU的参与。
网卡本身是有内存的，每个网卡一般都有4K以上的内存，用来发送，接收数据。
数据在从主内存搬到网卡之后，不是立即就能被发送出去的，而是要先在网卡自身的内存中排队，再按照先后顺序发送；同样的，数据从以太网传递到网卡时，网卡也是先把数据存储到自身的内存中，等到收到一帧数据了，再经过中断的方式，告诉主CPU（不是网卡本身的微处理器）把网卡内存的数据读走，而读走后的内存，又被清空，再次被使用，用来接收新的数据，如此循环往复。
而网卡本身的内存，又多是按照256字节为1页的方式，把所有内存分页，之后把这些页组成队列，大致的结构如图：
蓝色部分为发送数据用的页面总和，总共只有6个页面用于发送数据（40h~45h）；剩余的46h~80h都是接收数据用的，而在接收数据内存中，只有红色部分是有数据的，当接收新的数据时，是向红色部分前面的绿色中的256字节写入数据，同时“把当前指针”移动到+256字节的后面（网卡自动完成），而现在要读的数据，是在“边界指针”那里开始的256字节（紫色部分），下一个要读的数据，是在“下一包指针”的位置开始的256字节，当256字节被读出来了，就变成了重新可以使用的内存，即绿色所表示，而接收数据，就是把可用的内存拿来用，即变成了红色，当数据写到了0x80h后，又从0x46h开始写数据，这样循环，如果数据满了，则网卡就不能再接收数据，必须等待数据被读出去了，才能再继续接收。
下面是一些网卡常用的寄存器：
- CR(command register)---命令寄存器
- TSR(transmit state register)---发送状态寄存器
- ISR(interrupt state register)----中断状态寄存器
- RSR(receive state register)---接收状态寄存器
- RCR(receive configure register)---接收配置寄存器
- TCR(transmit configure register)---发送配置寄存器
- DCR(data configure register)---数据配置寄存器
- IMR(interrupt mask register)---中断屏蔽寄存器
- NCR(non-coding region)---包发送期间碰撞次数
- FIFO(first in first out)
- CNTR0(counter register)--- 帧同步错总计数器
- CNTR1---CRC错总计数器
- CNTR2---丢包总计数器
- PAR0~5(physical address register)---本地MAC地址
- MAR0~7(multiple address register)---多播地址匹配
- PSTOP(page stop register)---结束页面寄存器
- PSTART(page start register)---开始页面寄存器
- BNRY(boundary register)----边界页寄存器
- CURR(current page register)---当前页面寄存器
- CLDA0,1(Current Local DMA Address)---当前本地DMA寄存器
- TPSR(Transmit page start register)---传送页面开始寄存器
- TBCR0,1(transmit byte counter register)---传送字节计数寄存器
- CRDA0,1(current remote DMA address)---当前远程DMA寄存器
- RSAR0,1(remote start address register)---远程DMA起始地址寄存器
- RBCR0,1(remote byte counter register)---远程字节计数寄存器
- BPAGE(BROM page register)---BROM页面寄存器
1.1框架
网络子系统中，在本文中我们关注的是驱动和内核的交互。也就是网卡收到数据包后怎么交给内核，内核收到数据包后怎么交给协议栈处理。
在内核中，网卡设备是被net_device结构体描述的。驱动需要通过net_device向内核注册一组操作网卡硬件的函数，这样内核便可以使用网卡了。而所有的数据包在内核空间都是使用sk_buff结构体来表示，所以将网卡硬件收到的数据转换成内核认可的skb_buff也是驱动的工作。
在这之后，还有两个结构体也发挥了非常重要的作用。一个是为struct softnet_data，另一个是struct napi_struct。为软中断的方式处理数据包提供了支持。
1.2初始化
一切的起源都是上电那一刻，当系统初始化完毕后，我们的系统就应该是可用的了。网络子模块的初始化也是在Linux启动经历两阶段的混沌boost自举后，进入的第一个C函数start_kernel。在这之前是Bootloader和Linux的故事，在这之后，便是Linux的单人秀了。
网络子设备初始化调用链：start_kernel->rest_init->kernel_init->kernel_init_freeable->do_basic_setup->do_initcalls->do_initcalls->net_dev_init。
上面调用关系中的kernel_init是一个内核子线程中调用的：
pid = kernel_thread(kernel_init, NULL, CLONE_FS);
然后再一个问题就是当进入do_initcalls后我们会发现画风突变：
static void __init do_initcalls(void) { int level; for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++) do_initcall_level(level); }
我是谁，我来自哪，我要到哪去。
如果do_initcalls还给了我们一丝看下去的希望，点开do_initcall_level可能就真的绝望了。
static void __init do_initcall_level(int level) { initcall_t *fn; strcpy(initcall_command_line, saved_command_line); parse_args(initcall_level_names[level], initcall_command_line, __start___param, __stop___param - __start___param, level, level, NULL, &repair_env_string); trace_initcall_level(initcall_level_names[level]); for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++) do_one_initcall(*fn); }
全局一个fn指针，实现调用全靠猜。反正我不管，我说调用了net_dev_init就是调用了。伟大的google告诉我只要被下面这些宏定义包裹的函数就会被do_one_initcall调用，用了什么黑科技，先不管：
#file：include/linux/init.h #define pure_initcall(fn) __define_initcall(fn, 0) #define core_initcall(fn) __define_initcall(fn, 1) #define core_initcall_sync(fn) __define_initcall(fn, 1s) #define postcore_initcall(fn) __define_initcall(fn, 2) #define postcore_initcall_sync(fn) __define_initcall(fn, 2s) #define arch_initcall(fn) __define_initcall(fn, 3) #define arch_initcall_sync(fn) __define_initcall(fn, 3s) #define subsys_initcall(fn) __define_initcall(fn, 4) #define subsys_initcall_sync(fn) __define_initcall(fn, 4s) #define fs_initcall(fn) __define_initcall(fn, 5) #define fs_initcall_sync(fn) __define_initcall(fn, 5s) #define rootfs_initcall(fn) __define_initcall(fn, rootfs) #define device_initcall(fn) __define_initcall(fn, 6) #define device_initcall_sync(fn) __define_initcall(fn, 6s) #define late_initcall(fn) __define_initcall(fn, 7) #define late_initcall_sync(fn) __define_initcall(fn, 7s)
在net_dev_init的定义下面，我们可以找到subsys_initcall(net_dev_init);。Ok，网络子系统的初始化入口已找到到。
static int __init net_dev_init(void) { int i, rc = -ENOMEM; BUG_ON(!dev_boot_phase); if (dev_proc_init()) goto out; if (netdev_kobject_init()) goto out; INIT_LIST_HEAD(&ptype_all); for (i = 0; i < PTYPE_HASH_SIZE; i++) INIT_LIST_HEAD(&ptype_base[i]); INIT_LIST_HEAD(&offload_base); if (register_pernet_subsys(&netdev_net_ops)) goto out; /* * Initialise the packet receive queues. */ for_each_possible_cpu(i) { struct work_struct *flush = per_cpu_ptr(&flush_works, i); struct softnet_data *sd = &per_cpu(softnet_data, i); INIT_WORK(flush, flush_backlog); skb_queue_head_init(&sd->input_pkt_queue); skb_queue_head_init(&sd->process_queue); #ifdef CONFIG_XFRM_OFFLOAD skb_queue_head_init(&sd->xfrm_backlog); #endif INIT_LIST_HEAD(&sd->poll_list); sd->output_queue_tailp = &sd->output_queue; #ifdef CONFIG_RPS sd->csd.func = rps_trigger_softirq; sd->csd.info = sd; sd->cpu = i; #endif sd->backlog.poll = process_backlog; sd->backlog.weight = weight_p; } dev_boot_phase = 0; /* The loopback device is special if any other network devices * is present in a network namespace the loopback device must * be present. Since we now dynamically allocate and free the * loopback device ensure this invariant is maintained by * keeping the loopback device as the first device on the * list of network devices. Ensuring the loopback devices * is the first device that appears and the last network device * that disappears. */ if (register_pernet_device(&loopback_net_ops)) goto out; if (register_pernet_device(&default_device_ops)) goto out; open_softirq(NET_TX_SOFTIRQ, net_tx_action); open_softirq(NET_RX_SOFTIRQ, net_rx_action); rc = cpuhp_setup_state_nocalls(CPUHP_NET_DEV_DEAD, "net/dev:dead", NULL, dev_cpu_dead); WARN_ON(rc < 0); rc = 0; out: return rc; }
在net_dev_init中，初始化了内核收发包队列，开启了对应的软中断NET_TX_SOFTIRQ和NET_RX_SOFTIRQ。在其中，该函数为每个CPU初始化了一个softnet_data来挂载需要处理设备的napi_struct。这个结构非常重要，软中断的处理就是从这个链表上取napi_struct，然后收包的。这也是内核和驱动的接口之一。
再就是开启的两个软中断，当驱动在硬终端完成必要的上半部工作后，就会拉起对应的软中断。让数据包下半部软中断中处理。
net_dev_init执行完后，我们内核就有了处理数据包的能力，只要驱动能向softnet_data挂载需要收包设备的napi_struct。内核子线程ksoftirqd便会做后续的处理。接下来就是网卡驱动的初始化了。
各种网卡肯定有不同的驱动，各驱动封装各自硬件的差异，给内核提供一个统一的接口。我们这不关心，网卡驱动是怎么把数据发出去的，如何收回来的。而是探究网卡收到数据了，要怎么交给内核，内核如何将要发的数据给网卡。总之，驱动需要给内核提供哪些接口，内核又需要给网卡哪些支持。我们以e1000网卡为例子。看看它和内核的缠绵故事。
e1000网卡是一块PCI设备。所以它首先得要让内核能通过PCI总线探测到，需要向内核注册一个pci_driver结构，PCI设备的使用是另一个话题，这里不会探究，我也不知道：
static struct pci_driver e1000_driver = { .name = e1000_driver_name, .id_table = e1000_pci_tbl, .probe = e1000_probe, .remove = e1000_remove, #ifdef CONFIG_PM /* Power Management Hooks */ .suspend = e1000_suspend, .resume = e1000_resume, #endif .shutdown = e1000_shutdown, .err_handler = &e1000_err_handler };
其中e1000_probe就是给内核的探测回调函数，算是网卡的初始化函数吧，驱动需要在这里初始化网卡设备。去掉总线相关的代码，错误处理的代码，硬件相关的代码：
static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent) { struct net_device *netdev; netdev = alloc_etherdev(sizeof(struct e1000_adapter));//申请net_device设备 netdev->netdev_ops = &e1000_netdev_ops; //注册操作设备的回调函数 e1000_set_ethtool_ops(netdev); netdev->watchdog_timeo = 5 * HZ; netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);//软中断里会调用poll钩子函数 strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1); err = register_netdev(netdev); }
每一个网络设备都有一个对应的net_devie结构体来描述。其中像设备文件操作一样，保存了一种操作设备的接口函数netdev_ops，对e1000网卡是e1000_netdev_ops。当通过终端输入ifup，ifdowm命令操作网卡时，对应的open，close函数就会被调用。这段代码最重要的还是netif_napi_add的调用，它向内核注册了e1000_clean函数，用来给上面的CPU收包队列调用。
通过初始化，驱动注册了网卡描述net_device, 内核可以通过它操作到网卡设备。通过e1000_clean函数内核软中断也可以收包了。
1.3驱动收包
前面有一个内核软中断来收包，但这个软中断怎么触发呢？硬中断。当有数据到网卡时，会产生一个硬中断。这中断的注册是上面，e1000_netdev_ops中的e1000_up函数调用的。也就是网卡up时会注册这个硬中断处理函数e1000_intr。
/** * e1000_intr - Interrupt Handler * @irq: interrupt number * @data: pointer to a network interface device structure **/ static irqreturn_t e1000_intr(int irq, void *data) { struct net_device *netdev = data; struct e1000_adapter *adapter = netdev_priv(netdev); struct e1000_hw *hw = &adapter->hw; u32 icr = er32(ICR); /* disable interrupts, without the synchronize_irq bit */ ew32(IMC, ~0); E1000_WRITE_FLUSH(); if (likely(napi_schedule_prep(&adapter->napi))) { adapter->total_tx_bytes = 0; adapter->total_tx_packets = 0; adapter->total_rx_bytes = 0; adapter->total_rx_packets = 0; __napi_schedule(&adapter->napi); } else { /* this really should not happen! if it does it is basically a * bug, but not a hard error, so enable ints and continue */ if (!test_bit(__E1000_DOWN, &adapter->flags)) e1000_irq_enable(adapter); } return IRQ_HANDLED; }
去掉unlikely的代码，其中通过if (likely(napi_schedule_prep(&adapter->napi)))测试，网卡设备自己的napi是否正在被CPU使用。没有就调用__napi_schedule将自己的napi挂载到CPU的softnet_data上。这样软中断的内核线程就能轮询到这个软中断。
/** * __napi_schedule - schedule for receive * @n: entry to schedule * * The entry's receive function will be scheduled to run. * Consider using __napi_schedule_irqoff() if hard irqs are masked. */ void __napi_schedule(struct napi_struct *n) { unsigned long flags; local_irq_save(flags); ____napi_schedule(this_cpu_ptr(&softnet_data), n); local_irq_restore(flags); } /* 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); //设置软中断标志位NET_RX_SOFTIRQ }
这里的softnet_data就是前面net_dev_init函数为每个CPU初始化的。到这里硬件中断就处理完了，但我们依然没有发现任何有关数据包的处理，只知道了有一个napi被挂载。这是因为硬件中断不能显然太长，的确不会去做数据的处理工作。这些都交给软中断的内核线程来处理的。
