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>
|
2017-02-01 22:36:40 +07:00
|
|
|
#include <linux/sched/idle.h>
|
2017-02-09 00:51:35 +07:00
|
|
|
#include <linux/sched/debug.h>
|
2017-02-09 00:51:36 +07:00
|
|
|
#include <linux/sched/task.h>
|
2016-07-14 07:18:56 +07:00
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/export.h>
|
2008-04-25 22:39:01 +07:00
|
|
|
#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>
|
2016-12-25 02:46:01 +07:00
|
|
|
#include <linux/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>
|
2015-08-12 23:29:40 +07:00
|
|
|
#include <asm/mce.h>
|
2015-07-29 12:41:16 +07:00
|
|
|
#include <asm/vm86.h>
|
2016-08-13 23:38:18 +07:00
|
|
|
#include <asm/switch_to.h>
|
2017-02-20 23:56:14 +07:00
|
|
|
#include <asm/desc.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
|
2016-03-10 10:00:33 +07:00
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
.SYSENTER_stack_canary = STACK_END_MAGIC,
|
|
|
|
#endif
|
2015-03-06 10:19:06 +07:00
|
|
|
};
|
2015-05-05 01:16:44 +07:00
|
|
|
EXPORT_PER_CPU_SYMBOL(cpu_tss);
|
2012-05-03 16:03:01 +07:00
|
|
|
|
2017-02-20 23:56:14 +07:00
|
|
|
DEFINE_PER_CPU(bool, need_tr_refresh);
|
|
|
|
EXPORT_PER_CPU_SYMBOL_GPL(need_tr_refresh);
|
|
|
|
|
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)
|
|
|
|
{
|
2015-07-17 17:28:12 +07:00
|
|
|
memcpy(dst, src, arch_task_struct_size);
|
2015-10-31 12:42:46 +07:00
|
|
|
#ifdef CONFIG_VM86
|
|
|
|
dst->thread.vm86 = NULL;
|
|
|
|
#endif
|
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
|
|
|
}
|
2008-04-25 22:39:01 +07:00
|
|
|
|
2009-02-28 04:25:28 +07:00
|
|
|
/*
|
|
|
|
* Free current thread data structures etc..
|
|
|
|
*/
|
2016-05-21 07:00:20 +07:00
|
|
|
void exit_thread(struct task_struct *tsk)
|
2009-02-28 04:25:28 +07:00
|
|
|
{
|
2016-05-21 07:00:20 +07:00
|
|
|
struct thread_struct *t = &tsk->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-07-29 12:41:16 +07:00
|
|
|
free_vm86(t);
|
|
|
|
|
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 00:04:31 +07:00
|
|
|
fpu__drop(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-30 01:35:33 +07:00
|
|
|
fpu__clear(&tsk->thread.fpu);
|
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));
|
2017-02-20 23:56:14 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that the TSS limit is correct for the CPU
|
|
|
|
* to notice the IO bitmap.
|
|
|
|
*/
|
|
|
|
refresh_TR();
|
2009-02-28 04:25:28 +07:00
|
|
|
} 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
|
|
|
|
|
2013-03-22 04:50:03 +07:00
|
|
|
void arch_cpu_idle_enter(void)
|
|
|
|
{
|
2016-12-13 20:14:17 +07:00
|
|
|
tsc_verify_tsc_adjust(false);
|
2013-03-22 04:50:03 +07:00
|
|
|
local_touch_nmi();
|
|
|
|
}
|
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
|
|
|
*/
|
2016-10-08 07:02:55 +07:00
|
|
|
void __cpuidle default_idle(void)
|
2008-06-09 23:35:28 +07:00
|
|
|
{
|
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();
|
2015-08-12 23:29:40 +07:00
|
|
|
mcheck_cpu_clear(this_cpu_ptr(&cpu_info));
|
2008-11-11 20:33:44 +07:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2008-06-10 00:15:00 +07:00
|
|
|
/*
|
2016-12-10 01:29:11 +07:00
|
|
|
* AMD Erratum 400 aware idle routine. We handle it the same way as C3 power
|
|
|
|
* states (local apic timer and TSC stop).
|
2008-06-10 00:15:00 +07:00
|
|
|
*/
|
2011-04-02 03:59:53 +07:00
|
|
|
static void amd_e400_idle(void)
|
2008-06-10 00:15:00 +07:00
|
|
|
{
|
2016-12-10 01:29:11 +07:00
|
|
|
/*
|
|
|
|
* We cannot use static_cpu_has_bug() here because X86_BUG_AMD_APIC_C1E
|
|
|
|
* gets set after static_cpu_has() places have been converted via
|
|
|
|
* alternatives.
|
|
|
|
*/
|
|
|
|
if (!boot_cpu_has_bug(X86_BUG_AMD_APIC_C1E)) {
|
|
|
|
default_idle();
|
|
|
|
return;
|
2008-06-10 00:15:00 +07:00
|
|
|
}
|
|
|
|
|
2016-12-10 01:29:11 +07:00
|
|
|
tick_broadcast_enter();
|
2008-06-10 00:15:00 +07:00
|
|
|
|
2016-12-10 01:29:11 +07:00
|
|
|
default_idle();
|
2008-06-17 14:12:03 +07:00
|
|
|
|
2016-12-10 01:29:11 +07:00
|
|
|
/*
|
|
|
|
* The switch back from broadcast mode needs to be called with
|
|
|
|
* interrupts disabled.
|
|
|
|
*/
|
|
|
|
local_irq_disable();
|
|
|
|
tick_broadcast_exit();
|
|
|
|
local_irq_enable();
|
2008-06-10 00:15:00 +07:00
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2016-07-19 01:41:10 +07:00
|
|
|
if (!cpu_has(c, X86_FEATURE_MWAIT) || static_cpu_has_bug(X86_BUG_MONITOR))
|
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
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2015-05-26 15:28:09 +07: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 12:37:34 +07:00
|
|
|
*/
|
2016-10-08 07:02:55 +07:00
|
|
|
static __cpuidle void mwait_idle(void)
|
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
|
|
|
{
|
2014-01-18 23:14:44 +07:00
|
|
|
if (!current_set_polling_and_test()) {
|
2015-08-20 11:54:39 +07:00
|
|
|
trace_cpu_idle_rcuidle(1, smp_processor_id());
|
2014-01-18 23:14:44 +07:00
|
|
|
if (this_cpu_has(X86_BUG_CLFLUSH_MONITOR)) {
|
2016-01-29 00:02:51 +07:00
|
|
|
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);
|
2016-01-29 00:02:51 +07:00
|
|
|
mb(); /* quirk */
|
2014-01-18 23:14:44 +07:00
|
|
|
}
|
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();
|
2015-08-20 11:54:39 +07:00
|
|
|
trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
|
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;
|
|
|
|
|
2016-12-10 01:29:09 +07:00
|
|
|
if (boot_cpu_has_bug(X86_BUG_AMD_E400)) {
|
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
|
|
|
}
|
|
|
|
|
2016-12-10 01:29:11 +07:00
|
|
|
void amd_e400_c1e_apic_setup(void)
|
2009-03-17 11:20:34 +07:00
|
|
|
{
|
2016-12-10 01:29:11 +07:00
|
|
|
if (boot_cpu_has_bug(X86_BUG_AMD_APIC_C1E)) {
|
|
|
|
pr_info("Switch to broadcast mode on CPU%d\n", smp_processor_id());
|
|
|
|
local_irq_disable();
|
|
|
|
tick_broadcast_force();
|
|
|
|
local_irq_enable();
|
|
|
|
}
|
2009-03-17 11:20:34 +07:00
|
|
|
}
|
|
|
|
|
2016-12-10 01:29:10 +07:00
|
|
|
void __init arch_post_acpi_subsys_init(void)
|
|
|
|
{
|
|
|
|
u32 lo, hi;
|
|
|
|
|
|
|
|
if (!boot_cpu_has_bug(X86_BUG_AMD_E400))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* AMD E400 detection needs to happen after ACPI has been enabled. If
|
|
|
|
* the machine is affected K8_INTP_C1E_ACTIVE_MASK bits are set in
|
|
|
|
* MSR_K8_INT_PENDING_MSG.
|
|
|
|
*/
|
|
|
|
rdmsr(MSR_K8_INT_PENDING_MSG, lo, hi);
|
|
|
|
if (!(lo & K8_INTP_C1E_ACTIVE_MASK))
|
|
|
|
return;
|
|
|
|
|
|
|
|
boot_cpu_set_bug(X86_BUG_AMD_APIC_C1E);
|
|
|
|
|
|
|
|
if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
|
|
|
|
mark_tsc_unstable("TSC halt in AMD C1E");
|
|
|
|
pr_info("System has AMD C1E enabled\n");
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2016-10-12 03:53:56 +07:00
|
|
|
return randomize_page(mm->brk, 0x02000000);
|
2009-05-12 09:05:28 +07:00
|
|
|
}
|
|
|
|
|
2016-08-13 23:38:21 +07:00
|
|
|
/*
|
|
|
|
* Return saved PC of a blocked thread.
|
|
|
|
* What is this good for? it will be always the scheduler or ret_from_fork.
|
|
|
|
*/
|
|
|
|
unsigned long thread_saved_pc(struct task_struct *tsk)
|
|
|
|
{
|
|
|
|
struct inactive_task_frame *frame =
|
|
|
|
(struct inactive_task_frame *) READ_ONCE(tsk->thread.sp);
|
|
|
|
return READ_ONCE_NOCHECK(frame->ret_addr);
|
|
|
|
}
|
|
|
|
|
2015-09-30 15:38:23 +07:00
|
|
|
/*
|
|
|
|
* Called from fs/proc with a reference on @p to find the function
|
|
|
|
* which called into schedule(). This needs to be done carefully
|
|
|
|
* because the task might wake up and we might look at a stack
|
|
|
|
* changing under us.
|
|
|
|
*/
|
|
|
|
unsigned long get_wchan(struct task_struct *p)
|
|
|
|
{
|
2016-09-16 12:45:46 +07:00
|
|
|
unsigned long start, bottom, top, sp, fp, ip, ret = 0;
|
2015-09-30 15:38:23 +07:00
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
if (!p || p == current || p->state == TASK_RUNNING)
|
|
|
|
return 0;
|
|
|
|
|
2016-09-16 12:45:46 +07:00
|
|
|
if (!try_get_task_stack(p))
|
|
|
|
return 0;
|
|
|
|
|
2015-09-30 15:38:23 +07:00
|
|
|
start = (unsigned long)task_stack_page(p);
|
|
|
|
if (!start)
|
2016-09-16 12:45:46 +07:00
|
|
|
goto out;
|
2015-09-30 15:38:23 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Layout of the stack page:
|
|
|
|
*
|
|
|
|
* ----------- topmax = start + THREAD_SIZE - sizeof(unsigned long)
|
|
|
|
* PADDING
|
|
|
|
* ----------- top = topmax - TOP_OF_KERNEL_STACK_PADDING
|
|
|
|
* stack
|
2016-09-14 04:29:25 +07:00
|
|
|
* ----------- bottom = start
|
2015-09-30 15:38:23 +07:00
|
|
|
*
|
|
|
|
* The tasks stack pointer points at the location where the
|
|
|
|
* framepointer is stored. The data on the stack is:
|
|
|
|
* ... IP FP ... IP FP
|
|
|
|
*
|
|
|
|
* We need to read FP and IP, so we need to adjust the upper
|
|
|
|
* bound by another unsigned long.
|
|
|
|
*/
|
|
|
|
top = start + THREAD_SIZE - TOP_OF_KERNEL_STACK_PADDING;
|
|
|
|
top -= 2 * sizeof(unsigned long);
|
2016-09-14 04:29:25 +07:00
|
|
|
bottom = start;
|
2015-09-30 15:38:23 +07:00
|
|
|
|
|
|
|
sp = READ_ONCE(p->thread.sp);
|
|
|
|
if (sp < bottom || sp > top)
|
2016-09-16 12:45:46 +07:00
|
|
|
goto out;
|
2015-09-30 15:38:23 +07:00
|
|
|
|
2016-08-13 23:38:18 +07:00
|
|
|
fp = READ_ONCE_NOCHECK(((struct inactive_task_frame *)sp)->bp);
|
2015-09-30 15:38:23 +07:00
|
|
|
do {
|
|
|
|
if (fp < bottom || fp > top)
|
2016-09-16 12:45:46 +07:00
|
|
|
goto out;
|
2015-10-19 15:37:18 +07:00
|
|
|
ip = READ_ONCE_NOCHECK(*(unsigned long *)(fp + sizeof(unsigned long)));
|
2016-09-16 12:45:46 +07:00
|
|
|
if (!in_sched_functions(ip)) {
|
|
|
|
ret = ip;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-10-19 15:37:18 +07:00
|
|
|
fp = READ_ONCE_NOCHECK(*(unsigned long *)fp);
|
2015-09-30 15:38:23 +07:00
|
|
|
} while (count++ < 16 && p->state != TASK_RUNNING);
|
2016-09-16 12:45:46 +07:00
|
|
|
|
|
|
|
out:
|
|
|
|
put_task_stack(p);
|
|
|
|
return ret;
|
2015-09-30 15:38:23 +07:00
|
|
|
}
|