[PATCH v3 1/2] irq/matrix: Split out the CPU finding code into a helper

[Dou Liyang]

From: Dou Liyang <douly.f...@cn.fujitsu.com>

Linux finds the CPU which has the lowest vector allocation count to spread
out the non managed interrupt across the possible target CPUs.

This common CPU finding code will also be used in managed case,

So Split it out into a helper for preparation.

Signed-off-by: Dou Liyang <douly.f...@cn.fujitsu.com>
---
Changelog v3 --> v2

 - Make the matrix_find_best_cpu() simple and obvious suggested by tglx
 - Remove the indentation totally suggested by tglx

 kernel/irq/matrix.c | 65 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 38 insertions(+), 27 deletions(-)

diff --git a/kernel/irq/matrix.c b/kernel/irq/matrix.c
index 5092494bf261..67768bbe736e 100644
--- a/kernel/irq/matrix.c
+++ b/kernel/irq/matrix.c
@@ -124,6 +124,27 @@ static unsigned int matrix_alloc_area(struct irq_matrix 
*m, struct cpumap *cm,
        return area;
 }
 
+/* Find the best CPU which has the lowest vector allocation count */
+static unsigned int matrix_find_best_cpu(struct irq_matrix *m,
+                                       const struct cpumask *msk)
+{
+       unsigned int cpu, best_cpu, maxavl = 0;
+       struct cpumap *cm;
+
+       best_cpu = UINT_MAX;
+
+       for_each_cpu(cpu, msk) {
+               cm = per_cpu_ptr(m->maps, cpu);
+
+               if (!cm->online || cm->available <= maxavl)
+                       continue;
+
+               best_cpu = cpu;
+               maxavl = cm->available;
+       }
+       return best_cpu;
+}
+
 /**
  * irq_matrix_assign_system - Assign system wide entry in the matrix
  * @m:         Matrix pointer
@@ -322,37 +343,27 @@ void irq_matrix_remove_reserved(struct irq_matrix *m)
 int irq_matrix_alloc(struct irq_matrix *m, const struct cpumask *msk,
                     bool reserved, unsigned int *mapped_cpu)
 {
-       unsigned int cpu, best_cpu, maxavl = 0;
+       unsigned int cpu, bit;
        struct cpumap *cm;
-       unsigned int bit;
 
-       best_cpu = UINT_MAX;
-       for_each_cpu(cpu, msk) {
-               cm = per_cpu_ptr(m->maps, cpu);
-
-               if (!cm->online || cm->available <= maxavl)
-                       continue;
+       cpu = matrix_find_best_cpu(m, msk);
+       if (cpu == UINT_MAX)
+               return -ENOSPC;
 
-               best_cpu = cpu;
-               maxavl = cm->available;
-       }
+       cm = per_cpu_ptr(m->maps, cpu);
+       bit = matrix_alloc_area(m, cm, 1, false);
+       if (bit >= m->alloc_end)
+               return -ENOSPC;
+       cm->allocated++;
+       cm->available--;
+       m->total_allocated++;
+       m->global_available--;
+       if (reserved)
+               m->global_reserved--;
+       *mapped_cpu = cpu;
+       trace_irq_matrix_alloc(bit, cpu, m, cm);
+       return bit;
 
-       if (maxavl) {
-               cm = per_cpu_ptr(m->maps, best_cpu);
-               bit = matrix_alloc_area(m, cm, 1, false);
-               if (bit < m->alloc_end) {
-                       cm->allocated++;
-                       cm->available--;
-                       m->total_allocated++;
-                       m->global_available--;
-                       if (reserved)
-                               m->global_reserved--;
-                       *mapped_cpu = best_cpu;
-                       trace_irq_matrix_alloc(bit, best_cpu, m, cm);
-                       return bit;
-               }
-       }
-       return -ENOSPC;
 }
 
 /**
-- 
2.14.3