网络数据包收发流程:从驱动到协议栈
一、硬件环境
intel82546:PHY与MAC集成在一起的PCI网卡芯片,很强大
bcm5461: PHY芯片,与之对应的MAC是TSEC
TSEC: Three Speed Ethernet Controller,三速以太网控制器,PowerPc 架构CPU里面的MAC模块
注意,TSEC内部有DMA子模块
话说现在的CPU越来越牛叉了,什么功能都往里面加,最常见的如MAC功能。
TSEC只是MAC功能模块的一种,其他架构的cpu也有和TSEC类似的MAC功能模块。
这些集成到CPU芯片上的功能模块有个学名,叫平台设备,即 platform device。
二、网络收包原理
网络驱动收包大致有3种情况:
no NAPI:mac每收到一个以太网包,都会产生一个接收中断给cpu,即完全靠中断方式来收包
缺点是当网络流量很大时,cpu大部分时间都耗在了处理mac的中断。
netpoll:在网络和I/O子系统尚不能完整可用时,模拟了来自指定设备的中断,即轮询收包。
缺点是实时性差
NAPI: 采用 中断 + 轮询 的方式:mac收到一个包来后会产生接收中断,但是马上关闭。
直到收够了netdev_max_backlog个包(默认300),或者收完mac上所有包后,才再打开接收中断
通过sysctl来修改 net.core.netdev_max_backlog
或者通过proc修改 /proc/sys/net/core/netdev_max_backlog
下面只写内核配置成使用NAPI的情况,只写TSEC驱动。(非NAPI的情况和PCI网卡驱动 以后再说)
内核版本 linux 2.6.24
三、NAPI 相关数据结构
每个网络设备(MAC层)都有自己的net_device数据结构,这个结构上有napi_struct。
每当收到数据包时,网络设备驱动会把自己的napi_struct挂到CPU私有变量上。
这样在软中断时,net_rx_action会遍历cpu私有变量的poll_list,
执行上面所挂的napi_struct结构的poll钩子函数,将数据包从驱动传到网络协议栈。
四、内核启动时的准备工作
4.1 初始化网络相关的全局数据结构,并挂载处理网络相关软中断的钩子函数
start_kernel()
--> rest_init()
--> do_basic_setup()
--> do_initcall
-->net_dev_init
__init net_dev_init()
{
//每个CPU都有一个CPU私有变量 _get_cpu_var(softnet_data)
//_get_cpu_var(softnet_data).poll_list很重要,软中断中需要遍历它的
for_each_possible_cpu(i) {
struct softnet_data *queue;
queue = &per_cpu(softnet_data, i);
skb_queue_head_init(&queue->input_pkt_queue);
queue->completion_queue = NULL;
INIT_LIST_HEAD(&queue->poll_list);
queue->backlog.poll = process_backlog;
queue->backlog.weight = weight_p;
}
open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL); //在软中断上挂网络发送handler
open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL); //在软中断上挂网络接收handler
}
4.2 加载网络设备的驱动
NOTE:这里的网络设备是指MAC层的网络设备,即TSEC和PCI网卡(bcm5461是phy)
在网络设备驱动中创建net_device数据结构,并初始化其钩子函数 open(),close() 等
挂载TSEC的驱动的入口函数是 gfar_probe
// 平台设备 TSEC 的数据结构
static struct platform_driver gfar_driver = {
.probe = gfar_probe,
.remove = gfar_remove,
.driver = {
.name = "fsl-gianfar",
},
};
int gfar_probe(struct platform_device *pdev)
{
dev = alloc_etherdev(sizeof (*priv)); // 创建net_device数据结构
dev->open = gfar_enet_open;
dev->hard_start_xmit = gfar_start_xmit;
dev->tx_timeout = gfar_timeout;
dev->watchdog_timeo = TX_TIMEOUT;
#ifdef CONFIG_GFAR_NAPI
netif_napi_add(dev, &priv->napi,gfar_poll,GFAR_DEV_WEIGHT); //软中断里会调用poll钩子函数
#endif
#ifdef CONFIG_NET_POLL_CONTROLLER
dev->poll_controller = gfar_netpoll;
#endif
dev->stop = gfar_close;
dev->change_mtu = gfar_change_mtu;
dev->mtu = 1500;
dev->set_multicast_list = gfar_set_multi;
dev->set_mac_address = gfar_set_mac_address;
dev->ethtool_ops = &gfar_ethtool_ops;
}
五、启用网络设备
5.1 用户调用ifconfig等程序,然后通过ioctl系统调用进入内核
socket的ioctl()系统调用
--> sock_ioctl()
--> dev_ioctl() //判断SIOCSIFFLAGS
--> __dev_get_by_name(net, ifr->ifr_name) //根据名字选net_device
--> dev_change_flags() //判断IFF_UP
--> dev_open(net_device) //调用open钩子函数
对于TSEC来说,挂的钩子函数是 gfar_enet_open(net_device)
5.2 在网络设备的open钩子函数里,分配接收bd,挂中断ISR(包括rx、tx、err),对于TSEC来说
gfar_enet_open
--> 给Rx Tx Bd 分配一致性DMA内存
--> 把Rx Bd的“EA地址”赋给数据结构,物理地址赋给TSEC寄存器
--> 把Tx Bd的“EA地址”赋给数据结构,物理地址赋给TSEC寄存器
--> 给 tx_skbuff 指针数组 分配内存,并初始化为NULL
--> 给 rx_skbuff 指针数组 分配内存,并初始化为NULL
--> 初始化Tx Bd
--> 初始化Rx Bd,提前分配存储以太网包的skb,这里使用的是一次性dma映射
(注意:#define DEFAULT_RX_BUFFER_SIZE 1536保证了skb能存一个以太网包)
rxbdp = priv->rx_bd_base;
for (i = 0; i < priv->rx_ring_size; i++) {
struct sk_buff *skb = NULL;
rxbdp->status = 0;
//这里真正分配skb,并且初始化rxbpd->bufPtr, rxbdpd->length
skb = gfar_new_skb(dev, rxbdp);
priv->rx_skbuff[i] = skb;
rxbdp++;
}
rxbdp--;
rxbdp->status |= RXBD_WRAP; // 给最后一个bd设置标记WRAP标记
--> 注册TSEC相关的中断handler: 错误,接收,发送
request_irq(priv->interruptError, gfar_error, 0, "enet_error", dev)
request_irq(priv->interruptTransmit, gfar_transmit, 0, "enet_tx", dev)//包发送完
request_irq(priv->interruptReceive, gfar_receive, 0, "enet_rx", dev) //包接收完
-->gfar_start(net_device)
// 使能Rx、Tx
// 开启TSEC的 DMA 寄存器
// Mask 掉我们不关心的中断event
最终,TSEC相关的Bd等数据结构应该是下面这个样子的
六、中断里接收以太网包
TSEC的RX已经使能了,网络数据包进入内存的流程为:
网线 --> Rj45网口 --> MDI 差分线
--> bcm5461(PHY芯片进行数模转换) --> MII总线
--> TSEC的DMA Engine 会自动检查下一个可用的Rx bd
--> 把网络数据包 DMA 到 Rx bd 所指向的内存,即skb->data
接收到一个完整的以太网数据包后,TSEC会根据event mask触发一个 Rx 外部中断。
cpu保存现场,根据中断向量,开始执行外部中断处理函数do_IRQ()
do_IRQ 伪代码
{
上半部处理硬中断
查看中断源寄存器,得知是网络外设产生了外部中断
执行网络设备的rx中断handler(设备不同,函数不同,但流程类似,TSEC是gfar_receive)
1. mask 掉 rx event,再来数据包就不会产生rx中断
2. 给napi_struct.state加上 NAPI_STATE_SCHED 状态
3. 挂网络设备自己的napi_struct结构到cpu私有变量_get_cpu_var(softnet_data).poll_list
4. 触发网络接收软中断
下半部处理软中断
依次执行所有软中断handler,包括timer,tasklet等等
执行网络接收的软中断handler net_rx_action
1. 遍历cpu私有变量_get_cpu_var(softnet_data).poll_list
2. 取出poll_list上面挂的napi_struct 结构,执行钩子函数napi_struct.poll()
(设备不同,钩子函数不同,流程类似,TSEC是gfar_poll)
3. 若poll钩子函数处理完所有包,则打开rx event mask,再来数据包的话会产生rx中断
4. 调用napi_complete(napi_struct *n)
把napi_struct 结构从_get_cpu_var(softnet_data).poll_list 上移走
同时去掉 napi_struct.state 的 NAPI_STATE_SCHED 状态
}
6.1 TSEC的接收中断处理函数
gfar_receive
{
#ifdef CONFIG_GFAR_NAPI
// test_and_set当前net_device的napi_struct.state 为 NAPI_STATE_SCHED
// 在软中断里调用 net_rx_action 会检查状态 napi_struct.state
if (netif_rx_schedule_prep(dev, &priv->napi)) {
tempval = gfar_read(&priv->regs->imask);
tempval &= IMASK_RX_DISABLED; //mask掉rx,不再产生rx中断
gfar_write(&priv->regs->imask, tempval);
// 将当前net_device的 napi_struct.poll_list 挂到
// CPU私有变量__get_cpu_var(softnet_data).poll_list 上,并触发软中断
// 所以,在软中断中调用 net_rx_action 的时候,就会执行当前net_device的
// napi_struct.poll()钩子函数,即 gfar_poll()
__netif_rx_schedule(dev, &priv->napi);
}
#else
gfar_clean_rx_ring(dev, priv->rx_ring_size);
#endif
}
6.2 网络接收软中断net_rx_action
net_rx_action()
{
struct list_head *list = &__get_cpu_var(softnet_data).poll_list;
//通过 napi_struct.poll_list, 将N多个 napi_struct 链接到一条链上
//通过 CPU私有变量,我们找到了链头,然后开始遍历这个链
int budget = netdev_budget; //这个值就是 net.core.netdev_max_backlog,通过sysctl来修改
while (!list_empty(list)) {
struct napi_struct *n;
int work, weight;
local_irq_enable();
//从链上取一个 napi_struct 结构(接收中断处理函数里加到链表上的,如gfar_receive)
n = list_entry(list->next, struct napi_struct, poll_list);
weight = n->weight;
work = 0;
if (test_bit(NAPI_STATE_SCHED, &n->state)) //检查状态标记,此标记在接收中断里加上的
work = n->poll(n, weight); //使用NAPI的话,使用的是网络设备自己的napi_struct.poll
//对于TSEC是,是gfar_poll
WARN_ON_ONCE(work > weight);
budget -= work;
local_irq_disable();
if (unlikely(work == weight)) {
if (unlikely(napi_disable_pending(n)))
__napi_complete(n); //操作napi_struct,把去掉NAPI_STATE_SCHED状态,从链表中删去
else
list_move_tail(&n->poll_list, list);
}
netpoll_poll_unlock(have);
}
out:
local_irq_enable();
}
static int gfar_poll(struct napi_struct *napi, int budget)
{
struct gfar_private *priv = container_of(napi, struct gfar_private, napi);
struct net_device *dev = priv->dev; //TSEC对应的网络设备
int howmany;
//根据dev的rx bd,获取skb并送入协议栈,返回处理的skb的个数,即以太网包的个数
howmany = gfar_clean_rx_ring(dev, budget);
// 下面这个判断比较有讲究的
// 收到的包的个数小于budget,代表我们在一个软中断里就全处理完了,所以打开 rx硬中断
// 要是收到的包的个数大于budget,表示一个软中断里处理不完所有包,那就不打开 rx硬中断,
// 此次软中断的下一轮循环里再接着处理,直到包处理完(即howmany rx硬中断
if (howmany < budget) {
netif_rx_complete(dev, napi);
gfar_write(&priv->regs->rstat, RSTAT_CLEAR_RHALT);
//打开 rx 硬中断,rx 硬中断是在gfar_receive()中被关闭的
gfar_write(&priv->regs->imask, IMASK_DEFAULT);
}
return howmany;
}
gfar_clean_rx_ring(dev, budget)
{
bdp = priv->cur_rx;
while (!((bdp->status & RXBD_EMPTY) || (--rx_work_limit < 0))) {
rmb();
skb = priv->rx_skbuff[priv->skb_currx]; //从rx_skbuff[]中获取skb
howmany++;
dev->stats.rx_packets++;
pkt_len = bdp->length - 4; //从length中去掉以太网包的FCS长度
gfar_process_frame(dev, skb, pkt_len);
dev->stats.rx_bytes += pkt_len;
dev->last_rx = jiffies;
bdp->status &= ~RXBD_STATS; //清rx bd的状态
skb = gfar_new_skb(dev, bdp); // Add another skb for the future
priv->rx_skbuff[priv->skb_currx] = skb;
if (bdp->status & RXBD_WRAP) //更新指向bd的指针
bdp = priv->rx_bd_base; //bd有WARP标记,说明是最后一个bd了,需要“绕回来”
else
bdp++;
priv->skb_currx = (priv->skb_currx + 1) & RX_RING_MOD_MASK(priv->rx_ring_size);
}
priv->cur_rx = bdp; /* Update the current rxbd pointer to be the next one */
return howmany;
}
gfar_process_frame()
-->skb->protocol = eth_type_trans(skb, dev); //确定网络层包类型,IP、ARP、VLAN等等
-->RECEIVE(skb) //调用netif_receive_skb(skb)进入协议栈
#ifdef CONFIG_GFAR_NAPI
#define RECEIVE(x) netif_receive_skb(x)
#else
#define RECEIVE(x) netif_rx(x)
#endif
------------------------------------ 华丽的分割线 ---------------------------------------
呼,netif_receive_skb(skb) 可算到协议栈了,歇会儿....
以太网的FCS会在网卡中断(如gfar_clean_rx_ring)中忽略掉
/* Remove the FCS from the packet length */
pkt_len = bdp->length - 4;
至于填充数据,是在协议栈中被忽略掉的,比如ip协议ip_rcv()
/* Our transport medium may have padded the buffer out. Now we know it
* is IP we can trim to the true length of the frame.
* Note this now means skb->len holds ntohs(iph->tot_len).
*/
if (pskb_trim_rcsum(skb, len)) {
IP_INC_STATS_BH(IPSTATS_MIB_INDISCARDS);
goto drop;
}
上一篇讲的是内核配置成NAPI的情况,那也是绝大多数内核使用的配置
现在讲讲内核不配置成NAPI时的情况
一、no NAPI 数据结构
不配置NAPI的时候,网络设备不使用自己的napi_struct结构,
所有网络设备驱动都使用同一个napi_struct,即cpu私有变量__get_cpu_var(softnet_data).backlog
每当收到数据包时,网络设备驱动会把__get_cpu_var(softnet_data).backlog挂到__get_cpu_var(softnet_data).poll_list上面。
所以软中断里net_rx_action遍历cpu私有变量__get_cpu_var(softnet_data).poll_list时,
上面挂的napi_struct只有一个
二、内核启动时的准备工作
也是在net_dev_init中,初始化了cpu私有变量的napi_struct,即所有网络设备驱动使用的napi_struct
__init net_dev_init()
{
//每个CPU都有一个私有变量 _get_cpu_var(softnet_data)
//_get_cpu_var(softnet_data).poll_list很重要,软中断中需要遍历它的
for_each_possible_cpu(i) {
struct softnet_data *queue;
queue = &per_cpu(softnet_data, i);
skb_queue_head_init(&queue->input_pkt_queue); // 不配置NAPI时,才使用这个接收队列
queue->completion_queue = NULL;
INIT_LIST_HEAD(&queue->poll_list);
queue->backlog.poll = process_backlog; // poll钩子函数初始化
queue->backlog.weight = weight_p; //
}
open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL); //在软中断上挂网络接收handler
open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL); //在软中断上挂网络发送handler
}
三、中断里接受以太网包
TSEC的接收中断处理函数
gfar_receive
{
gfar_write(&priv->regs->ievent, IEVENT_RX_MASK);
#ifdef CONFIG_GFAR_NAPI
// test_and_set当前net_device的napi_struct.state 为 NAPI_STATE_SCHED
// 在软中断里调用 net_rx_action 会检查状态 napi_struct.state
if (netif_rx_schedule_prep(dev, &priv->napi)) {
tempval = gfar_read(&priv->regs->imask);
tempval &= IMASK_RX_DISABLED;
gfar_write(&priv->regs->imask, tempval);
// 将当前net_device的 napi_struct.poll_list 挂到
// CPU私有变量 &__get_cpu_var(softnet_data).poll_list 上,并触发软中断
// 所以,在软中断中调用 net_rx_action 的时候,就会执行当前net_device的
// napi_struct.poll()钩子函数,即 gfar_poll()
__netif_rx_schedule(dev, &priv->napi);
}
#else
gfar_clean_rx_ring(dev, priv->rx_ring_size);
#endif
}
gfar_clean_rx_ring
-->gfar_process_frame
-->初始化了skb->dev,这样在软中断里才能判断这个数据包来自哪里
-->RECEIVE(skb) // 调用netif_rx(skb)
#ifdef CONFIG_GFAR_NAPI
#define RECEIVE(x) netif_receive_skb(x)
#else
#define RECEIVE(x) netif_rx(x)
#endif
netif_rx(skb)
{
queue = &__get_cpu_var(softnet_data);
__skb_queue_tail(&queue->input_pkt_queue, skb); //将skb放到接收队列(在net_dev_init初始化)中
napi_schedule(&queue->backlog); //将cpu私有变量的的napi_struct挂到cpu私有变量的poll_list上
//test_and_set napi_struct.state为 NAPI_STATE_SCHED
//触发网络接收软中断
}
软中断net_rx_action中调用poll钩子函数
虽说软中断里也遍历cpu私有变量的poll_list,事实上poll_list现在只挂一个napi_struct结构
即cpu私有变量的backlog成员(它在net_dev_init中初始化),所以现在调用的poll钩子函数就是process_backlog了
static int process_backlog(struct napi_struct *napi, int quota)
{
struct softnet_data *queue = &__get_cpu_var(softnet_data);
napi->weight = weight_p;
do {
struct sk_buff *skb;
struct net_device *dev;
local_irq_disable();
skb = __skb_dequeue(&queue->input_pkt_queue); //从接收队列中取出skb,
if (!skb) { //这些skb是在netif_rx中进入队列的
__napi_complete(napi);
local_irq_enable();
break;
}
local_irq_enable();
dev = skb->dev;
netif_receive_skb(skb); //进入协议协议栈
dev_put(dev);
} while (++work < quota && jiffies == start_time);
return work;
}
进入函数netif_receive_skb()后,skb正式开始协议栈之旅。
先上图,协议栈大致过程如下所示:
跟OSI七层模型不同,linux根据包结构对网络进行分层。
比如,arp头和ip头都是紧跟在以太网头后面的,所以在linux协议栈中arp和ip地位相同(如上图)
但是在OSI七层模型中,arp属于链路层,ip属于网络层.....
这里就不死抠概念,我们就说arp,ip都属于第二层。下面是网络第二层的处理流程
一、相关数据结构
内核处理网络第二层,有下面2个重要list_head变量 (文件linux_2_6_24/net/core/dev.c)
list_head 链表上挂了很多packet_type数据结构
static struct list_head ptype_base[16] __read_mostly; /* 16 way hashed list */
static struct list_head ptype_all __read_mostly; /* Taps */
struct packet_type {
__be16 type; /* This is really htons(ether_type).*/
struct net_device *dev; /* NULL is wildcarded here */
int (*func) (struct sk_buff *,
struct net_device *,
struct packet_type *,
struct net_device *);
struct sk_buff *(*gso_segment)(struct sk_buff *skb, int features);
int (*gso_send_check)(struct sk_buff *skb);
void *af_packet_priv;
struct list_head list;
};
type 成员保存了二层协议类型,ETH_P_IP、ETH_P_ARP等等
func 成员就是钩子函数了,如 ip_rcv()、arp_rcv()等等
二、操作packet_type的API
//把packet_type结构挂在与type对应的list_head上面
void dev_add_pack(struct packet_type *pt){
int hash;
spin_lock_bh(&ptype_lock);
if (pt->type == htons(ETH_P_ALL)) //type为ETH_P_ALL时,挂在ptype_all上面
list_add_rcu(&pt->list, &ptype_all);
else {
hash = ntohs(pt->type) & 15; //否则,挂在ptype_base[type&15]上面
list_add_rcu(&pt->list, &ptype_base[hash]);
}
spin_unlock_bh(&ptype_lock);
}
//把packet_type从list_head上删除
void dev_remove_pack(struct packet_type *pt){
__dev_remove_pack(pt);
synchronize_net();
}
void __dev_remove_pack(struct packet_type *pt){
struct list_head *head;
struct packet_type *pt1;
spin_lock_bh(&ptype_lock);
if (pt->type == htons(ETH_P_ALL))
head = &ptype_all; //找到链表头
else
head = &ptype_base[ntohs(pt->type) & 15]; //
list_for_each_entry(pt1, head, list) {
if (pt == pt1) {
list_del_rcu(&pt->list);
goto out;
}
}
printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt);
out:
spin_unlock_bh(&ptype_lock);
}
三、进入二层协议处理函数
int netif_receive_skb(struct sk_buff *skb)
{
//略去一些代码
rcu_read_lock();
//第一步:先处理 ptype_all 上所有的 packet_type->func()
//所有包都会调func,对性能影响严重!内核默认没挂任何钩子函数
list_for_each_entry_rcu(ptype, &ptype_all, list) { //遍历ptye_all链表
if (!ptype->dev || ptype->dev == skb->dev) { //上面的paket_type.type 为 ETH_P_ALL
if (pt_prev) //对所有包调用paket_type.func()
ret = deliver_skb(skb, pt_prev, orig_dev); //此函数最终调用paket_type.func()
pt_prev = ptype;
}
}
//第二步:若编译内核时选上BRIDGE,下面会执行网桥模块
//调用函数指针 br_handle_frame_hook(skb), 在动态模块 linux_2_6_24/net/bridge/br.c中
//br_handle_frame_hook = br_handle_frame;
//所以实际函数 br_handle_frame。
//注意:在此网桥模块里初始化 skb->pkt_type 为 PACKET_HOST、PACKET_OTHERHOST
skb = handle_bridge(skb, &pt_prev, &ret, orig_dev);
if (!skb) goto out;
//第三步:编译内核时选上MAC_VLAN模块,下面才会执行
//调用 macvlan_handle_frame_hook(skb), 在动态模块linux_2_6_24/drivers/net/macvlan.c中
//macvlan_handle_frame_hook = macvlan_handle_frame;
//所以实际函数为 macvlan_handle_frame。
//注意:此函数里会初始化 skb->pkt_type 为 PACKET_BROADCAST、PACKET_MULTICAST、PACKET_HOST
skb = handle_macvlan(skb, &pt_prev, &ret, orig_dev);
if (!skb) goto out;
//第四步:最后 type = skb->protocol; &ptype_base[ntohs(type)&15]
//处理ptype_base[ntohs(type)&15]上的所有的 packet_type->func()
//根据第二层不同协议来进入不同的钩子函数,重要的有:ip_rcv() arp_rcv()
type = skb->protocol;
list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {
if (ptype->type == type && //遍历包type所对应的链表
(!ptype->dev || ptype->dev == skb->dev)) { //调用链表上所有pakcet_type.func()
if (pt_prev)
ret = deliver_skb(skb, pt_prev, orig_dev); //就这里!arp包会调arp_rcv()
pt_prev = ptype; // ip包会调ip_rcv()
}
}
if (pt_prev) {
ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);
} else { //下面就是数据包从协议栈返回来了
kfree_skb(skb); //注意这句,若skb没进入socket的接收队列,则在这里被释放
ret = NET_RX_DROP; //若skb进入接收队列,则系统调用取包时skb释放,这里skb引用数减一而已
}
out:
rcu_read_unlock();
return ret;
}
int deliver_skb(struct sk_buff *skb,struct packet_type *pt_prev, struct net_device *orig_dev){
atomic_inc(&skb->users); //这句不容忽视,与后面流程的kfree_skb()相呼应
return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);//调函数ip_rcv() arp_rcv()等
}
这里只是将大致流程,arp_rcv(), ip_rcv() 什么的具体流程,以后再写。
四、网络抓包tcpdump
tcpdump也是在二层抓包的,用的是libpcap库,它的基本原理是
1.先创建socket,内核dev_add_packet()挂上自己的钩子函数
2.然后在钩子函数中,把skb放到自己的接收队列中,
3.接着系统调用recv取出skb来,把数据包skb->data拷贝到用户空间
4.最后关闭socket,内核dev_remove_packet()删除自己的钩子函数
下面是一些重要的数据结构,用到的钩子函数都在这里初始化好了
static const struct proto_ops packet_ops = {
.family = PF_PACKET,
.owner = THIS_MODULE,
.release = packet_release, //关闭socket的时候调这个
.bind = packet_bind,
.connect = sock_no_connect,
.socketpair = sock_no_socketpair,
.accept = sock_no_accept,
.getname = packet_getname,
.poll = packet_poll,
.ioctl = packet_ioctl,
.listen = sock_no_listen,
.shutdown = sock_no_shutdown,
.setsockopt = packet_setsockopt,
.getsockopt = packet_getsockopt,
.sendmsg = packet_sendmsg,
.recvmsg = packet_recvmsg, //socket收包的时候调这个
.mmap = packet_mmap,
.sendpage = sock_no_sendpage,
};
static struct net_proto_family packet_family_ops = {
.family = PF_PACKET,
.create = packet_create, //创建socket的时候调这个
.owner = THIS_MODULE,
};
至于系统调用 socket、recv、close是如何调到这些内核钩子函数的,以后再讲。这里只关注packet_type
4.1 系统调用socket
libpcap系统调用socket,内核最终调用 packet_create
static int packet_create(struct net *net, struct socket *sock, int protocol){
po->prot_hook.func = packet_rcv; //初始化钩子函数指针
po->prot_hook.af_packet_priv = sk;
if (protocol) {
po->prot_hook.type = protocol; //类型是系统调用socket形参指定的
dev_add_pack(&po->prot_hook);//关键!!
sock_hold(sk);
po->running = 1;
}
return(0);
}
4.2 钩子函数 packet_rcv 将skb放入到接收队列
文件 linux_2_6_24/net/packet/af_packet.c
简单来说,packet_rcv中,skb越过了整个协议栈,直接进入队列
4.3 系统调用recv
系统调用recv、read、recvmsg,内核最终会调用packet_recvmsg
从接收队列中取出skb,将数据包内容skb->data拷贝到用户空间
4.4 系统调用close
内核最终会调用packet_release
static int packet_release(struct socket *sock){
struct sock *sk = sock->sk;
struct packet_sock *po;
if (!sk) return 0;
po = pkt_sk(sk);
write_lock_bh(&packet_sklist_lock);
sk_del_node_init(sk);
write_unlock_bh(&packet_sklist_lock);
// Unhook packet receive handler.
if (po->running) {
dev_remove_pack(&po->prot_hook); //就是这句!!把packet_type从链表中删除
po->running = 0;
po->num = 0;
__sock_put(sk);
}
packet_flush_mclist(sk);
// Now the socket is dead. No more input will appear.
sock_orphan(sk);
sock->sk = NULL;
/* Purge queues */
skb_queue_purge(&sk->sk_receive_queue);
sk_refcnt_debug_release(sk);
sock_put(sk);
return 0;
}
----------------------------------------------------------------------------------------------
搜一下内核源代码,二层协议还真是多。。。
drivers/net/wan/hdlc.c: dev_add_pack(&hdlc_packet_type); //ETH_P_HDLC hdlc_rcv
drivers/net/wan/lapbether.c:
dev_add_pack(&lapbeth_packet_type); //ETH_P_DEC lapbeth_rcv
drivers/net/wan/syncppp.c:
dev_add_pack(&sppp_packet_type); //ETH_P_WAN_PPP sppp_rcv
drivers/net/bonding/bond_alb.c: dev_add_pack(pk_type); //ETH_P_ARP rlb_arp_recv
drivers/net/bonding/bond_main.c:dev_add_pack(pk_type); //PKT_TYPE_LACPDU bond_3ad_lacpdu_recv
drivers/net/bonding/bond_main.c:dev_add_pack(pt); //ETH_P_ARP bond_arp_rcv
drivers/net/pppoe.c: dev_add_pack(&pppoes_ptype); //ETH_P_PPP_SES pppoe_rcv
drivers/net/pppoe.c: dev_add_pack(&pppoed_ptype); //ETH_P_PPP_DISC pppoe_disc_rcv
drivers/net/hamradio/bpqether.c:
dev_add_pack(&bpq_packet_type); //ETH_P_BPQ bpq_rcv
net/ipv4/af_inet.c: dev_add_pack(&ip_packet_type); //ETH_P_IP ip_rcv
net/ipv4/arp.c: dev_add_pack(&arp_packet_type); //ETH_P_ARP arp_rcv
net/ipv4/ipconfig.c: dev_add_pack(&rarp_packet_type); //ETH_P_RARP ic_rarp_recv
net/ipv4/ipconfig.c: dev_add_pack(&bootp_packet_type); //ETH_P_IP ic_bootp_recv
net/llc/llc_core.c: dev_add_pack(&llc_packet_type); //ETH_P_802_2 llc_rcv
net/llc/llc_core.c: dev_add_pack(&llc_tr_packet_type); //ETH_P_TR_802_2 llc_rcv
net/x25/af_x25.c: dev_add_pack(&x25_packet_type); //ETH_P_X25 x25_lapb_receive_frame
net/8021q/vlan.c: dev_add_pack(&vlan_packet_type); //ETH_P_8021Q vlan_skb_recv
这些不同协议的packet_type,有些是linux系统启动时挂上去的
比如处理ip协议的pakcet_type,就是在 inet_init()时挂上去的
还有些驱动模块加载的时候才加上去的。
网络数据包收发流程:从驱动到协议栈相关推荐
- 网络数据包收发流程(三):e1000网卡和DMA
早就想整理网络数据包收发流程了,一直太懒没动笔.今天下决心写了 一.硬件环境 intel82546:PHY与MAC集成在一起的PCI网卡芯片,很强大 bcm5461: PHY芯片,与之对应的MAC ...
- 网络数据包收发流程(四):协议栈之packet_type
进入函数netif_receive_skb()后,skb正式开始协议栈之旅. 先上图,协议栈大致过程如下所示: 跟OSI七层模型不同,linux根据包结构对网络进行分层. 比如,arp头和ip头都是紧 ...
- 【STM32学习】——USART串口数据包HEX/文本数据包收发流程串口收发HEX/文本数据包实操
文章目录 前言 一.数据包格式(江科大规定) 1.HEX数据包 2.文本数据包 3.两者对比 二.数据包收发流程 1.HEX数据包接收(只演示固定包长) 2.文本数据包接收(只演示可变包长) 三.实操 ...
- Linux内核网络数据包处理流程
Linux内核网络数据包处理流程 from kernel-4.9: 0. Linux内核网络数据包处理流程 - 网络硬件 网卡工作在物理层和数据链路层,主要由PHY/MAC芯片.Tx/Rx FIFO. ...
- java udp包_基于UDP协议的数据包收发程序(代码+报告)Java
[实例简介] 设计要求: 1)按照UDP协议数据包发送方式实现用户端之间的通信. 2)统计包的发送和接收数,计算数据包的丢失数. 3)设计美观易用的图形界面. [实例截图] [核心代码] 基于UDP协 ...
- linux内核协议栈 邻居协议之 arp 数据包收发处理流程
目录 前言 1 arp数据包文接收 arp_rcv() 1.1 处理arp请求 arp_process()[核心] 2 arp数据包发送 arp_send() 2.1 arp 数据包构造 arp_cr ...
- linux接收网络数据并存存储,Linux网络设备驱动之数据接收流程(六)
网络设备接收数据的主要方法是由中断引发设备的中断处理函数,中断处理函数判断中断类型,如果为接收中断,则读取接收到的数据,分配 sk_buffer 数据结构和数据缓冲区,将接收到的数据复制到数据缓冲区, ...
- Linux: 网络数据收发流程简析
文章目录 1. 前言 2. 背景 3. 网卡数据收发流程 3.1 网络数据接收流程 3.1.1 网卡数据接收流程 3.1.2 网卡数据向上传递给L3,L4的流程 3.2 网卡数据发送流程 1. 前言 ...
- linux接收网络数据并存存储,linux网络数据包数据结构 Socket Buffer
Linux网络核心数据结构是套接字缓存(socket buffer),简称skb.它代表一个要发送或处理的报文,并贯穿于整个协议栈.1.套接字缓存skb由两部分组成:(1)报文数据:它保存了实际在网络 ...
- 物联网LWIP网络开发 LWIP网卡设计原理11.1 协议栈内存管理
lwIP协议栈内存管理上 lwIP 内存管理需求 常用内存管理需求 静态分配的变量 -> RAM 任务堆栈 动态存储器管理 malloc & free lwip内存管理需求 lwip 内 ...
最新文章
- 在Eclipse中打开Hadoop工程
- 全球及中国一次性造口袋行业发展前景预测及投资价值分析报告2021-2027年版
- 8Manage项目管理:嵌入人工智能的项目管理平台
- Django进阶Model篇—数据库操作(ORM)
- node mysql 连接池创建_Node.js使用MySQL连接池的方法实例
- 二进制编译安装mysql_数据库(MySQL)二进制安装+编译安装 + MariaDB编译安装
- 抓包工具,知道手机app上面使用的接口是哪个
- Swift中文教程(十四) 初始化
- 【微信开发】-- 发送模板消息
- vector中resize()和reserve()区别
- 房间计费系统改造E-R图纸设计
- 阿里云OpenSearch使用体验V1
- Quartz配置文件
- win10连接共享打印机出现0x0000011b
- 美食数据接口API (豆果美食NodeJs版API)
- 02网络爬虫-使用 Beautiful Soup 解析网页
- 路由 OSPF简介、OSPF与其它路由的区别、OSPF区域概念、OSPF路由代名词IR、BR、ABR、ASBR概念简介。
- 北京物资学院计算机考研资料汇总
- 阿里入股新浪微博:动机与前景分析
- java系统智能手表_java_智能手表开发API接口,随着移动技术的发展,许多传 - phpStudy...