kernel/smp.c: cleanups

We sometimes use "struct call_single_data *data" and sometimes "struct
call_single_data *csd".  Use "csd" consistently.

We sometimes use "struct call_function_data *data" and sometimes "struct
call_function_data *cfd".  Use "cfd" consistently.

Also, avoid some 80-col layout tricks.

Cc: Ingo Molnar <mingo@elte.hu>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Shaohua Li <shli@fusionio.com>
Cc: Shaohua Li <shli@kernel.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/kernel/smp.c b/kernel/smp.c
index b320622543e901741eda59d636ed812b4329d60a..4dba0f7b72ad716cf447f1fdbdd082ff7e0e73cf 100644 (file)
--- a/kernel/smp.c
+++ b/kernel/smp.c
@@ -100,16 +100,16 @@ void __init call_function_init(void)
  * previous function call. For multi-cpu calls its even more interesting
  * as we'll have to ensure no other cpu is observing our csd.
  */
-static void csd_lock_wait(struct call_single_data *data)
+static void csd_lock_wait(struct call_single_data *csd)
 {
-       while (data->flags & CSD_FLAG_LOCK)
+       while (csd->flags & CSD_FLAG_LOCK)
                cpu_relax();
 }
 
-static void csd_lock(struct call_single_data *data)
+static void csd_lock(struct call_single_data *csd)
 {
-       csd_lock_wait(data);
-       data->flags |= CSD_FLAG_LOCK;
+       csd_lock_wait(csd);
+       csd->flags |= CSD_FLAG_LOCK;
 
        /*
         * prevent CPU from reordering the above assignment
@@ -119,16 +119,16 @@ static void csd_lock(struct call_single_data *data)
        smp_mb();
 }
 
-static void csd_unlock(struct call_single_data *data)
+static void csd_unlock(struct call_single_data *csd)
 {
-       WARN_ON(!(data->flags & CSD_FLAG_LOCK));
+       WARN_ON(!(csd->flags & CSD_FLAG_LOCK));
 
        /*
         * ensure we're all done before releasing data:
         */
        smp_mb();
 
-       data->flags &= ~CSD_FLAG_LOCK;
+       csd->flags &= ~CSD_FLAG_LOCK;
 }
 
 /*
@@ -137,7 +137,7 @@ static void csd_unlock(struct call_single_data *data)
  * ->func, ->info, and ->flags set.
  */
 static
-void generic_exec_single(int cpu, struct call_single_data *data, int wait)
+void generic_exec_single(int cpu, struct call_single_data *csd, int wait)
 {
        struct call_single_queue *dst = &per_cpu(call_single_queue, cpu);
        unsigned long flags;
@@ -145,7 +145,7 @@ void generic_exec_single(int cpu, struct call_single_data *data, int wait)
 
        raw_spin_lock_irqsave(&dst->lock, flags);
        ipi = list_empty(&dst->list);
-       list_add_tail(&data->list, &dst->list);
+       list_add_tail(&csd->list, &dst->list);
        raw_spin_unlock_irqrestore(&dst->lock, flags);
 
        /*
@@ -163,7 +163,7 @@ void generic_exec_single(int cpu, struct call_single_data *data, int wait)
                arch_send_call_function_single_ipi(cpu);
 
        if (wait)
-               csd_lock_wait(data);
+               csd_lock_wait(csd);
 }
 
 /*
@@ -173,7 +173,6 @@ void generic_exec_single(int cpu, struct call_single_data *data, int wait)
 void generic_smp_call_function_single_interrupt(void)
 {
        struct call_single_queue *q = &__get_cpu_var(call_single_queue);
-       unsigned int data_flags;
        LIST_HEAD(list);
 
        /*
@@ -186,25 +185,26 @@ void generic_smp_call_function_single_interrupt(void)
        raw_spin_unlock(&q->lock);
 
        while (!list_empty(&list)) {
-               struct call_single_data *data;
+               struct call_single_data *csd;
+               unsigned int csd_flags;
 
-               data = list_entry(list.next, struct call_single_data, list);
-               list_del(&data->list);
+               csd = list_entry(list.next, struct call_single_data, list);
+               list_del(&csd->list);
 
                /*
-                * 'data' can be invalid after this call if flags == 0
+                * 'csd' can be invalid after this call if flags == 0
                 * (when called through generic_exec_single()),
                 * so save them away before making the call:
                 */
-               data_flags = data->flags;
+               csd_flags = csd->flags;
 
-               data->func(data->info);
+               csd->func(csd->info);
 
                /*
                 * Unlocked CSDs are valid through generic_exec_single():
                 */
-               if (data_flags & CSD_FLAG_LOCK)
-                       csd_unlock(data);
+               if (csd_flags & CSD_FLAG_LOCK)
+                       csd_unlock(csd);
        }
 }
 
