iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

net: flush the softnet backlog in process context

Browse Source 
Currently in process_backlog(), the process_queue dequeuing is
performed with local IRQ disabled, to protect against
flush_backlog(), which runs in hard IRQ context.

This patch moves the flush operation to a work queue and runs the
callback with bottom half disabled to protect the process_queue
against dequeuing.
Since process_queue is now always manipulated in bottom half context,
the irq disable/enable pair around the dequeue operation are removed.

To keep the flush time as low as possible, the flush
works are scheduled on all online cpu simultaneously, using the
high priority work-queue and statically allocated, per cpu,
work structs.

Overall this change increases the time required to destroy a device
to improve slightly the packets reinjection performances.

Acked-by: Hannes Frederic Sowa <hannes@stressinduktion.org>
Signed-off-by: Paolo Abeni <pabeni@redhat.com>
Acked-by: Eric Dumazet <edumazet@google.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Paolo Abeni 2016-08-25 15:58:44 +02:00 committed by David S. Miller
parent 72f4af4e47
commit 145dd5f9c8
1 changed files with 52 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
net/core/dev.c
View File

@ -4292,15 +4292,25 @@ int netif_receive_skb(struct sk_buff *skb)
}
EXPORT_SYMBOL(netif_receive_skb);
/* Network device is going away, flush any packets still pending
* Called with irqs disabled.
*/
static void flush_backlog(void *arg)
{
struct net_device *dev = arg;
struct softnet_data *sd = this_cpu_ptr(&softnet_data);
struct sk_buff *skb, *tmp;
struct flush_work {
struct net_device *dev;
struct work_struct work;
};
DEFINE_PER_CPU(struct flush_work, flush_works);
/* Network device is going away, flush any packets still pending */
static void flush_backlog(struct work_struct *work)
{
struct flush_work *flush = container_of(work, typeof(*flush), work);
struct net_device *dev = flush->dev;
struct sk_buff *skb, *tmp;
struct softnet_data *sd;
local_bh_disable();
sd = this_cpu_ptr(&softnet_data);
local_irq_disable();
rps_lock(sd);
skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) {
if (skb->dev == dev) {
@ -4310,6 +4320,7 @@ static void flush_backlog(void *arg)
}
}
rps_unlock(sd);
local_irq_enable();
skb_queue_walk_safe(&sd->process_queue, skb, tmp) {
if (skb->dev == dev) {
@ -4318,6 +4329,27 @@ static void flush_backlog(void *arg)
input_queue_head_incr(sd);
}
}
local_bh_enable();
}
static void flush_all_backlogs(struct net_device *dev)
{
unsigned int cpu;
get_online_cpus();
for_each_online_cpu(cpu) {
struct flush_work *flush = per_cpu_ptr(&flush_works, cpu);
INIT_WORK(&flush->work, flush_backlog);
flush->dev = dev;
queue_work_on(cpu, system_highpri_wq, &flush->work);
}
for_each_online_cpu(cpu)
flush_work(&per_cpu_ptr(&flush_works, cpu)->work);
put_online_cpus();
}
static int napi_gro_complete(struct sk_buff *skb)
@ -4805,8 +4837,9 @@ static bool sd_has_rps_ipi_waiting(struct softnet_data *sd)
static int process_backlog(struct napi_struct *napi, int quota)
{
int work = 0;
struct softnet_data *sd = container_of(napi, struct softnet_data, backlog);
bool again = true;
int work = 0;
/* Check if we have pending ipi, its better to send them now,
* not waiting net_rx_action() end.
@ -4817,23 +4850,20 @@ static int process_backlog(struct napi_struct *napi, int quota)
}
napi->weight = weight_p;
local_irq_disable();
while (1) {
while (again) {
struct sk_buff *skb;
while ((skb = __skb_dequeue(&sd->process_queue))) {
rcu_read_lock();
local_irq_enable();
__netif_receive_skb(skb);
rcu_read_unlock();
local_irq_disable();
input_queue_head_incr(sd);
if (++work >= quota) {
local_irq_enable();
if (++work >= quota)
return work;
}
}
local_irq_disable();
rps_lock(sd);
if (skb_queue_empty(&sd->input_pkt_queue)) {
/*
@ -4845,16 +4875,14 @@ static int process_backlog(struct napi_struct *napi, int quota)
* and we dont need an smp_mb() memory barrier.
*/
napi->state = 0;
rps_unlock(sd);
break;
again = false;
} else {
skb_queue_splice_tail_init(&sd->input_pkt_queue,
&sd->process_queue);
}
skb_queue_splice_tail_init(&sd->input_pkt_queue,
&sd->process_queue);
rps_unlock(sd);
local_irq_enable();
}
local_irq_enable();
return work;
}
@ -6707,7 +6735,7 @@ static void rollback_registered_many(struct list_head *head)
unlist_netdevice(dev);
dev->reg_state = NETREG_UNREGISTERING;
on_each_cpu(flush_backlog, dev, 1);
flush_all_backlogs(dev);
}
synchronize_net();