arch/x86/kernel/process-xen.c

   1 #include <linux/errno.h>
   2 #include <linux/kernel.h>
   3 #include <linux/mm.h>
   4 #include <linux/smp.h>
   5 #include <linux/prctl.h>
   6 #include <linux/slab.h>
   7 #include <linux/sched.h>
   8 #include <linux/module.h>
   9 #include <linux/pm.h>
  10 #include <linux/clockchips.h>
  11 #include <linux/random.h>
  12 #include <linux/user-return-notifier.h>
  13 #include <linux/dmi.h>
  14 #include <linux/utsname.h>
  15 #include <linux/stackprotector.h>
  16 #include <linux/tick.h>
  17 #include <linux/cpuidle.h>
  18 #include <trace/events/power.h>
  19 #include <linux/hw_breakpoint.h>
  20 #include <asm/cpu.h>
  21 #include <asm/apic.h>
  22 #include <asm/syscalls.h>
  23 #include <asm/idle.h>
  24 #include <asm/uaccess.h>
  25 #include <asm/i387.h>
  26 #include <asm/fpu-internal.h>
  27 #include <asm/debugreg.h>
  28 #include <asm/nmi.h>
  29 #include <xen/evtchn.h>
  30
  31 #ifdef CONFIG_X86_64
  32 static DEFINE_PER_CPU(unsigned char, is_idle);
  33 static ATOMIC_NOTIFIER_HEAD(idle_notifier);
  34
  35 void idle_notifier_register(struct notifier_block *n)
  36 {
  37         atomic_notifier_chain_register(&idle_notifier, n);
  38 }
  39 EXPORT_SYMBOL_GPL(idle_notifier_register);
  40
  41 void idle_notifier_unregister(struct notifier_block *n)
  42 {
  43         atomic_notifier_chain_unregister(&idle_notifier, n);
  44 }
  45 EXPORT_SYMBOL_GPL(idle_notifier_unregister);
  46 #endif
  47
  48 struct kmem_cache *task_xstate_cachep;
  49 EXPORT_SYMBOL_GPL(task_xstate_cachep);
  50
  51 int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
  52 {
  53         int ret;
  54
  55         *dst = *src;
  56         if (fpu_allocated(&src->thread.fpu)) {
  57                 memset(&dst->thread.fpu, 0, sizeof(dst->thread.fpu));
  58                 ret = fpu_alloc(&dst->thread.fpu);
  59                 if (ret)
  60                         return ret;
  61                 fpu_copy(&dst->thread.fpu, &src->thread.fpu);
  62         }
  63         return 0;
  64 }
  65
  66 void free_thread_xstate(struct task_struct *tsk)
  67 {
  68         fpu_free(&tsk->thread.fpu);
  69 }
  70
  71 void free_thread_info(struct thread_info *ti)
  72 {
  73         free_thread_xstate(ti->task);
  74         free_pages((unsigned long)ti, THREAD_ORDER);
  75 }
  76
  77 void arch_task_cache_init(void)
  78 {
  79         task_xstate_cachep =
  80                 kmem_cache_create("task_xstate", xstate_size,
  81                                   __alignof__(union thread_xstate),
  82                                   SLAB_PANIC | SLAB_NOTRACK, NULL);
  83 }
  84
  85 /*
  86  * Free current thread data structures etc..
  87  */
  88 void exit_thread(void)
  89 {
  90         struct task_struct *me = current;
  91         struct thread_struct *t = &me->thread;
  92         unsigned long *bp = t->io_bitmap_ptr;
  93
  94         if (bp) {
  95                 struct physdev_set_iobitmap set_iobitmap;
  96
  97                 t->io_bitmap_ptr = NULL;
  98                 clear_thread_flag(TIF_IO_BITMAP);
  99                 /*
 100                  * Careful, clear this in the TSS too:
 101                  */
 102                 memset(&set_iobitmap, 0, sizeof(set_iobitmap));
 103                 WARN_ON(HYPERVISOR_physdev_op(PHYSDEVOP_set_iobitmap,
 104                                               &set_iobitmap));
 105                 t->io_bitmap_max = 0;
 106                 kfree(bp);
 107         }
 108 }
 109
 110 void show_regs(struct pt_regs *regs)
 111 {
 112         show_registers(regs);
 113         show_trace(NULL, regs, (unsigned long *)kernel_stack_pointer(regs), 0);
 114 }
 115
 116 void show_regs_common(void)
 117 {
 118         const char *vendor, *product, *board;
 119
 120         vendor = dmi_get_system_info(DMI_SYS_VENDOR);
 121         if (!vendor)
 122                 vendor = "";
 123         product = dmi_get_system_info(DMI_PRODUCT_NAME);
 124         if (!product)
 125                 product = "";
 126
 127         /* Board Name is optional */
 128         board = dmi_get_system_info(DMI_BOARD_NAME);
 129
 130         printk(KERN_CONT "\n");
 131         printk(KERN_DEFAULT "Pid: %d, comm: %.20s %s %s %.*s",
 132                 current->pid, current->comm, print_tainted(),
 133                 init_utsname()->release,
 134                 (int)strcspn(init_utsname()->version, " "),
 135                 init_utsname()->version);
 136         printk(KERN_CONT " %s %s", vendor, product);
 137         if (board)
 138                 printk(KERN_CONT "/%s", board);
 139         printk(KERN_CONT "\n");
 140 }
 141
 142 void flush_thread(void)
 143 {
 144         struct task_struct *tsk = current;
 145
 146         flush_ptrace_hw_breakpoint(tsk);
 147         memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
 148         /*
 149          * Forget coprocessor state..
 150          */
 151         tsk->fpu_counter = 0;
 152         clear_fpu(tsk);
 153         clear_used_math();
 154 }
 155
 156 static void hard_disable_TSC(void)
 157 {
 158         write_cr4(read_cr4() | X86_CR4_TSD);
 159 }
 160
 161 void disable_TSC(void)
 162 {
 163         preempt_disable();
 164         if (!test_and_set_thread_flag(TIF_NOTSC))
 165                 /*
 166                  * Must flip the CPU state synchronously with
 167                  * TIF_NOTSC in the current running context.
 168                  */
 169                 hard_disable_TSC();
 170         preempt_enable();
 171 }
 172
 173 static void hard_enable_TSC(void)
 174 {
 175         write_cr4(read_cr4() & ~X86_CR4_TSD);
 176 }
 177
 178 static void enable_TSC(void)
 179 {
 180         preempt_disable();
 181         if (test_and_clear_thread_flag(TIF_NOTSC))
 182                 /*
 183                  * Must flip the CPU state synchronously with
 184                  * TIF_NOTSC in the current running context.
 185                  */
 186                 hard_enable_TSC();
 187         preempt_enable();
 188 }
 189
 190 int get_tsc_mode(unsigned long adr)
 191 {
 192         unsigned int val;
 193
 194         if (test_thread_flag(TIF_NOTSC))
 195                 val = PR_TSC_SIGSEGV;
 196         else
 197                 val = PR_TSC_ENABLE;
 198
 199         return put_user(val, (unsigned int __user *)adr);
 200 }
 201
 202 int set_tsc_mode(unsigned int val)
 203 {
 204         if (val == PR_TSC_SIGSEGV)
 205                 disable_TSC();
 206         else if (val == PR_TSC_ENABLE)
 207                 enable_TSC();
 208         else
 209                 return -EINVAL;
 210
 211         return 0;
 212 }
 213
 214 void __switch_to_xtra(struct task_struct *prev_p, struct task_struct *next_p)
 215 {
 216         struct thread_struct *prev, *next;
 217
 218         prev = &prev_p->thread;
 219         next = &next_p->thread;
 220
 221         if (test_tsk_thread_flag(prev_p, TIF_BLOCKSTEP) ^
 222             test_tsk_thread_flag(next_p, TIF_BLOCKSTEP)) {
 223                 unsigned long debugctl = get_debugctlmsr();
 224
 225                 debugctl &= ~DEBUGCTLMSR_BTF;
 226                 if (test_tsk_thread_flag(next_p, TIF_BLOCKSTEP))
 227                         debugctl |= DEBUGCTLMSR_BTF;
 228
 229                 update_debugctlmsr(debugctl);
 230         }
 231
 232         if (test_tsk_thread_flag(prev_p, TIF_NOTSC) ^
 233             test_tsk_thread_flag(next_p, TIF_NOTSC)) {
 234                 /* prev and next are different */
 235                 if (test_tsk_thread_flag(next_p, TIF_NOTSC))
 236                         hard_disable_TSC();
 237                 else
 238                         hard_enable_TSC();
 239         }
 240         propagate_user_return_notify(prev_p, next_p);
 241 }
 242
 243 int sys_fork(struct pt_regs *regs)
 244 {
 245         return do_fork(SIGCHLD, regs->sp, regs, 0, NULL, NULL);
 246 }
 247
 248 /*
 249  * This is trivial, and on the face of it looks like it
 250  * could equally well be done in user mode.
 251  *
 252  * Not so, for quite unobvious reasons - register pressure.
 253  * In user mode vfork() cannot have a stack frame, and if
 254  * done by calling the "clone()" system call directly, you
 255  * do not have enough call-clobbered registers to hold all
 256  * the information you need.
 257  */
 258 int sys_vfork(struct pt_regs *regs)
 259 {
 260         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->sp, regs, 0,
 261                        NULL, NULL);
 262 }
 263
 264 long
 265 sys_clone(unsigned long clone_flags, unsigned long newsp,
 266           void __user *parent_tid, void __user *child_tid, struct pt_regs *regs)
 267 {
 268         if (!newsp)
 269                 newsp = regs->sp;
 270         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
 271 }
 272
 273 /*
 274  * This gets run with %si containing the
 275  * function to call, and %di containing
 276  * the "args".
 277  */
 278 extern void kernel_thread_helper(void);
 279
 280 /*
 281  * Create a kernel thread
 282  */
 283 int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
 284 {
 285         struct pt_regs regs;
 286
 287         memset(&regs, 0, sizeof(regs));
 288
 289         regs.si = (unsigned long) fn;
 290         regs.di = (unsigned long) arg;
 291
 292 #ifdef CONFIG_X86_32
 293         regs.ds = __USER_DS;
 294         regs.es = __USER_DS;
 295         regs.fs = __KERNEL_PERCPU;
 296         regs.gs = __KERNEL_STACK_CANARY;
 297 #else
 298         regs.ss = __KERNEL_DS;
 299 #endif
 300
 301         regs.orig_ax = -1;
 302         regs.ip = (unsigned long) kernel_thread_helper;
 303         regs.cs = __KERNEL_CS | get_kernel_rpl();
 304         regs.flags = X86_EFLAGS_IF | X86_EFLAGS_BIT1;
 305
 306         /* Ok, create the new process.. */
 307         return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
 308 }
 309 EXPORT_SYMBOL(kernel_thread);
 310
 311 /*
 312  * sys_execve() executes a new program.
 313  */
 314 long sys_execve(const char __user *name,
 315                 const char __user *const __user *argv,
 316                 const char __user *const __user *envp, struct pt_regs *regs)
 317 {
 318         long error;
 319         char *filename;
 320
 321         filename = getname(name);
 322         error = PTR_ERR(filename);
 323         if (IS_ERR(filename))
 324                 return error;
 325         error = do_execve(filename, argv, envp, regs);
 326
 327 #ifdef CONFIG_X86_32
 328         if (error == 0) {
 329                 /* Make sure we don't return using sysenter.. */
 330                 set_thread_flag(TIF_IRET);
 331         }
 332 #endif
 333
 334         putname(filename);
 335         return error;
 336 }
 337
 338 /*
 339  * Idle related variables and functions
 340  */
 341 unsigned long boot_option_idle_override = IDLE_NO_OVERRIDE;
 342 EXPORT_SYMBOL(boot_option_idle_override);
 343
 344 /*
 345  * Powermanagement idle function, if any..
 346  */
 347 void (*pm_idle)(void);
 348 #ifdef CONFIG_APM_MODULE
 349 EXPORT_SYMBOL(pm_idle);
 350 #endif
 351
 352 #ifndef CONFIG_SMP
 353 static inline void play_dead(void)
 354 {
 355         BUG();
 356 }
 357 #endif
 358
 359 #ifdef CONFIG_X86_64
 360 void enter_idle(void)
 361 {
 362         percpu_write(is_idle, 1);
 363         atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
 364 }
 365
 366 static void __exit_idle(void)
 367 {
 368         if (x86_test_and_clear_bit_percpu(0, is_idle) == 0)
 369                 return;
 370         atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL);
 371 }
 372
 373 /* Called from interrupts to signify idle end */
 374 void exit_idle(void)
 375 {
 376         /* idle loop has pid 0 */
 377         if (current->pid)
 378                 return;
 379         __exit_idle();
 380 }
 381 #endif
 382
 383 /*
 384  * The idle thread. There's no useful work to be
 385  * done, so just try to conserve power and have a
 386  * low exit latency (ie sit in a loop waiting for
 387  * somebody to say that they'd like to reschedule)
 388  */
 389 void cpu_idle(void)
 390 {
 391         /*
 392          * If we're the non-boot CPU, nothing set the stack canary up
 393          * for us.  CPU0 already has it initialized but no harm in
 394          * doing it again.  This is a good place for updating it, as
 395          * we wont ever return from this function (so the invalid
 396          * canaries already on the stack wont ever trigger).
 397          */
 398         boot_init_stack_canary();
 399         current_thread_info()->status |= TS_POLLING;
 400
 401         /* endless idle loop with no priority at all */
 402         while (1) {
 403                 tick_nohz_idle_enter();
 404
 405                 while (!need_resched()) {
 406                         rmb();
 407
 408                         if (cpu_is_offline(smp_processor_id()))
 409                                 play_dead();
 410
 411                         /*
 412                          * Idle routines should keep interrupts disabled
 413                          * from here on, until they go to idle.
 414                          * Otherwise, idle callbacks can misfire.
 415                          */
 416                         local_touch_nmi();
 417                         local_irq_disable();
 418
 419                         enter_idle();
 420
 421                         /* Don't trace irqs off for idle */
 422                         stop_critical_timings();
 423
 424                         /* enter_idle() needs rcu for notifiers */
 425                         rcu_idle_enter();
 426
 427                         if (cpuidle_idle_call())
 428                                 xen_idle();
 429
 430                         rcu_idle_exit();
 431                         start_critical_timings();
 432
 433                         /* In many cases the interrupt that ended idle
 434                            has already called exit_idle. But some idle
 435                            loops can be woken up without interrupt. */
 436                         __exit_idle();
 437                 }
 438
 439                 tick_nohz_idle_exit();
 440                 preempt_enable_no_resched();
 441                 schedule();
 442                 preempt_disable();
 443         }
 444 }
 445
 446 /*
 447  * We use this if we don't have any better
 448  * idle routine..
 449  */
 450 void xen_idle(void)
 451 {
 452         trace_power_start_rcuidle(POWER_CSTATE, 1, smp_processor_id());
 453         trace_cpu_idle_rcuidle(1, smp_processor_id());
 454         current_thread_info()->status &= ~TS_POLLING;
 455         /*
 456          * TS_POLLING-cleared state must be visible before we
 457          * test NEED_RESCHED:
 458          */
 459         smp_mb();
 460
 461         if (!need_resched())
 462                 safe_halt();    /* enables interrupts racelessly */
 463         else
 464                 local_irq_enable();
 465         current_thread_info()->status |= TS_POLLING;
 466         trace_power_end_rcuidle(smp_processor_id());
 467         trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
 468 }
 469 #ifdef CONFIG_APM_MODULE
 470 EXPORT_SYMBOL(default_idle);
 471 #endif
 472
 473 bool __init set_pm_idle_to_default(void)
 474 {
 475         bool ret = !!pm_idle;
 476
 477         pm_idle = xen_idle;
 478
 479         return ret;
 480 }
 481 void stop_this_cpu(void *dummy)
 482 {
 483         local_irq_disable();
 484         /*
 485          * Remove this CPU:
 486          */
 487         set_cpu_online(smp_processor_id(), false);
 488         disable_all_local_evtchn();
 489
 490         for (;;) {
 491                 if (hlt_works(smp_processor_id()))
 492                         halt();
 493         }
 494 }
 495
 496 static void do_nothing(void *unused)
 497 {
 498 }
 499
 500 /*
 501  * cpu_idle_wait - Used to ensure that all the CPUs discard old value of
 502  * pm_idle and update to new pm_idle value. Required while changing pm_idle
 503  * handler on SMP systems.
 504  *
 505  * Caller must have changed pm_idle to the new value before the call. Old
 506  * pm_idle value will not be used by any CPU after the return of this function.
 507  */
 508 void cpu_idle_wait(void)
 509 {
 510         smp_mb();
 511         /* kick all the CPUs so that they exit out of pm_idle */
 512         smp_call_function(do_nothing, NULL, 1);
 513 }
 514 EXPORT_SYMBOL_GPL(cpu_idle_wait);
 515
 516 #ifndef CONFIG_XEN
 517 /* Default MONITOR/MWAIT with no hints, used for default C1 state */
 518 static void mwait_idle(void)
 519 {
 520         if (!need_resched()) {
 521                 trace_power_start_rcuidle(POWER_CSTATE, 1, smp_processor_id());
 522                 trace_cpu_idle_rcuidle(1, smp_processor_id());
 523                 if (this_cpu_has(X86_FEATURE_CLFLUSH_MONITOR))
 524                         clflush((void *)&current_thread_info()->flags);
 525
 526                 __monitor((void *)&current_thread_info()->flags, 0, 0);
 527                 smp_mb();
 528                 if (!need_resched())
 529                         __sti_mwait(0, 0);
 530                 else
 531                         local_irq_enable();
 532                 trace_power_end_rcuidle(smp_processor_id());
 533                 trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
 534         } else
 535                 local_irq_enable();
 536 }
 537 #endif
 538
 539 /*
 540  * On SMP it's slightly faster (but much more power-consuming!)
 541  * to poll the ->work.need_resched flag instead of waiting for the
 542  * cross-CPU IPI to arrive. Use this option with caution.
 543  */
 544 static void poll_idle(void)
 545 {
 546         trace_power_start_rcuidle(POWER_CSTATE, 0, smp_processor_id());
 547         trace_cpu_idle_rcuidle(0, smp_processor_id());
 548         local_irq_enable();
 549         while (!need_resched())
 550                 cpu_relax();
 551         trace_power_end_rcuidle(smp_processor_id());
 552         trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
 553 }
 554
 555 #ifndef CONFIG_XEN
 556 /*
 557  * mwait selection logic:
 558  *
 559  * It depends on the CPU. For AMD CPUs that support MWAIT this is
 560  * wrong. Family 0x10 and 0x11 CPUs will enter C1 on HLT. Powersavings
 561  * then depend on a clock divisor and current Pstate of the core. If
 562  * all cores of a processor are in halt state (C1) the processor can
 563  * enter the C1E (C1 enhanced) state. If mwait is used this will never
 564  * happen.
 565  *
 566  * idle=mwait overrides this decision and forces the usage of mwait.
 567  */
 568
 569 #define MWAIT_INFO                      0x05
 570 #define MWAIT_ECX_EXTENDED_INFO         0x01
 571 #define MWAIT_EDX_C1                    0xf0
 572
 573 int mwait_usable(const struct cpuinfo_x86 *c)
 574 {
 575         u32 eax, ebx, ecx, edx;
 576
 577         if (boot_option_idle_override == IDLE_FORCE_MWAIT)
 578                 return 1;
 579
 580         if (c->cpuid_level < MWAIT_INFO)
 581                 return 0;
 582
 583         cpuid(MWAIT_INFO, &eax, &ebx, &ecx, &edx);
 584         /* Check, whether EDX has extended info about MWAIT */
 585         if (!(ecx & MWAIT_ECX_EXTENDED_INFO))
 586                 return 1;
 587
 588         /*
 589          * edx enumeratios MONITOR/MWAIT extensions. Check, whether
 590          * C1  supports MWAIT
 591          */
 592         return (edx & MWAIT_EDX_C1);
 593 }
 594
 595 bool amd_e400_c1e_detected;
 596 EXPORT_SYMBOL(amd_e400_c1e_detected);
 597
 598 static cpumask_var_t amd_e400_c1e_mask;
 599
 600 void amd_e400_remove_cpu(int cpu)
 601 {
 602         if (amd_e400_c1e_mask != NULL)
 603                 cpumask_clear_cpu(cpu, amd_e400_c1e_mask);
 604 }
 605
 606 /*
 607  * AMD Erratum 400 aware idle routine. We check for C1E active in the interrupt
 608  * pending message MSR. If we detect C1E, then we handle it the same
 609  * way as C3 power states (local apic timer and TSC stop)
 610  */
 611 static void amd_e400_idle(void)
 612 {
 613         if (need_resched())
 614                 return;
 615
 616         if (!amd_e400_c1e_detected) {
 617                 u32 lo, hi;
 618
 619                 rdmsr(MSR_K8_INT_PENDING_MSG, lo, hi);
 620
 621                 if (lo & K8_INTP_C1E_ACTIVE_MASK) {
 622                         amd_e400_c1e_detected = true;
 623                         if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
 624                                 mark_tsc_unstable("TSC halt in AMD C1E");
 625                         printk(KERN_INFO "System has AMD C1E enabled\n");
 626                 }
 627         }
 628
 629         if (amd_e400_c1e_detected) {
 630                 int cpu = smp_processor_id();
 631
 632                 if (!cpumask_test_cpu(cpu, amd_e400_c1e_mask)) {
 633                         cpumask_set_cpu(cpu, amd_e400_c1e_mask);
 634                         /*
 635                          * Force broadcast so ACPI can not interfere.
 636                          */
 637                         clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_FORCE,
 638                                            &cpu);
 639                         printk(KERN_INFO "Switch to broadcast mode on CPU%d\n",
 640                                cpu);
 641                 }
 642                 clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &cpu);
 643
 644                 default_idle();
 645
 646                 /*
 647                  * The switch back from broadcast mode needs to be
 648                  * called with interrupts disabled.
 649                  */
 650                  local_irq_disable();
 651                  clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &cpu);
 652                  local_irq_enable();
 653         } else
 654                 default_idle();
 655 }
 656 #endif
 657
 658 void __cpuinit select_idle_routine(const struct cpuinfo_x86 *c)
 659 {
 660 #ifndef CONFIG_XEN
 661 #ifdef CONFIG_SMP
 662         if (pm_idle == poll_idle && smp_num_siblings > 1) {
 663                 printk_once(KERN_WARNING "WARNING: polling idle and HT enabled,"
 664                         " performance may degrade.\n");
 665         }
 666 #endif
 667         if (pm_idle)
 668                 return;
 669
 670         if (cpu_has(c, X86_FEATURE_MWAIT) && mwait_usable(c)) {
 671                 /*
 672                  * One CPU supports mwait => All CPUs supports mwait
 673                  */
 674                 printk(KERN_INFO "using mwait in idle threads.\n");
 675                 pm_idle = mwait_idle;
 676         } else if (cpu_has_amd_erratum(amd_erratum_400)) {
 677                 /* E400: APIC timer interrupt does not wake up CPU from C1e */
 678                 printk(KERN_INFO "using AMD E400 aware idle routine\n");
 679                 pm_idle = amd_e400_idle;
 680         } else
 681                 pm_idle = default_idle;
 682 #endif
 683 }
 684
 685 void __init init_amd_e400_c1e_mask(void)
 686 {
 687 #ifndef CONFIG_XEN
 688         /* If we're using amd_e400_idle, we need to allocate amd_e400_c1e_mask. */
 689         if (pm_idle == amd_e400_idle)
 690                 zalloc_cpumask_var(&amd_e400_c1e_mask, GFP_KERNEL);
 691 #endif
 692 }
 693
 694 static int __init idle_setup(char *str)
 695 {
 696         if (!str)
 697                 return -EINVAL;
 698
 699         if (!strcmp(str, "poll")) {
 700                 printk("using polling idle threads.\n");
 701                 pm_idle = poll_idle;
 702                 boot_option_idle_override = IDLE_POLL;
 703 #ifndef CONFIG_XEN
 704         } else if (!strcmp(str, "mwait")) {
 705                 boot_option_idle_override = IDLE_FORCE_MWAIT;
 706                 WARN_ONCE(1, "\"idle=mwait\" will be removed in 2012\n");
 707         } else if (!strcmp(str, "halt")) {
 708                 /*
 709                  * When the boot option of idle=halt is added, halt is
 710                  * forced to be used for CPU idle. In such case CPU C2/C3
 711                  * won't be used again.
 712                  * To continue to load the CPU idle driver, don't touch
 713                  * the boot_option_idle_override.
 714                  */
 715                 pm_idle = default_idle;
 716                 boot_option_idle_override = IDLE_HALT;
 717         } else if (!strcmp(str, "nomwait")) {
 718                 /*
 719                  * If the boot option of "idle=nomwait" is added,
 720                  * it means that mwait will be disabled for CPU C2/C3
 721                  * states. In such case it won't touch the variable
 722                  * of boot_option_idle_override.
 723                  */
 724                 boot_option_idle_override = IDLE_NOMWAIT;
 725 #endif
 726         } else
 727                 return -1;
 728
 729         return 0;
 730 }
 731 early_param("idle", idle_setup);
 732
 733 unsigned long arch_align_stack(unsigned long sp)
 734 {
 735         if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
 736                 sp -= get_random_int() % 8192;
 737         return sp & ~0xf;
 738 }
 739
 740 unsigned long arch_randomize_brk(struct mm_struct *mm)
 741 {
 742         unsigned long range_end = mm->brk + 0x02000000;
 743         return randomize_range(mm->brk, range_end, 0) ? : mm->brk;
 744 }
 745