@@ -249,16 +249,16 @@ int smp_call_function_single(int cpu, smp_call_func_t func, void *info,
                local_irq_restore(flags);
        } else {
                if ((unsigned)cpu < nr_cpu_ids && cpu_online(cpu)) {
-                       struct call_single_data *data = &d;
+                       struct call_single_data *csd = &d;
 
                        if (!wait)
-                               data = &__get_cpu_var(csd_data);
+                               csd = &__get_cpu_var(csd_data);
 
-                       csd_lock(data);
+                       csd_lock(csd);
 
-                       data->func = func;
-                       data->info = info;
-                       generic_exec_single(cpu, data, wait);
+                       csd->func = func;
+                       csd->info = info;
+                       generic_exec_single(cpu, csd, wait);
                } else {
                        err = -ENXIO;   /* CPU not online */
                }
@@ -325,7 +325,7 @@ EXPORT_SYMBOL_GPL(smp_call_function_any);
  * pre-allocated data structure. Useful for embedding @data inside
  * other structures, for instance.
  */
-void __smp_call_function_single(int cpu, struct call_single_data *data,
+void __smp_call_function_single(int cpu, struct call_single_data *csd,
                                int wait)
 {
        unsigned int this_cpu;
@@ -343,11 +343,11 @@ void __smp_call_function_single(int cpu, struct call_single_data *data,
 
        if (cpu == this_cpu) {
                local_irq_save(flags);
-               data->func(data->info);
+               csd->func(csd->info);
                local_irq_restore(flags);
        } else {
-               csd_lock(data);
-               generic_exec_single(cpu, data, wait);
+               csd_lock(csd);
+               generic_exec_single(cpu, csd, wait);
        }
        put_cpu();
 }
@@ -369,7 +369,7 @@ void __smp_call_function_single(int cpu, struct call_single_data *data,
 void smp_call_function_many(const struct cpumask *mask,
                            smp_call_func_t func, void *info, bool wait)
 {
-       struct call_function_data *data;
+       struct call_function_data *cfd;
        int cpu, next_cpu, this_cpu = smp_processor_id();
 
        /*
@@ -401,24 +401,24 @@ void smp_call_function_many(const struct cpumask *mask,
                return;
        }
 
-       data = &__get_cpu_var(cfd_data);
+       cfd = &__get_cpu_var(cfd_data);
 
-       cpumask_and(data->cpumask, mask, cpu_online_mask);
-       cpumask_clear_cpu(this_cpu, data->cpumask);
+       cpumask_and(cfd->cpumask, mask, cpu_online_mask);
+       cpumask_clear_cpu(this_cpu, cfd->cpumask);
 
        /* Some callers race with other cpus changing the passed mask */
-       if (unlikely(!cpumask_weight(data->cpumask)))
+       if (unlikely(!cpumask_weight(cfd->cpumask)))
                return;
 
        /*
-        * After we put an entry into the list, data->cpumask
-        * may be cleared again when another CPU sends another IPI for
-        * a SMP function call, so data->cpumask will be zero.
+        * After we put an entry into the list, cfd->cpumask may be cleared
+        * again when another CPU sends another IPI for a SMP function call, so
+        * cfd->cpumask will be zero.
         */
-       cpumask_copy(data->cpumask_ipi, data->cpumask);
+       cpumask_copy(cfd->cpumask_ipi, cfd->cpumask);
 
-       for_each_cpu(cpu, data->cpumask) {
-               struct call_single_data *csd = per_cpu_ptr(data->csd, cpu);
+       for_each_cpu(cpu, cfd->cpumask) {
+               struct call_single_data *csd = per_cpu_ptr(cfd->csd, cpu);
                struct call_single_queue *dst =
                                        &per_cpu(call_single_queue, cpu);
                unsigned long flags;
@@ -433,12 +433,13 @@ void smp_call_function_many(const struct cpumask *mask,
        }
 
        /* Send a message to all CPUs in the map */
-       arch_send_call_function_ipi_mask(data->cpumask_ipi);
+       arch_send_call_function_ipi_mask(cfd->cpumask_ipi);
 
        if (wait) {
-               for_each_cpu(cpu, data->cpumask) {
-                       struct call_single_data *csd =
-                                       per_cpu_ptr(data->csd, cpu);
+               for_each_cpu(cpu, cfd->cpumask) {
+                       struct call_single_data *csd;
+
+                       csd = per_cpu_ptr(cfd->csd, cpu);
                        csd_lock_wait(csd);
                }
        }