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 #define KMSG_COMPONENT "cpu" 24 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 25 26 #include <linux/module.h> 27 #include <linux/init.h> 28 #include <linux/mm.h> 29 #include <linux/err.h> 30 #include <linux/spinlock.h> 31 #include <linux/kernel_stat.h> 32 #include <linux/delay.h> 33 #include <linux/cache.h> 34 #include <linux/interrupt.h> 35 #include <linux/cpu.h> 36 #include <linux/timex.h> 37 #include <linux/bootmem.h> 38 #include <asm/ipl.h> 39 #include <asm/setup.h> 40 #include <asm/sigp.h> 41 #include <asm/pgalloc.h> 42 #include <asm/irq.h> 43 #include <asm/s390_ext.h> 44 #include <asm/cpcmd.h> 45 #include <asm/tlbflush.h> 46 #include <asm/timer.h> 47 #include <asm/lowcore.h> 48 #include <asm/sclp.h> 49 #include <asm/cpu.h> 50 #include <asm/vdso.h> 51 #include "entry.h" 52 53 /* 54 * An array with a pointer the lowcore of every CPU. 55 */ 56 struct _lowcore *lowcore_ptr[NR_CPUS]; 57 EXPORT_SYMBOL(lowcore_ptr); 58 59 static struct task_struct *current_set[NR_CPUS]; 60 61 static u8 smp_cpu_type; 62 static int smp_use_sigp_detection; 63 64 enum s390_cpu_state { 65 CPU_STATE_STANDBY, 66 CPU_STATE_CONFIGURED, 67 }; 68 69 DEFINE_MUTEX(smp_cpu_state_mutex); 70 int smp_cpu_polarization[NR_CPUS]; 71 static int smp_cpu_state[NR_CPUS]; 72 static int cpu_management; 73 74 static DEFINE_PER_CPU(struct cpu, cpu_devices); 75 76 static void smp_ext_bitcall(int, ec_bit_sig); 77 78 void smp_send_stop(void) 79 { 80 int cpu, rc; 81 82 /* Disable all interrupts/machine checks */ 83 __load_psw_mask(psw_kernel_bits & ~PSW_MASK_MCHECK); 84 85 /* write magic number to zero page (absolute 0) */ 86 lowcore_ptr[smp_processor_id()]->panic_magic = __PANIC_MAGIC; 87 88 /* stop all processors */ 89 for_each_online_cpu(cpu) { 90 if (cpu == smp_processor_id()) 91 continue; 92 do { 93 rc = signal_processor(cpu, sigp_stop); 94 } while (rc == sigp_busy); 95 96 while (!smp_cpu_not_running(cpu)) 97 cpu_relax(); 98 } 99 } 100 101 /* 102 * This is the main routine where commands issued by other 103 * cpus are handled. 104 */ 105 106 static void do_ext_call_interrupt(__u16 code) 107 { 108 unsigned long bits; 109 110 /* 111 * handle bit signal external calls 112 * 113 * For the ec_schedule signal we have to do nothing. All the work 114 * is done automatically when we return from the interrupt. 115 */ 116 bits = xchg(&S390_lowcore.ext_call_fast, 0); 117 118 if (test_bit(ec_call_function, &bits)) 119 generic_smp_call_function_interrupt(); 120 121 if (test_bit(ec_call_function_single, &bits)) 122 generic_smp_call_function_single_interrupt(); 123 } 124 125 /* 126 * Send an external call sigp to another cpu and return without waiting 127 * for its completion. 128 */ 129 static void smp_ext_bitcall(int cpu, ec_bit_sig sig) 130 { 131 /* 132 * Set signaling bit in lowcore of target cpu and kick it 133 */ 134 set_bit(sig, (unsigned long *) &lowcore_ptr[cpu]->ext_call_fast); 135 while (signal_processor(cpu, sigp_emergency_signal) == sigp_busy) 136 udelay(10); 137 } 138 139 void arch_send_call_function_ipi(cpumask_t mask) 140 { 141 int cpu; 142 143 for_each_cpu_mask(cpu, mask) 144 smp_ext_bitcall(cpu, ec_call_function); 145 } 146 147 void arch_send_call_function_single_ipi(int cpu) 148 { 149 smp_ext_bitcall(cpu, ec_call_function_single); 150 } 151 152 #ifndef CONFIG_64BIT 153 /* 154 * this function sends a 'purge tlb' signal to another CPU. 155 */ 156 static void smp_ptlb_callback(void *info) 157 { 158 __tlb_flush_local(); 159 } 160 161 void smp_ptlb_all(void) 162 { 163 on_each_cpu(smp_ptlb_callback, NULL, 1); 164 } 165 EXPORT_SYMBOL(smp_ptlb_all); 166 #endif /* ! CONFIG_64BIT */ 167 168 /* 169 * this function sends a 'reschedule' IPI to another CPU. 170 * it goes straight through and wastes no time serializing 171 * anything. Worst case is that we lose a reschedule ... 172 */ 173 void smp_send_reschedule(int cpu) 174 { 175 smp_ext_bitcall(cpu, ec_schedule); 176 } 177 178 /* 179 * parameter area for the set/clear control bit callbacks 180 */ 181 struct ec_creg_mask_parms { 182 unsigned long orvals[16]; 183 unsigned long andvals[16]; 184 }; 185 186 /* 187 * callback for setting/clearing control bits 188 */ 189 static void smp_ctl_bit_callback(void *info) 190 { 191 struct ec_creg_mask_parms *pp = info; 192 unsigned long cregs[16]; 193 int i; 194 195 __ctl_store(cregs, 0, 15); 196 for (i = 0; i <= 15; i++) 197 cregs[i] = (cregs[i] & pp->andvals[i]) | pp->orvals[i]; 198 __ctl_load(cregs, 0, 15); 199 } 200 201 /* 202 * Set a bit in a control register of all cpus 203 */ 204 void smp_ctl_set_bit(int cr, int bit) 205 { 206 struct ec_creg_mask_parms parms; 207 208 memset(&parms.orvals, 0, sizeof(parms.orvals)); 209 memset(&parms.andvals, 0xff, sizeof(parms.andvals)); 210 parms.orvals[cr] = 1 << bit; 211 on_each_cpu(smp_ctl_bit_callback, &parms, 1); 212 } 213 EXPORT_SYMBOL(smp_ctl_set_bit); 214 215 /* 216 * Clear a bit in a control register of all cpus 217 */ 218 void smp_ctl_clear_bit(int cr, int bit) 219 { 220 struct ec_creg_mask_parms parms; 221 222 memset(&parms.orvals, 0, sizeof(parms.orvals)); 223 memset(&parms.andvals, 0xff, sizeof(parms.andvals)); 224 parms.andvals[cr] = ~(1L << bit); 225 on_each_cpu(smp_ctl_bit_callback, &parms, 1); 226 } 227 EXPORT_SYMBOL(smp_ctl_clear_bit); 228 229 /* 230 * In early ipl state a temp. logically cpu number is needed, so the sigp 231 * functions can be used to sense other cpus. Since NR_CPUS is >= 2 on 232 * CONFIG_SMP and the ipl cpu is logical cpu 0, it must be 1. 233 */ 234 #define CPU_INIT_NO 1 235 236 #if defined(CONFIG_ZFCPDUMP) || defined(CONFIG_ZFCPDUMP_MODULE) 237 238 /* 239 * zfcpdump_prefix_array holds prefix registers for the following scenario: 240 * 64 bit zfcpdump kernel and 31 bit kernel which is to be dumped. We have to 241 * save its prefix registers, since they get lost, when switching from 31 bit 242 * to 64 bit. 243 */ 244 unsigned int zfcpdump_prefix_array[NR_CPUS + 1] \ 245 __attribute__((__section__(".data"))); 246 247 static void __init smp_get_save_area(unsigned int cpu, unsigned int phy_cpu) 248 { 249 if (ipl_info.type != IPL_TYPE_FCP_DUMP) 250 return; 251 if (cpu >= NR_CPUS) { 252 pr_warning("CPU %i exceeds the maximum %i and is excluded from " 253 "the dump\n", cpu, NR_CPUS - 1); 254 return; 255 } 256 zfcpdump_save_areas[cpu] = kmalloc(sizeof(union save_area), GFP_KERNEL); 257 __cpu_logical_map[CPU_INIT_NO] = (__u16) phy_cpu; 258 while (signal_processor(CPU_INIT_NO, sigp_stop_and_store_status) == 259 sigp_busy) 260 cpu_relax(); 261 memcpy(zfcpdump_save_areas[cpu], 262 (void *)(unsigned long) store_prefix() + SAVE_AREA_BASE, 263 SAVE_AREA_SIZE); 264 #ifdef CONFIG_64BIT 265 /* copy original prefix register */ 266 zfcpdump_save_areas[cpu]->s390x.pref_reg = zfcpdump_prefix_array[cpu]; 267 #endif 268 } 269 270 union save_area *zfcpdump_save_areas[NR_CPUS + 1]; 271 EXPORT_SYMBOL_GPL(zfcpdump_save_areas); 272 273 #else 274 275 static inline void smp_get_save_area(unsigned int cpu, unsigned int phy_cpu) { } 276 277 #endif /* CONFIG_ZFCPDUMP || CONFIG_ZFCPDUMP_MODULE */ 278 279 static int cpu_stopped(int cpu) 280 { 281 __u32 status; 282 283 /* Check for stopped state */ 284 if (signal_processor_ps(&status, 0, cpu, sigp_sense) == 285 sigp_status_stored) { 286 if (status & 0x40) 287 return 1; 288 } 289 return 0; 290 } 291 292 static int cpu_known(int cpu_id) 293 { 294 int cpu; 295 296 for_each_present_cpu(cpu) { 297 if (__cpu_logical_map[cpu] == cpu_id) 298 return 1; 299 } 300 return 0; 301 } 302 303 static int smp_rescan_cpus_sigp(cpumask_t avail) 304 { 305 int cpu_id, logical_cpu; 306 307 logical_cpu = first_cpu(avail); 308 if (logical_cpu == NR_CPUS) 309 return 0; 310 for (cpu_id = 0; cpu_id <= 65535; cpu_id++) { 311 if (cpu_known(cpu_id)) 312 continue; 313 __cpu_logical_map[logical_cpu] = cpu_id; 314 smp_cpu_polarization[logical_cpu] = POLARIZATION_UNKNWN; 315 if (!cpu_stopped(logical_cpu)) 316 continue; 317 cpu_set(logical_cpu, cpu_present_map); 318 smp_cpu_state[logical_cpu] = CPU_STATE_CONFIGURED; 319 logical_cpu = next_cpu(logical_cpu, avail); 320 if (logical_cpu == NR_CPUS) 321 break; 322 } 323 return 0; 324 } 325 326 static int smp_rescan_cpus_sclp(cpumask_t avail) 327 { 328 struct sclp_cpu_info *info; 329 int cpu_id, logical_cpu, cpu; 330 int rc; 331 332 logical_cpu = first_cpu(avail); 333 if (logical_cpu == NR_CPUS) 334 return 0; 335 info = kmalloc(sizeof(*info), GFP_KERNEL); 336 if (!info) 337 return -ENOMEM; 338 rc = sclp_get_cpu_info(info); 339 if (rc) 340 goto out; 341 for (cpu = 0; cpu < info->combined; cpu++) { 342 if (info->has_cpu_type && info->cpu[cpu].type != smp_cpu_type) 343 continue; 344 cpu_id = info->cpu[cpu].address; 345 if (cpu_known(cpu_id)) 346 continue; 347 __cpu_logical_map[logical_cpu] = cpu_id; 348 smp_cpu_polarization[logical_cpu] = POLARIZATION_UNKNWN; 349 cpu_set(logical_cpu, cpu_present_map); 350 if (cpu >= info->configured) 351 smp_cpu_state[logical_cpu] = CPU_STATE_STANDBY; 352 else 353 smp_cpu_state[logical_cpu] = CPU_STATE_CONFIGURED; 354 logical_cpu = next_cpu(logical_cpu, avail); 355 if (logical_cpu == NR_CPUS) 356 break; 357 } 358 out: 359 kfree(info); 360 return rc; 361 } 362 363 static int __smp_rescan_cpus(void) 364 { 365 cpumask_t avail; 366 367 cpus_xor(avail, cpu_possible_map, cpu_present_map); 368 if (smp_use_sigp_detection) 369 return smp_rescan_cpus_sigp(avail); 370 else 371 return smp_rescan_cpus_sclp(avail); 372 } 373 374 static void __init smp_detect_cpus(void) 375 { 376 unsigned int cpu, c_cpus, s_cpus; 377 struct sclp_cpu_info *info; 378 u16 boot_cpu_addr, cpu_addr; 379 380 c_cpus = 1; 381 s_cpus = 0; 382 boot_cpu_addr = S390_lowcore.cpu_data.cpu_addr; 383 info = kmalloc(sizeof(*info), GFP_KERNEL); 384 if (!info) 385 panic("smp_detect_cpus failed to allocate memory\n"); 386 /* Use sigp detection algorithm if sclp doesn't work. */ 387 if (sclp_get_cpu_info(info)) { 388 smp_use_sigp_detection = 1; 389 for (cpu = 0; cpu <= 65535; cpu++) { 390 if (cpu == boot_cpu_addr) 391 continue; 392 __cpu_logical_map[CPU_INIT_NO] = cpu; 393 if (!cpu_stopped(CPU_INIT_NO)) 394 continue; 395 smp_get_save_area(c_cpus, cpu); 396 c_cpus++; 397 } 398 goto out; 399 } 400 401 if (info->has_cpu_type) { 402 for (cpu = 0; cpu < info->combined; cpu++) { 403 if (info->cpu[cpu].address == boot_cpu_addr) { 404 smp_cpu_type = info->cpu[cpu].type; 405 break; 406 } 407 } 408 } 409 410 for (cpu = 0; cpu < info->combined; cpu++) { 411 if (info->has_cpu_type && info->cpu[cpu].type != smp_cpu_type) 412 continue; 413 cpu_addr = info->cpu[cpu].address; 414 if (cpu_addr == boot_cpu_addr) 415 continue; 416 __cpu_logical_map[CPU_INIT_NO] = cpu_addr; 417 if (!cpu_stopped(CPU_INIT_NO)) { 418 s_cpus++; 419 continue; 420 } 421 smp_get_save_area(c_cpus, cpu_addr); 422 c_cpus++; 423 } 424 out: 425 kfree(info); 426 pr_info("%d configured CPUs, %d standby CPUs\n", c_cpus, s_cpus); 427 get_online_cpus(); 428 __smp_rescan_cpus(); 429 put_online_cpus(); 430 } 431 432 /* 433 * Activate a secondary processor. 434 */ 435 int __cpuinit start_secondary(void *cpuvoid) 436 { 437 /* Setup the cpu */ 438 cpu_init(); 439 preempt_disable(); 440 /* Enable TOD clock interrupts on the secondary cpu. */ 441 init_cpu_timer(); 442 /* Enable cpu timer interrupts on the secondary cpu. */ 443 init_cpu_vtimer(); 444 /* Enable pfault pseudo page faults on this cpu. */ 445 pfault_init(); 446 447 /* call cpu notifiers */ 448 notify_cpu_starting(smp_processor_id()); 449 /* Mark this cpu as online */ 450 ipi_call_lock(); 451 cpu_set(smp_processor_id(), cpu_online_map); 452 ipi_call_unlock(); 453 /* Switch on interrupts */ 454 local_irq_enable(); 455 /* Print info about this processor */ 456 print_cpu_info(&S390_lowcore.cpu_data); 457 /* cpu_idle will call schedule for us */ 458 cpu_idle(); 459 return 0; 460 } 461 462 static void __init smp_create_idle(unsigned int cpu) 463 { 464 struct task_struct *p; 465 466 /* 467 * don't care about the psw and regs settings since we'll never 468 * reschedule the forked task. 469 */ 470 p = fork_idle(cpu); 471 if (IS_ERR(p)) 472 panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p)); 473 current_set[cpu] = p; 474 } 475 476 static int __cpuinit smp_alloc_lowcore(int cpu) 477 { 478 unsigned long async_stack, panic_stack; 479 struct _lowcore *lowcore; 480 int lc_order; 481 482 lc_order = sizeof(long) == 8 ? 1 : 0; 483 lowcore = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, lc_order); 484 if (!lowcore) 485 return -ENOMEM; 486 async_stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER); 487 panic_stack = __get_free_page(GFP_KERNEL); 488 if (!panic_stack || !async_stack) 489 goto out; 490 memcpy(lowcore, &S390_lowcore, 512); 491 memset((char *)lowcore + 512, 0, sizeof(*lowcore) - 512); 492 lowcore->async_stack = async_stack + ASYNC_SIZE; 493 lowcore->panic_stack = panic_stack + PAGE_SIZE; 494 495 #ifndef CONFIG_64BIT 496 if (MACHINE_HAS_IEEE) { 497 unsigned long save_area; 498 499 save_area = get_zeroed_page(GFP_KERNEL); 500 if (!save_area) 501 goto out; 502 lowcore->extended_save_area_addr = (u32) save_area; 503 } 504 #else 505 if (vdso_alloc_per_cpu(cpu, lowcore)) 506 goto out; 507 #endif 508 lowcore_ptr[cpu] = lowcore; 509 return 0; 510 511 out: 512 free_page(panic_stack); 513 free_pages(async_stack, ASYNC_ORDER); 514 free_pages((unsigned long) lowcore, lc_order); 515 return -ENOMEM; 516 } 517 518 #ifdef CONFIG_HOTPLUG_CPU 519 static void smp_free_lowcore(int cpu) 520 { 521 struct _lowcore *lowcore; 522 int lc_order; 523 524 lc_order = sizeof(long) == 8 ? 1 : 0; 525 lowcore = lowcore_ptr[cpu]; 526 #ifndef CONFIG_64BIT 527 if (MACHINE_HAS_IEEE) 528 free_page((unsigned long) lowcore->extended_save_area_addr); 529 #else 530 vdso_free_per_cpu(cpu, lowcore); 531 #endif 532 free_page(lowcore->panic_stack - PAGE_SIZE); 533 free_pages(lowcore->async_stack - ASYNC_SIZE, ASYNC_ORDER); 534 free_pages((unsigned long) lowcore, lc_order); 535 lowcore_ptr[cpu] = NULL; 536 } 537 #endif /* CONFIG_HOTPLUG_CPU */ 538 539 /* Upping and downing of CPUs */ 540 int __cpuinit __cpu_up(unsigned int cpu) 541 { 542 struct task_struct *idle; 543 struct _lowcore *cpu_lowcore; 544 struct stack_frame *sf; 545 sigp_ccode ccode; 546 547 if (smp_cpu_state[cpu] != CPU_STATE_CONFIGURED) 548 return -EIO; 549 if (smp_alloc_lowcore(cpu)) 550 return -ENOMEM; 551 552 ccode = signal_processor_p((__u32)(unsigned long)(lowcore_ptr[cpu]), 553 cpu, sigp_set_prefix); 554 if (ccode) 555 return -EIO; 556 557 idle = current_set[cpu]; 558 cpu_lowcore = lowcore_ptr[cpu]; 559 cpu_lowcore->kernel_stack = (unsigned long) 560 task_stack_page(idle) + THREAD_SIZE; 561 cpu_lowcore->thread_info = (unsigned long) task_thread_info(idle); 562 sf = (struct stack_frame *) (cpu_lowcore->kernel_stack 563 - sizeof(struct pt_regs) 564 - sizeof(struct stack_frame)); 565 memset(sf, 0, sizeof(struct stack_frame)); 566 sf->gprs[9] = (unsigned long) sf; 567 cpu_lowcore->save_area[15] = (unsigned long) sf; 568 __ctl_store(cpu_lowcore->cregs_save_area, 0, 15); 569 asm volatile( 570 " stam 0,15,0(%0)" 571 : : "a" (&cpu_lowcore->access_regs_save_area) : "memory"); 572 cpu_lowcore->percpu_offset = __per_cpu_offset[cpu]; 573 cpu_lowcore->current_task = (unsigned long) idle; 574 cpu_lowcore->cpu_data.cpu_nr = cpu; 575 cpu_lowcore->kernel_asce = S390_lowcore.kernel_asce; 576 cpu_lowcore->ipl_device = S390_lowcore.ipl_device; 577 eieio(); 578 579 while (signal_processor(cpu, sigp_restart) == sigp_busy) 580 udelay(10); 581 582 while (!cpu_online(cpu)) 583 cpu_relax(); 584 return 0; 585 } 586 587 static int __init setup_possible_cpus(char *s) 588 { 589 int pcpus, cpu; 590 591 pcpus = simple_strtoul(s, NULL, 0); 592 cpu_possible_map = cpumask_of_cpu(0); 593 for (cpu = 1; cpu < pcpus && cpu < NR_CPUS; cpu++) 594 cpu_set(cpu, cpu_possible_map); 595 return 0; 596 } 597 early_param("possible_cpus", setup_possible_cpus); 598 599 #ifdef CONFIG_HOTPLUG_CPU 600 601 int __cpu_disable(void) 602 { 603 struct ec_creg_mask_parms cr_parms; 604 int cpu = smp_processor_id(); 605 606 cpu_clear(cpu, cpu_online_map); 607 608 /* Disable pfault pseudo page faults on this cpu. */ 609 pfault_fini(); 610 611 memset(&cr_parms.orvals, 0, sizeof(cr_parms.orvals)); 612 memset(&cr_parms.andvals, 0xff, sizeof(cr_parms.andvals)); 613 614 /* disable all external interrupts */ 615 cr_parms.orvals[0] = 0; 616 cr_parms.andvals[0] = ~(1 << 15 | 1 << 14 | 1 << 13 | 1 << 12 | 617 1 << 11 | 1 << 10 | 1 << 6 | 1 << 4); 618 /* disable all I/O interrupts */ 619 cr_parms.orvals[6] = 0; 620 cr_parms.andvals[6] = ~(1 << 31 | 1 << 30 | 1 << 29 | 1 << 28 | 621 1 << 27 | 1 << 26 | 1 << 25 | 1 << 24); 622 /* disable most machine checks */ 623 cr_parms.orvals[14] = 0; 624 cr_parms.andvals[14] = ~(1 << 28 | 1 << 27 | 1 << 26 | 625 1 << 25 | 1 << 24); 626 627 smp_ctl_bit_callback(&cr_parms); 628 629 return 0; 630 } 631 632 void __cpu_die(unsigned int cpu) 633 { 634 /* Wait until target cpu is down */ 635 while (!smp_cpu_not_running(cpu)) 636 cpu_relax(); 637 smp_free_lowcore(cpu); 638 pr_info("Processor %d stopped\n", cpu); 639 } 640 641 void cpu_die(void) 642 { 643 idle_task_exit(); 644 signal_processor(smp_processor_id(), sigp_stop); 645 BUG(); 646 for (;;); 647 } 648 649 #endif /* CONFIG_HOTPLUG_CPU */ 650 651 void __init smp_prepare_cpus(unsigned int max_cpus) 652 { 653 #ifndef CONFIG_64BIT 654 unsigned long save_area = 0; 655 #endif 656 unsigned long async_stack, panic_stack; 657 struct _lowcore *lowcore; 658 unsigned int cpu; 659 int lc_order; 660 661 smp_detect_cpus(); 662 663 /* request the 0x1201 emergency signal external interrupt */ 664 if (register_external_interrupt(0x1201, do_ext_call_interrupt) != 0) 665 panic("Couldn't request external interrupt 0x1201"); 666 print_cpu_info(&S390_lowcore.cpu_data); 667 668 /* Reallocate current lowcore, but keep its contents. */ 669 lc_order = sizeof(long) == 8 ? 1 : 0; 670 lowcore = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, lc_order); 671 panic_stack = __get_free_page(GFP_KERNEL); 672 async_stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER); 673 BUG_ON(!lowcore || !panic_stack || !async_stack); 674 #ifndef CONFIG_64BIT 675 if (MACHINE_HAS_IEEE) 676 save_area = get_zeroed_page(GFP_KERNEL); 677 #endif 678 local_irq_disable(); 679 local_mcck_disable(); 680 lowcore_ptr[smp_processor_id()] = lowcore; 681 *lowcore = S390_lowcore; 682 lowcore->panic_stack = panic_stack + PAGE_SIZE; 683 lowcore->async_stack = async_stack + ASYNC_SIZE; 684 #ifndef CONFIG_64BIT 685 if (MACHINE_HAS_IEEE) 686 lowcore->extended_save_area_addr = (u32) save_area; 687 #else 688 if (vdso_alloc_per_cpu(smp_processor_id(), lowcore)) 689 BUG(); 690 #endif 691 set_prefix((u32)(unsigned long) lowcore); 692 local_mcck_enable(); 693 local_irq_enable(); 694 for_each_possible_cpu(cpu) 695 if (cpu != smp_processor_id()) 696 smp_create_idle(cpu); 697 } 698 699 void __init smp_prepare_boot_cpu(void) 700 { 701 BUG_ON(smp_processor_id() != 0); 702 703 current_thread_info()->cpu = 0; 704 cpu_set(0, cpu_present_map); 705 cpu_set(0, cpu_online_map); 706 S390_lowcore.percpu_offset = __per_cpu_offset[0]; 707 current_set[0] = current; 708 smp_cpu_state[0] = CPU_STATE_CONFIGURED; 709 smp_cpu_polarization[0] = POLARIZATION_UNKNWN; 710 } 711 712 void __init smp_cpus_done(unsigned int max_cpus) 713 { 714 } 715 716 /* 717 * the frequency of the profiling timer can be changed 718 * by writing a multiplier value into /proc/profile. 719 * 720 * usually you want to run this on all CPUs ;) 721 */ 722 int setup_profiling_timer(unsigned int multiplier) 723 { 724 return 0; 725 } 726 727 #ifdef CONFIG_HOTPLUG_CPU 728 static ssize_t cpu_configure_show(struct sys_device *dev, 729 struct sysdev_attribute *attr, char *buf) 730 { 731 ssize_t count; 732 733 mutex_lock(&smp_cpu_state_mutex); 734 count = sprintf(buf, "%d\n", smp_cpu_state[dev->id]); 735 mutex_unlock(&smp_cpu_state_mutex); 736 return count; 737 } 738 739 static ssize_t cpu_configure_store(struct sys_device *dev, 740 struct sysdev_attribute *attr, 741 const char *buf, size_t count) 742 { 743 int cpu = dev->id; 744 int val, rc; 745 char delim; 746 747 if (sscanf(buf, "%d %c", &val, &delim) != 1) 748 return -EINVAL; 749 if (val != 0 && val != 1) 750 return -EINVAL; 751 752 get_online_cpus(); 753 mutex_lock(&smp_cpu_state_mutex); 754 rc = -EBUSY; 755 if (cpu_online(cpu)) 756 goto out; 757 rc = 0; 758 switch (val) { 759 case 0: 760 if (smp_cpu_state[cpu] == CPU_STATE_CONFIGURED) { 761 rc = sclp_cpu_deconfigure(__cpu_logical_map[cpu]); 762 if (!rc) { 763 smp_cpu_state[cpu] = CPU_STATE_STANDBY; 764 smp_cpu_polarization[cpu] = POLARIZATION_UNKNWN; 765 } 766 } 767 break; 768 case 1: 769 if (smp_cpu_state[cpu] == CPU_STATE_STANDBY) { 770 rc = sclp_cpu_configure(__cpu_logical_map[cpu]); 771 if (!rc) { 772 smp_cpu_state[cpu] = CPU_STATE_CONFIGURED; 773 smp_cpu_polarization[cpu] = POLARIZATION_UNKNWN; 774 } 775 } 776 break; 777 default: 778 break; 779 } 780 out: 781 mutex_unlock(&smp_cpu_state_mutex); 782 put_online_cpus(); 783 return rc ? rc : count; 784 } 785 static SYSDEV_ATTR(configure, 0644, cpu_configure_show, cpu_configure_store); 786 #endif /* CONFIG_HOTPLUG_CPU */ 787 788 static ssize_t cpu_polarization_show(struct sys_device *dev, 789 struct sysdev_attribute *attr, char *buf) 790 { 791 int cpu = dev->id; 792 ssize_t count; 793 794 mutex_lock(&smp_cpu_state_mutex); 795 switch (smp_cpu_polarization[cpu]) { 796 case POLARIZATION_HRZ: 797 count = sprintf(buf, "horizontal\n"); 798 break; 799 case POLARIZATION_VL: 800 count = sprintf(buf, "vertical:low\n"); 801 break; 802 case POLARIZATION_VM: 803 count = sprintf(buf, "vertical:medium\n"); 804 break; 805 case POLARIZATION_VH: 806 count = sprintf(buf, "vertical:high\n"); 807 break; 808 default: 809 count = sprintf(buf, "unknown\n"); 810 break; 811 } 812 mutex_unlock(&smp_cpu_state_mutex); 813 return count; 814 } 815 static SYSDEV_ATTR(polarization, 0444, cpu_polarization_show, NULL); 816 817 static ssize_t show_cpu_address(struct sys_device *dev, 818 struct sysdev_attribute *attr, char *buf) 819 { 820 return sprintf(buf, "%d\n", __cpu_logical_map[dev->id]); 821 } 822 static SYSDEV_ATTR(address, 0444, show_cpu_address, NULL); 823 824 825 static struct attribute *cpu_common_attrs[] = { 826 #ifdef CONFIG_HOTPLUG_CPU 827 &attr_configure.attr, 828 #endif 829 &attr_address.attr, 830 &attr_polarization.attr, 831 NULL, 832 }; 833 834 static struct attribute_group cpu_common_attr_group = { 835 .attrs = cpu_common_attrs, 836 }; 837 838 static ssize_t show_capability(struct sys_device *dev, 839 struct sysdev_attribute *attr, char *buf) 840 { 841 unsigned int capability; 842 int rc; 843 844 rc = get_cpu_capability(&capability); 845 if (rc) 846 return rc; 847 return sprintf(buf, "%u\n", capability); 848 } 849 static SYSDEV_ATTR(capability, 0444, show_capability, NULL); 850 851 static ssize_t show_idle_count(struct sys_device *dev, 852 struct sysdev_attribute *attr, char *buf) 853 { 854 struct s390_idle_data *idle; 855 unsigned long long idle_count; 856 857 idle = &per_cpu(s390_idle, dev->id); 858 spin_lock(&idle->lock); 859 idle_count = idle->idle_count; 860 if (idle->idle_enter) 861 idle_count++; 862 spin_unlock(&idle->lock); 863 return sprintf(buf, "%llu\n", idle_count); 864 } 865 static SYSDEV_ATTR(idle_count, 0444, show_idle_count, NULL); 866 867 static ssize_t show_idle_time(struct sys_device *dev, 868 struct sysdev_attribute *attr, char *buf) 869 { 870 struct s390_idle_data *idle; 871 unsigned long long now, idle_time, idle_enter; 872 873 idle = &per_cpu(s390_idle, dev->id); 874 spin_lock(&idle->lock); 875 now = get_clock(); 876 idle_time = idle->idle_time; 877 idle_enter = idle->idle_enter; 878 if (idle_enter != 0ULL && idle_enter < now) 879 idle_time += now - idle_enter; 880 spin_unlock(&idle->lock); 881 return sprintf(buf, "%llu\n", idle_time >> 12); 882 } 883 static SYSDEV_ATTR(idle_time_us, 0444, show_idle_time, NULL); 884 885 static struct attribute *cpu_online_attrs[] = { 886 &attr_capability.attr, 887 &attr_idle_count.attr, 888 &attr_idle_time_us.attr, 889 NULL, 890 }; 891 892 static struct attribute_group cpu_online_attr_group = { 893 .attrs = cpu_online_attrs, 894 }; 895 896 static int __cpuinit smp_cpu_notify(struct notifier_block *self, 897 unsigned long action, void *hcpu) 898 { 899 unsigned int cpu = (unsigned int)(long)hcpu; 900 struct cpu *c = &per_cpu(cpu_devices, cpu); 901 struct sys_device *s = &c->sysdev; 902 struct s390_idle_data *idle; 903 904 switch (action) { 905 case CPU_ONLINE: 906 case CPU_ONLINE_FROZEN: 907 idle = &per_cpu(s390_idle, cpu); 908 spin_lock_irq(&idle->lock); 909 idle->idle_enter = 0; 910 idle->idle_time = 0; 911 idle->idle_count = 0; 912 spin_unlock_irq(&idle->lock); 913 if (sysfs_create_group(&s->kobj, &cpu_online_attr_group)) 914 return NOTIFY_BAD; 915 break; 916 case CPU_DEAD: 917 case CPU_DEAD_FROZEN: 918 sysfs_remove_group(&s->kobj, &cpu_online_attr_group); 919 break; 920 } 921 return NOTIFY_OK; 922 } 923 924 static struct notifier_block __cpuinitdata smp_cpu_nb = { 925 .notifier_call = smp_cpu_notify, 926 }; 927 928 static int __devinit smp_add_present_cpu(int cpu) 929 { 930 struct cpu *c = &per_cpu(cpu_devices, cpu); 931 struct sys_device *s = &c->sysdev; 932 int rc; 933 934 c->hotpluggable = 1; 935 rc = register_cpu(c, cpu); 936 if (rc) 937 goto out; 938 rc = sysfs_create_group(&s->kobj, &cpu_common_attr_group); 939 if (rc) 940 goto out_cpu; 941 if (!cpu_online(cpu)) 942 goto out; 943 rc = sysfs_create_group(&s->kobj, &cpu_online_attr_group); 944 if (!rc) 945 return 0; 946 sysfs_remove_group(&s->kobj, &cpu_common_attr_group); 947 out_cpu: 948 #ifdef CONFIG_HOTPLUG_CPU 949 unregister_cpu(c); 950 #endif 951 out: 952 return rc; 953 } 954 955 #ifdef CONFIG_HOTPLUG_CPU 956 957 int __ref smp_rescan_cpus(void) 958 { 959 cpumask_t newcpus; 960 int cpu; 961 int rc; 962 963 get_online_cpus(); 964 mutex_lock(&smp_cpu_state_mutex); 965 newcpus = cpu_present_map; 966 rc = __smp_rescan_cpus(); 967 if (rc) 968 goto out; 969 cpus_andnot(newcpus, cpu_present_map, newcpus); 970 for_each_cpu_mask(cpu, newcpus) { 971 rc = smp_add_present_cpu(cpu); 972 if (rc) 973 cpu_clear(cpu, cpu_present_map); 974 } 975 rc = 0; 976 out: 977 mutex_unlock(&smp_cpu_state_mutex); 978 put_online_cpus(); 979 if (!cpus_empty(newcpus)) 980 topology_schedule_update(); 981 return rc; 982 } 983 984 static ssize_t __ref rescan_store(struct sysdev_class *class, const char *buf, 985 size_t count) 986 { 987 int rc; 988 989 rc = smp_rescan_cpus(); 990 return rc ? rc : count; 991 } 992 static SYSDEV_CLASS_ATTR(rescan, 0200, NULL, rescan_store); 993 #endif /* CONFIG_HOTPLUG_CPU */ 994 995 static ssize_t dispatching_show(struct sysdev_class *class, char *buf) 996 { 997 ssize_t count; 998 999 mutex_lock(&smp_cpu_state_mutex); 1000 count = sprintf(buf, "%d\n", cpu_management); 1001 mutex_unlock(&smp_cpu_state_mutex); 1002 return count; 1003 } 1004 1005 static ssize_t dispatching_store(struct sysdev_class *dev, const char *buf, 1006 size_t count) 1007 { 1008 int val, rc; 1009 char delim; 1010 1011 if (sscanf(buf, "%d %c", &val, &delim) != 1) 1012 return -EINVAL; 1013 if (val != 0 && val != 1) 1014 return -EINVAL; 1015 rc = 0; 1016 get_online_cpus(); 1017 mutex_lock(&smp_cpu_state_mutex); 1018 if (cpu_management == val) 1019 goto out; 1020 rc = topology_set_cpu_management(val); 1021 if (!rc) 1022 cpu_management = val; 1023 out: 1024 mutex_unlock(&smp_cpu_state_mutex); 1025 put_online_cpus(); 1026 return rc ? rc : count; 1027 } 1028 static SYSDEV_CLASS_ATTR(dispatching, 0644, dispatching_show, 1029 dispatching_store); 1030 1031 static int __init topology_init(void) 1032 { 1033 int cpu; 1034 int rc; 1035 1036 register_cpu_notifier(&smp_cpu_nb); 1037 1038 #ifdef CONFIG_HOTPLUG_CPU 1039 rc = sysdev_class_create_file(&cpu_sysdev_class, &attr_rescan); 1040 if (rc) 1041 return rc; 1042 #endif 1043 rc = sysdev_class_create_file(&cpu_sysdev_class, &attr_dispatching); 1044 if (rc) 1045 return rc; 1046 for_each_present_cpu(cpu) { 1047 rc = smp_add_present_cpu(cpu); 1048 if (rc) 1049 return rc; 1050 } 1051 return 0; 1052 } 1053 subsys_initcall(topology_init); 1054