2012-05-22 09:50:07 +07:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2008-03-11 05:28:04 +07:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/smp.h>
|
2009-02-28 04:25:28 +07:00
|
|
|
#include <linux/prctl.h>
|
2008-03-11 05:28:04 +07:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/sched.h>
|
2008-04-25 22:39:01 +07:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pm.h>
|
2015-04-03 07:01:28 +07:00
|
|
|
#include <linux/tick.h>
|
2009-05-12 09:05:28 +07:00
|
|
|
#include <linux/random.h>
|
2009-09-19 13:40:22 +07:00
|
|
|
#include <linux/user-return-notifier.h>
|
2009-12-08 15:29:42 +07:00
|
|
|
#include <linux/dmi.h>
|
|
|
|
#include <linux/utsname.h>
|
2012-03-26 04:00:04 +07:00
|
|
|
#include <linux/stackprotector.h>
|
|
|
|
#include <linux/tick.h>
|
|
|
|
#include <linux/cpuidle.h>
|
2009-09-17 21:11:28 +07:00
|
|
|
#include <trace/events/power.h>
|
2009-09-10 00:22:48 +07:00
|
|
|
#include <linux/hw_breakpoint.h>
|
2011-01-20 21:42:52 +07:00
|
|
|
#include <asm/cpu.h>
|
2008-11-11 20:33:44 +07:00
|
|
|
#include <asm/apic.h>
|
2009-04-11 01:33:10 +07:00
|
|
|
#include <asm/syscalls.h>
|
2009-02-28 04:25:28 +07:00
|
|
|
#include <asm/idle.h>
|
|
|
|
#include <asm/uaccess.h>
|
sched/idle/x86: Restore mwait_idle() to fix boot hangs, to improve power savings and to improve performance
In Linux-3.9 we removed the mwait_idle() loop:
69fb3676df33 ("x86 idle: remove mwait_idle() and "idle=mwait" cmdline param")
The reasoning was that modern machines should be sufficiently
happy during the boot process using the default_idle() HALT
loop, until cpuidle loads and either acpi_idle or intel_idle
invoke the newer MWAIT-with-hints idle loop.
But two machines reported problems:
1. Certain Core2-era machines support MWAIT-C1 and HALT only.
MWAIT-C1 is preferred for optimal power and performance.
But if they support just C1, cpuidle never loads and
so they use the boot-time default idle loop forever.
2. Some laptops will boot-hang if HALT is used,
but will boot successfully if MWAIT is used.
This appears to be a hidden assumption in BIOS SMI,
that is presumably valid on the proprietary OS
where the BIOS was validated.
https://bugzilla.kernel.org/show_bug.cgi?id=60770
So here we effectively revert the patch above, restoring
the mwait_idle() loop. However, we don't bother restoring
the idle=mwait cmdline parameter, since it appears to add
no value.
Maintainer notes:
For 3.9, simply revert 69fb3676df
for 3.10, patch -F3 applies, fuzz needed due to __cpuinit use in
context For 3.11, 3.12, 3.13, this patch applies cleanly
Tested-by: Mike Galbraith <bitbucket@online.de>
Signed-off-by: Len Brown <len.brown@intel.com>
Acked-by: Mike Galbraith <bitbucket@online.de>
Cc: <stable@vger.kernel.org> # 3.9+
Cc: Borislav Petkov <bp@alien8.de>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Ian Malone <ibmalone@gmail.com>
Cc: Josh Boyer <jwboyer@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/345254a551eb5a6a866e048d7ab570fd2193aca4.1389763084.git.len.brown@intel.com
[ Ported to recent kernels. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-15 12:37:34 +07:00
|
|
|
#include <asm/mwait.h>
|
2015-04-24 07:54:44 +07:00
|
|
|
#include <asm/fpu/internal.h>
|
2009-06-02 01:14:55 +07:00
|
|
|
#include <asm/debugreg.h>
|
2012-03-26 04:00:04 +07:00
|
|
|
#include <asm/nmi.h>
|
2014-10-25 05:58:07 +07:00
|
|
|
#include <asm/tlbflush.h>
|
2012-03-26 04:00:04 +07:00
|
|
|
|
2012-05-03 16:03:01 +07:00
|
|
|
/*
|
|
|
|
* per-CPU TSS segments. Threads are completely 'soft' on Linux,
|
|
|
|
* no more per-task TSS's. The TSS size is kept cacheline-aligned
|
|
|
|
* so they are allowed to end up in the .data..cacheline_aligned
|
|
|
|
* section. Since TSS's are completely CPU-local, we want them
|
|
|
|
* on exact cacheline boundaries, to eliminate cacheline ping-pong.
|
|
|
|
*/
|
2015-03-06 10:19:06 +07:00
|
|
|
__visible DEFINE_PER_CPU_SHARED_ALIGNED(struct tss_struct, cpu_tss) = {
|
|
|
|
.x86_tss = {
|
2015-03-11 01:05:59 +07:00
|
|
|
.sp0 = TOP_OF_INIT_STACK,
|
2015-03-06 10:19:06 +07:00
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
.ss0 = __KERNEL_DS,
|
|
|
|
.ss1 = __KERNEL_CS,
|
|
|
|
.io_bitmap_base = INVALID_IO_BITMAP_OFFSET,
|
|
|
|
#endif
|
|
|
|
},
|
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
/*
|
|
|
|
* Note that the .io_bitmap member must be extra-big. This is because
|
|
|
|
* the CPU will access an additional byte beyond the end of the IO
|
|
|
|
* permission bitmap. The extra byte must be all 1 bits, and must
|
|
|
|
* be within the limit.
|
|
|
|
*/
|
|
|
|
.io_bitmap = { [0 ... IO_BITMAP_LONGS] = ~0 },
|
|
|
|
#endif
|
|
|
|
};
|
2015-05-05 01:16:44 +07:00
|
|
|
EXPORT_PER_CPU_SYMBOL(cpu_tss);
|
2012-05-03 16:03:01 +07:00
|
|
|
|
2012-03-26 04:00:04 +07:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
static DEFINE_PER_CPU(unsigned char, is_idle);
|
|
|
|
static ATOMIC_NOTIFIER_HEAD(idle_notifier);
|
|
|
|
|
|
|
|
void idle_notifier_register(struct notifier_block *n)
|
|
|
|
{
|
|
|
|
atomic_notifier_chain_register(&idle_notifier, n);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(idle_notifier_register);
|
|
|
|
|
|
|
|
void idle_notifier_unregister(struct notifier_block *n)
|
|
|
|
{
|
|
|
|
atomic_notifier_chain_unregister(&idle_notifier, n);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(idle_notifier_unregister);
|
|
|
|
#endif
|
2008-06-24 16:58:53 +07:00
|
|
|
|
2012-05-17 05:03:51 +07:00
|
|
|
/*
|
|
|
|
* this gets called so that we can store lazy state into memory and copy the
|
|
|
|
* current task into the new thread.
|
|
|
|
*/
|
2008-03-11 05:28:04 +07:00
|
|
|
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
|
|
|
{
|
|
|
|
*dst = *src;
|
2014-09-03 00:57:23 +07:00
|
|
|
|
2015-04-24 07:07:15 +07:00
|
|
|
return fpu__copy(&dst->thread.fpu, &src->thread.fpu);
|
2008-03-11 05:28:04 +07:00
|
|
|
}
|
|
|
|
|
2012-05-05 22:05:42 +07:00
|
|
|
void arch_release_task_struct(struct task_struct *tsk)
|
2008-03-11 05:28:05 +07:00
|
|
|
{
|
2015-04-22 16:44:46 +07:00
|
|
|
fpstate_free(&tsk->thread.fpu);
|
2008-03-11 05:28:04 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void arch_task_cache_init(void)
|
|
|
|
{
|
2015-04-22 20:41:56 +07:00
|
|
|
fpstate_cache_init();
|
2008-03-11 05:28:04 +07:00
|
|
|
}
|
2008-04-25 22:39:01 +07:00
|
|
|
|
2009-02-28 04:25:28 +07:00
|
|
|
/*
|
|
|
|
* Free current thread data structures etc..
|
|
|
|
*/
|
|
|
|
void exit_thread(void)
|
|
|
|
{
|
|
|
|
struct task_struct *me = current;
|
|
|
|
struct thread_struct *t = &me->thread;
|
2009-03-16 19:07:21 +07:00
|
|
|
unsigned long *bp = t->io_bitmap_ptr;
|
2015-04-23 17:33:50 +07:00
|
|
|
struct fpu *fpu = &t->fpu;
|
2009-02-28 04:25:28 +07:00
|
|
|
|
2009-03-16 19:07:21 +07:00
|
|
|
if (bp) {
|
2015-03-06 10:19:05 +07:00
|
|
|
struct tss_struct *tss = &per_cpu(cpu_tss, get_cpu());
|
2009-02-28 04:25:28 +07:00
|
|
|
|
|
|
|
t->io_bitmap_ptr = NULL;
|
|
|
|
clear_thread_flag(TIF_IO_BITMAP);
|
|
|
|
/*
|
|
|
|
* Careful, clear this in the TSS too:
|
|
|
|
*/
|
|
|
|
memset(tss->io_bitmap, 0xff, t->io_bitmap_max);
|
|
|
|
t->io_bitmap_max = 0;
|
|
|
|
put_cpu();
|
2009-03-16 19:07:21 +07:00
|
|
|
kfree(bp);
|
2009-02-28 04:25:28 +07:00
|
|
|
}
|
2012-05-17 05:03:54 +07:00
|
|
|
|
2015-04-23 17:33:50 +07:00
|
|
|
drop_fpu(fpu);
|
2009-02-28 04:25:28 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void flush_thread(void)
|
|
|
|
{
|
|
|
|
struct task_struct *tsk = current;
|
|
|
|
|
2009-09-10 00:22:48 +07:00
|
|
|
flush_ptrace_hw_breakpoint(tsk);
|
2009-02-28 04:25:28 +07:00
|
|
|
memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
|
2015-01-20 01:52:12 +07:00
|
|
|
|
2015-04-24 07:28:23 +07:00
|
|
|
fpu__clear(tsk);
|
2009-02-28 04:25:28 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hard_disable_TSC(void)
|
|
|
|
{
|
2014-10-25 05:58:07 +07:00
|
|
|
cr4_set_bits(X86_CR4_TSD);
|
2009-02-28 04:25:28 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
void disable_TSC(void)
|
|
|
|
{
|
|
|
|
preempt_disable();
|
|
|
|
if (!test_and_set_thread_flag(TIF_NOTSC))
|
|
|
|
/*
|
|
|
|
* Must flip the CPU state synchronously with
|
|
|
|
* TIF_NOTSC in the current running context.
|
|
|
|
*/
|
|
|
|
hard_disable_TSC();
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hard_enable_TSC(void)
|
|
|
|
{
|
2014-10-25 05:58:07 +07:00
|
|
|
cr4_clear_bits(X86_CR4_TSD);
|
2009-02-28 04:25:28 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void enable_TSC(void)
|
|
|
|
{
|
|
|
|
preempt_disable();
|
|
|
|
if (test_and_clear_thread_flag(TIF_NOTSC))
|
|
|
|
/*
|
|
|
|
* Must flip the CPU state synchronously with
|
|
|
|
* TIF_NOTSC in the current running context.
|
|
|
|
*/
|
|
|
|
hard_enable_TSC();
|
|
|
|
preempt_enable();
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_tsc_mode(unsigned long adr)
|
|
|
|
{
|
|
|
|
unsigned int val;
|
|
|
|
|
|
|
|
if (test_thread_flag(TIF_NOTSC))
|
|
|
|
val = PR_TSC_SIGSEGV;
|
|
|
|
else
|
|
|
|
val = PR_TSC_ENABLE;
|
|
|
|
|
|
|
|
return put_user(val, (unsigned int __user *)adr);
|
|
|
|
}
|
|
|
|
|
|
|
|
int set_tsc_mode(unsigned int val)
|
|
|
|
{
|
|
|
|
if (val == PR_TSC_SIGSEGV)
|
|
|
|
disable_TSC();
|
|
|
|
else if (val == PR_TSC_ENABLE)
|
|
|
|
enable_TSC();
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void __switch_to_xtra(struct task_struct *prev_p, struct task_struct *next_p,
|
|
|
|
struct tss_struct *tss)
|
|
|
|
{
|
|
|
|
struct thread_struct *prev, *next;
|
|
|
|
|
|
|
|
prev = &prev_p->thread;
|
|
|
|
next = &next_p->thread;
|
|
|
|
|
2010-03-25 20:51:51 +07:00
|
|
|
if (test_tsk_thread_flag(prev_p, TIF_BLOCKSTEP) ^
|
|
|
|
test_tsk_thread_flag(next_p, TIF_BLOCKSTEP)) {
|
|
|
|
unsigned long debugctl = get_debugctlmsr();
|
|
|
|
|
|
|
|
debugctl &= ~DEBUGCTLMSR_BTF;
|
|
|
|
if (test_tsk_thread_flag(next_p, TIF_BLOCKSTEP))
|
|
|
|
debugctl |= DEBUGCTLMSR_BTF;
|
|
|
|
|
|
|
|
update_debugctlmsr(debugctl);
|
|
|
|
}
|
2009-02-28 04:25:28 +07:00
|
|
|
|
|
|
|
if (test_tsk_thread_flag(prev_p, TIF_NOTSC) ^
|
|
|
|
test_tsk_thread_flag(next_p, TIF_NOTSC)) {
|
|
|
|
/* prev and next are different */
|
|
|
|
if (test_tsk_thread_flag(next_p, TIF_NOTSC))
|
|
|
|
hard_disable_TSC();
|
|
|
|
else
|
|
|
|
hard_enable_TSC();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (test_tsk_thread_flag(next_p, TIF_IO_BITMAP)) {
|
|
|
|
/*
|
|
|
|
* Copy the relevant range of the IO bitmap.
|
|
|
|
* Normally this is 128 bytes or less:
|
|
|
|
*/
|
|
|
|
memcpy(tss->io_bitmap, next->io_bitmap_ptr,
|
|
|
|
max(prev->io_bitmap_max, next->io_bitmap_max));
|
|
|
|
} else if (test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)) {
|
|
|
|
/*
|
|
|
|
* Clear any possible leftover bits:
|
|
|
|
*/
|
|
|
|
memset(tss->io_bitmap, 0xff, prev->io_bitmap_max);
|
|
|
|
}
|
2009-09-19 13:40:22 +07:00
|
|
|
propagate_user_return_notify(prev_p, next_p);
|
2009-02-28 04:25:28 +07:00
|
|
|
}
|
|
|
|
|
2008-06-09 23:35:28 +07:00
|
|
|
/*
|
|
|
|
* Idle related variables and functions
|
|
|
|
*/
|
2010-11-03 23:06:14 +07:00
|
|
|
unsigned long boot_option_idle_override = IDLE_NO_OVERRIDE;
|
2008-06-09 23:35:28 +07:00
|
|
|
EXPORT_SYMBOL(boot_option_idle_override);
|
|
|
|
|
2013-02-10 09:45:03 +07:00
|
|
|
static void (*x86_idle)(void);
|
2008-06-09 23:35:28 +07:00
|
|
|
|
2012-03-26 04:00:04 +07:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
static inline void play_dead(void)
|
|
|
|
{
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
void enter_idle(void)
|
|
|
|
{
|
2012-05-11 14:35:27 +07:00
|
|
|
this_cpu_write(is_idle, 1);
|
2012-03-26 04:00:04 +07:00
|
|
|
atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit_idle(void)
|
|
|
|
{
|
|
|
|
if (x86_test_and_clear_bit_percpu(0, is_idle) == 0)
|
|
|
|
return;
|
|
|
|
atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Called from interrupts to signify idle end */
|
|
|
|
void exit_idle(void)
|
|
|
|
{
|
|
|
|
/* idle loop has pid 0 */
|
|
|
|
if (current->pid)
|
|
|
|
return;
|
|
|
|
__exit_idle();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2013-03-22 04:50:03 +07:00
|
|
|
void arch_cpu_idle_enter(void)
|
|
|
|
{
|
|
|
|
local_touch_nmi();
|
|
|
|
enter_idle();
|
|
|
|
}
|
2012-03-26 04:00:04 +07:00
|
|
|
|
2013-03-22 04:50:03 +07:00
|
|
|
void arch_cpu_idle_exit(void)
|
|
|
|
{
|
|
|
|
__exit_idle();
|
|
|
|
}
|
2012-03-26 04:00:04 +07:00
|
|
|
|
2013-03-22 04:50:03 +07:00
|
|
|
void arch_cpu_idle_dead(void)
|
|
|
|
{
|
|
|
|
play_dead();
|
|
|
|
}
|
2012-03-26 04:00:04 +07:00
|
|
|
|
2013-03-22 04:50:03 +07:00
|
|
|
/*
|
|
|
|
* Called from the generic idle code.
|
|
|
|
*/
|
|
|
|
void arch_cpu_idle(void)
|
|
|
|
{
|
2014-01-30 00:45:12 +07:00
|
|
|
x86_idle();
|
2012-03-26 04:00:04 +07:00
|
|
|
}
|
|
|
|
|
2008-06-09 23:35:28 +07:00
|
|
|
/*
|
2013-03-22 04:50:03 +07:00
|
|
|
* We use this if we don't have any better idle routine..
|
2008-06-09 23:35:28 +07:00
|
|
|
*/
|
|
|
|
void default_idle(void)
|
|
|
|
{
|
2012-10-25 23:13:11 +07:00
|
|
|
trace_cpu_idle_rcuidle(1, smp_processor_id());
|
2013-03-22 04:50:03 +07:00
|
|
|
safe_halt();
|
2012-10-25 23:13:11 +07:00
|
|
|
trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
|
2008-06-09 23:35:28 +07:00
|
|
|
}
|
2011-06-15 02:45:10 +07:00
|
|
|
#ifdef CONFIG_APM_MODULE
|
2008-06-09 23:35:28 +07:00
|
|
|
EXPORT_SYMBOL(default_idle);
|
|
|
|
#endif
|
|
|
|
|
2013-02-10 11:08:07 +07:00
|
|
|
#ifdef CONFIG_XEN
|
|
|
|
bool xen_set_default_idle(void)
|
2011-11-22 06:02:02 +07:00
|
|
|
{
|
2013-02-10 09:45:03 +07:00
|
|
|
bool ret = !!x86_idle;
|
2011-11-22 06:02:02 +07:00
|
|
|
|
2013-02-10 09:45:03 +07:00
|
|
|
x86_idle = default_idle;
|
2011-11-22 06:02:02 +07:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2013-02-10 11:08:07 +07:00
|
|
|
#endif
|
2008-11-11 20:33:44 +07:00
|
|
|
void stop_this_cpu(void *dummy)
|
|
|
|
{
|
|
|
|
local_irq_disable();
|
|
|
|
/*
|
|
|
|
* Remove this CPU:
|
|
|
|
*/
|
2009-03-13 11:19:54 +07:00
|
|
|
set_cpu_online(smp_processor_id(), false);
|
2008-11-11 20:33:44 +07:00
|
|
|
disable_local_APIC();
|
|
|
|
|
x86 idle: remove 32-bit-only "no-hlt" parameter, hlt_works_ok flag
Remove 32-bit x86 a cmdline param "no-hlt",
and the cpuinfo_x86.hlt_works_ok that it sets.
If a user wants to avoid HLT, then "idle=poll"
is much more useful, as it avoids invocation of HLT
in idle, while "no-hlt" failed to do so.
Indeed, hlt_works_ok was consulted in only 3 places.
First, in /proc/cpuinfo where "hlt_bug yes"
would be printed if and only if the user booted
the system with "no-hlt" -- as there was no other code
to set that flag.
Second, check_hlt() would not invoke halt() if "no-hlt"
were on the cmdline.
Third, it was consulted in stop_this_cpu(), which is invoked
by native_machine_halt()/reboot_interrupt()/smp_stop_nmi_callback() --
all cases where the machine is being shutdown/reset.
The flag was not consulted in the more frequently invoked
play_dead()/hlt_play_dead() used in processor offline and suspend.
Since Linux-3.0 there has been a run-time notice upon "no-hlt" invocations
indicating that it would be removed in 2012.
Signed-off-by: Len Brown <len.brown@intel.com>
Cc: x86@kernel.org
2013-02-10 14:28:46 +07:00
|
|
|
for (;;)
|
|
|
|
halt();
|
2008-04-25 22:39:01 +07:00
|
|
|
}
|
|
|
|
|
2011-04-02 03:59:53 +07:00
|
|
|
bool amd_e400_c1e_detected;
|
|
|
|
EXPORT_SYMBOL(amd_e400_c1e_detected);
|
2008-06-10 00:15:00 +07:00
|
|
|
|
2011-04-02 03:59:53 +07:00
|
|
|
static cpumask_var_t amd_e400_c1e_mask;
|
2008-09-22 23:54:29 +07:00
|
|
|
|
2011-04-02 03:59:53 +07:00
|
|
|
void amd_e400_remove_cpu(int cpu)
|
2008-09-22 23:54:29 +07:00
|
|
|
{
|
2011-04-02 03:59:53 +07:00
|
|
|
if (amd_e400_c1e_mask != NULL)
|
|
|
|
cpumask_clear_cpu(cpu, amd_e400_c1e_mask);
|
2008-09-22 23:54:29 +07:00
|
|
|
}
|
|
|
|
|
2008-06-10 00:15:00 +07:00
|
|
|
/*
|
2011-04-02 03:59:53 +07:00
|
|
|
* AMD Erratum 400 aware idle routine. We check for C1E active in the interrupt
|
2008-06-10 00:15:00 +07:00
|
|
|
* pending message MSR. If we detect C1E, then we handle it the same
|
|
|
|
* way as C3 power states (local apic timer and TSC stop)
|
|
|
|
*/
|
2011-04-02 03:59:53 +07:00
|
|
|
static void amd_e400_idle(void)
|
2008-06-10 00:15:00 +07:00
|
|
|
{
|
2011-04-02 03:59:53 +07:00
|
|
|
if (!amd_e400_c1e_detected) {
|
2008-06-10 00:15:00 +07:00
|
|
|
u32 lo, hi;
|
|
|
|
|
|
|
|
rdmsr(MSR_K8_INT_PENDING_MSG, lo, hi);
|
2010-07-27 23:53:35 +07:00
|
|
|
|
2008-06-10 00:15:00 +07:00
|
|
|
if (lo & K8_INTP_C1E_ACTIVE_MASK) {
|
2011-04-02 03:59:53 +07:00
|
|
|
amd_e400_c1e_detected = true;
|
2008-11-18 07:11:37 +07:00
|
|
|
if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
|
2008-09-19 02:12:10 +07:00
|
|
|
mark_tsc_unstable("TSC halt in AMD C1E");
|
2012-05-22 09:50:07 +07:00
|
|
|
pr_info("System has AMD C1E enabled\n");
|
2008-06-10 00:15:00 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-02 03:59:53 +07:00
|
|
|
if (amd_e400_c1e_detected) {
|
2008-06-10 00:15:00 +07:00
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
2011-04-02 03:59:53 +07:00
|
|
|
if (!cpumask_test_cpu(cpu, amd_e400_c1e_mask)) {
|
|
|
|
cpumask_set_cpu(cpu, amd_e400_c1e_mask);
|
2015-04-03 07:01:28 +07:00
|
|
|
/* Force broadcast so ACPI can not interfere. */
|
|
|
|
tick_broadcast_force();
|
2012-05-22 09:50:07 +07:00
|
|
|
pr_info("Switch to broadcast mode on CPU%d\n", cpu);
|
2008-06-10 00:15:00 +07:00
|
|
|
}
|
2015-04-03 07:05:53 +07:00
|
|
|
tick_broadcast_enter();
|
2008-06-17 14:12:03 +07:00
|
|
|
|
2008-06-10 00:15:00 +07:00
|
|
|
default_idle();
|
2008-06-17 14:12:03 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The switch back from broadcast mode needs to be
|
|
|
|
* called with interrupts disabled.
|
|
|
|
*/
|
2013-09-11 17:43:13 +07:00
|
|
|
local_irq_disable();
|
2015-04-03 07:05:53 +07:00
|
|
|
tick_broadcast_exit();
|
2013-09-11 17:43:13 +07:00
|
|
|
local_irq_enable();
|
2008-06-10 00:15:00 +07:00
|
|
|
} else
|
|
|
|
default_idle();
|
|
|
|
}
|
|
|
|
|
sched/idle/x86: Restore mwait_idle() to fix boot hangs, to improve power savings and to improve performance
In Linux-3.9 we removed the mwait_idle() loop:
69fb3676df33 ("x86 idle: remove mwait_idle() and "idle=mwait" cmdline param")
The reasoning was that modern machines should be sufficiently
happy during the boot process using the default_idle() HALT
loop, until cpuidle loads and either acpi_idle or intel_idle
invoke the newer MWAIT-with-hints idle loop.
But two machines reported problems:
1. Certain Core2-era machines support MWAIT-C1 and HALT only.
MWAIT-C1 is preferred for optimal power and performance.
But if they support just C1, cpuidle never loads and
so they use the boot-time default idle loop forever.
2. Some laptops will boot-hang if HALT is used,
but will boot successfully if MWAIT is used.
This appears to be a hidden assumption in BIOS SMI,
that is presumably valid on the proprietary OS
where the BIOS was validated.
https://bugzilla.kernel.org/show_bug.cgi?id=60770
So here we effectively revert the patch above, restoring
the mwait_idle() loop. However, we don't bother restoring
the idle=mwait cmdline parameter, since it appears to add
no value.
Maintainer notes:
For 3.9, simply revert 69fb3676df
for 3.10, patch -F3 applies, fuzz needed due to __cpuinit use in
context For 3.11, 3.12, 3.13, this patch applies cleanly
Tested-by: Mike Galbraith <bitbucket@online.de>
Signed-off-by: Len Brown <len.brown@intel.com>
Acked-by: Mike Galbraith <bitbucket@online.de>
Cc: <stable@vger.kernel.org> # 3.9+
Cc: Borislav Petkov <bp@alien8.de>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Ian Malone <ibmalone@gmail.com>
Cc: Josh Boyer <jwboyer@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/345254a551eb5a6a866e048d7ab570fd2193aca4.1389763084.git.len.brown@intel.com
[ Ported to recent kernels. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-15 12:37:34 +07:00
|
|
|
/*
|
|
|
|
* Intel Core2 and older machines prefer MWAIT over HALT for C1.
|
|
|
|
* We can't rely on cpuidle installing MWAIT, because it will not load
|
|
|
|
* on systems that support only C1 -- so the boot default must be MWAIT.
|
|
|
|
*
|
|
|
|
* Some AMD machines are the opposite, they depend on using HALT.
|
|
|
|
*
|
|
|
|
* So for default C1, which is used during boot until cpuidle loads,
|
|
|
|
* use MWAIT-C1 on Intel HW that has it, else use HALT.
|
|
|
|
*/
|
|
|
|
static int prefer_mwait_c1_over_halt(const struct cpuinfo_x86 *c)
|
|
|
|
{
|
|
|
|
if (c->x86_vendor != X86_VENDOR_INTEL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!cpu_has(c, X86_FEATURE_MWAIT))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MONITOR/MWAIT with no hints, used for default default C1 state.
|
|
|
|
* This invokes MWAIT with interrutps enabled and no flags,
|
|
|
|
* which is backwards compatible with the original MWAIT implementation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void mwait_idle(void)
|
|
|
|
{
|
2014-01-18 23:14:44 +07:00
|
|
|
if (!current_set_polling_and_test()) {
|
|
|
|
if (this_cpu_has(X86_BUG_CLFLUSH_MONITOR)) {
|
|
|
|
smp_mb(); /* quirk */
|
sched/idle/x86: Restore mwait_idle() to fix boot hangs, to improve power savings and to improve performance
In Linux-3.9 we removed the mwait_idle() loop:
69fb3676df33 ("x86 idle: remove mwait_idle() and "idle=mwait" cmdline param")
The reasoning was that modern machines should be sufficiently
happy during the boot process using the default_idle() HALT
loop, until cpuidle loads and either acpi_idle or intel_idle
invoke the newer MWAIT-with-hints idle loop.
But two machines reported problems:
1. Certain Core2-era machines support MWAIT-C1 and HALT only.
MWAIT-C1 is preferred for optimal power and performance.
But if they support just C1, cpuidle never loads and
so they use the boot-time default idle loop forever.
2. Some laptops will boot-hang if HALT is used,
but will boot successfully if MWAIT is used.
This appears to be a hidden assumption in BIOS SMI,
that is presumably valid on the proprietary OS
where the BIOS was validated.
https://bugzilla.kernel.org/show_bug.cgi?id=60770
So here we effectively revert the patch above, restoring
the mwait_idle() loop. However, we don't bother restoring
the idle=mwait cmdline parameter, since it appears to add
no value.
Maintainer notes:
For 3.9, simply revert 69fb3676df
for 3.10, patch -F3 applies, fuzz needed due to __cpuinit use in
context For 3.11, 3.12, 3.13, this patch applies cleanly
Tested-by: Mike Galbraith <bitbucket@online.de>
Signed-off-by: Len Brown <len.brown@intel.com>
Acked-by: Mike Galbraith <bitbucket@online.de>
Cc: <stable@vger.kernel.org> # 3.9+
Cc: Borislav Petkov <bp@alien8.de>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Ian Malone <ibmalone@gmail.com>
Cc: Josh Boyer <jwboyer@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/345254a551eb5a6a866e048d7ab570fd2193aca4.1389763084.git.len.brown@intel.com
[ Ported to recent kernels. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-15 12:37:34 +07:00
|
|
|
clflush((void *)¤t_thread_info()->flags);
|
2014-01-18 23:14:44 +07:00
|
|
|
smp_mb(); /* quirk */
|
|
|
|
}
|
sched/idle/x86: Restore mwait_idle() to fix boot hangs, to improve power savings and to improve performance
In Linux-3.9 we removed the mwait_idle() loop:
69fb3676df33 ("x86 idle: remove mwait_idle() and "idle=mwait" cmdline param")
The reasoning was that modern machines should be sufficiently
happy during the boot process using the default_idle() HALT
loop, until cpuidle loads and either acpi_idle or intel_idle
invoke the newer MWAIT-with-hints idle loop.
But two machines reported problems:
1. Certain Core2-era machines support MWAIT-C1 and HALT only.
MWAIT-C1 is preferred for optimal power and performance.
But if they support just C1, cpuidle never loads and
so they use the boot-time default idle loop forever.
2. Some laptops will boot-hang if HALT is used,
but will boot successfully if MWAIT is used.
This appears to be a hidden assumption in BIOS SMI,
that is presumably valid on the proprietary OS
where the BIOS was validated.
https://bugzilla.kernel.org/show_bug.cgi?id=60770
So here we effectively revert the patch above, restoring
the mwait_idle() loop. However, we don't bother restoring
the idle=mwait cmdline parameter, since it appears to add
no value.
Maintainer notes:
For 3.9, simply revert 69fb3676df
for 3.10, patch -F3 applies, fuzz needed due to __cpuinit use in
context For 3.11, 3.12, 3.13, this patch applies cleanly
Tested-by: Mike Galbraith <bitbucket@online.de>
Signed-off-by: Len Brown <len.brown@intel.com>
Acked-by: Mike Galbraith <bitbucket@online.de>
Cc: <stable@vger.kernel.org> # 3.9+
Cc: Borislav Petkov <bp@alien8.de>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Ian Malone <ibmalone@gmail.com>
Cc: Josh Boyer <jwboyer@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/345254a551eb5a6a866e048d7ab570fd2193aca4.1389763084.git.len.brown@intel.com
[ Ported to recent kernels. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-15 12:37:34 +07:00
|
|
|
|
|
|
|
__monitor((void *)¤t_thread_info()->flags, 0, 0);
|
|
|
|
if (!need_resched())
|
|
|
|
__sti_mwait(0, 0);
|
|
|
|
else
|
|
|
|
local_irq_enable();
|
2014-01-18 23:14:44 +07:00
|
|
|
} else {
|
sched/idle/x86: Restore mwait_idle() to fix boot hangs, to improve power savings and to improve performance
In Linux-3.9 we removed the mwait_idle() loop:
69fb3676df33 ("x86 idle: remove mwait_idle() and "idle=mwait" cmdline param")
The reasoning was that modern machines should be sufficiently
happy during the boot process using the default_idle() HALT
loop, until cpuidle loads and either acpi_idle or intel_idle
invoke the newer MWAIT-with-hints idle loop.
But two machines reported problems:
1. Certain Core2-era machines support MWAIT-C1 and HALT only.
MWAIT-C1 is preferred for optimal power and performance.
But if they support just C1, cpuidle never loads and
so they use the boot-time default idle loop forever.
2. Some laptops will boot-hang if HALT is used,
but will boot successfully if MWAIT is used.
This appears to be a hidden assumption in BIOS SMI,
that is presumably valid on the proprietary OS
where the BIOS was validated.
https://bugzilla.kernel.org/show_bug.cgi?id=60770
So here we effectively revert the patch above, restoring
the mwait_idle() loop. However, we don't bother restoring
the idle=mwait cmdline parameter, since it appears to add
no value.
Maintainer notes:
For 3.9, simply revert 69fb3676df
for 3.10, patch -F3 applies, fuzz needed due to __cpuinit use in
context For 3.11, 3.12, 3.13, this patch applies cleanly
Tested-by: Mike Galbraith <bitbucket@online.de>
Signed-off-by: Len Brown <len.brown@intel.com>
Acked-by: Mike Galbraith <bitbucket@online.de>
Cc: <stable@vger.kernel.org> # 3.9+
Cc: Borislav Petkov <bp@alien8.de>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Ian Malone <ibmalone@gmail.com>
Cc: Josh Boyer <jwboyer@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/345254a551eb5a6a866e048d7ab570fd2193aca4.1389763084.git.len.brown@intel.com
[ Ported to recent kernels. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-15 12:37:34 +07:00
|
|
|
local_irq_enable();
|
2014-01-18 23:14:44 +07:00
|
|
|
}
|
|
|
|
__current_clr_polling();
|
sched/idle/x86: Restore mwait_idle() to fix boot hangs, to improve power savings and to improve performance
In Linux-3.9 we removed the mwait_idle() loop:
69fb3676df33 ("x86 idle: remove mwait_idle() and "idle=mwait" cmdline param")
The reasoning was that modern machines should be sufficiently
happy during the boot process using the default_idle() HALT
loop, until cpuidle loads and either acpi_idle or intel_idle
invoke the newer MWAIT-with-hints idle loop.
But two machines reported problems:
1. Certain Core2-era machines support MWAIT-C1 and HALT only.
MWAIT-C1 is preferred for optimal power and performance.
But if they support just C1, cpuidle never loads and
so they use the boot-time default idle loop forever.
2. Some laptops will boot-hang if HALT is used,
but will boot successfully if MWAIT is used.
This appears to be a hidden assumption in BIOS SMI,
that is presumably valid on the proprietary OS
where the BIOS was validated.
https://bugzilla.kernel.org/show_bug.cgi?id=60770
So here we effectively revert the patch above, restoring
the mwait_idle() loop. However, we don't bother restoring
the idle=mwait cmdline parameter, since it appears to add
no value.
Maintainer notes:
For 3.9, simply revert 69fb3676df
for 3.10, patch -F3 applies, fuzz needed due to __cpuinit use in
context For 3.11, 3.12, 3.13, this patch applies cleanly
Tested-by: Mike Galbraith <bitbucket@online.de>
Signed-off-by: Len Brown <len.brown@intel.com>
Acked-by: Mike Galbraith <bitbucket@online.de>
Cc: <stable@vger.kernel.org> # 3.9+
Cc: Borislav Petkov <bp@alien8.de>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Ian Malone <ibmalone@gmail.com>
Cc: Josh Boyer <jwboyer@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/345254a551eb5a6a866e048d7ab570fd2193aca4.1389763084.git.len.brown@intel.com
[ Ported to recent kernels. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-15 12:37:34 +07:00
|
|
|
}
|
|
|
|
|
x86: delete __cpuinit usage from all x86 files
The __cpuinit type of throwaway sections might have made sense
some time ago when RAM was more constrained, but now the savings
do not offset the cost and complications. For example, the fix in
commit 5e427ec2d0 ("x86: Fix bit corruption at CPU resume time")
is a good example of the nasty type of bugs that can be created
with improper use of the various __init prefixes.
After a discussion on LKML[1] it was decided that cpuinit should go
the way of devinit and be phased out. Once all the users are gone,
we can then finally remove the macros themselves from linux/init.h.
Note that some harmless section mismatch warnings may result, since
notify_cpu_starting() and cpu_up() are arch independent (kernel/cpu.c)
are flagged as __cpuinit -- so if we remove the __cpuinit from
arch specific callers, we will also get section mismatch warnings.
As an intermediate step, we intend to turn the linux/init.h cpuinit
content into no-ops as early as possible, since that will get rid
of these warnings. In any case, they are temporary and harmless.
This removes all the arch/x86 uses of the __cpuinit macros from
all C files. x86 only had the one __CPUINIT used in assembly files,
and it wasn't paired off with a .previous or a __FINIT, so we can
delete it directly w/o any corresponding additional change there.
[1] https://lkml.org/lkml/2013/5/20/589
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: x86@kernel.org
Acked-by: Ingo Molnar <mingo@kernel.org>
Acked-by: Thomas Gleixner <tglx@linutronix.de>
Acked-by: H. Peter Anvin <hpa@linux.intel.com>
Signed-off-by: Paul Gortmaker <paul.gortmaker@windriver.com>
2013-06-19 05:23:59 +07:00
|
|
|
void select_idle_routine(const struct cpuinfo_x86 *c)
|
2008-04-25 22:39:01 +07:00
|
|
|
{
|
2009-01-27 23:07:08 +07:00
|
|
|
#ifdef CONFIG_SMP
|
2013-03-22 04:50:03 +07:00
|
|
|
if (boot_option_idle_override == IDLE_POLL && smp_num_siblings > 1)
|
2012-05-22 09:50:07 +07:00
|
|
|
pr_warn_once("WARNING: polling idle and HT enabled, performance may degrade\n");
|
2008-04-25 22:39:01 +07:00
|
|
|
#endif
|
2013-03-22 04:50:03 +07:00
|
|
|
if (x86_idle || boot_option_idle_override == IDLE_POLL)
|
2008-06-09 21:59:53 +07:00
|
|
|
return;
|
|
|
|
|
2013-03-20 21:07:28 +07:00
|
|
|
if (cpu_has_bug(c, X86_BUG_AMD_APIC_C1E)) {
|
2010-07-29 00:09:31 +07:00
|
|
|
/* E400: APIC timer interrupt does not wake up CPU from C1e */
|
2012-05-22 09:50:07 +07:00
|
|
|
pr_info("using AMD E400 aware idle routine\n");
|
2013-02-10 09:45:03 +07:00
|
|
|
x86_idle = amd_e400_idle;
|
sched/idle/x86: Restore mwait_idle() to fix boot hangs, to improve power savings and to improve performance
In Linux-3.9 we removed the mwait_idle() loop:
69fb3676df33 ("x86 idle: remove mwait_idle() and "idle=mwait" cmdline param")
The reasoning was that modern machines should be sufficiently
happy during the boot process using the default_idle() HALT
loop, until cpuidle loads and either acpi_idle or intel_idle
invoke the newer MWAIT-with-hints idle loop.
But two machines reported problems:
1. Certain Core2-era machines support MWAIT-C1 and HALT only.
MWAIT-C1 is preferred for optimal power and performance.
But if they support just C1, cpuidle never loads and
so they use the boot-time default idle loop forever.
2. Some laptops will boot-hang if HALT is used,
but will boot successfully if MWAIT is used.
This appears to be a hidden assumption in BIOS SMI,
that is presumably valid on the proprietary OS
where the BIOS was validated.
https://bugzilla.kernel.org/show_bug.cgi?id=60770
So here we effectively revert the patch above, restoring
the mwait_idle() loop. However, we don't bother restoring
the idle=mwait cmdline parameter, since it appears to add
no value.
Maintainer notes:
For 3.9, simply revert 69fb3676df
for 3.10, patch -F3 applies, fuzz needed due to __cpuinit use in
context For 3.11, 3.12, 3.13, this patch applies cleanly
Tested-by: Mike Galbraith <bitbucket@online.de>
Signed-off-by: Len Brown <len.brown@intel.com>
Acked-by: Mike Galbraith <bitbucket@online.de>
Cc: <stable@vger.kernel.org> # 3.9+
Cc: Borislav Petkov <bp@alien8.de>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Ian Malone <ibmalone@gmail.com>
Cc: Josh Boyer <jwboyer@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/345254a551eb5a6a866e048d7ab570fd2193aca4.1389763084.git.len.brown@intel.com
[ Ported to recent kernels. ]
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2014-01-15 12:37:34 +07:00
|
|
|
} else if (prefer_mwait_c1_over_halt(c)) {
|
|
|
|
pr_info("using mwait in idle threads\n");
|
|
|
|
x86_idle = mwait_idle;
|
2008-06-09 21:59:53 +07:00
|
|
|
} else
|
2013-02-10 09:45:03 +07:00
|
|
|
x86_idle = default_idle;
|
2008-04-25 22:39:01 +07:00
|
|
|
}
|
|
|
|
|
2011-04-02 03:59:53 +07:00
|
|
|
void __init init_amd_e400_c1e_mask(void)
|
2009-03-17 11:20:34 +07:00
|
|
|
{
|
2011-04-02 03:59:53 +07:00
|
|
|
/* If we're using amd_e400_idle, we need to allocate amd_e400_c1e_mask. */
|
2013-02-10 09:45:03 +07:00
|
|
|
if (x86_idle == amd_e400_idle)
|
2011-04-02 03:59:53 +07:00
|
|
|
zalloc_cpumask_var(&amd_e400_c1e_mask, GFP_KERNEL);
|
2009-03-17 11:20:34 +07:00
|
|
|
}
|
|
|
|
|
2008-04-25 22:39:01 +07:00
|
|
|
static int __init idle_setup(char *str)
|
|
|
|
{
|
2008-07-05 18:53:36 +07:00
|
|
|
if (!str)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-25 22:39:01 +07:00
|
|
|
if (!strcmp(str, "poll")) {
|
2012-05-22 09:50:07 +07:00
|
|
|
pr_info("using polling idle threads\n");
|
2010-11-03 23:06:14 +07:00
|
|
|
boot_option_idle_override = IDLE_POLL;
|
2013-03-22 04:50:03 +07:00
|
|
|
cpu_idle_poll_ctrl(true);
|
2010-11-03 23:06:14 +07:00
|
|
|
} else if (!strcmp(str, "halt")) {
|
2008-06-24 16:58:53 +07:00
|
|
|
/*
|
|
|
|
* When the boot option of idle=halt is added, halt is
|
|
|
|
* forced to be used for CPU idle. In such case CPU C2/C3
|
|
|
|
* won't be used again.
|
|
|
|
* To continue to load the CPU idle driver, don't touch
|
|
|
|
* the boot_option_idle_override.
|
|
|
|
*/
|
2013-02-10 09:45:03 +07:00
|
|
|
x86_idle = default_idle;
|
2010-11-03 23:06:14 +07:00
|
|
|
boot_option_idle_override = IDLE_HALT;
|
2008-06-24 17:01:09 +07:00
|
|
|
} else if (!strcmp(str, "nomwait")) {
|
|
|
|
/*
|
|
|
|
* If the boot option of "idle=nomwait" is added,
|
|
|
|
* it means that mwait will be disabled for CPU C2/C3
|
|
|
|
* states. In such case it won't touch the variable
|
|
|
|
* of boot_option_idle_override.
|
|
|
|
*/
|
2010-11-03 23:06:14 +07:00
|
|
|
boot_option_idle_override = IDLE_NOMWAIT;
|
2008-06-24 16:58:53 +07:00
|
|
|
} else
|
2008-04-25 22:39:01 +07:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("idle", idle_setup);
|
|
|
|
|
2009-05-12 09:05:28 +07:00
|
|
|
unsigned long arch_align_stack(unsigned long sp)
|
|
|
|
{
|
|
|
|
if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
|
|
|
|
sp -= get_random_int() % 8192;
|
|
|
|
return sp & ~0xf;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long arch_randomize_brk(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
unsigned long range_end = mm->brk + 0x02000000;
|
|
|
|
return randomize_range(mm->brk, range_end, 0) ? : mm->brk;
|
|
|
|
}
|
|
|
|
|