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