Merge /pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / arch / s390 / kernel / smp.c
1 /*
2  *  arch/s390/kernel/smp.c
3  *
4  *    Copyright IBM Corp. 1999,2007
5  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
6  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
7  *               Heiko Carstens (heiko.carstens@de.ibm.com)
8  *
9  *  based on other smp stuff by
10  *    (c) 1995 Alan Cox, CymruNET Ltd  <alan@cymru.net>
11  *    (c) 1998 Ingo Molnar
12  *
13  * We work with logical cpu numbering everywhere we can. The only
14  * functions using the real cpu address (got from STAP) are the sigp
15  * functions. For all other functions we use the identity mapping.
16  * That means that cpu_number_map[i] == i for every cpu. cpu_number_map is
17  * used e.g. to find the idle task belonging to a logical cpu. Every array
18  * in the kernel is sorted by the logical cpu number and not by the physical
19  * one which is causing all the confusion with __cpu_logical_map and
20  * cpu_number_map in other architectures.
21  */
22
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/mm.h>
26 #include <linux/spinlock.h>
27 #include <linux/kernel_stat.h>
28 #include <linux/smp_lock.h>
29 #include <linux/delay.h>
30 #include <linux/cache.h>
31 #include <linux/interrupt.h>
32 #include <linux/cpu.h>
33 #include <linux/timex.h>
34 #include <linux/bootmem.h>
35 #include <asm/ipl.h>
36 #include <asm/setup.h>
37 #include <asm/sigp.h>
38 #include <asm/pgalloc.h>
39 #include <asm/irq.h>
40 #include <asm/s390_ext.h>
41 #include <asm/cpcmd.h>
42 #include <asm/tlbflush.h>
43 #include <asm/timer.h>
44 #include <asm/lowcore.h>
45
46 /*
47  * An array with a pointer the lowcore of every CPU.
48  */
49 struct _lowcore *lowcore_ptr[NR_CPUS];
50 EXPORT_SYMBOL(lowcore_ptr);
51
52 cpumask_t cpu_online_map = CPU_MASK_NONE;
53 EXPORT_SYMBOL(cpu_online_map);
54
55 cpumask_t cpu_possible_map = CPU_MASK_NONE;
56 EXPORT_SYMBOL(cpu_possible_map);
57
58 static struct task_struct *current_set[NR_CPUS];
59
60 static void smp_ext_bitcall(int, ec_bit_sig);
61
62 /*
63  * Structure and data for __smp_call_function_map(). This is designed to
64  * minimise static memory requirements. It also looks cleaner.
65  */
66 static DEFINE_SPINLOCK(call_lock);
67
68 struct call_data_struct {
69         void (*func) (void *info);
70         void *info;
71         cpumask_t started;
72         cpumask_t finished;
73         int wait;
74 };
75
76 static struct call_data_struct *call_data;
77
78 /*
79  * 'Call function' interrupt callback
80  */
81 static void do_call_function(void)
82 {
83         void (*func) (void *info) = call_data->func;
84         void *info = call_data->info;
85         int wait = call_data->wait;
86
87         cpu_set(smp_processor_id(), call_data->started);
88         (*func)(info);
89         if (wait)
90                 cpu_set(smp_processor_id(), call_data->finished);;
91 }
92
93 static void __smp_call_function_map(void (*func) (void *info), void *info,
94                                     int nonatomic, int wait, cpumask_t map)
95 {
96         struct call_data_struct data;
97         int cpu, local = 0;
98
99         /*
100          * Can deadlock when interrupts are disabled or if in wrong context.
101          */
102         WARN_ON(irqs_disabled() || in_irq());
103
104         /*
105          * Check for local function call. We have to have the same call order
106          * as in on_each_cpu() because of machine_restart_smp().
107          */
108         if (cpu_isset(smp_processor_id(), map)) {
109                 local = 1;
110                 cpu_clear(smp_processor_id(), map);
111         }
112
113         cpus_and(map, map, cpu_online_map);
114         if (cpus_empty(map))
115                 goto out;
116
117         data.func = func;
118         data.info = info;
119         data.started = CPU_MASK_NONE;
120         data.wait = wait;
121         if (wait)
122                 data.finished = CPU_MASK_NONE;
123
124         spin_lock_bh(&call_lock);
125         call_data = &data;
126
127         for_each_cpu_mask(cpu, map)
128                 smp_ext_bitcall(cpu, ec_call_function);
129
130         /* Wait for response */
131         while (!cpus_equal(map, data.started))
132                 cpu_relax();
133
134         if (wait)
135                 while (!cpus_equal(map, data.finished))
136                         cpu_relax();
137
138         spin_unlock_bh(&call_lock);
139
140 out:
141         local_irq_disable();
142         if (local)
143                 func(info);
144         local_irq_enable();
145 }
146
147 /*
148  * smp_call_function:
149  * @func: the function to run; this must be fast and non-blocking
150  * @info: an arbitrary pointer to pass to the function
151  * @nonatomic: unused
152  * @wait: if true, wait (atomically) until function has completed on other CPUs
153  *
154  * Run a function on all other CPUs.
155  *
156  * You must not call this function with disabled interrupts, from a
157  * hardware interrupt handler or from a bottom half.
158  */
159 int smp_call_function(void (*func) (void *info), void *info, int nonatomic,
160                       int wait)
161 {
162         cpumask_t map;
163
164         preempt_disable();
165         map = cpu_online_map;
166         cpu_clear(smp_processor_id(), map);
167         __smp_call_function_map(func, info, nonatomic, wait, map);
168         preempt_enable();
169         return 0;
170 }
171 EXPORT_SYMBOL(smp_call_function);
172
173 /*
174  * smp_call_function_on:
175  * @func: the function to run; this must be fast and non-blocking
176  * @info: an arbitrary pointer to pass to the function
177  * @nonatomic: unused
178  * @wait: if true, wait (atomically) until function has completed on other CPUs
179  * @cpu: the CPU where func should run
180  *
181  * Run a function on one processor.
182  *
183  * You must not call this function with disabled interrupts, from a
184  * hardware interrupt handler or from a bottom half.
185  */
186 int smp_call_function_on(void (*func) (void *info), void *info, int nonatomic,
187                          int wait, int cpu)
188 {
189         cpumask_t map = CPU_MASK_NONE;
190
191         preempt_disable();
192         cpu_set(cpu, map);
193         __smp_call_function_map(func, info, nonatomic, wait, map);
194         preempt_enable();
195         return 0;
196 }
197 EXPORT_SYMBOL(smp_call_function_on);
198
199 static void do_send_stop(void)
200 {
201         int cpu, rc;
202
203         /* stop all processors */
204         for_each_online_cpu(cpu) {
205                 if (cpu == smp_processor_id())
206                         continue;
207                 do {
208                         rc = signal_processor(cpu, sigp_stop);
209                 } while (rc == sigp_busy);
210         }
211 }
212
213 static void do_store_status(void)
214 {
215         int cpu, rc;
216
217         /* store status of all processors in their lowcores (real 0) */
218         for_each_online_cpu(cpu) {
219                 if (cpu == smp_processor_id())
220                         continue;
221                 do {
222                         rc = signal_processor_p(
223                                 (__u32)(unsigned long) lowcore_ptr[cpu], cpu,
224                                 sigp_store_status_at_address);
225                 } while (rc == sigp_busy);
226         }
227 }
228
229 static void do_wait_for_stop(void)
230 {
231         int cpu;
232
233         /* Wait for all other cpus to enter stopped state */
234         for_each_online_cpu(cpu) {
235                 if (cpu == smp_processor_id())
236                         continue;
237                 while (!smp_cpu_not_running(cpu))
238                         cpu_relax();
239         }
240 }
241
242 /*
243  * this function sends a 'stop' sigp to all other CPUs in the system.
244  * it goes straight through.
245  */
246 void smp_send_stop(void)
247 {
248         /* Disable all interrupts/machine checks */
249         __load_psw_mask(psw_kernel_bits & ~PSW_MASK_MCHECK);
250
251         /* write magic number to zero page (absolute 0) */
252         lowcore_ptr[smp_processor_id()]->panic_magic = __PANIC_MAGIC;
253
254         /* stop other processors. */
255         do_send_stop();
256
257         /* wait until other processors are stopped */
258         do_wait_for_stop();
259
260         /* store status of other processors. */
261         do_store_status();
262 }
263
264 /*
265  * Reboot, halt and power_off routines for SMP.
266  */
267 void machine_restart_smp(char *__unused)
268 {
269         smp_send_stop();
270         do_reipl();
271 }
272
273 void machine_halt_smp(void)
274 {
275         smp_send_stop();
276         if (MACHINE_IS_VM && strlen(vmhalt_cmd) > 0)
277                 __cpcmd(vmhalt_cmd, NULL, 0, NULL);
278         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
279         for (;;);
280 }
281
282 void machine_power_off_smp(void)
283 {
284         smp_send_stop();
285         if (MACHINE_IS_VM && strlen(vmpoff_cmd) > 0)
286                 __cpcmd(vmpoff_cmd, NULL, 0, NULL);
287         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
288         for (;;);
289 }
290
291 /*
292  * This is the main routine where commands issued by other
293  * cpus are handled.
294  */
295
296 static void do_ext_call_interrupt(__u16 code)
297 {
298         unsigned long bits;
299
300         /*
301          * handle bit signal external calls
302          *
303          * For the ec_schedule signal we have to do nothing. All the work
304          * is done automatically when we return from the interrupt.
305          */
306         bits = xchg(&S390_lowcore.ext_call_fast, 0);
307
308         if (test_bit(ec_call_function, &bits))
309                 do_call_function();
310 }
311
312 /*
313  * Send an external call sigp to another cpu and return without waiting
314  * for its completion.
315  */
316 static void smp_ext_bitcall(int cpu, ec_bit_sig sig)
317 {
318         /*
319          * Set signaling bit in lowcore of target cpu and kick it
320          */
321         set_bit(sig, (unsigned long *) &lowcore_ptr[cpu]->ext_call_fast);
322         while (signal_processor(cpu, sigp_emergency_signal) == sigp_busy)
323                 udelay(10);
324 }
325
326 #ifndef CONFIG_64BIT
327 /*
328  * this function sends a 'purge tlb' signal to another CPU.
329  */
330 void smp_ptlb_callback(void *info)
331 {
332         local_flush_tlb();
333 }
334
335 void smp_ptlb_all(void)
336 {
337         on_each_cpu(smp_ptlb_callback, NULL, 0, 1);
338 }
339 EXPORT_SYMBOL(smp_ptlb_all);
340 #endif /* ! CONFIG_64BIT */
341
342 /*
343  * this function sends a 'reschedule' IPI to another CPU.
344  * it goes straight through and wastes no time serializing
345  * anything. Worst case is that we lose a reschedule ...
346  */
347 void smp_send_reschedule(int cpu)
348 {
349         smp_ext_bitcall(cpu, ec_schedule);
350 }
351
352 /*
353  * parameter area for the set/clear control bit callbacks
354  */
355 struct ec_creg_mask_parms {
356         unsigned long orvals[16];
357         unsigned long andvals[16];
358 };
359
360 /*
361  * callback for setting/clearing control bits
362  */
363 static void smp_ctl_bit_callback(void *info)
364 {
365         struct ec_creg_mask_parms *pp = info;
366         unsigned long cregs[16];
367         int i;
368
369         __ctl_store(cregs, 0, 15);
370         for (i = 0; i <= 15; i++)
371                 cregs[i] = (cregs[i] & pp->andvals[i]) | pp->orvals[i];
372         __ctl_load(cregs, 0, 15);
373 }
374
375 /*
376  * Set a bit in a control register of all cpus
377  */
378 void smp_ctl_set_bit(int cr, int bit)
379 {
380         struct ec_creg_mask_parms parms;
381
382         memset(&parms.orvals, 0, sizeof(parms.orvals));
383         memset(&parms.andvals, 0xff, sizeof(parms.andvals));
384         parms.orvals[cr] = 1 << bit;
385         on_each_cpu(smp_ctl_bit_callback, &parms, 0, 1);
386 }
387 EXPORT_SYMBOL(smp_ctl_set_bit);
388
389 /*
390  * Clear a bit in a control register of all cpus
391  */
392 void smp_ctl_clear_bit(int cr, int bit)
393 {
394         struct ec_creg_mask_parms parms;
395
396         memset(&parms.orvals, 0, sizeof(parms.orvals));
397         memset(&parms.andvals, 0xff, sizeof(parms.andvals));
398         parms.andvals[cr] = ~(1L << bit);
399         on_each_cpu(smp_ctl_bit_callback, &parms, 0, 1);
400 }
401 EXPORT_SYMBOL(smp_ctl_clear_bit);
402
403 #if defined(CONFIG_ZFCPDUMP) || defined(CONFIG_ZFCPDUMP_MODULE)
404
405 /*
406  * zfcpdump_prefix_array holds prefix registers for the following scenario:
407  * 64 bit zfcpdump kernel and 31 bit kernel which is to be dumped. We have to
408  * save its prefix registers, since they get lost, when switching from 31 bit
409  * to 64 bit.
410  */
411 unsigned int zfcpdump_prefix_array[NR_CPUS + 1] \
412         __attribute__((__section__(".data")));
413
414 static void __init smp_get_save_areas(void)
415 {
416         unsigned int cpu, cpu_num, rc;
417         __u16 boot_cpu_addr;
418
419         if (ipl_info.type != IPL_TYPE_FCP_DUMP)
420                 return;
421         boot_cpu_addr = S390_lowcore.cpu_data.cpu_addr;
422         cpu_num = 1;
423         for (cpu = 0; cpu <= 65535; cpu++) {
424                 if ((u16) cpu == boot_cpu_addr)
425                         continue;
426                 __cpu_logical_map[1] = (__u16) cpu;
427                 if (signal_processor(1, sigp_sense) == sigp_not_operational)
428                         continue;
429                 if (cpu_num >= NR_CPUS) {
430                         printk("WARNING: Registers for cpu %i are not "
431                                "saved, since dump kernel was compiled with"
432                                "NR_CPUS=%i!\n", cpu_num, NR_CPUS);
433                         continue;
434                 }
435                 zfcpdump_save_areas[cpu_num] =
436                         alloc_bootmem(sizeof(union save_area));
437                 while (1) {
438                         rc = signal_processor(1, sigp_stop_and_store_status);
439                         if (rc != sigp_busy)
440                                 break;
441                         cpu_relax();
442                 }
443                 memcpy(zfcpdump_save_areas[cpu_num],
444                        (void *)(unsigned long) store_prefix() +
445                        SAVE_AREA_BASE, SAVE_AREA_SIZE);
446 #ifdef __s390x__
447                 /* copy original prefix register */
448                 zfcpdump_save_areas[cpu_num]->s390x.pref_reg =
449                         zfcpdump_prefix_array[cpu_num];
450 #endif
451                 cpu_num++;
452         }
453 }
454
455 union save_area *zfcpdump_save_areas[NR_CPUS + 1];
456 EXPORT_SYMBOL_GPL(zfcpdump_save_areas);
457
458 #else
459 #define smp_get_save_areas() do { } while (0)
460 #endif
461
462 /*
463  * Lets check how many CPUs we have.
464  */
465
466 static unsigned int __init smp_count_cpus(void)
467 {
468         unsigned int cpu, num_cpus;
469         __u16 boot_cpu_addr;
470
471         /*
472          * cpu 0 is the boot cpu. See smp_prepare_boot_cpu.
473          */
474
475         boot_cpu_addr = S390_lowcore.cpu_data.cpu_addr;
476         current_thread_info()->cpu = 0;
477         num_cpus = 1;
478         for (cpu = 0; cpu <= 65535; cpu++) {
479                 if ((__u16) cpu == boot_cpu_addr)
480                         continue;
481                 __cpu_logical_map[1] = (__u16) cpu;
482                 if (signal_processor(1, sigp_sense) == sigp_not_operational)
483                         continue;
484                 num_cpus++;
485         }
486
487         printk("Detected %d CPU's\n", (int) num_cpus);
488         printk("Boot cpu address %2X\n", boot_cpu_addr);
489
490         return num_cpus;
491 }
492
493 /*
494  *      Activate a secondary processor.
495  */
496 int __devinit start_secondary(void *cpuvoid)
497 {
498         /* Setup the cpu */
499         cpu_init();
500         preempt_disable();
501         /* Enable TOD clock interrupts on the secondary cpu. */
502         init_cpu_timer();
503 #ifdef CONFIG_VIRT_TIMER
504         /* Enable cpu timer interrupts on the secondary cpu. */
505         init_cpu_vtimer();
506 #endif
507         /* Enable pfault pseudo page faults on this cpu. */
508         pfault_init();
509
510         /* Mark this cpu as online */
511         cpu_set(smp_processor_id(), cpu_online_map);
512         /* Switch on interrupts */
513         local_irq_enable();
514         /* Print info about this processor */
515         print_cpu_info(&S390_lowcore.cpu_data);
516         /* cpu_idle will call schedule for us */
517         cpu_idle();
518         return 0;
519 }
520
521 static void __init smp_create_idle(unsigned int cpu)
522 {
523         struct task_struct *p;
524
525         /*
526          *  don't care about the psw and regs settings since we'll never
527          *  reschedule the forked task.
528          */
529         p = fork_idle(cpu);
530         if (IS_ERR(p))
531                 panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
532         current_set[cpu] = p;
533 }
534
535 static int cpu_stopped(int cpu)
536 {
537         __u32 status;
538
539         /* Check for stopped state */
540         if (signal_processor_ps(&status, 0, cpu, sigp_sense) ==
541             sigp_status_stored) {
542                 if (status & 0x40)
543                         return 1;
544         }
545         return 0;
546 }
547
548 /* Upping and downing of CPUs */
549
550 int __cpu_up(unsigned int cpu)
551 {
552         struct task_struct *idle;
553         struct _lowcore *cpu_lowcore;
554         struct stack_frame *sf;
555         sigp_ccode ccode;
556         int curr_cpu;
557
558         for (curr_cpu = 0; curr_cpu <= 65535; curr_cpu++) {
559                 __cpu_logical_map[cpu] = (__u16) curr_cpu;
560                 if (cpu_stopped(cpu))
561                         break;
562         }
563
564         if (!cpu_stopped(cpu))
565                 return -ENODEV;
566
567         ccode = signal_processor_p((__u32)(unsigned long)(lowcore_ptr[cpu]),
568                                    cpu, sigp_set_prefix);
569         if (ccode) {
570                 printk("sigp_set_prefix failed for cpu %d "
571                        "with condition code %d\n",
572                        (int) cpu, (int) ccode);
573                 return -EIO;
574         }
575
576         idle = current_set[cpu];
577         cpu_lowcore = lowcore_ptr[cpu];
578         cpu_lowcore->kernel_stack = (unsigned long)
579                 task_stack_page(idle) + THREAD_SIZE;
580         sf = (struct stack_frame *) (cpu_lowcore->kernel_stack
581                                      - sizeof(struct pt_regs)
582                                      - sizeof(struct stack_frame));
583         memset(sf, 0, sizeof(struct stack_frame));
584         sf->gprs[9] = (unsigned long) sf;
585         cpu_lowcore->save_area[15] = (unsigned long) sf;
586         __ctl_store(cpu_lowcore->cregs_save_area[0], 0, 15);
587         asm volatile(
588                 "       stam    0,15,0(%0)"
589                 : : "a" (&cpu_lowcore->access_regs_save_area) : "memory");
590         cpu_lowcore->percpu_offset = __per_cpu_offset[cpu];
591         cpu_lowcore->current_task = (unsigned long) idle;
592         cpu_lowcore->cpu_data.cpu_nr = cpu;
593         eieio();
594
595         while (signal_processor(cpu, sigp_restart) == sigp_busy)
596                 udelay(10);
597
598         while (!cpu_online(cpu))
599                 cpu_relax();
600         return 0;
601 }
602
603 static unsigned int __initdata additional_cpus;
604 static unsigned int __initdata possible_cpus;
605
606 void __init smp_setup_cpu_possible_map(void)
607 {
608         unsigned int phy_cpus, pos_cpus, cpu;
609
610         smp_get_save_areas();
611         phy_cpus = smp_count_cpus();
612         pos_cpus = min(phy_cpus + additional_cpus, (unsigned int) NR_CPUS);
613
614         if (possible_cpus)
615                 pos_cpus = min(possible_cpus, (unsigned int) NR_CPUS);
616
617         for (cpu = 0; cpu < pos_cpus; cpu++)
618                 cpu_set(cpu, cpu_possible_map);
619
620         phy_cpus = min(phy_cpus, pos_cpus);
621
622         for (cpu = 0; cpu < phy_cpus; cpu++)
623                 cpu_set(cpu, cpu_present_map);
624 }
625
626 #ifdef CONFIG_HOTPLUG_CPU
627
628 static int __init setup_additional_cpus(char *s)
629 {
630         additional_cpus = simple_strtoul(s, NULL, 0);
631         return 0;
632 }
633 early_param("additional_cpus", setup_additional_cpus);
634
635 static int __init setup_possible_cpus(char *s)
636 {
637         possible_cpus = simple_strtoul(s, NULL, 0);
638         return 0;
639 }
640 early_param("possible_cpus", setup_possible_cpus);
641
642 int __cpu_disable(void)
643 {
644         struct ec_creg_mask_parms cr_parms;
645         int cpu = smp_processor_id();
646
647         cpu_clear(cpu, cpu_online_map);
648
649         /* Disable pfault pseudo page faults on this cpu. */
650         pfault_fini();
651
652         memset(&cr_parms.orvals, 0, sizeof(cr_parms.orvals));
653         memset(&cr_parms.andvals, 0xff, sizeof(cr_parms.andvals));
654
655         /* disable all external interrupts */
656         cr_parms.orvals[0] = 0;
657         cr_parms.andvals[0] = ~(1 << 15 | 1 << 14 | 1 << 13 | 1 << 12 |
658                                 1 << 11 | 1 << 10 | 1 <<  6 | 1 <<  4);
659         /* disable all I/O interrupts */
660         cr_parms.orvals[6] = 0;
661         cr_parms.andvals[6] = ~(1 << 31 | 1 << 30 | 1 << 29 | 1 << 28 |
662                                 1 << 27 | 1 << 26 | 1 << 25 | 1 << 24);
663         /* disable most machine checks */
664         cr_parms.orvals[14] = 0;
665         cr_parms.andvals[14] = ~(1 << 28 | 1 << 27 | 1 << 26 |
666                                  1 << 25 | 1 << 24);
667
668         smp_ctl_bit_callback(&cr_parms);
669
670         return 0;
671 }
672
673 void __cpu_die(unsigned int cpu)
674 {
675         /* Wait until target cpu is down */
676         while (!smp_cpu_not_running(cpu))
677                 cpu_relax();
678         printk("Processor %d spun down\n", cpu);
679 }
680
681 void cpu_die(void)
682 {
683         idle_task_exit();
684         signal_processor(smp_processor_id(), sigp_stop);
685         BUG();
686         for (;;);
687 }
688
689 #endif /* CONFIG_HOTPLUG_CPU */
690
691 /*
692  *      Cycle through the processors and setup structures.
693  */
694
695 void __init smp_prepare_cpus(unsigned int max_cpus)
696 {
697         unsigned long stack;
698         unsigned int cpu;
699         int i;
700
701         /* request the 0x1201 emergency signal external interrupt */
702         if (register_external_interrupt(0x1201, do_ext_call_interrupt) != 0)
703                 panic("Couldn't request external interrupt 0x1201");
704         memset(lowcore_ptr, 0, sizeof(lowcore_ptr));
705         /*
706          *  Initialize prefix pages and stacks for all possible cpus
707          */
708         print_cpu_info(&S390_lowcore.cpu_data);
709
710         for_each_possible_cpu(i) {
711                 lowcore_ptr[i] = (struct _lowcore *)
712                         __get_free_pages(GFP_KERNEL | GFP_DMA,
713                                          sizeof(void*) == 8 ? 1 : 0);
714                 stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER);
715                 if (!lowcore_ptr[i] || !stack)
716                         panic("smp_boot_cpus failed to allocate memory\n");
717
718                 *(lowcore_ptr[i]) = S390_lowcore;
719                 lowcore_ptr[i]->async_stack = stack + ASYNC_SIZE;
720                 stack = __get_free_pages(GFP_KERNEL, 0);
721                 if (!stack)
722                         panic("smp_boot_cpus failed to allocate memory\n");
723                 lowcore_ptr[i]->panic_stack = stack + PAGE_SIZE;
724 #ifndef CONFIG_64BIT
725                 if (MACHINE_HAS_IEEE) {
726                         lowcore_ptr[i]->extended_save_area_addr =
727                                 (__u32) __get_free_pages(GFP_KERNEL, 0);
728                         if (!lowcore_ptr[i]->extended_save_area_addr)
729                                 panic("smp_boot_cpus failed to "
730                                       "allocate memory\n");
731                 }
732 #endif
733         }
734 #ifndef CONFIG_64BIT
735         if (MACHINE_HAS_IEEE)
736                 ctl_set_bit(14, 29); /* enable extended save area */
737 #endif
738         set_prefix((u32)(unsigned long) lowcore_ptr[smp_processor_id()]);
739
740         for_each_possible_cpu(cpu)
741                 if (cpu != smp_processor_id())
742                         smp_create_idle(cpu);
743 }
744
745 void __devinit smp_prepare_boot_cpu(void)
746 {
747         BUG_ON(smp_processor_id() != 0);
748
749         cpu_set(0, cpu_online_map);
750         S390_lowcore.percpu_offset = __per_cpu_offset[0];
751         current_set[0] = current;
752 }
753
754 void smp_cpus_done(unsigned int max_cpus)
755 {
756         cpu_present_map = cpu_possible_map;
757 }
758
759 /*
760  * the frequency of the profiling timer can be changed
761  * by writing a multiplier value into /proc/profile.
762  *
763  * usually you want to run this on all CPUs ;)
764  */
765 int setup_profiling_timer(unsigned int multiplier)
766 {
767         return 0;
768 }
769
770 static DEFINE_PER_CPU(struct cpu, cpu_devices);
771
772 static ssize_t show_capability(struct sys_device *dev, char *buf)
773 {
774         unsigned int capability;
775         int rc;
776
777         rc = get_cpu_capability(&capability);
778         if (rc)
779                 return rc;
780         return sprintf(buf, "%u\n", capability);
781 }
782 static SYSDEV_ATTR(capability, 0444, show_capability, NULL);
783
784 static int __cpuinit smp_cpu_notify(struct notifier_block *self,
785                                     unsigned long action, void *hcpu)
786 {
787         unsigned int cpu = (unsigned int)(long)hcpu;
788         struct cpu *c = &per_cpu(cpu_devices, cpu);
789         struct sys_device *s = &c->sysdev;
790
791         switch (action) {
792         case CPU_ONLINE:
793                 if (sysdev_create_file(s, &attr_capability))
794                         return NOTIFY_BAD;
795                 break;
796         case CPU_DEAD:
797                 sysdev_remove_file(s, &attr_capability);
798                 break;
799         }
800         return NOTIFY_OK;
801 }
802
803 static struct notifier_block __cpuinitdata smp_cpu_nb = {
804         .notifier_call = smp_cpu_notify,
805 };
806
807 static int __init topology_init(void)
808 {
809         int cpu;
810
811         register_cpu_notifier(&smp_cpu_nb);
812
813         for_each_possible_cpu(cpu) {
814                 struct cpu *c = &per_cpu(cpu_devices, cpu);
815                 struct sys_device *s = &c->sysdev;
816
817                 c->hotpluggable = 1;
818                 register_cpu(c, cpu);
819                 if (!cpu_online(cpu))
820                         continue;
821                 s = &c->sysdev;
822                 sysdev_create_file(s, &attr_capability);
823         }
824         return 0;
825 }
826 subsys_initcall(topology_init);