[ARM SMP] Add hotplug CPU infrastructure
[linux-2.6.git] / arch / arm / kernel / smp.c
1 /*
2  *  linux/arch/arm/kernel/smp.c
3  *
4  *  Copyright (C) 2002 ARM Limited, All Rights Reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10 #include <linux/config.h>
11 #include <linux/delay.h>
12 #include <linux/init.h>
13 #include <linux/spinlock.h>
14 #include <linux/sched.h>
15 #include <linux/interrupt.h>
16 #include <linux/cache.h>
17 #include <linux/profile.h>
18 #include <linux/errno.h>
19 #include <linux/mm.h>
20 #include <linux/cpu.h>
21 #include <linux/smp.h>
22 #include <linux/seq_file.h>
23
24 #include <asm/atomic.h>
25 #include <asm/cacheflush.h>
26 #include <asm/cpu.h>
27 #include <asm/mmu_context.h>
28 #include <asm/pgtable.h>
29 #include <asm/pgalloc.h>
30 #include <asm/processor.h>
31 #include <asm/tlbflush.h>
32 #include <asm/ptrace.h>
33
34 /*
35  * bitmask of present and online CPUs.
36  * The present bitmask indicates that the CPU is physically present.
37  * The online bitmask indicates that the CPU is up and running.
38  */
39 cpumask_t cpu_possible_map;
40 cpumask_t cpu_online_map;
41
42 /*
43  * as from 2.5, kernels no longer have an init_tasks structure
44  * so we need some other way of telling a new secondary core
45  * where to place its SVC stack
46  */
47 struct secondary_data secondary_data;
48
49 /*
50  * structures for inter-processor calls
51  * - A collection of single bit ipi messages.
52  */
53 struct ipi_data {
54         spinlock_t lock;
55         unsigned long ipi_count;
56         unsigned long bits;
57 };
58
59 static DEFINE_PER_CPU(struct ipi_data, ipi_data) = {
60         .lock   = SPIN_LOCK_UNLOCKED,
61 };
62
63 enum ipi_msg_type {
64         IPI_TIMER,
65         IPI_RESCHEDULE,
66         IPI_CALL_FUNC,
67         IPI_CPU_STOP,
68 };
69
70 struct smp_call_struct {
71         void (*func)(void *info);
72         void *info;
73         int wait;
74         cpumask_t pending;
75         cpumask_t unfinished;
76 };
77
78 static struct smp_call_struct * volatile smp_call_function_data;
79 static DEFINE_SPINLOCK(smp_call_function_lock);
80
81 int __cpuinit __cpu_up(unsigned int cpu)
82 {
83         struct cpuinfo_arm *ci = &per_cpu(cpu_data, cpu);
84         struct task_struct *idle = ci->idle;
85         pgd_t *pgd;
86         pmd_t *pmd;
87         int ret;
88
89         /*
90          * Spawn a new process manually, if not already done.
91          * Grab a pointer to its task struct so we can mess with it
92          */
93         if (!idle) {
94                 idle = fork_idle(cpu);
95                 if (IS_ERR(idle)) {
96                         printk(KERN_ERR "CPU%u: fork() failed\n", cpu);
97                         return PTR_ERR(idle);
98                 }
99                 ci->idle = idle;
100         }
101
102         /*
103          * Allocate initial page tables to allow the new CPU to
104          * enable the MMU safely.  This essentially means a set
105          * of our "standard" page tables, with the addition of
106          * a 1:1 mapping for the physical address of the kernel.
107          */
108         pgd = pgd_alloc(&init_mm);
109         pmd = pmd_offset(pgd, PHYS_OFFSET);
110         *pmd = __pmd((PHYS_OFFSET & PGDIR_MASK) |
111                      PMD_TYPE_SECT | PMD_SECT_AP_WRITE);
112
113         /*
114          * We need to tell the secondary core where to find
115          * its stack and the page tables.
116          */
117         secondary_data.stack = (void *)idle->thread_info + THREAD_START_SP;
118         secondary_data.pgdir = virt_to_phys(pgd);
119         wmb();
120
121         /*
122          * Now bring the CPU into our world.
123          */
124         ret = boot_secondary(cpu, idle);
125         if (ret == 0) {
126                 unsigned long timeout;
127
128                 /*
129                  * CPU was successfully started, wait for it
130                  * to come online or time out.
131                  */
132                 timeout = jiffies + HZ;
133                 while (time_before(jiffies, timeout)) {
134                         if (cpu_online(cpu))
135                                 break;
136
137                         udelay(10);
138                         barrier();
139                 }
140
141                 if (!cpu_online(cpu))
142                         ret = -EIO;
143         }
144
145         secondary_data.stack = 0;
146         secondary_data.pgdir = 0;
147
148         *pmd_offset(pgd, PHYS_OFFSET) = __pmd(0);
149         pgd_free(pgd);
150
151         if (ret) {
152                 printk(KERN_CRIT "CPU%u: processor failed to boot\n", cpu);
153
154                 /*
155                  * FIXME: We need to clean up the new idle thread. --rmk
156                  */
157         }
158
159         return ret;
160 }
161
162 #ifdef CONFIG_HOTPLUG_CPU
163 /*
164  * __cpu_disable runs on the processor to be shutdown.
165  */
166 int __cpuexit __cpu_disable(void)
167 {
168         unsigned int cpu = smp_processor_id();
169         struct task_struct *p;
170         int ret;
171
172         ret = mach_cpu_disable(cpu);
173         if (ret)
174                 return ret;
175
176         /*
177          * Take this CPU offline.  Once we clear this, we can't return,
178          * and we must not schedule until we're ready to give up the cpu.
179          */
180         cpu_clear(cpu, cpu_online_map);
181
182         /*
183          * OK - migrate IRQs away from this CPU
184          */
185         migrate_irqs();
186
187         /*
188          * Flush user cache and TLB mappings, and then remove this CPU
189          * from the vm mask set of all processes.
190          */
191         flush_cache_all();
192         local_flush_tlb_all();
193
194         read_lock(&tasklist_lock);
195         for_each_process(p) {
196                 if (p->mm)
197                         cpu_clear(cpu, p->mm->cpu_vm_mask);
198         }
199         read_unlock(&tasklist_lock);
200
201         return 0;
202 }
203
204 /*
205  * called on the thread which is asking for a CPU to be shutdown -
206  * waits until shutdown has completed, or it is timed out.
207  */
208 void __cpuexit __cpu_die(unsigned int cpu)
209 {
210         if (!platform_cpu_kill(cpu))
211                 printk("CPU%u: unable to kill\n", cpu);
212 }
213
214 /*
215  * Called from the idle thread for the CPU which has been shutdown.
216  *
217  * Note that we disable IRQs here, but do not re-enable them
218  * before returning to the caller. This is also the behaviour
219  * of the other hotplug-cpu capable cores, so presumably coming
220  * out of idle fixes this.
221  */
222 void __cpuexit cpu_die(void)
223 {
224         unsigned int cpu = smp_processor_id();
225
226         local_irq_disable();
227         idle_task_exit();
228
229         /*
230          * actual CPU shutdown procedure is at least platform (if not
231          * CPU) specific
232          */
233         platform_cpu_die(cpu);
234
235         /*
236          * Do not return to the idle loop - jump back to the secondary
237          * cpu initialisation.  There's some initialisation which needs
238          * to be repeated to undo the effects of taking the CPU offline.
239          */
240         __asm__("mov    sp, %0\n"
241         "       b       secondary_start_kernel"
242                 :
243                 : "r" ((void *)current->thread_info + THREAD_SIZE - 8));
244 }
245 #endif /* CONFIG_HOTPLUG_CPU */
246
247 /*
248  * This is the secondary CPU boot entry.  We're using this CPUs
249  * idle thread stack, but a set of temporary page tables.
250  */
251 asmlinkage void __cpuinit secondary_start_kernel(void)
252 {
253         struct mm_struct *mm = &init_mm;
254         unsigned int cpu = smp_processor_id();
255
256         printk("CPU%u: Booted secondary processor\n", cpu);
257
258         /*
259          * All kernel threads share the same mm context; grab a
260          * reference and switch to it.
261          */
262         atomic_inc(&mm->mm_users);
263         atomic_inc(&mm->mm_count);
264         current->active_mm = mm;
265         cpu_set(cpu, mm->cpu_vm_mask);
266         cpu_switch_mm(mm->pgd, mm);
267         enter_lazy_tlb(mm, current);
268         local_flush_tlb_all();
269
270         cpu_init();
271
272         /*
273          * Give the platform a chance to do its own initialisation.
274          */
275         platform_secondary_init(cpu);
276
277         /*
278          * Enable local interrupts.
279          */
280         local_irq_enable();
281         local_fiq_enable();
282
283         calibrate_delay();
284
285         smp_store_cpu_info(cpu);
286
287         /*
288          * OK, now it's safe to let the boot CPU continue
289          */
290         cpu_set(cpu, cpu_online_map);
291
292         /*
293          * OK, it's off to the idle thread for us
294          */
295         cpu_idle();
296 }
297
298 /*
299  * Called by both boot and secondaries to move global data into
300  * per-processor storage.
301  */
302 void __cpuinit smp_store_cpu_info(unsigned int cpuid)
303 {
304         struct cpuinfo_arm *cpu_info = &per_cpu(cpu_data, cpuid);
305
306         cpu_info->loops_per_jiffy = loops_per_jiffy;
307 }
308
309 void __init smp_cpus_done(unsigned int max_cpus)
310 {
311         int cpu;
312         unsigned long bogosum = 0;
313
314         for_each_online_cpu(cpu)
315                 bogosum += per_cpu(cpu_data, cpu).loops_per_jiffy;
316
317         printk(KERN_INFO "SMP: Total of %d processors activated "
318                "(%lu.%02lu BogoMIPS).\n",
319                num_online_cpus(),
320                bogosum / (500000/HZ),
321                (bogosum / (5000/HZ)) % 100);
322 }
323
324 void __init smp_prepare_boot_cpu(void)
325 {
326         unsigned int cpu = smp_processor_id();
327
328         per_cpu(cpu_data, cpu).idle = current;
329
330         cpu_set(cpu, cpu_possible_map);
331         cpu_set(cpu, cpu_present_map);
332         cpu_set(cpu, cpu_online_map);
333 }
334
335 static void send_ipi_message(cpumask_t callmap, enum ipi_msg_type msg)
336 {
337         unsigned long flags;
338         unsigned int cpu;
339
340         local_irq_save(flags);
341
342         for_each_cpu_mask(cpu, callmap) {
343                 struct ipi_data *ipi = &per_cpu(ipi_data, cpu);
344
345                 spin_lock(&ipi->lock);
346                 ipi->bits |= 1 << msg;
347                 spin_unlock(&ipi->lock);
348         }
349
350         /*
351          * Call the platform specific cross-CPU call function.
352          */
353         smp_cross_call(callmap);
354
355         local_irq_restore(flags);
356 }
357
358 /*
359  * You must not call this function with disabled interrupts, from a
360  * hardware interrupt handler, nor from a bottom half handler.
361  */
362 int smp_call_function_on_cpu(void (*func)(void *info), void *info, int retry,
363                              int wait, cpumask_t callmap)
364 {
365         struct smp_call_struct data;
366         unsigned long timeout;
367         int ret = 0;
368
369         data.func = func;
370         data.info = info;
371         data.wait = wait;
372
373         cpu_clear(smp_processor_id(), callmap);
374         if (cpus_empty(callmap))
375                 goto out;
376
377         data.pending = callmap;
378         if (wait)
379                 data.unfinished = callmap;
380
381         /*
382          * try to get the mutex on smp_call_function_data
383          */
384         spin_lock(&smp_call_function_lock);
385         smp_call_function_data = &data;
386
387         send_ipi_message(callmap, IPI_CALL_FUNC);
388
389         timeout = jiffies + HZ;
390         while (!cpus_empty(data.pending) && time_before(jiffies, timeout))
391                 barrier();
392
393         /*
394          * did we time out?
395          */
396         if (!cpus_empty(data.pending)) {
397                 /*
398                  * this may be causing our panic - report it
399                  */
400                 printk(KERN_CRIT
401                        "CPU%u: smp_call_function timeout for %p(%p)\n"
402                        "      callmap %lx pending %lx, %swait\n",
403                        smp_processor_id(), func, info, *cpus_addr(callmap),
404                        *cpus_addr(data.pending), wait ? "" : "no ");
405
406                 /*
407                  * TRACE
408                  */
409                 timeout = jiffies + (5 * HZ);
410                 while (!cpus_empty(data.pending) && time_before(jiffies, timeout))
411                         barrier();
412
413                 if (cpus_empty(data.pending))
414                         printk(KERN_CRIT "     RESOLVED\n");
415                 else
416                         printk(KERN_CRIT "     STILL STUCK\n");
417         }
418
419         /*
420          * whatever happened, we're done with the data, so release it
421          */
422         smp_call_function_data = NULL;
423         spin_unlock(&smp_call_function_lock);
424
425         if (!cpus_empty(data.pending)) {
426                 ret = -ETIMEDOUT;
427                 goto out;
428         }
429
430         if (wait)
431                 while (!cpus_empty(data.unfinished))
432                         barrier();
433  out:
434
435         return 0;
436 }
437
438 int smp_call_function(void (*func)(void *info), void *info, int retry,
439                       int wait)
440 {
441         return smp_call_function_on_cpu(func, info, retry, wait,
442                                         cpu_online_map);
443 }
444
445 void show_ipi_list(struct seq_file *p)
446 {
447         unsigned int cpu;
448
449         seq_puts(p, "IPI:");
450
451         for_each_present_cpu(cpu)
452                 seq_printf(p, " %10lu", per_cpu(ipi_data, cpu).ipi_count);
453
454         seq_putc(p, '\n');
455 }
456
457 static void ipi_timer(struct pt_regs *regs)
458 {
459         int user = user_mode(regs);
460
461         irq_enter();
462         profile_tick(CPU_PROFILING, regs);
463         update_process_times(user);
464         irq_exit();
465 }
466
467 /*
468  * ipi_call_function - handle IPI from smp_call_function()
469  *
470  * Note that we copy data out of the cross-call structure and then
471  * let the caller know that we're here and have done with their data
472  */
473 static void ipi_call_function(unsigned int cpu)
474 {
475         struct smp_call_struct *data = smp_call_function_data;
476         void (*func)(void *info) = data->func;
477         void *info = data->info;
478         int wait = data->wait;
479
480         cpu_clear(cpu, data->pending);
481
482         func(info);
483
484         if (wait)
485                 cpu_clear(cpu, data->unfinished);
486 }
487
488 static DEFINE_SPINLOCK(stop_lock);
489
490 /*
491  * ipi_cpu_stop - handle IPI from smp_send_stop()
492  */
493 static void ipi_cpu_stop(unsigned int cpu)
494 {
495         spin_lock(&stop_lock);
496         printk(KERN_CRIT "CPU%u: stopping\n", cpu);
497         dump_stack();
498         spin_unlock(&stop_lock);
499
500         cpu_clear(cpu, cpu_online_map);
501
502         local_fiq_disable();
503         local_irq_disable();
504
505         while (1)
506                 cpu_relax();
507 }
508
509 /*
510  * Main handler for inter-processor interrupts
511  *
512  * For ARM, the ipimask now only identifies a single
513  * category of IPI (Bit 1 IPIs have been replaced by a
514  * different mechanism):
515  *
516  *  Bit 0 - Inter-processor function call
517  */
518 void do_IPI(struct pt_regs *regs)
519 {
520         unsigned int cpu = smp_processor_id();
521         struct ipi_data *ipi = &per_cpu(ipi_data, cpu);
522
523         ipi->ipi_count++;
524
525         for (;;) {
526                 unsigned long msgs;
527
528                 spin_lock(&ipi->lock);
529                 msgs = ipi->bits;
530                 ipi->bits = 0;
531                 spin_unlock(&ipi->lock);
532
533                 if (!msgs)
534                         break;
535
536                 do {
537                         unsigned nextmsg;
538
539                         nextmsg = msgs & -msgs;
540                         msgs &= ~nextmsg;
541                         nextmsg = ffz(~nextmsg);
542
543                         switch (nextmsg) {
544                         case IPI_TIMER:
545                                 ipi_timer(regs);
546                                 break;
547
548                         case IPI_RESCHEDULE:
549                                 /*
550                                  * nothing more to do - eveything is
551                                  * done on the interrupt return path
552                                  */
553                                 break;
554
555                         case IPI_CALL_FUNC:
556                                 ipi_call_function(cpu);
557                                 break;
558
559                         case IPI_CPU_STOP:
560                                 ipi_cpu_stop(cpu);
561                                 break;
562
563                         default:
564                                 printk(KERN_CRIT "CPU%u: Unknown IPI message 0x%x\n",
565                                        cpu, nextmsg);
566                                 break;
567                         }
568                 } while (msgs);
569         }
570 }
571
572 void smp_send_reschedule(int cpu)
573 {
574         send_ipi_message(cpumask_of_cpu(cpu), IPI_RESCHEDULE);
575 }
576
577 void smp_send_timer(void)
578 {
579         cpumask_t mask = cpu_online_map;
580         cpu_clear(smp_processor_id(), mask);
581         send_ipi_message(mask, IPI_TIMER);
582 }
583
584 void smp_send_stop(void)
585 {
586         cpumask_t mask = cpu_online_map;
587         cpu_clear(smp_processor_id(), mask);
588         send_ipi_message(mask, IPI_CPU_STOP);
589 }
590
591 /*
592  * not supported here
593  */
594 int __init setup_profiling_timer(unsigned int multiplier)
595 {
596         return -EINVAL;
597 }
598
599 static int
600 on_each_cpu_mask(void (*func)(void *), void *info, int retry, int wait,
601                  cpumask_t mask)
602 {
603         int ret = 0;
604
605         preempt_disable();
606
607         ret = smp_call_function_on_cpu(func, info, retry, wait, mask);
608         if (cpu_isset(smp_processor_id(), mask))
609                 func(info);
610
611         preempt_enable();
612
613         return ret;
614 }
615
616 /**********************************************************************/
617
618 /*
619  * TLB operations
620  */
621 struct tlb_args {
622         struct vm_area_struct *ta_vma;
623         unsigned long ta_start;
624         unsigned long ta_end;
625 };
626
627 static inline void ipi_flush_tlb_all(void *ignored)
628 {
629         local_flush_tlb_all();
630 }
631
632 static inline void ipi_flush_tlb_mm(void *arg)
633 {
634         struct mm_struct *mm = (struct mm_struct *)arg;
635
636         local_flush_tlb_mm(mm);
637 }
638
639 static inline void ipi_flush_tlb_page(void *arg)
640 {
641         struct tlb_args *ta = (struct tlb_args *)arg;
642
643         local_flush_tlb_page(ta->ta_vma, ta->ta_start);
644 }
645
646 static inline void ipi_flush_tlb_kernel_page(void *arg)
647 {
648         struct tlb_args *ta = (struct tlb_args *)arg;
649
650         local_flush_tlb_kernel_page(ta->ta_start);
651 }
652
653 static inline void ipi_flush_tlb_range(void *arg)
654 {
655         struct tlb_args *ta = (struct tlb_args *)arg;
656
657         local_flush_tlb_range(ta->ta_vma, ta->ta_start, ta->ta_end);
658 }
659
660 static inline void ipi_flush_tlb_kernel_range(void *arg)
661 {
662         struct tlb_args *ta = (struct tlb_args *)arg;
663
664         local_flush_tlb_kernel_range(ta->ta_start, ta->ta_end);
665 }
666
667 void flush_tlb_all(void)
668 {
669         on_each_cpu(ipi_flush_tlb_all, NULL, 1, 1);
670 }
671
672 void flush_tlb_mm(struct mm_struct *mm)
673 {
674         cpumask_t mask = mm->cpu_vm_mask;
675
676         on_each_cpu_mask(ipi_flush_tlb_mm, mm, 1, 1, mask);
677 }
678
679 void flush_tlb_page(struct vm_area_struct *vma, unsigned long uaddr)
680 {
681         cpumask_t mask = vma->vm_mm->cpu_vm_mask;
682         struct tlb_args ta;
683
684         ta.ta_vma = vma;
685         ta.ta_start = uaddr;
686
687         on_each_cpu_mask(ipi_flush_tlb_page, &ta, 1, 1, mask);
688 }
689
690 void flush_tlb_kernel_page(unsigned long kaddr)
691 {
692         struct tlb_args ta;
693
694         ta.ta_start = kaddr;
695
696         on_each_cpu(ipi_flush_tlb_kernel_page, &ta, 1, 1);
697 }
698
699 void flush_tlb_range(struct vm_area_struct *vma,
700                      unsigned long start, unsigned long end)
701 {
702         cpumask_t mask = vma->vm_mm->cpu_vm_mask;
703         struct tlb_args ta;
704
705         ta.ta_vma = vma;
706         ta.ta_start = start;
707         ta.ta_end = end;
708
709         on_each_cpu_mask(ipi_flush_tlb_range, &ta, 1, 1, mask);
710 }
711
712 void flush_tlb_kernel_range(unsigned long start, unsigned long end)
713 {
714         struct tlb_args ta;
715
716         ta.ta_start = start;
717         ta.ta_end = end;
718
719         on_each_cpu(ipi_flush_tlb_kernel_range, &ta, 1, 1);
720 }