网络处理的软中断机制分析
http://blog.csdn.net/joshua_yu/archive/2006/01/27/589451.aspx
内核默认软中断机制分析（ process_backlog ）
首先需要介绍的就是 netif_rx （在 net/core/dev.c 中定义）函数，这个函数在网卡驱动程序与 linux 内核之间建立了一道桥梁，将网卡接收上来的数据包（ sk_buff 形式）插入内核维护的接收缓冲 区队列当中：
int netif_rx(struct sk_buff *skb)
{
int this_cpu = smp_processor_id();
struct softnet_data *queue;
unsigned long flags;
if (skb->stamp.tv_sec == 0)
do_gettimeofday(&skb->stamp);
/*
获取当前处理 CPU 的接收数据包缓冲区队列指针。系统为 每一个 CPU 都维 护一个独立的列表，这样可以避免共享访问互斥问题。
*/
queue = &softnet_data[this_cpu];
local_irq_save(flags);
netdev_rx_stat[this_cpu].total++;
/*
这里判断当前输入队列 的长度是否超过预定义的一个值，如果没有超过，则向下执行。
如果当前队列的长度大 于 0 ，则将 sk_buff 插入队列，并且返回，注意这 里并没有调用 __cpu_raise_softirq 产生一个软中断，而较老的内核版本当中，插入队列以后立刻调用这个函数产生软中断。
另外，如果队列长度为 0 ，则需要调用 netif_rx_schedule 及后续的 __netif_rx_schedule 函 数将当前网络设备加入 softnet_data 的轮询列表（ poll_list ）当中，这个列表维护所有网络设备的列表，当系统软中断处理函数运行时，逐个检索处于 poll_list 中的设备，然后调用设备 的 dev->poll 方法处理输入数据包队列中的数据。
将设备加入 poll_list 列表当中后，返回 enqueue 标记处继续将 sk_buff 加入输入数据包队列中，然后 返回。
*/
if (queue->input_pkt_queue.qlen <= netdev_max_backlog) {
if (queue->input_pkt_queue.qlen) {
if (queue->throttle)
goto drop;
enqueue:
dev_hold(skb->dev);
/*
将当前 sk_buff 插入 input_pkt_queue 队列的尾部，即刻返回。
*/
__skb_queue_tail(&queue->input_pkt_queue,skb);
local_irq_restore(flags);
return queue->cng_level;
}
if (queue->throttle) {
queue->throttle = 0;
}
netif_rx_schedule(&queue->blog_dev);
goto enqueue;
}
if (queue->throttle == 0) {
queue->throttle = 1;
netdev_rx_stat[this_cpu].throttled++;
}
drop:
netdev_rx_stat[this_cpu].dropped++;
local_irq_restore(flags);
kfree_skb(skb);
return NET_RX_DROP;
}
从上面的分析可以知道， netif_rx 函数主要负责将数据包插入内核队列中，并触发软中断，这一点与较早的版本是不同的，那么软中断是在 什么地方触发的呢？
以前的章节介绍过，硬件中断是在 irq.c 的 do_IRQ 函数中调用 handle_IRQ_event 函数，进而调用相应硬件驱动程序的中断处理函数实现的。在 do_IRQ 函数执行完硬件处理函数以后，接 着就会调用 do_softirq 函数执行软中断，并且根据软中断号在 softirq_vec 数组中查找相应中断的 action 方法，对于 NET_RX_SOFTIRQ 类型的软中断来说，系统将其 action 注册为 net_rx_action ，这样我们就进入了 net_rx_action 函数当中：
static void net_rx_action(struct softirq_action *h)
{
int this_cpu = smp_processor_id();
struct softnet_data *queue = &softnet_data[this_cpu];
unsigned long start_time = jiffies;
int budget = netdev_max_backlog; （系统每次从队列中取 300 个 sk_buff 处理）
br_read_lock(BR_NETPROTO_LOCK);
local_irq_disable();
/*
在这里循环判断当前轮 询列表是否为空。如果不为空，则进入软中断处理过程。
*/
while (!list_empty(&queue->poll_list)) {
struct net_device *dev;
if (budget <= 0 || jiffies - start_time > 1)
goto softnet_break;
local_irq_enable();
/*
从轮询 列表中取出当前的设备 dev 指针，接着为 dev 调用 poll 方法，这是设备初始化过程中已经定义好的方法，如果设备未能自己实现该函数，则系统默认注册为 process_backlog 。 poll 函数执行成功返回 0 ，失败返回－ 1 。这里逻辑判断是， dev->quota 必须大于 0 ，而 poll 函数执行成功，则可以继续，直到所有 的设备都查询一遍为止。
*/
dev = list_entry(queue->poll_list.next, struct net_device, poll_list);
if (dev->quota <= 0 || dev->poll(dev, &budget)) {
/*
这里的 poll 函数是 netdevice 结构的一个函数指针，对于不同的网卡驱动程序，我们可以根据自己的情况定义 poll 方法的实现（ e1000 网卡驱动程序就自己实现了一个 poll 方法，详情后面来分析），而系统默 认提供一个方法。
*/
local_irq_disable();
list_del(&dev->poll_list);
list_add_tail(&dev->poll_list, &queue->poll_list);
if (dev->quota < 0)
dev->quota += dev->weight;
else
dev->quota = dev->weight;
} else {
dev_put(dev);
local_irq_disable();
}
}
local_irq_enable();
br_read_unlock(BR_NETPROTO_LOCK);
return;
softnet_break:
netdev_rx_stat[this_cpu].time_squeeze++;
/*
触发软中断处理，等待 下一次调用本函数。
*/
__cpu_raise_softirq(this_cpu, NET_RX_SOFTIRQ);
local_irq_enable();
br_read_unlock(BR_NETPROTO_LOCK);
}
软中断处理函数 net_rx_action 实际上就是调用各个网络设备的 poll 方法处理数据包的，一般的讲， poll 默认为 process_backlog （在 net/core/dev..c 中定义）：
static int process_backlog(struct net_device *backlog_dev, int *budget)
{
int work = 0;
int quota = min(backlog_dev->quota, *budget);
int this_cpu = smp_processor_id();
struct softnet_data *queue = &softnet_data[this_cpu];
unsigned long start_time = jiffies;
for (;;) {
struct sk_buff *skb;
struct net_device *dev;
local_irq_disable();
/*
从输入 缓冲区队列中取出 sk_buff ，调用 netif_receive_skb 函数将 sk_buff 交给上层协议进行处理。这里就是循环调用 __skb_dequeue 取出 skb ，直到所有的 skb 处理完毕为止。
*/
skb = __skb_dequeue(&queue->input_pkt_queue);
if (skb == NULL)
goto job_done;
local_irq_enable();
dev = skb->dev;
netif_receive_skb(skb);
dev_put(dev);
work++;
if (work >= quota || jiffies - start_time > 1)
break;
}
}
接下来看一下 sk_buff 是如何被递交到上层协议进行处理的，只是通过调用 netif_receive_skb （在 net/core/dev.c 中定义）函数 实现的：
int netif_receive_skb(struct sk_buff *skb)
{
struct packet_type *ptype, *pt_prev;
int ret = NET_RX_DROP;
unsigned short type = skb->protocol;
/*
给每个网络数据包打上 时间戳。
*/
if (skb->stamp.tv_sec == 0)
do_gettimeofday(&skb->stamp);
skb_bond(skb);
pt_prev = NULL;
/*
上层的每个协议在其初 始化的过程中会调用 dev_add_pack 函数将自己的 packet_type 结构加入到 ptye_all 列表当中，其中 packet_type 结构中定义了该协议的处理方法，对于 ip 协议来说， func 方法就注册为 ip_rcv 。另外，一般协议 packet_type 结构的 dev 字段设为 NULL ，所以下面的 ptype->dev 就为 NULL 。
另外，如果我们需要增 加自己的协议，则需要创建一个 packet_type 结构，用我们自己的协议处理函数填充该结构的 func 方法，并且调用 dev_add_pack 函数将我们自己的协议加入 ptype_all 数组当中。
*/
for (ptype = ptype_all; ptype; ptype = ptype->next) {
/*
这里每 一种协议在定义其 packet_type 结构时都设置接收这种
数据包 协议类型的设备指针，如果设置为 NULL ，则可以从
任何设备接收数据包。
这里针对协议类型为 ETH_P_ALL 的情况进行处理，对于 IP
协议来说，类型定义为 ETH_P_IP ，因此不在这里处理。
*/
if (!ptype->dev || ptype->dev == skb->dev) {
if (pt_prev) {
if (!pt_prev->data) {
ret = deliver_to_old_ones(pt_prev, skb, 0);
} else {
atomic_inc(&skb->users);
ret = pt_prev->func(skb, skb->dev, pt_prev);
}
}
pt_prev = ptype;
}
}
/*
这里针对各种协议进行处理， IP 包的类型为 ETH_P_IP ，因此在这里处理。
*/
for (ptype=ptype_base[ntohs(type)&15];ptype;ptype=ptype->next) {
if (ptype->type == type &&
(!ptype->dev || ptype->dev == skb->dev)) {
if (pt_prev) {
if (!pt_prev->data) {
ret = deliver_to_old_ones(pt_prev, skb, 0);
} else {
atomic_inc(&skb->users);
ret = pt_prev->func(skb, skb->dev, pt_prev);
}
}
pt_prev = ptype;
}
}
if (pt_prev) {
if (!pt_prev->data) {
ret = deliver_to_old_ones(pt_prev, skb, 1);
} else {
ret = pt_prev->func(skb, skb->dev, pt_prev);
}
} else {
kfree_skb(skb);
/* Jamal, now you will not able to escape explaining
* me how you were going to use this. :-)
*/
ret = NET_RX_DROP;
}
return ret;
}
在软中断处理函数当中，我们根据数据包的类型，调用相应的底层数据处理函数，对于 IP 包来说，就是调用 ip_rcv 函数并且进一步向上层协议递交 和处理。至此，内核的软中断的主要过程已经结束了。
接下来我们分析一下 IP 层以上的网络协议栈是如何进一步处理数据的，详细的说明文档见《 网络数据接收的协议处理过程分析 》。