Pull miscellaneous into release branch
[linux-2.6] / arch / ia64 / kernel / smp.c
1 /*
2  * SMP Support
3  *
4  * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
5  * Copyright (C) 1999, 2001, 2003 David Mosberger-Tang <davidm@hpl.hp.com>
6  *
7  * Lots of stuff stolen from arch/alpha/kernel/smp.c
8  *
9  * 01/05/16 Rohit Seth <rohit.seth@intel.com>  IA64-SMP functions. Reorganized
10  * the existing code (on the lines of x86 port).
11  * 00/09/11 David Mosberger <davidm@hpl.hp.com> Do loops_per_jiffy
12  * calibration on each CPU.
13  * 00/08/23 Asit Mallick <asit.k.mallick@intel.com> fixed logical processor id
14  * 00/03/31 Rohit Seth <rohit.seth@intel.com>   Fixes for Bootstrap Processor
15  * & cpu_online_map now gets done here (instead of setup.c)
16  * 99/10/05 davidm      Update to bring it in sync with new command-line processing
17  *  scheme.
18  * 10/13/00 Goutham Rao <goutham.rao@intel.com> Updated smp_call_function and
19  *              smp_call_function_single to resend IPI on timeouts
20  */
21 #include <linux/module.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/smp.h>
27 #include <linux/kernel_stat.h>
28 #include <linux/mm.h>
29 #include <linux/cache.h>
30 #include <linux/delay.h>
31 #include <linux/efi.h>
32 #include <linux/bitops.h>
33 #include <linux/kexec.h>
34
35 #include <asm/atomic.h>
36 #include <asm/current.h>
37 #include <asm/delay.h>
38 #include <asm/machvec.h>
39 #include <asm/io.h>
40 #include <asm/irq.h>
41 #include <asm/page.h>
42 #include <asm/pgalloc.h>
43 #include <asm/pgtable.h>
44 #include <asm/processor.h>
45 #include <asm/ptrace.h>
46 #include <asm/sal.h>
47 #include <asm/system.h>
48 #include <asm/tlbflush.h>
49 #include <asm/unistd.h>
50 #include <asm/mca.h>
51
52 /*
53  * Note: alignment of 4 entries/cacheline was empirically determined
54  * to be a good tradeoff between hot cachelines & spreading the array
55  * across too many cacheline.
56  */
57 static struct local_tlb_flush_counts {
58         unsigned int count;
59 } __attribute__((__aligned__(32))) local_tlb_flush_counts[NR_CPUS];
60
61 static DEFINE_PER_CPU(unsigned int, shadow_flush_counts[NR_CPUS]) ____cacheline_aligned;
62
63
64 /*
65  * Structure and data for smp_call_function(). This is designed to minimise static memory
66  * requirements. It also looks cleaner.
67  */
68 static  __cacheline_aligned DEFINE_SPINLOCK(call_lock);
69
70 struct call_data_struct {
71         void (*func) (void *info);
72         void *info;
73         long wait;
74         atomic_t started;
75         atomic_t finished;
76 };
77
78 static volatile struct call_data_struct *call_data;
79
80 #define IPI_CALL_FUNC           0
81 #define IPI_CPU_STOP            1
82 #define IPI_KDUMP_CPU_STOP      3
83
84 /* This needs to be cacheline aligned because it is written to by *other* CPUs.  */
85 static DEFINE_PER_CPU_SHARED_ALIGNED(u64, ipi_operation);
86
87 extern void cpu_halt (void);
88
89 void
90 lock_ipi_calllock(void)
91 {
92         spin_lock_irq(&call_lock);
93 }
94
95 void
96 unlock_ipi_calllock(void)
97 {
98         spin_unlock_irq(&call_lock);
99 }
100
101 static void
102 stop_this_cpu (void)
103 {
104         /*
105          * Remove this CPU:
106          */
107         cpu_clear(smp_processor_id(), cpu_online_map);
108         max_xtp();
109         local_irq_disable();
110         cpu_halt();
111 }
112
113 void
114 cpu_die(void)
115 {
116         max_xtp();
117         local_irq_disable();
118         cpu_halt();
119         /* Should never be here */
120         BUG();
121         for (;;);
122 }
123
124 irqreturn_t
125 handle_IPI (int irq, void *dev_id)
126 {
127         int this_cpu = get_cpu();
128         unsigned long *pending_ipis = &__ia64_per_cpu_var(ipi_operation);
129         unsigned long ops;
130
131         mb();   /* Order interrupt and bit testing. */
132         while ((ops = xchg(pending_ipis, 0)) != 0) {
133                 mb();   /* Order bit clearing and data access. */
134                 do {
135                         unsigned long which;
136
137                         which = ffz(~ops);
138                         ops &= ~(1 << which);
139
140                         switch (which) {
141                               case IPI_CALL_FUNC:
142                               {
143                                       struct call_data_struct *data;
144                                       void (*func)(void *info);
145                                       void *info;
146                                       int wait;
147
148                                       /* release the 'pointer lock' */
149                                       data = (struct call_data_struct *) call_data;
150                                       func = data->func;
151                                       info = data->info;
152                                       wait = data->wait;
153
154                                       mb();
155                                       atomic_inc(&data->started);
156                                       /*
157                                        * At this point the structure may be gone unless
158                                        * wait is true.
159                                        */
160                                       (*func)(info);
161
162                                       /* Notify the sending CPU that the task is done.  */
163                                       mb();
164                                       if (wait)
165                                               atomic_inc(&data->finished);
166                               }
167                               break;
168
169                               case IPI_CPU_STOP:
170                                 stop_this_cpu();
171                                 break;
172 #ifdef CONFIG_KEXEC
173                               case IPI_KDUMP_CPU_STOP:
174                                 unw_init_running(kdump_cpu_freeze, NULL);
175                                 break;
176 #endif
177                               default:
178                                 printk(KERN_CRIT "Unknown IPI on CPU %d: %lu\n", this_cpu, which);
179                                 break;
180                         }
181                 } while (ops);
182                 mb();   /* Order data access and bit testing. */
183         }
184         put_cpu();
185         return IRQ_HANDLED;
186 }
187
188 /*
189  * Called with preemption disabled.
190  */
191 static inline void
192 send_IPI_single (int dest_cpu, int op)
193 {
194         set_bit(op, &per_cpu(ipi_operation, dest_cpu));
195         platform_send_ipi(dest_cpu, IA64_IPI_VECTOR, IA64_IPI_DM_INT, 0);
196 }
197
198 /*
199  * Called with preemption disabled.
200  */
201 static inline void
202 send_IPI_allbutself (int op)
203 {
204         unsigned int i;
205
206         for_each_online_cpu(i) {
207                 if (i != smp_processor_id())
208                         send_IPI_single(i, op);
209         }
210 }
211
212 /*
213  * Called with preemption disabled.
214  */
215 static inline void
216 send_IPI_mask(cpumask_t mask, int op)
217 {
218         unsigned int cpu;
219
220         for_each_cpu_mask(cpu, mask) {
221                         send_IPI_single(cpu, op);
222         }
223 }
224
225 /*
226  * Called with preemption disabled.
227  */
228 static inline void
229 send_IPI_all (int op)
230 {
231         int i;
232
233         for_each_online_cpu(i) {
234                 send_IPI_single(i, op);
235         }
236 }
237
238 /*
239  * Called with preemption disabled.
240  */
241 static inline void
242 send_IPI_self (int op)
243 {
244         send_IPI_single(smp_processor_id(), op);
245 }
246
247 #ifdef CONFIG_KEXEC
248 void
249 kdump_smp_send_stop(void)
250 {
251         send_IPI_allbutself(IPI_KDUMP_CPU_STOP);
252 }
253
254 void
255 kdump_smp_send_init(void)
256 {
257         unsigned int cpu, self_cpu;
258         self_cpu = smp_processor_id();
259         for_each_online_cpu(cpu) {
260                 if (cpu != self_cpu) {
261                         if(kdump_status[cpu] == 0)
262                                 platform_send_ipi(cpu, 0, IA64_IPI_DM_INIT, 0);
263                 }
264         }
265 }
266 #endif
267 /*
268  * Called with preemption disabled.
269  */
270 void
271 smp_send_reschedule (int cpu)
272 {
273         platform_send_ipi(cpu, IA64_IPI_RESCHEDULE, IA64_IPI_DM_INT, 0);
274 }
275
276 /*
277  * Called with preemption disabled.
278  */
279 static void
280 smp_send_local_flush_tlb (int cpu)
281 {
282         platform_send_ipi(cpu, IA64_IPI_LOCAL_TLB_FLUSH, IA64_IPI_DM_INT, 0);
283 }
284
285 void
286 smp_local_flush_tlb(void)
287 {
288         /*
289          * Use atomic ops. Otherwise, the load/increment/store sequence from
290          * a "++" operation can have the line stolen between the load & store.
291          * The overhead of the atomic op in negligible in this case & offers
292          * significant benefit for the brief periods where lots of cpus
293          * are simultaneously flushing TLBs.
294          */
295         ia64_fetchadd(1, &local_tlb_flush_counts[smp_processor_id()].count, acq);
296         local_flush_tlb_all();
297 }
298
299 #define FLUSH_DELAY     5 /* Usec backoff to eliminate excessive cacheline bouncing */
300
301 void
302 smp_flush_tlb_cpumask(cpumask_t xcpumask)
303 {
304         unsigned int *counts = __ia64_per_cpu_var(shadow_flush_counts);
305         cpumask_t cpumask = xcpumask;
306         int mycpu, cpu, flush_mycpu = 0;
307
308         preempt_disable();
309         mycpu = smp_processor_id();
310
311         for_each_cpu_mask(cpu, cpumask)
312                 counts[cpu] = local_tlb_flush_counts[cpu].count;
313
314         mb();
315         for_each_cpu_mask(cpu, cpumask) {
316                 if (cpu == mycpu)
317                         flush_mycpu = 1;
318                 else
319                         smp_send_local_flush_tlb(cpu);
320         }
321
322         if (flush_mycpu)
323                 smp_local_flush_tlb();
324
325         for_each_cpu_mask(cpu, cpumask)
326                 while(counts[cpu] == local_tlb_flush_counts[cpu].count)
327                         udelay(FLUSH_DELAY);
328
329         preempt_enable();
330 }
331
332 void
333 smp_flush_tlb_all (void)
334 {
335         on_each_cpu((void (*)(void *))local_flush_tlb_all, NULL, 1, 1);
336 }
337
338 void
339 smp_flush_tlb_mm (struct mm_struct *mm)
340 {
341         preempt_disable();
342         /* this happens for the common case of a single-threaded fork():  */
343         if (likely(mm == current->active_mm && atomic_read(&mm->mm_users) == 1))
344         {
345                 local_finish_flush_tlb_mm(mm);
346                 preempt_enable();
347                 return;
348         }
349
350         preempt_enable();
351         /*
352          * We could optimize this further by using mm->cpu_vm_mask to track which CPUs
353          * have been running in the address space.  It's not clear that this is worth the
354          * trouble though: to avoid races, we have to raise the IPI on the target CPU
355          * anyhow, and once a CPU is interrupted, the cost of local_flush_tlb_all() is
356          * rather trivial.
357          */
358         on_each_cpu((void (*)(void *))local_finish_flush_tlb_mm, mm, 1, 1);
359 }
360
361 /*
362  * Run a function on a specific CPU
363  *  <func>      The function to run. This must be fast and non-blocking.
364  *  <info>      An arbitrary pointer to pass to the function.
365  *  <nonatomic> Currently unused.
366  *  <wait>      If true, wait until function has completed on other CPUs.
367  *  [RETURNS]   0 on success, else a negative status code.
368  *
369  * Does not return until the remote CPU is nearly ready to execute <func>
370  * or is or has executed.
371  */
372
373 int
374 smp_call_function_single (int cpuid, void (*func) (void *info), void *info, int nonatomic,
375                           int wait)
376 {
377         struct call_data_struct data;
378         int cpus = 1;
379         int me = get_cpu(); /* prevent preemption and reschedule on another processor */
380
381         if (cpuid == me) {
382                 local_irq_disable();
383                 func(info);
384                 local_irq_enable();
385                 put_cpu();
386                 return 0;
387         }
388
389         data.func = func;
390         data.info = info;
391         atomic_set(&data.started, 0);
392         data.wait = wait;
393         if (wait)
394                 atomic_set(&data.finished, 0);
395
396         spin_lock_bh(&call_lock);
397
398         call_data = &data;
399         mb();   /* ensure store to call_data precedes setting of IPI_CALL_FUNC */
400         send_IPI_single(cpuid, IPI_CALL_FUNC);
401
402         /* Wait for response */
403         while (atomic_read(&data.started) != cpus)
404                 cpu_relax();
405
406         if (wait)
407                 while (atomic_read(&data.finished) != cpus)
408                         cpu_relax();
409         call_data = NULL;
410
411         spin_unlock_bh(&call_lock);
412         put_cpu();
413         return 0;
414 }
415 EXPORT_SYMBOL(smp_call_function_single);
416
417 /**
418  * smp_call_function_mask(): Run a function on a set of other CPUs.
419  * <mask>       The set of cpus to run on.  Must not include the current cpu.
420  * <func>       The function to run. This must be fast and non-blocking.
421  * <info>       An arbitrary pointer to pass to the function.
422  * <wait>       If true, wait (atomically) until function
423  *              has completed on other CPUs.
424  *
425  * Returns 0 on success, else a negative status code.
426  *
427  * If @wait is true, then returns once @func has returned; otherwise
428  * it returns just before the target cpu calls @func.
429  *
430  * You must not call this function with disabled interrupts or from a
431  * hardware interrupt handler or from a bottom half handler.
432  */
433 int smp_call_function_mask(cpumask_t mask,
434                            void (*func)(void *), void *info,
435                            int wait)
436 {
437         struct call_data_struct data;
438         cpumask_t allbutself;
439         int cpus;
440
441         spin_lock(&call_lock);
442         allbutself = cpu_online_map;
443         cpu_clear(smp_processor_id(), allbutself);
444
445         cpus_and(mask, mask, allbutself);
446         cpus = cpus_weight(mask);
447         if (!cpus) {
448                 spin_unlock(&call_lock);
449                 return 0;
450         }
451
452         /* Can deadlock when called with interrupts disabled */
453         WARN_ON(irqs_disabled());
454
455         data.func = func;
456         data.info = info;
457         atomic_set(&data.started, 0);
458         data.wait = wait;
459         if (wait)
460                 atomic_set(&data.finished, 0);
461
462         call_data = &data;
463         mb(); /* ensure store to call_data precedes setting of IPI_CALL_FUNC*/
464
465         /* Send a message to other CPUs */
466         if (cpus_equal(mask, allbutself))
467                 send_IPI_allbutself(IPI_CALL_FUNC);
468         else
469                 send_IPI_mask(mask, IPI_CALL_FUNC);
470
471         /* Wait for response */
472         while (atomic_read(&data.started) != cpus)
473                 cpu_relax();
474
475         if (wait)
476                 while (atomic_read(&data.finished) != cpus)
477                         cpu_relax();
478         call_data = NULL;
479
480         spin_unlock(&call_lock);
481         return 0;
482
483 }
484 EXPORT_SYMBOL(smp_call_function_mask);
485
486 /*
487  * this function sends a 'generic call function' IPI to all other CPUs
488  * in the system.
489  */
490
491 /*
492  *  [SUMMARY]   Run a function on all other CPUs.
493  *  <func>      The function to run. This must be fast and non-blocking.
494  *  <info>      An arbitrary pointer to pass to the function.
495  *  <nonatomic> currently unused.
496  *  <wait>      If true, wait (atomically) until function has completed on other CPUs.
497  *  [RETURNS]   0 on success, else a negative status code.
498  *
499  * Does not return until remote CPUs are nearly ready to execute <func> or are or have
500  * executed.
501  *
502  * You must not call this function with disabled interrupts or from a
503  * hardware interrupt handler or from a bottom half handler.
504  */
505 int
506 smp_call_function (void (*func) (void *info), void *info, int nonatomic, int wait)
507 {
508         struct call_data_struct data;
509         int cpus;
510
511         spin_lock(&call_lock);
512         cpus = num_online_cpus() - 1;
513         if (!cpus) {
514                 spin_unlock(&call_lock);
515                 return 0;
516         }
517
518         /* Can deadlock when called with interrupts disabled */
519         WARN_ON(irqs_disabled());
520
521         data.func = func;
522         data.info = info;
523         atomic_set(&data.started, 0);
524         data.wait = wait;
525         if (wait)
526                 atomic_set(&data.finished, 0);
527
528         call_data = &data;
529         mb();   /* ensure store to call_data precedes setting of IPI_CALL_FUNC */
530         send_IPI_allbutself(IPI_CALL_FUNC);
531
532         /* Wait for response */
533         while (atomic_read(&data.started) != cpus)
534                 cpu_relax();
535
536         if (wait)
537                 while (atomic_read(&data.finished) != cpus)
538                         cpu_relax();
539         call_data = NULL;
540
541         spin_unlock(&call_lock);
542         return 0;
543 }
544 EXPORT_SYMBOL(smp_call_function);
545
546 /*
547  * this function calls the 'stop' function on all other CPUs in the system.
548  */
549 void
550 smp_send_stop (void)
551 {
552         send_IPI_allbutself(IPI_CPU_STOP);
553 }
554
555 int
556 setup_profiling_timer (unsigned int multiplier)
557 {
558         return -EINVAL;
559 }