使用NAPI的完整例子

hns_nic_try_get_ae->hns_nic_init_ring_data
static int hns_nic_init_ring_data(struct hns_nic_priv *priv)
{
struct hnae_handle *h = priv->ae_handle;
struct hns_nic_ring_data *rd;
bool is_ver1 = AE_IS_VER1(priv->enet_ver);
int i;


if (h->q_num > NIC_MAX_Q_PER_VF) {
netdev_err(priv->netdev, "too much queue (%d)\n", h->q_num);
return -EINVAL;
}


priv->ring_data = kzalloc(h->q_num * sizeof(*priv->ring_data) * 2,
 GFP_KERNEL);
if (!priv->ring_data)
return -ENOMEM;


for (i = 0; i < h->q_num; i++) {
rd = &priv->ring_data[i];
rd->queue_index = i;
rd->ring = &h->qs[i]->tx_ring;
rd->poll_one = hns_nic_tx_poll_one;
rd->fini_process = is_ver1 ? hns_nic_tx_fini_pro :
hns_nic_tx_fini_pro_v2;
//调用netif_napi_add将priv->netdev和NAPI的结构rd->napi绑定，注意这里的poll函数是hns_nic_common_poll
netif_napi_add(priv->netdev, &rd->napi,
      hns_nic_common_poll, NIC_TX_CLEAN_MAX_NUM);
rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED;
}
for (i = h->q_num; i < h->q_num * 2; i++) {
rd = &priv->ring_data[i];
rd->queue_index = i - h->q_num;
rd->ring = &h->qs[i - h->q_num]->rx_ring;
rd->poll_one = hns_nic_rx_poll_one;
rd->ex_process = hns_nic_rx_up_pro;
rd->fini_process = is_ver1 ? hns_nic_rx_fini_pro :
hns_nic_rx_fini_pro_v2;


netif_napi_add(priv->netdev, &rd->napi,
      hns_nic_common_poll, NIC_RX_CLEAN_MAX_NUM);
rd->ring->irq_init_flag = RCB_IRQ_NOT_INITED;
}


return 0;
}


hns_nic_net_open->hns_nic_net_up->hns_nic_ring_open
static int hns_nic_ring_open(struct net_device *netdev, int idx)
{
struct hns_nic_priv *priv = netdev_priv(netdev);
struct hnae_handle *h = priv->ae_handle;


napi_enable(&priv->ring_data[idx].napi);


enable_irq(priv->ring_data[idx].ring->irq);
h->dev->ops->toggle_ring_irq(priv->ring_data[idx].ring, 0);


return 0;
}
在hns_nic_ring_open 中调用napi_enable来使能napi




这样当hns的中断到来是，会调用中断的处理函数
hns_nic_net_open->hns_nic_net_up->hns_nic_init_irq
static int hns_nic_init_irq(struct hns_nic_priv *priv)
{
struct hnae_handle *h = priv->ae_handle;
struct hns_nic_ring_data *rd;
int i;
int ret;
int cpu;


for (i = 0; i < h->q_num * 2; i++) {
rd = &priv->ring_data[i];


if (rd->ring->irq_init_flag == RCB_IRQ_INITED)
break;


snprintf(rd->ring->ring_name, RCB_RING_NAME_LEN,
"%s-%s%d", priv->netdev->name,
(is_tx_ring(rd->ring) ? "tx" : "rx"), rd->queue_index);


rd->ring->ring_name[RCB_RING_NAME_LEN - 1] = '\0';
//rx和tx的中断处理函数都是hns_irq_handle
ret = request_irq(rd->ring->irq,
 hns_irq_handle, 0, rd->ring->ring_name, rd);
if (ret) {
netdev_err(priv->netdev, "request irq(%d) fail\n",
  rd->ring->irq);
return ret;
}


return 0;
}


static irqreturn_t hns_irq_handle(int irq, void *dev)
{
struct hns_nic_ring_data *ring_data = (struct hns_nic_ring_data *)dev;


ring_data->ring->q->handle->dev->ops->toggle_ring_irq(
ring_data->ring, 1);
napi_schedule(&ring_data->napi);


return IRQ_HANDLED;
}
在中断处理函数hns_irq_handle 中会调用napi_schedule 来调度NAPI
napi_schedule->__napi_schedule
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);
}
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);
}


最终在____napi_schedule 通过__raise_softirq_irqoff来触发一个软件中断，这个软件中断的回调函数
是在net_dev_init 中注册的.


static int __init net_dev_init(void)
{
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);
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;
}
open_softirq(NET_TX_SOFTIRQ, net_tx_action);
open_softirq(NET_RX_SOFTIRQ, net_rx_action);


}
net_rx_action->napi_poll
static int napi_poll(struct napi_struct *n, struct list_head *repoll)
{
if (test_bit(NAPI_STATE_SCHED, &n->state)) {
work = n->poll(n, weight);
trace_napi_poll(n, work, weight);
}


WARN_ON_ONCE(work > weight);


if (likely(work < weight))
goto out_unlock;


/* Drivers must not modify the NAPI state if they
* consume the entire weight.  In such cases this code
* still "owns" the NAPI instance and therefore can
* move the instance around on the list at-will.
*/
if (unlikely(napi_disable_pending(n))) {
napi_complete(n);
goto out_unlock;
}
}
最终还是设备自己的poll函数，如果处理完所有的包后调用napi_complete
从前面可知设备自己注册的poll函数为hns_nic_common_poll
static int hns_nic_common_poll(struct napi_struct *napi, int budget)
{
int clean_complete = 0;
struct hns_nic_ring_data *ring_data =
container_of(napi, struct hns_nic_ring_data, napi);
struct hnae_ring *ring = ring_data->ring;


try_again:
//再针对tx和rx分别调用自己的poll_one 函数
clean_complete += ring_data->poll_one(
ring_data, budget - clean_complete,
ring_data->ex_process);


if (clean_complete < budget) {
//如果处理完成调用napi_complete 告诉NAPI 已经处理完成了
if (ring_data->fini_process(ring_data)) {
napi_complete(napi);
ring->q->handle->dev->ops->toggle_ring_irq(ring, 0);
} else {
goto try_again;
}
}


return clean_complete;
}


我们继续看hns_nic_rx_poll_one中会通过下面的code调用
/* do update ip stack process*/
((void (*)(struct hns_nic_ring_data *, struct sk_buff *))v)(
ring_data, skb);
这里的v就是hns_nic_rx_up_pro
static void hns_nic_rx_up_pro(struct hns_nic_ring_data *ring_data,
     struct sk_buff *skb)
{
struct net_device *ndev = ring_data->napi.dev;


skb->protocol = eth_type_trans(skb, ndev);
(void)napi_gro_receive(&ring_data->napi, skb);
}
 最终会在hns_nic_rx_up_pro 中调用napi_gro_receive 将在hns_nic_rx_poll_one 中准备好的skb发送给上层.