padata: make padata_do_parallel find alternate callback CPU

padata_do_parallel currently returns -EINVAL if the callback CPU isn't
in the callback cpumask.

pcrypt tries to prevent this situation by keeping its own callback
cpumask in sync with padata's and checks that the callback CPU it passes
to padata is valid.  Make padata handle this instead.

padata_do_parallel now takes a pointer to the callback CPU and updates
it for the caller if an alternate CPU is used.  Overall behavior in
terms of which callback CPUs are chosen stays the same.

Prepares for removal of the padata cpumask notifier in pcrypt, which
will fix a lockdep complaint about nested acquisition of the CPU hotplug
lock later in the series.

Signed-off-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Acked-by: Steffen Klassert <steffen.klassert@secunet.com>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: Lai Jiangshan <jiangshanlai@gmail.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Tejun Heo <tj@kernel.org>
Cc: linux-crypto@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

1 files changed, 20 insertions, 7 deletions

diff --git a/kernel/padata.c b/kernel/padata.c
index 58728cd7f40c..9a17922ec436 100644
--- a/kernel/padata.c
+++ b/kernel/padata.c
@@ -94,17 +94,19 @@ static void padata_parallel_worker(struct work_struct *parallel_work)
  *
  * @pinst: padata instance
  * @padata: object to be parallelized
- * @cb_cpu: cpu the serialization callback function will run on,
- *          must be in the serial cpumask of padata(i.e. cpumask.cbcpu).
+ * @cb_cpu: pointer to the CPU that the serialization callback function should
+ *          run on.  If it's not in the serial cpumask of @pinst
+ *          (i.e. cpumask.cbcpu), this function selects a fallback CPU and if
+ *          none found, returns -EINVAL.
  *
  * The parallelization callback function will run with BHs off.
  * Note: Every object which is parallelized by padata_do_parallel
  * must be seen by padata_do_serial.
  */
 int padata_do_parallel(struct padata_instance *pinst,
-                       struct padata_priv *padata, int cb_cpu)
+                       struct padata_priv *padata, int *cb_cpu)
 {
-        int target_cpu, err;
+        int i, cpu, cpu_index, target_cpu, err;
         struct padata_parallel_queue *queue;
         struct parallel_data *pd;
 
@@ -116,8 +118,19 @@ int padata_do_parallel(struct padata_instance *pinst,
         if (!(pinst->flags & PADATA_INIT) || pinst->flags & PADATA_INVALID)
                 goto out;
 
-        if (!cpumask_test_cpu(cb_cpu, pd->cpumask.cbcpu))
-                goto out;
+        if (!cpumask_test_cpu(*cb_cpu, pd->cpumask.cbcpu)) {
+                if (!cpumask_weight(pd->cpumask.cbcpu))
+                        goto out;
+
+                /* Select an alternate fallback CPU and notify the caller. */
+                cpu_index = *cb_cpu % cpumask_weight(pd->cpumask.cbcpu);
+
+                cpu = cpumask_first(pd->cpumask.cbcpu);
+                for (i = 0; i < cpu_index; i++)
+                        cpu = cpumask_next(cpu, pd->cpumask.cbcpu);
+
+                *cb_cpu = cpu;
+        }
 
         err =  -EBUSY;
         if ((pinst->flags & PADATA_RESET))
@@ -129,7 +142,7 @@ int padata_do_parallel(struct padata_instance *pinst,
         err = 0;
         atomic_inc(&pd->refcnt);
         padata->pd = pd;
-        padata->cb_cpu = cb_cpu;
+        padata->cb_cpu = *cb_cpu;
 
         target_cpu = padata_cpu_hash(pd);
         padata->cpu = target_cpu;