2012-05-22 10:50:07 +08:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2008-03-11 06:28:04 +08:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/smp.h>
|
2009-02-28 05:25:28 +08:00
|
|
|
#include <linux/prctl.h>
|
2008-03-11 06:28:04 +08:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/sched.h>
|
2008-04-25 23:39:01 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pm.h>
|
2015-04-03 08:01:28 +08:00
|
|
|
#include <linux/tick.h>
|
2009-05-12 10:05:28 +08:00
|
|
|
#include <linux/random.h>
|
2009-09-19 14:40:22 +08:00
|
|
|
#include <linux/user-return-notifier.h>
|
2009-12-08 16:29:42 +08:00
|
|
|
#include <linux/dmi.h>
|
|
|
|
#include <linux/utsname.h>
|
2012-03-26 05:00:04 +08:00
|
|
|
#include <linux/stackprotector.h>
|
|
|
|
#include <linux/tick.h>
|
|
|
|
#include <linux/cpuidle.h>
|
2009-09-17 22:11:28 +08:00
|
|
|
#include <trace/events/power.h>
|
2009-09-10 01:22:48 +08:00
|
|
|
#include <linux/hw_breakpoint.h>
|
2011-01-20 22:42:52 +08:00
|
|
|
#include <asm/cpu.h>
|
2008-11-11 21:33:44 +08:00
|
|
|
#include <asm/apic.h>
|
2009-04-11 02:33:10 +08:00
|
|
|
#include <asm/syscalls.h>
|
2009-02-28 05:25:28 +08: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 13:37:34 +08:00
|
|
|
#include <asm/mwait.h>
|
2015-04-24 08:54:44 +08:00
|
|
|
#include <asm/fpu/internal.h>
|
2009-06-02 02:14:55 +08:00
|
|
|
#include <asm/debugreg.h>
|
2012-03-26 05:00:04 +08:00
|
|
|
#include <asm/nmi.h>
|
2014-10-25 06:58:07 +08:00
|
|
|
#include <asm/tlbflush.h>
|
2012-03-26 05:00:04 +08:00
|
|
|
|
2012-05-03 17:03:01 +08: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 11:19:06 +08:00
|
|
|
__visible DEFINE_PER_CPU_SHARED_ALIGNED(struct tss_struct, cpu_tss) = {
|
|
|
|
.x86_tss = {
|
2015-03-11 02:05:59 +08:00
|
|
|
.sp0 = TOP_OF_INIT_STACK,
|
2015-03-06 11:19:06 +08: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 02:16:44 +08:00
|
|
|
EXPORT_PER_CPU_SYMBOL(cpu_tss);
|
2012-05-03 17:03:01 +08:00
|
|
|
|
2012-03-26 05:00:04 +08: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 17:58:53 +08:00
|
|
|
|
2012-05-17 06:03:51 +08: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 06:28:04 +08:00
|
|
|
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
|
|
|
{
|
2015-07-17 18:28:12 +08:00
|
|
|
memcpy(dst, src, arch_task_struct_size);
|
2014-09-03 01:57:23 +08:00
|
|
|
|
2015-04-24 08:07:15 +08:00
|
|
|
return fpu__copy(&dst->thread.fpu, &src->thread.fpu);
|
2008-03-11 06:28:04 +08:00
|
|
|
}
|
2008-04-25 23:39:01 +08:00
|
|
|
|
2009-02-28 05:25:28 +08: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 20:07:21 +08:00
|
|
|
unsigned long *bp = t->io_bitmap_ptr;
|
2015-04-23 18:33:50 +08:00
|
|
|
struct fpu *fpu = &t->fpu;
|
2009-02-28 05:25:28 +08:00
|
|
|
|
2009-03-16 20:07:21 +08:00
|
|
|
if (bp) {
|
2015-03-06 11:19:05 +08:00
|
|
|
struct tss_struct *tss = &per_cpu(cpu_tss, get_cpu());
|
2009-02-28 05:25:28 +08: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 20:07:21 +08:00
|
|
|
kfree(bp);
|
2009-02-28 05:25:28 +08:00
|
|
|
}
|
2012-05-17 06:03:54 +08:00
|
|
|
|
x86/fpu: Synchronize the naming of drop_fpu() and fpu_reset_state()
drop_fpu() and fpu_reset_state() are similar in functionality
and in scope, yet this is not apparent from their names.
drop_fpu() deactivates FPU contents (both the fpregs and the fpstate),
but leaves register contents intact in the eager-FPU case, mostly as an
optimization. It disables fpregs in the lazy FPU case. The drop_fpu()
method can be used to destroy FPU state in an optimized way, when we
know that a new state will be loaded before user-space might see
any remains of the old FPU state:
- such as in sys_exit()'s exit_thread() where we know this task
won't execute any user-space instructions anymore and the
next context switch cleans up the FPU. The old FPU state
might still be around in the eagerfpu case but won't be
saved.
- in __restore_xstate_sig(), where we use drop_fpu() before
copying a new state into the fpstate and activating that one.
No user-pace instructions can execute between those steps.
- in sys_execve()'s fpu__clear(): there we use drop_fpu() in
the !eagerfpu case, where it's equivalent to a full reinit.
fpu_reset_state() is a stronger version of drop_fpu(): both in
the eagerfpu and the lazy-FPU case it guarantees that fpregs
are reinitialized to init state. This method is used in cases
where we need a full reset:
- handle_signal() uses fpu_reset_state() to reset the FPU state
to init before executing a user-space signal handler. While we
have already saved the original FPU state at this point, and
always restore the original state, the signal handling code
still has to do this reinit, because signals may interrupt
any user-space instruction, and the FPU might be in various
intermediate states (such as an unbalanced x87 stack) that is
not immediately usable for general C signal handler code.
- __restore_xstate_sig() uses fpu_reset_state() when the signal
frame has no FP context. Since the signal handler may have
modified the FPU state, it gets reset back to init state.
- in another branch __restore_xstate_sig() uses fpu_reset_state()
to handle a restoration error: when restore_user_xstate() fails
to restore FPU state and we might have inconsistent FPU data,
fpu_reset_state() is used to reset it back to a known good
state.
- __kernel_fpu_end() uses fpu_reset_state() in an error branch.
This is in a 'must not trigger' error branch, so on bug-free
kernels this never triggers.
- fpu__restore() uses fpu_reset_state() in an error path
as well: if the fpstate was set up with invalid FPU state
(via ptrace or via a signal handler), then it's reset back
to init state.
- likewise, the scheduler's switch_fpu_finish() uses it in a
restoration error path too.
Move both drop_fpu() and fpu_reset_state() to the fpu__*() namespace
and harmonize their naming with their function:
fpu__drop()
fpu__reset()
This clearly shows that both methods operate on the full state of the
FPU, just like fpu__restore().
Also add comments to explain what each function does.
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Fenghua Yu <fenghua.yu@intel.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-04-30 01:04:31 +08:00
|
|
|
fpu__drop(fpu);
|
2009-02-28 05:25:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void flush_thread(void)
|
|
|
|
{
|
|
|
|
struct task_struct *tsk = current;
|
|
|
|
|
2009-09-10 01:22:48 +08:00
|
|
|
flush_ptrace_hw_breakpoint(tsk);
|
2009-02-28 05:25:28 +08:00
|
|
|
memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
|
2015-01-20 02:52:12 +08:00
|
|
|
|
2015-04-30 02:35:33 +08:00
|
|
|
fpu__clear(&tsk->thread.fpu);
|
2009-02-28 05:25:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hard_disable_TSC(void)
|
|
|
|
{
|
2014-10-25 06:58:07 +08:00
|
|
|
cr4_set_bits(X86_CR4_TSD);
|
2009-02-28 05:25:28 +08: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 06:58:07 +08:00
|
|
|
cr4_clear_bits(X86_CR4_TSD);
|
2009-02-28 05:25:28 +08: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 21:51:51 +08: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 05:25:28 +08: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 14:40:22 +08:00
|
|
|
propagate_user_return_notify(prev_p, next_p);
|
2009-02-28 05:25:28 +08:00
|
|
|
}
|
|
|
|
|
2008-06-10 00:35:28 +08:00
|
|
|
/*
|
|
|
|
* Idle related variables and functions
|
|
|
|
*/
|
2010-11-04 00:06:14 +08:00
|
|
|
unsigned long boot_option_idle_override = IDLE_NO_OVERRIDE;
|
2008-06-10 00:35:28 +08:00
|
|
|
EXPORT_SYMBOL(boot_option_idle_override);
|
|
|
|
|
2013-02-10 10:45:03 +08:00
|
|
|
static void (*x86_idle)(void);
|
2008-06-10 00:35:28 +08:00
|
|
|
|
2012-03-26 05:00:04 +08:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
static inline void play_dead(void)
|
|
|
|
{
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
void enter_idle(void)
|
|
|
|
{
|
2012-05-11 15:35:27 +08:00
|
|
|
this_cpu_write(is_idle, 1);
|
2012-03-26 05:00:04 +08: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 05:50:03 +08:00
|
|
|
void arch_cpu_idle_enter(void)
|
|
|
|
{
|
|
|
|
local_touch_nmi();
|
|
|
|
enter_idle();
|
|
|
|
}
|
2012-03-26 05:00:04 +08:00
|
|
|
|
2013-03-22 05:50:03 +08:00
|
|
|
void arch_cpu_idle_exit(void)
|
|
|
|
{
|
|
|
|
__exit_idle();
|
|
|
|
}
|
2012-03-26 05:00:04 +08:00
|
|
|
|
2013-03-22 05:50:03 +08:00
|
|
|
void arch_cpu_idle_dead(void)
|
|
|
|
{
|
|
|
|
play_dead();
|
|
|
|
}
|
2012-03-26 05:00:04 +08:00
|
|
|
|
2013-03-22 05:50:03 +08:00
|
|
|
/*
|
|
|
|
* Called from the generic idle code.
|
|
|
|
*/
|
|
|
|
void arch_cpu_idle(void)
|
|
|
|
{
|
2014-01-30 01:45:12 +08:00
|
|
|
x86_idle();
|
2012-03-26 05:00:04 +08:00
|
|
|
}
|
|
|
|
|
2008-06-10 00:35:28 +08:00
|
|
|
/*
|
2013-03-22 05:50:03 +08:00
|
|
|
* We use this if we don't have any better idle routine..
|
2008-06-10 00:35:28 +08:00
|
|
|
*/
|
|
|
|
void default_idle(void)
|
|
|
|
{
|
2012-10-26 00:13:11 +08:00
|
|
|
trace_cpu_idle_rcuidle(1, smp_processor_id());
|
2013-03-22 05:50:03 +08:00
|
|
|
safe_halt();
|
2012-10-26 00:13:11 +08:00
|
|
|
trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
|
2008-06-10 00:35:28 +08:00
|
|
|
}
|
2011-06-15 03:45:10 +08:00
|
|
|
#ifdef CONFIG_APM_MODULE
|
2008-06-10 00:35:28 +08:00
|
|
|
EXPORT_SYMBOL(default_idle);
|
|
|
|
#endif
|
|
|
|
|
2013-02-10 12:08:07 +08:00
|
|
|
#ifdef CONFIG_XEN
|
|
|
|
bool xen_set_default_idle(void)
|
2011-11-22 07:02:02 +08:00
|
|
|
{
|
2013-02-10 10:45:03 +08:00
|
|
|
bool ret = !!x86_idle;
|
2011-11-22 07:02:02 +08:00
|
|
|
|
2013-02-10 10:45:03 +08:00
|
|
|
x86_idle = default_idle;
|
2011-11-22 07:02:02 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2013-02-10 12:08:07 +08:00
|
|
|
#endif
|
2008-11-11 21:33:44 +08:00
|
|
|
void stop_this_cpu(void *dummy)
|
|
|
|
{
|
|
|
|
local_irq_disable();
|
|
|
|
/*
|
|
|
|
* Remove this CPU:
|
|
|
|
*/
|
2009-03-13 12:19:54 +08:00
|
|
|
set_cpu_online(smp_processor_id(), false);
|
2008-11-11 21:33:44 +08: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 15:28:46 +08:00
|
|
|
for (;;)
|
|
|
|
halt();
|
2008-04-25 23:39:01 +08:00
|
|
|
}
|
|
|
|
|
2011-04-02 04:59:53 +08:00
|
|
|
bool amd_e400_c1e_detected;
|
|
|
|
EXPORT_SYMBOL(amd_e400_c1e_detected);
|
2008-06-10 01:15:00 +08:00
|
|
|
|
2011-04-02 04:59:53 +08:00
|
|
|
static cpumask_var_t amd_e400_c1e_mask;
|
2008-09-23 00:54:29 +08:00
|
|
|
|
2011-04-02 04:59:53 +08:00
|
|
|
void amd_e400_remove_cpu(int cpu)
|
2008-09-23 00:54:29 +08:00
|
|
|
{
|
2011-04-02 04:59:53 +08:00
|
|
|
if (amd_e400_c1e_mask != NULL)
|
|
|
|
cpumask_clear_cpu(cpu, amd_e400_c1e_mask);
|
2008-09-23 00:54:29 +08:00
|
|
|
}
|
|
|
|
|
2008-06-10 01:15:00 +08:00
|
|
|
/*
|
2011-04-02 04:59:53 +08:00
|
|
|
* AMD Erratum 400 aware idle routine. We check for C1E active in the interrupt
|
2008-06-10 01:15:00 +08: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 04:59:53 +08:00
|
|
|
static void amd_e400_idle(void)
|
2008-06-10 01:15:00 +08:00
|
|
|
{
|
2011-04-02 04:59:53 +08:00
|
|
|
if (!amd_e400_c1e_detected) {
|
2008-06-10 01:15:00 +08:00
|
|
|
u32 lo, hi;
|
|
|
|
|
|
|
|
rdmsr(MSR_K8_INT_PENDING_MSG, lo, hi);
|
2010-07-28 00:53:35 +08:00
|
|
|
|
2008-06-10 01:15:00 +08:00
|
|
|
if (lo & K8_INTP_C1E_ACTIVE_MASK) {
|
2011-04-02 04:59:53 +08:00
|
|
|
amd_e400_c1e_detected = true;
|
2008-11-18 08:11:37 +08:00
|
|
|
if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
|
2008-09-19 03:12:10 +08:00
|
|
|
mark_tsc_unstable("TSC halt in AMD C1E");
|
2012-05-22 10:50:07 +08:00
|
|
|
pr_info("System has AMD C1E enabled\n");
|
2008-06-10 01:15:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-02 04:59:53 +08:00
|
|
|
if (amd_e400_c1e_detected) {
|
2008-06-10 01:15:00 +08:00
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
2011-04-02 04:59:53 +08:00
|
|
|
if (!cpumask_test_cpu(cpu, amd_e400_c1e_mask)) {
|
|
|
|
cpumask_set_cpu(cpu, amd_e400_c1e_mask);
|
2015-04-03 08:01:28 +08:00
|
|
|
/* Force broadcast so ACPI can not interfere. */
|
|
|
|
tick_broadcast_force();
|
2012-05-22 10:50:07 +08:00
|
|
|
pr_info("Switch to broadcast mode on CPU%d\n", cpu);
|
2008-06-10 01:15:00 +08:00
|
|
|
}
|
2015-04-03 08:05:53 +08:00
|
|
|
tick_broadcast_enter();
|
2008-06-17 15:12:03 +08:00
|
|
|
|
2008-06-10 01:15:00 +08:00
|
|
|
default_idle();
|
2008-06-17 15:12:03 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The switch back from broadcast mode needs to be
|
|
|
|
* called with interrupts disabled.
|
|
|
|
*/
|
2013-09-11 18:43:13 +08:00
|
|
|
local_irq_disable();
|
2015-04-03 08:05:53 +08:00
|
|
|
tick_broadcast_exit();
|
2013-09-11 18:43:13 +08:00
|
|
|
local_irq_enable();
|
2008-06-10 01:15:00 +08: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 13:37:34 +08: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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-05-26 16:28:09 +08:00
|
|
|
* MONITOR/MWAIT with no hints, used for default C1 state. This invokes MWAIT
|
|
|
|
* with interrupts enabled and no flags, which is backwards compatible with the
|
|
|
|
* original MWAIT implementation.
|
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 13:37:34 +08:00
|
|
|
*/
|
|
|
|
static void mwait_idle(void)
|
|
|
|
{
|
2014-01-19 00:14:44 +08: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 13:37:34 +08:00
|
|
|
clflush((void *)¤t_thread_info()->flags);
|
2014-01-19 00:14:44 +08: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 13:37:34 +08:00
|
|
|
|
|
|
|
__monitor((void *)¤t_thread_info()->flags, 0, 0);
|
|
|
|
if (!need_resched())
|
|
|
|
__sti_mwait(0, 0);
|
|
|
|
else
|
|
|
|
local_irq_enable();
|
2014-01-19 00:14:44 +08: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 13:37:34 +08:00
|
|
|
local_irq_enable();
|
2014-01-19 00:14:44 +08: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 13:37:34 +08: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 06:23:59 +08:00
|
|
|
void select_idle_routine(const struct cpuinfo_x86 *c)
|
2008-04-25 23:39:01 +08:00
|
|
|
{
|
2009-01-28 00:07:08 +08:00
|
|
|
#ifdef CONFIG_SMP
|
2013-03-22 05:50:03 +08:00
|
|
|
if (boot_option_idle_override == IDLE_POLL && smp_num_siblings > 1)
|
2012-05-22 10:50:07 +08:00
|
|
|
pr_warn_once("WARNING: polling idle and HT enabled, performance may degrade\n");
|
2008-04-25 23:39:01 +08:00
|
|
|
#endif
|
2013-03-22 05:50:03 +08:00
|
|
|
if (x86_idle || boot_option_idle_override == IDLE_POLL)
|
2008-06-09 22:59:53 +08:00
|
|
|
return;
|
|
|
|
|
2013-03-20 22:07:28 +08:00
|
|
|
if (cpu_has_bug(c, X86_BUG_AMD_APIC_C1E)) {
|
2010-07-29 01:09:31 +08:00
|
|
|
/* E400: APIC timer interrupt does not wake up CPU from C1e */
|
2012-05-22 10:50:07 +08:00
|
|
|
pr_info("using AMD E400 aware idle routine\n");
|
2013-02-10 10:45:03 +08: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 13:37:34 +08:00
|
|
|
} else if (prefer_mwait_c1_over_halt(c)) {
|
|
|
|
pr_info("using mwait in idle threads\n");
|
|
|
|
x86_idle = mwait_idle;
|
2008-06-09 22:59:53 +08:00
|
|
|
} else
|
2013-02-10 10:45:03 +08:00
|
|
|
x86_idle = default_idle;
|
2008-04-25 23:39:01 +08:00
|
|
|
}
|
|
|
|
|
2011-04-02 04:59:53 +08:00
|
|
|
void __init init_amd_e400_c1e_mask(void)
|
2009-03-17 12:20:34 +08:00
|
|
|
{
|
2011-04-02 04:59:53 +08:00
|
|
|
/* If we're using amd_e400_idle, we need to allocate amd_e400_c1e_mask. */
|
2013-02-10 10:45:03 +08:00
|
|
|
if (x86_idle == amd_e400_idle)
|
2011-04-02 04:59:53 +08:00
|
|
|
zalloc_cpumask_var(&amd_e400_c1e_mask, GFP_KERNEL);
|
2009-03-17 12:20:34 +08:00
|
|
|
}
|
|
|
|
|
2008-04-25 23:39:01 +08:00
|
|
|
static int __init idle_setup(char *str)
|
|
|
|
{
|
2008-07-05 19:53:36 +08:00
|
|
|
if (!str)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-25 23:39:01 +08:00
|
|
|
if (!strcmp(str, "poll")) {
|
2012-05-22 10:50:07 +08:00
|
|
|
pr_info("using polling idle threads\n");
|
2010-11-04 00:06:14 +08:00
|
|
|
boot_option_idle_override = IDLE_POLL;
|
2013-03-22 05:50:03 +08:00
|
|
|
cpu_idle_poll_ctrl(true);
|
2010-11-04 00:06:14 +08:00
|
|
|
} else if (!strcmp(str, "halt")) {
|
2008-06-24 17:58:53 +08: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 10:45:03 +08:00
|
|
|
x86_idle = default_idle;
|
2010-11-04 00:06:14 +08:00
|
|
|
boot_option_idle_override = IDLE_HALT;
|
2008-06-24 18:01:09 +08: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-04 00:06:14 +08:00
|
|
|
boot_option_idle_override = IDLE_NOMWAIT;
|
2008-06-24 17:58:53 +08:00
|
|
|
} else
|
2008-04-25 23:39:01 +08:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("idle", idle_setup);
|
|
|
|
|
2009-05-12 10:05:28 +08: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;
|
|
|
|
}
|
|
|
|
|