Commit d46a5ac7 authored by Steffen Klassert's avatar Steffen Klassert Committed by Herbert Xu
Browse files

padata: Use a timer to handle remaining objects in the reorder queues 



padata_get_next needs to check whether the next object that
need serialization must be parallel processed by the local cpu.
This check was wrong implemented and returned always true,
so the try_again loop in padata_reorder was never taken. This
can lead to object leaks in some rare cases due to a race that
appears with the trylock in padata_reorder. The try_again loop
was not a good idea after all, because a cpu could take that
loop frequently, so we handle this with a timer instead.

This patch adds a timer to handle the race that appears with
the trylock. If cpu1 queues an object to the reorder queue while
cpu2 holds the pd->lock but left the while loop in padata_reorder
already, cpu2 can't care for this object and cpu1 exits because
it can't get the lock. Usually the next cpu that takes the lock
cares for this object too. We need the timer just if this object
was the last one that arrives to the reorder queues. The timer
function sends it out in this case.

Signed-off-by: default avatarSteffen Klassert <steffen.klassert@secunet.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent 18eb8ea6

include/linux/padata.h

+2 −0
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <linux/workqueue.h>

#include <linux/spinlock.h>

#include <linux/list.h>

#include <linux/timer.h>



struct padata_priv {

	struct list_head	list;
@@ -60,6 +61,7 @@ struct parallel_data { 
	unsigned int		max_seq_nr;

	cpumask_var_t		cpumask;

	spinlock_t              lock;

	struct timer_list       timer;

};



struct padata_instance {

kernel/padata.c

+18 −7
Original line number Diff line number Diff line
@@ -231,7 +231,8 @@ static struct padata_priv *padata_get_next(struct parallel_data *pd) 
		goto out;

	}



	if (next_nr % num_cpus == next_queue->cpu_index) {

	queue = per_cpu_ptr(pd->queue, smp_processor_id());

	if (queue->cpu_index == next_queue->cpu_index) {

		padata = ERR_PTR(-ENODATA);

		goto out;

	}
@@ -247,9 +248,8 @@ static void padata_reorder(struct parallel_data *pd) 
	struct padata_queue *queue;

	struct padata_instance *pinst = pd->pinst;



try_again:

	if (!spin_trylock_bh(&pd->lock))

		goto out;

		return;



	while (1) {

		padata = padata_get_next(pd);
@@ -258,8 +258,9 @@ try_again: 
			break;



		if (PTR_ERR(padata) == -ENODATA) {

			del_timer(&pd->timer);

			spin_unlock_bh(&pd->lock);

			goto out;

			return;

		}



		queue = per_cpu_ptr(pd->queue, padata->cb_cpu);
@@ -273,13 +274,22 @@ try_again: 


	spin_unlock_bh(&pd->lock);



	if (atomic_read(&pd->reorder_objects))

		goto try_again;

	if (atomic_read(&pd->reorder_objects)

			&& !(pinst->flags & PADATA_RESET))

		mod_timer(&pd->timer, jiffies + HZ);

	else

		del_timer(&pd->timer);



out:

	return;

}



static void padata_reorder_timer(unsigned long arg)

{

	struct parallel_data *pd = (struct parallel_data *)arg;



	padata_reorder(pd);

}



static void padata_serial_worker(struct work_struct *work)

{

	struct padata_queue *queue;
@@ -383,6 +393,7 @@ static struct parallel_data *padata_alloc_pd(struct padata_instance *pinst, 
	num_cpus = cpumask_weight(pd->cpumask);

	pd->max_seq_nr = (MAX_SEQ_NR / num_cpus) * num_cpus - 1;



	setup_timer(&pd->timer, padata_reorder_timer, (unsigned long)pd);

	atomic_set(&pd->seq_nr, -1);

	atomic_set(&pd->reorder_objects, 0);

	atomic_set(&pd->refcnt, 0);

CRA Git | Maintained and supported by SUSTech CRA and CCSE