网络子系统在链路层的收发过程剖析（三）

（4），poll函数

NON—NAPI方式：

       这种方式对应该的poll函数为process_backlog：

 

       struct softnet_data *queue = &__get_cpu_var(softnet_data);

       for (;;) {

 

              local_irq_disable();

              skb = __skb_dequeue(&queue->input_pkt_queue);

              local_irq_enable();

 

              netif_receive_skb(skb);

}

 

它首先找到当前CPU的softnet_data结构，然后遍历其数据队SKB，并将数据上交netif_receive_skb(skb)处理。

 

NAPI方式：

       这种方式下，NIC驱动程序会提供自己的poll函数和私有接收队列。

如intel 8255x系列网卡程序e100,它有在初始化的时候首先分配一个接收队列，而不像以上那种方式在接收到数据帧的时候再为其分配数据空间。这样，NAPI的poll函数在处理接收的时候，它遍历的是自己的私有队列：

 

       static int e100_poll(struct net_device *netdev, int *budget)

{

       e100_rx_clean(nic, &work_done, work_to_do);

       ……

}

 

static void e100_rx_clean(struct nic *nic, unsigned int *work_done,

       unsigned int work_to_do)

{

       …….

       /* Indicate newly arrived packets */

       for(rx = nic->rx_to_clean; rx->skb; rx = nic->rx_to_clean = rx->next) {

              int err = e100_rx_indicate(nic, rx, work_done, work_to_do);

              if(-EAGAIN == err) {

              ……

       }

              ……

}

 

static int e100_rx_indicate(struct nic *nic, struct rx *rx,

       unsigned int *work_done, unsigned int work_to_do)

{

       struct sk_buff *skb = rx->skb;

       struct rfd *rfd = (struct rfd *)skb->data;

       rfd_status = le16_to_cpu(rfd->status);

 

       /* Get actual data size */

       actual_size = le16_to_cpu(rfd->actual_size) & 0x3FFF;

 

       /* Pull off the RFD and put the actual data (minus eth hdr) */

       skb_reserve(skb, sizeof(struct rfd));

       skb_put(skb, actual_size);

       skb->protocol = eth_type_trans(skb, nic->netdev);

 

       netif_receive_skb(skb);

 

       return 0;

}

 

主要工作在e100_rx_indicate()中完成，这主要重设SKB的一些参数，然后跟process_backlog(),一样，最终调用netif_receive_skb(skb)。

 

 

（5），netif_receive_skb(skb)

这是一个辅助函数，用于在poll中处理接收到的帧。它主要是向各个已注册的协议处理例程发送一个SKB。

每个协议的类型由一个packet_type结构表示：

 

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, 为要处理的协议

                       func, 为处理这个协议的例程

 

所用到的协议在系统或模块加载的时候初始化，如IP协议：

static struct packet_type ip_packet_type = {

       .type = __constant_htons(ETH_P_IP),

       .func = ip_rcv,

       .gso_send_check = inet_gso_send_check,

       .gso_segment = inet_gso_segment,

};

 

static int __init inet_init(void)

{

       ……

dev_add_pack(&ip_packet_type);

……

}

 

void dev_add_pack(struct packet_type *pt)

{

       int hash;

 

       spin_lock_bh(&ptype_lock);

       if (pt->type == htons(ETH_P_ALL)) {

              netdev_nit++;

              list_add_rcu(&pt->list, &ptype_all);

       } else {

              hash = ntohs(pt->type) & 15;

              list_add_rcu(&pt->list, &ptype_base[hash]);

       }

       spin_unlock_bh(&ptype_lock);

}

 

可以看到，dev_add_pack()是将一个协议类型结构链入某一个链表， 当协议类型为ETH_P_ALL时，它将被链入ptype_all链表，这个链表是用于sniffer这样一些程序的，它接收所有NIC收到的包。还有一个是HASH链表ptype_base，用于各种协议，它是一个16个元素的数组，dev_add_pack()会根据协议类型将这个packet_type链入相应的HASH链表中。

 

而ptype_base与ptype_all的组织结构如下，一个为HASH链表，一个为双向链表：

 

 

 

int netif_receive_skb(struct sk_buff *skb)

{

 

       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;

              }

       }

 

       type = skb->protocol;

       list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type)&15], list) {

              if (ptype->type == type &&

                  (!ptype->dev || ptype->dev == skb->dev)) {

                     if (pt_prev)

                            ret = deliver_skb(skb, pt_prev, orig_dev);

                     pt_prev = ptype;

              }

       }

 

       if (pt_prev) {

              ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev);

       }

       return ret;

}

 

 

 

netif_receive_skb()的主要作用体现在两个遍历链表的操作中，其中之一为遍历ptype_all链，这些为注册到内核的一些sniffer，将上传给这些sniffer，另一个就是遍历ptype_base，这个就是具体的协议类型。假高如上图如示，当eth1接收到一个IP数据包时，它首先分别发送一份副本给两个ptype_all链表中的packet_type，它们都由package_rcv处理，然后再根据HASH值，在遍历另一个HASH表时，发送一份给类型为ETH_P_IP的类型，它由ip_rcv处理。如果这个链中还注册有其它IP层的协议，它也会同时发送一个副本给它。

 

其中，这个是由deliver_skb(skb, pt_prev, orig_dev)去完成的：

static __inline__ int deliver_skb(struct sk_buff *skb,

                              struct packet_type *pt_prev,

                              struct net_device *orig_dev)

{

       atomic_inc(&skb->users);

       return pt_prev->func(skb, skb->dev, pt_prev, orig_dev);

}

 

可以看到，它只是一个包装函数，它只去执行相应packet_type里的func处理函数，如对于ETH_P_IP类型，由上面可以看到，它执行的就是ip_rcv了。

 

至此，一个以太网帧的链路层接收过程就全部完成，再下去就是网络层的处理了。