blob: fb67dfa8394edc70174a51fd93b72965a3929b71 [file] [log] [blame]
Jens Axboe3d442232008-06-26 11:21:34 +02001/*
2 * Generic helpers for smp ipi calls
3 *
4 * (C) Jens Axboe <jens.axboe@oracle.com> 2008
Jens Axboe3d442232008-06-26 11:21:34 +02005 */
Jens Axboe3d442232008-06-26 11:21:34 +02006#include <linux/rcupdate.h>
Linus Torvalds59190f42008-07-15 14:02:33 -07007#include <linux/rculist.h>
Ingo Molnar641cd4c2009-03-13 10:47:34 +01008#include <linux/kernel.h>
Ingo Molnar0b13fda2009-02-25 16:52:11 +01009#include <linux/module.h>
10#include <linux/percpu.h>
11#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090012#include <linux/gfp.h>
Jens Axboe3d442232008-06-26 11:21:34 +020013#include <linux/smp.h>
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010014#include <linux/cpu.h>
Jens Axboe3d442232008-06-26 11:21:34 +020015
Amerigo Wang351f8f82011-01-12 16:59:39 -080016#ifdef CONFIG_USE_GENERIC_SMP_HELPERS
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010017static struct {
18 struct list_head queue;
Thomas Gleixner9f5a5622009-11-17 15:40:01 +010019 raw_spinlock_t lock;
Ingo Molnar0b13fda2009-02-25 16:52:11 +010020} call_function __cacheline_aligned_in_smp =
21 {
22 .queue = LIST_HEAD_INIT(call_function.queue),
Thomas Gleixner9f5a5622009-11-17 15:40:01 +010023 .lock = __RAW_SPIN_LOCK_UNLOCKED(call_function.lock),
Ingo Molnar0b13fda2009-02-25 16:52:11 +010024 };
Jens Axboe3d442232008-06-26 11:21:34 +020025
26enum {
Peter Zijlstra6e275632009-02-25 13:59:48 +010027 CSD_FLAG_LOCK = 0x01,
Jens Axboe3d442232008-06-26 11:21:34 +020028};
29
30struct call_function_data {
Ingo Molnar0b13fda2009-02-25 16:52:11 +010031 struct call_single_data csd;
Xiao Guangrong54fdade2009-09-22 16:43:39 -070032 atomic_t refs;
Ingo Molnar0b13fda2009-02-25 16:52:11 +010033 cpumask_var_t cpumask;
Jens Axboe3d442232008-06-26 11:21:34 +020034};
35
Milton Millere03bcb62010-01-18 13:00:51 +110036static DEFINE_PER_CPU_SHARED_ALIGNED(struct call_function_data, cfd_data);
37
Jens Axboe3d442232008-06-26 11:21:34 +020038struct call_single_queue {
Ingo Molnar0b13fda2009-02-25 16:52:11 +010039 struct list_head list;
Thomas Gleixner9f5a5622009-11-17 15:40:01 +010040 raw_spinlock_t lock;
Jens Axboe3d442232008-06-26 11:21:34 +020041};
42
Milton Millere03bcb62010-01-18 13:00:51 +110043static DEFINE_PER_CPU_SHARED_ALIGNED(struct call_single_queue, call_single_queue);
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010044
45static int
46hotplug_cfd(struct notifier_block *nfb, unsigned long action, void *hcpu)
47{
48 long cpu = (long)hcpu;
49 struct call_function_data *cfd = &per_cpu(cfd_data, cpu);
50
51 switch (action) {
52 case CPU_UP_PREPARE:
53 case CPU_UP_PREPARE_FROZEN:
Yinghai Lueaa95842009-06-06 14:51:36 -070054 if (!zalloc_cpumask_var_node(&cfd->cpumask, GFP_KERNEL,
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010055 cpu_to_node(cpu)))
Akinobu Mita80b51842010-05-26 14:43:32 -070056 return notifier_from_errno(-ENOMEM);
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010057 break;
58
Xiao Guangrong69dd6472009-08-06 15:07:29 -070059#ifdef CONFIG_HOTPLUG_CPU
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010060 case CPU_UP_CANCELED:
61 case CPU_UP_CANCELED_FROZEN:
62
63 case CPU_DEAD:
64 case CPU_DEAD_FROZEN:
65 free_cpumask_var(cfd->cpumask);
66 break;
67#endif
68 };
69
70 return NOTIFY_OK;
71}
72
73static struct notifier_block __cpuinitdata hotplug_cfd_notifier = {
Ingo Molnar0b13fda2009-02-25 16:52:11 +010074 .notifier_call = hotplug_cfd,
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010075};
76
Takao Indohd8ad7d12011-03-29 12:35:04 -040077void __init call_function_init(void)
Jens Axboe3d442232008-06-26 11:21:34 +020078{
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010079 void *cpu = (void *)(long)smp_processor_id();
Jens Axboe3d442232008-06-26 11:21:34 +020080 int i;
81
82 for_each_possible_cpu(i) {
83 struct call_single_queue *q = &per_cpu(call_single_queue, i);
84
Thomas Gleixner9f5a5622009-11-17 15:40:01 +010085 raw_spin_lock_init(&q->lock);
Jens Axboe3d442232008-06-26 11:21:34 +020086 INIT_LIST_HEAD(&q->list);
87 }
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010088
89 hotplug_cfd(&hotplug_cfd_notifier, CPU_UP_PREPARE, cpu);
90 register_cpu_notifier(&hotplug_cfd_notifier);
Jens Axboe3d442232008-06-26 11:21:34 +020091}
92
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010093/*
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010094 * csd_lock/csd_unlock used to serialize access to per-cpu csd resources
95 *
Ingo Molnar0b13fda2009-02-25 16:52:11 +010096 * For non-synchronous ipi calls the csd can still be in use by the
97 * previous function call. For multi-cpu calls its even more interesting
98 * as we'll have to ensure no other cpu is observing our csd.
Peter Zijlstra8969a5e2009-02-25 13:59:47 +010099 */
Peter Zijlstra6e275632009-02-25 13:59:48 +0100100static void csd_lock_wait(struct call_single_data *data)
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100101{
102 while (data->flags & CSD_FLAG_LOCK)
103 cpu_relax();
Peter Zijlstra6e275632009-02-25 13:59:48 +0100104}
105
106static void csd_lock(struct call_single_data *data)
107{
108 csd_lock_wait(data);
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100109 data->flags = CSD_FLAG_LOCK;
110
111 /*
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100112 * prevent CPU from reordering the above assignment
113 * to ->flags with any subsequent assignments to other
114 * fields of the specified call_single_data structure:
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100115 */
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100116 smp_mb();
117}
118
119static void csd_unlock(struct call_single_data *data)
120{
121 WARN_ON(!(data->flags & CSD_FLAG_LOCK));
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100122
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100123 /*
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100124 * ensure we're all done before releasing data:
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100125 */
126 smp_mb();
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100127
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100128 data->flags &= ~CSD_FLAG_LOCK;
Jens Axboe3d442232008-06-26 11:21:34 +0200129}
130
131/*
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100132 * Insert a previously allocated call_single_data element
133 * for execution on the given CPU. data must already have
134 * ->func, ->info, and ->flags set.
Jens Axboe3d442232008-06-26 11:21:34 +0200135 */
Peter Zijlstra6e275632009-02-25 13:59:48 +0100136static
137void generic_exec_single(int cpu, struct call_single_data *data, int wait)
Jens Axboe3d442232008-06-26 11:21:34 +0200138{
139 struct call_single_queue *dst = &per_cpu(call_single_queue, cpu);
Jens Axboe3d442232008-06-26 11:21:34 +0200140 unsigned long flags;
Peter Zijlstra6e275632009-02-25 13:59:48 +0100141 int ipi;
Jens Axboe3d442232008-06-26 11:21:34 +0200142
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100143 raw_spin_lock_irqsave(&dst->lock, flags);
Jens Axboe3d442232008-06-26 11:21:34 +0200144 ipi = list_empty(&dst->list);
145 list_add_tail(&data->list, &dst->list);
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100146 raw_spin_unlock_irqrestore(&dst->lock, flags);
Jens Axboe3d442232008-06-26 11:21:34 +0200147
Suresh Siddha561920a02008-10-30 18:28:41 +0100148 /*
Nick Piggin15d0d3b2009-02-25 06:22:45 +0100149 * The list addition should be visible before sending the IPI
150 * handler locks the list to pull the entry off it because of
151 * normal cache coherency rules implied by spinlocks.
152 *
153 * If IPIs can go out of order to the cache coherency protocol
154 * in an architecture, sufficient synchronisation should be added
155 * to arch code to make it appear to obey cache coherency WRT
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100156 * locking and barrier primitives. Generic code isn't really
157 * equipped to do the right thing...
Suresh Siddha561920a02008-10-30 18:28:41 +0100158 */
Jens Axboe3d442232008-06-26 11:21:34 +0200159 if (ipi)
160 arch_send_call_function_single_ipi(cpu);
161
162 if (wait)
Peter Zijlstra6e275632009-02-25 13:59:48 +0100163 csd_lock_wait(data);
Jens Axboe3d442232008-06-26 11:21:34 +0200164}
165
166/*
167 * Invoked by arch to handle an IPI for call function. Must be called with
168 * interrupts disabled.
169 */
170void generic_smp_call_function_interrupt(void)
171{
172 struct call_function_data *data;
Xiao Guangrongc0f68c22009-12-14 18:00:16 -0800173 int cpu = smp_processor_id();
Jens Axboe3d442232008-06-26 11:21:34 +0200174
175 /*
Suresh Siddha269c8612009-08-19 18:05:35 -0700176 * Shouldn't receive this interrupt on a cpu that is not yet online.
177 */
178 WARN_ON_ONCE(!cpu_online(cpu));
179
180 /*
Nick Piggin15d0d3b2009-02-25 06:22:45 +0100181 * Ensure entry is visible on call_function_queue after we have
182 * entered the IPI. See comment in smp_call_function_many.
183 * If we don't have this, then we may miss an entry on the list
184 * and never get another IPI to process it.
185 */
186 smp_mb();
187
188 /*
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100189 * It's ok to use list_for_each_rcu() here even though we may
190 * delete 'pos', since list_del_rcu() doesn't clear ->next
Jens Axboe3d442232008-06-26 11:21:34 +0200191 */
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100192 list_for_each_entry_rcu(data, &call_function.queue, csd.list) {
Jens Axboe3d442232008-06-26 11:21:34 +0200193 int refs;
Milton Millerc8def552011-03-15 13:27:17 -0600194 smp_call_func_t func;
Jens Axboe3d442232008-06-26 11:21:34 +0200195
Anton Blanchard6dc19892011-01-20 14:44:33 -0800196 /*
197 * Since we walk the list without any locks, we might
198 * see an entry that was completed, removed from the
199 * list and is in the process of being reused.
200 *
201 * We must check that the cpu is in the cpumask before
202 * checking the refs, and both must be set before
203 * executing the callback on this cpu.
204 */
205
206 if (!cpumask_test_cpu(cpu, data->cpumask))
207 continue;
208
209 smp_rmb();
210
211 if (atomic_read(&data->refs) == 0)
212 continue;
213
Milton Millerc8def552011-03-15 13:27:17 -0600214 func = data->csd.func; /* save for later warn */
215 func(data->csd.info);
Jens Axboe3d442232008-06-26 11:21:34 +0200216
Milton Miller225c8e02011-01-20 14:44:34 -0800217 /*
Milton Millerc8def552011-03-15 13:27:17 -0600218 * If the cpu mask is not still set then func enabled
219 * interrupts (BUG), and this cpu took another smp call
220 * function interrupt and executed func(info) twice
221 * on this cpu. That nested execution decremented refs.
Milton Miller225c8e02011-01-20 14:44:34 -0800222 */
223 if (!cpumask_test_and_clear_cpu(cpu, data->cpumask)) {
Milton Millerc8def552011-03-15 13:27:17 -0600224 WARN(1, "%pf enabled interrupts and double executed\n", func);
Milton Miller225c8e02011-01-20 14:44:34 -0800225 continue;
226 }
227
Xiao Guangrong54fdade2009-09-22 16:43:39 -0700228 refs = atomic_dec_return(&data->refs);
229 WARN_ON(refs < 0);
Jens Axboe3d442232008-06-26 11:21:34 +0200230
231 if (refs)
232 continue;
233
Milton Miller225c8e02011-01-20 14:44:34 -0800234 WARN_ON(!cpumask_empty(data->cpumask));
235
236 raw_spin_lock(&call_function.lock);
237 list_del_rcu(&data->csd.list);
238 raw_spin_unlock(&call_function.lock);
239
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100240 csd_unlock(&data->csd);
Jens Axboe3d442232008-06-26 11:21:34 +0200241 }
Jens Axboe3d442232008-06-26 11:21:34 +0200242
Jens Axboe3d442232008-06-26 11:21:34 +0200243}
244
245/*
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100246 * Invoked by arch to handle an IPI for call function single. Must be
247 * called from the arch with interrupts disabled.
Jens Axboe3d442232008-06-26 11:21:34 +0200248 */
249void generic_smp_call_function_single_interrupt(void)
250{
251 struct call_single_queue *q = &__get_cpu_var(call_single_queue);
Nick Piggin15d0d3b2009-02-25 06:22:45 +0100252 unsigned int data_flags;
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100253 LIST_HEAD(list);
Jens Axboe3d442232008-06-26 11:21:34 +0200254
Suresh Siddha269c8612009-08-19 18:05:35 -0700255 /*
256 * Shouldn't receive this interrupt on a cpu that is not yet online.
257 */
258 WARN_ON_ONCE(!cpu_online(smp_processor_id()));
259
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100260 raw_spin_lock(&q->lock);
Nick Piggin15d0d3b2009-02-25 06:22:45 +0100261 list_replace_init(&q->list, &list);
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100262 raw_spin_unlock(&q->lock);
Jens Axboe3d442232008-06-26 11:21:34 +0200263
Nick Piggin15d0d3b2009-02-25 06:22:45 +0100264 while (!list_empty(&list)) {
265 struct call_single_data *data;
Jens Axboe3d442232008-06-26 11:21:34 +0200266
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100267 data = list_entry(list.next, struct call_single_data, list);
Nick Piggin15d0d3b2009-02-25 06:22:45 +0100268 list_del(&data->list);
Jens Axboe3d442232008-06-26 11:21:34 +0200269
Jens Axboe3d442232008-06-26 11:21:34 +0200270 /*
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100271 * 'data' can be invalid after this call if flags == 0
272 * (when called through generic_exec_single()),
273 * so save them away before making the call:
Jens Axboe3d442232008-06-26 11:21:34 +0200274 */
Nick Piggin15d0d3b2009-02-25 06:22:45 +0100275 data_flags = data->flags;
276
277 data->func(data->info);
278
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100279 /*
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100280 * Unlocked CSDs are valid through generic_exec_single():
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100281 */
282 if (data_flags & CSD_FLAG_LOCK)
283 csd_unlock(data);
Jens Axboe3d442232008-06-26 11:21:34 +0200284 }
285}
286
Milton Millere03bcb62010-01-18 13:00:51 +1100287static DEFINE_PER_CPU_SHARED_ALIGNED(struct call_single_data, csd_data);
Steven Rostedtd7240b92009-01-29 10:08:01 -0500288
Jens Axboe3d442232008-06-26 11:21:34 +0200289/*
290 * smp_call_function_single - Run a function on a specific CPU
291 * @func: The function to run. This must be fast and non-blocking.
292 * @info: An arbitrary pointer to pass to the function.
Jens Axboe3d442232008-06-26 11:21:34 +0200293 * @wait: If true, wait until function has completed on other CPUs.
294 *
Sheng Yang72f279b2009-10-22 19:19:34 +0800295 * Returns 0 on success, else a negative status code.
Jens Axboe3d442232008-06-26 11:21:34 +0200296 */
David Howells3a5f65d2010-10-27 17:28:36 +0100297int smp_call_function_single(int cpu, smp_call_func_t func, void *info,
Jens Axboe8691e5a2008-06-06 11:18:06 +0200298 int wait)
Jens Axboe3d442232008-06-26 11:21:34 +0200299{
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100300 struct call_single_data d = {
301 .flags = 0,
302 };
Jens Axboe3d442232008-06-26 11:21:34 +0200303 unsigned long flags;
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100304 int this_cpu;
H. Peter Anvinf73be6d2008-08-25 17:07:14 -0700305 int err = 0;
Jens Axboe3d442232008-06-26 11:21:34 +0200306
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100307 /*
308 * prevent preemption and reschedule on another processor,
309 * as well as CPU removal
310 */
311 this_cpu = get_cpu();
312
Suresh Siddha269c8612009-08-19 18:05:35 -0700313 /*
314 * Can deadlock when called with interrupts disabled.
315 * We allow cpu's that are not yet online though, as no one else can
316 * send smp call function interrupt to this cpu and as such deadlocks
317 * can't happen.
318 */
319 WARN_ON_ONCE(cpu_online(this_cpu) && irqs_disabled()
320 && !oops_in_progress);
Jens Axboe3d442232008-06-26 11:21:34 +0200321
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100322 if (cpu == this_cpu) {
Jens Axboe3d442232008-06-26 11:21:34 +0200323 local_irq_save(flags);
324 func(info);
325 local_irq_restore(flags);
H. Peter Anvinf73be6d2008-08-25 17:07:14 -0700326 } else {
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100327 if ((unsigned)cpu < nr_cpu_ids && cpu_online(cpu)) {
328 struct call_single_data *data = &d;
329
330 if (!wait)
331 data = &__get_cpu_var(csd_data);
332
333 csd_lock(data);
334
335 data->func = func;
336 data->info = info;
337 generic_exec_single(cpu, data, wait);
338 } else {
339 err = -ENXIO; /* CPU not online */
340 }
Jens Axboe3d442232008-06-26 11:21:34 +0200341 }
342
343 put_cpu();
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100344
H. Peter Anvinf73be6d2008-08-25 17:07:14 -0700345 return err;
Jens Axboe3d442232008-06-26 11:21:34 +0200346}
347EXPORT_SYMBOL(smp_call_function_single);
348
Rusty Russell2ea6dec2009-11-17 14:27:27 -0800349/*
350 * smp_call_function_any - Run a function on any of the given cpus
351 * @mask: The mask of cpus it can run on.
352 * @func: The function to run. This must be fast and non-blocking.
353 * @info: An arbitrary pointer to pass to the function.
354 * @wait: If true, wait until function has completed.
355 *
356 * Returns 0 on success, else a negative status code (if no cpus were online).
357 * Note that @wait will be implicitly turned on in case of allocation failures,
358 * since we fall back to on-stack allocation.
359 *
360 * Selection preference:
361 * 1) current cpu if in @mask
362 * 2) any cpu of current node if in @mask
363 * 3) any other online cpu in @mask
364 */
365int smp_call_function_any(const struct cpumask *mask,
David Howells3a5f65d2010-10-27 17:28:36 +0100366 smp_call_func_t func, void *info, int wait)
Rusty Russell2ea6dec2009-11-17 14:27:27 -0800367{
368 unsigned int cpu;
369 const struct cpumask *nodemask;
370 int ret;
371
372 /* Try for same CPU (cheapest) */
373 cpu = get_cpu();
374 if (cpumask_test_cpu(cpu, mask))
375 goto call;
376
377 /* Try for same node. */
David Johnaf2422c2010-01-15 17:01:23 -0800378 nodemask = cpumask_of_node(cpu_to_node(cpu));
Rusty Russell2ea6dec2009-11-17 14:27:27 -0800379 for (cpu = cpumask_first_and(nodemask, mask); cpu < nr_cpu_ids;
380 cpu = cpumask_next_and(cpu, nodemask, mask)) {
381 if (cpu_online(cpu))
382 goto call;
383 }
384
385 /* Any online will do: smp_call_function_single handles nr_cpu_ids. */
386 cpu = cpumask_any_and(mask, cpu_online_mask);
387call:
388 ret = smp_call_function_single(cpu, func, info, wait);
389 put_cpu();
390 return ret;
391}
392EXPORT_SYMBOL_GPL(smp_call_function_any);
393
Jens Axboe3d442232008-06-26 11:21:34 +0200394/**
Heiko Carstens27c379f2010-09-10 13:47:29 +0200395 * __smp_call_function_single(): Run a function on a specific CPU
Jens Axboe3d442232008-06-26 11:21:34 +0200396 * @cpu: The CPU to run on.
397 * @data: Pre-allocated and setup data structure
Heiko Carstens27c379f2010-09-10 13:47:29 +0200398 * @wait: If true, wait until function has completed on specified CPU.
Jens Axboe3d442232008-06-26 11:21:34 +0200399 *
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100400 * Like smp_call_function_single(), but allow caller to pass in a
401 * pre-allocated data structure. Useful for embedding @data inside
402 * other structures, for instance.
Jens Axboe3d442232008-06-26 11:21:34 +0200403 */
Peter Zijlstra6e275632009-02-25 13:59:48 +0100404void __smp_call_function_single(int cpu, struct call_single_data *data,
405 int wait)
Jens Axboe3d442232008-06-26 11:21:34 +0200406{
Heiko Carstens27c379f2010-09-10 13:47:29 +0200407 unsigned int this_cpu;
408 unsigned long flags;
Jens Axboe3d442232008-06-26 11:21:34 +0200409
Heiko Carstens27c379f2010-09-10 13:47:29 +0200410 this_cpu = get_cpu();
Suresh Siddha269c8612009-08-19 18:05:35 -0700411 /*
412 * Can deadlock when called with interrupts disabled.
413 * We allow cpu's that are not yet online though, as no one else can
414 * send smp call function interrupt to this cpu and as such deadlocks
415 * can't happen.
416 */
417 WARN_ON_ONCE(cpu_online(smp_processor_id()) && wait && irqs_disabled()
418 && !oops_in_progress);
Peter Zijlstra6e275632009-02-25 13:59:48 +0100419
Heiko Carstens27c379f2010-09-10 13:47:29 +0200420 if (cpu == this_cpu) {
421 local_irq_save(flags);
422 data->func(data->info);
423 local_irq_restore(flags);
424 } else {
425 csd_lock(data);
426 generic_exec_single(cpu, data, wait);
427 }
428 put_cpu();
Jens Axboe3d442232008-06-26 11:21:34 +0200429}
430
431/**
Rusty Russell54b11e62008-12-30 09:05:16 +1030432 * smp_call_function_many(): Run a function on a set of other CPUs.
433 * @mask: The set of cpus to run on (only runs on online subset).
Jens Axboe3d442232008-06-26 11:21:34 +0200434 * @func: The function to run. This must be fast and non-blocking.
435 * @info: An arbitrary pointer to pass to the function.
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100436 * @wait: If true, wait (atomically) until function has completed
437 * on other CPUs.
Jens Axboe3d442232008-06-26 11:21:34 +0200438 *
Sheng Yang72f279b2009-10-22 19:19:34 +0800439 * If @wait is true, then returns once @func has returned.
Jens Axboe3d442232008-06-26 11:21:34 +0200440 *
441 * You must not call this function with disabled interrupts or from a
442 * hardware interrupt handler or from a bottom half handler. Preemption
443 * must be disabled when calling this function.
444 */
Rusty Russell54b11e62008-12-30 09:05:16 +1030445void smp_call_function_many(const struct cpumask *mask,
David Howells3a5f65d2010-10-27 17:28:36 +0100446 smp_call_func_t func, void *info, bool wait)
Jens Axboe3d442232008-06-26 11:21:34 +0200447{
Rusty Russell54b11e62008-12-30 09:05:16 +1030448 struct call_function_data *data;
Jens Axboe3d442232008-06-26 11:21:34 +0200449 unsigned long flags;
Milton Miller723aae22011-03-15 13:27:17 -0600450 int refs, cpu, next_cpu, this_cpu = smp_processor_id();
Jens Axboe3d442232008-06-26 11:21:34 +0200451
Suresh Siddha269c8612009-08-19 18:05:35 -0700452 /*
453 * Can deadlock when called with interrupts disabled.
454 * We allow cpu's that are not yet online though, as no one else can
455 * send smp call function interrupt to this cpu and as such deadlocks
456 * can't happen.
457 */
458 WARN_ON_ONCE(cpu_online(this_cpu) && irqs_disabled()
Tejun Heobd924e82011-01-20 12:07:13 +0100459 && !oops_in_progress && !early_boot_irqs_disabled);
Jens Axboe3d442232008-06-26 11:21:34 +0200460
Milton Miller723aae22011-03-15 13:27:17 -0600461 /* Try to fastpath. So, what's a CPU they want? Ignoring this one. */
Rusty Russell54b11e62008-12-30 09:05:16 +1030462 cpu = cpumask_first_and(mask, cpu_online_mask);
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100463 if (cpu == this_cpu)
Rusty Russell54b11e62008-12-30 09:05:16 +1030464 cpu = cpumask_next_and(cpu, mask, cpu_online_mask);
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100465
Rusty Russell54b11e62008-12-30 09:05:16 +1030466 /* No online cpus? We're done. */
467 if (cpu >= nr_cpu_ids)
468 return;
Jens Axboe3d442232008-06-26 11:21:34 +0200469
Rusty Russell54b11e62008-12-30 09:05:16 +1030470 /* Do we have another CPU which isn't us? */
471 next_cpu = cpumask_next_and(cpu, mask, cpu_online_mask);
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100472 if (next_cpu == this_cpu)
Rusty Russell54b11e62008-12-30 09:05:16 +1030473 next_cpu = cpumask_next_and(next_cpu, mask, cpu_online_mask);
474
475 /* Fastpath: do that cpu by itself. */
476 if (next_cpu >= nr_cpu_ids) {
477 smp_call_function_single(cpu, func, info, wait);
478 return;
Jens Axboe3d442232008-06-26 11:21:34 +0200479 }
480
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100481 data = &__get_cpu_var(cfd_data);
482 csd_lock(&data->csd);
Milton Miller45a57912011-03-15 13:27:16 -0600483
484 /* This BUG_ON verifies our reuse assertions and can be removed */
Anton Blanchard6dc19892011-01-20 14:44:33 -0800485 BUG_ON(atomic_read(&data->refs) || !cpumask_empty(data->cpumask));
Jens Axboe3d442232008-06-26 11:21:34 +0200486
Milton Miller45a57912011-03-15 13:27:16 -0600487 /*
488 * The global call function queue list add and delete are protected
489 * by a lock, but the list is traversed without any lock, relying
490 * on the rcu list add and delete to allow safe concurrent traversal.
491 * We reuse the call function data without waiting for any grace
492 * period after some other cpu removes it from the global queue.
493 * This means a cpu might find our data block as it is being
494 * filled out.
495 *
496 * We hold off the interrupt handler on the other cpu by
497 * ordering our writes to the cpu mask vs our setting of the
498 * refs counter. We assert only the cpu owning the data block
499 * will set a bit in cpumask, and each bit will only be cleared
500 * by the subject cpu. Each cpu must first find its bit is
501 * set and then check that refs is set indicating the element is
502 * ready to be processed, otherwise it must skip the entry.
503 *
504 * On the previous iteration refs was set to 0 by another cpu.
505 * To avoid the use of transitivity, set the counter to 0 here
506 * so the wmb will pair with the rmb in the interrupt handler.
507 */
508 atomic_set(&data->refs, 0); /* convert 3rd to 1st party write */
509
Jens Axboe3d442232008-06-26 11:21:34 +0200510 data->csd.func = func;
511 data->csd.info = info;
Milton Miller45a57912011-03-15 13:27:16 -0600512
513 /* Ensure 0 refs is visible before mask. Also orders func and info */
514 smp_wmb();
515
516 /* We rely on the "and" being processed before the store */
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100517 cpumask_and(data->cpumask, mask, cpu_online_mask);
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100518 cpumask_clear_cpu(this_cpu, data->cpumask);
Milton Miller723aae22011-03-15 13:27:17 -0600519 refs = cpumask_weight(data->cpumask);
520
521 /* Some callers race with other cpus changing the passed mask */
522 if (unlikely(!refs)) {
523 csd_unlock(&data->csd);
524 return;
525 }
Anton Blanchard6dc19892011-01-20 14:44:33 -0800526
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100527 raw_spin_lock_irqsave(&call_function.lock, flags);
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100528 /*
529 * Place entry at the _HEAD_ of the list, so that any cpu still
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100530 * observing the entry in generic_smp_call_function_interrupt()
531 * will not miss any other list entries:
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100532 */
533 list_add_rcu(&data->csd.list, &call_function.queue);
Milton Millere6cd1e02011-03-15 13:27:16 -0600534 /*
Milton Miller45a57912011-03-15 13:27:16 -0600535 * We rely on the wmb() in list_add_rcu to complete our writes
536 * to the cpumask before this write to refs, which indicates
537 * data is on the list and is ready to be processed.
Milton Millere6cd1e02011-03-15 13:27:16 -0600538 */
Milton Miller723aae22011-03-15 13:27:17 -0600539 atomic_set(&data->refs, refs);
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100540 raw_spin_unlock_irqrestore(&call_function.lock, flags);
Jens Axboe3d442232008-06-26 11:21:34 +0200541
Suresh Siddha561920a02008-10-30 18:28:41 +0100542 /*
543 * Make the list addition visible before sending the ipi.
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100544 * (IPIs must obey or appear to obey normal Linux cache
545 * coherency rules -- see comment in generic_exec_single).
Suresh Siddha561920a02008-10-30 18:28:41 +0100546 */
547 smp_mb();
548
Jens Axboe3d442232008-06-26 11:21:34 +0200549 /* Send a message to all CPUs in the map */
Peter Zijlstra8969a5e2009-02-25 13:59:47 +0100550 arch_send_call_function_ipi_mask(data->cpumask);
Jens Axboe3d442232008-06-26 11:21:34 +0200551
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100552 /* Optionally wait for the CPUs to complete */
Rusty Russell54b11e62008-12-30 09:05:16 +1030553 if (wait)
Peter Zijlstra6e275632009-02-25 13:59:48 +0100554 csd_lock_wait(&data->csd);
Jens Axboe3d442232008-06-26 11:21:34 +0200555}
Rusty Russell54b11e62008-12-30 09:05:16 +1030556EXPORT_SYMBOL(smp_call_function_many);
Jens Axboe3d442232008-06-26 11:21:34 +0200557
558/**
559 * smp_call_function(): Run a function on all other CPUs.
560 * @func: The function to run. This must be fast and non-blocking.
561 * @info: An arbitrary pointer to pass to the function.
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100562 * @wait: If true, wait (atomically) until function has completed
563 * on other CPUs.
Jens Axboe3d442232008-06-26 11:21:34 +0200564 *
Rusty Russell54b11e62008-12-30 09:05:16 +1030565 * Returns 0.
Jens Axboe3d442232008-06-26 11:21:34 +0200566 *
567 * If @wait is true, then returns once @func has returned; otherwise
Sheng Yang72f279b2009-10-22 19:19:34 +0800568 * it returns just before the target cpu calls @func.
Jens Axboe3d442232008-06-26 11:21:34 +0200569 *
570 * You must not call this function with disabled interrupts or from a
571 * hardware interrupt handler or from a bottom half handler.
572 */
David Howells3a5f65d2010-10-27 17:28:36 +0100573int smp_call_function(smp_call_func_t func, void *info, int wait)
Jens Axboe3d442232008-06-26 11:21:34 +0200574{
Jens Axboe3d442232008-06-26 11:21:34 +0200575 preempt_disable();
Rusty Russell54b11e62008-12-30 09:05:16 +1030576 smp_call_function_many(cpu_online_mask, func, info, wait);
Jens Axboe3d442232008-06-26 11:21:34 +0200577 preempt_enable();
Ingo Molnar0b13fda2009-02-25 16:52:11 +0100578
Rusty Russell54b11e62008-12-30 09:05:16 +1030579 return 0;
Jens Axboe3d442232008-06-26 11:21:34 +0200580}
581EXPORT_SYMBOL(smp_call_function);
582
583void ipi_call_lock(void)
584{
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100585 raw_spin_lock(&call_function.lock);
Jens Axboe3d442232008-06-26 11:21:34 +0200586}
587
588void ipi_call_unlock(void)
589{
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100590 raw_spin_unlock(&call_function.lock);
Jens Axboe3d442232008-06-26 11:21:34 +0200591}
592
593void ipi_call_lock_irq(void)
594{
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100595 raw_spin_lock_irq(&call_function.lock);
Jens Axboe3d442232008-06-26 11:21:34 +0200596}
597
598void ipi_call_unlock_irq(void)
599{
Thomas Gleixner9f5a5622009-11-17 15:40:01 +0100600 raw_spin_unlock_irq(&call_function.lock);
Jens Axboe3d442232008-06-26 11:21:34 +0200601}
Amerigo Wang351f8f82011-01-12 16:59:39 -0800602#endif /* USE_GENERIC_SMP_HELPERS */
603
Amerigo Wang34db18a02011-03-22 16:34:06 -0700604/* Setup configured maximum number of CPUs to activate */
605unsigned int setup_max_cpus = NR_CPUS;
606EXPORT_SYMBOL(setup_max_cpus);
607
608
609/*
610 * Setup routine for controlling SMP activation
611 *
612 * Command-line option of "nosmp" or "maxcpus=0" will disable SMP
613 * activation entirely (the MPS table probe still happens, though).
614 *
615 * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer
616 * greater than 0, limits the maximum number of CPUs activated in
617 * SMP mode to <NUM>.
618 */
619
620void __weak arch_disable_smp_support(void) { }
621
622static int __init nosmp(char *str)
623{
624 setup_max_cpus = 0;
625 arch_disable_smp_support();
626
627 return 0;
628}
629
630early_param("nosmp", nosmp);
631
632/* this is hard limit */
633static int __init nrcpus(char *str)
634{
635 int nr_cpus;
636
637 get_option(&str, &nr_cpus);
638 if (nr_cpus > 0 && nr_cpus < nr_cpu_ids)
639 nr_cpu_ids = nr_cpus;
640
641 return 0;
642}
643
644early_param("nr_cpus", nrcpus);
645
646static int __init maxcpus(char *str)
647{
648 get_option(&str, &setup_max_cpus);
649 if (setup_max_cpus == 0)
650 arch_disable_smp_support();
651
652 return 0;
653}
654
655early_param("maxcpus", maxcpus);
656
657/* Setup number of possible processor ids */
658int nr_cpu_ids __read_mostly = NR_CPUS;
659EXPORT_SYMBOL(nr_cpu_ids);
660
661/* An arch may set nr_cpu_ids earlier if needed, so this would be redundant */
662void __init setup_nr_cpu_ids(void)
663{
664 nr_cpu_ids = find_last_bit(cpumask_bits(cpu_possible_mask),NR_CPUS) + 1;
665}
666
667/* Called by boot processor to activate the rest. */
668void __init smp_init(void)
669{
670 unsigned int cpu;
671
672 /* FIXME: This should be done in userspace --RR */
673 for_each_present_cpu(cpu) {
674 if (num_online_cpus() >= setup_max_cpus)
675 break;
676 if (!cpu_online(cpu))
677 cpu_up(cpu);
678 }
679
680 /* Any cleanup work */
681 printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus());
682 smp_cpus_done(setup_max_cpus);
683}
684
Amerigo Wang351f8f82011-01-12 16:59:39 -0800685/*
Tejun Heobd924e82011-01-20 12:07:13 +0100686 * Call a function on all processors. May be used during early boot while
687 * early_boot_irqs_disabled is set. Use local_irq_save/restore() instead
688 * of local_irq_disable/enable().
Amerigo Wang351f8f82011-01-12 16:59:39 -0800689 */
690int on_each_cpu(void (*func) (void *info), void *info, int wait)
691{
Tejun Heobd924e82011-01-20 12:07:13 +0100692 unsigned long flags;
Amerigo Wang351f8f82011-01-12 16:59:39 -0800693 int ret = 0;
694
695 preempt_disable();
696 ret = smp_call_function(func, info, wait);
Tejun Heobd924e82011-01-20 12:07:13 +0100697 local_irq_save(flags);
Amerigo Wang351f8f82011-01-12 16:59:39 -0800698 func(info);
Tejun Heobd924e82011-01-20 12:07:13 +0100699 local_irq_restore(flags);
Amerigo Wang351f8f82011-01-12 16:59:39 -0800700 preempt_enable();
701 return ret;
702}
703EXPORT_SYMBOL(on_each_cpu);