2012-05-22 04:50:07 +02:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2008-03-10 23:28:04 +01:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/smp.h>
|
2009-02-27 22:25:28 +01:00
|
|
|
#include <linux/prctl.h>
|
2008-03-10 23:28:04 +01:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/sched.h>
|
2008-04-25 17:39:01 +02:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pm.h>
|
2008-06-09 19:15:00 +02:00
|
|
|
#include <linux/clockchips.h>
|
2009-05-12 04:05:28 +02:00
|
|
|
#include <linux/random.h>
|
2009-09-19 08:40:22 +02:00
|
|
|
#include <linux/user-return-notifier.h>
|
2009-12-08 09:29:42 +01:00
|
|
|
#include <linux/dmi.h>
|
|
|
|
#include <linux/utsname.h>
|
2012-03-25 23:00:04 +02:00
|
|
|
#include <linux/stackprotector.h>
|
|
|
|
#include <linux/tick.h>
|
|
|
|
#include <linux/cpuidle.h>
|
2009-09-17 16:11:28 +02:00
|
|
|
#include <trace/events/power.h>
|
2009-09-09 19:22:48 +02:00
|
|
|
#include <linux/hw_breakpoint.h>
|
2011-01-20 15:42:52 +01:00
|
|
|
#include <asm/cpu.h>
|
2008-11-11 14:33:44 +01:00
|
|
|
#include <asm/apic.h>
|
2009-04-10 20:33:10 +02:00
|
|
|
#include <asm/syscalls.h>
|
2009-02-27 22:25:28 +01:00
|
|
|
#include <asm/idle.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/i387.h>
|
2012-02-21 22:19:22 +01:00
|
|
|
#include <asm/fpu-internal.h>
|
2009-06-01 20:14:55 +02:00
|
|
|
#include <asm/debugreg.h>
|
2012-03-25 23:00:04 +02:00
|
|
|
#include <asm/nmi.h>
|
|
|
|
|
2012-05-03 11:03:01 +02: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.
|
|
|
|
*/
|
2013-08-06 00:02:43 +02:00
|
|
|
__visible DEFINE_PER_CPU_SHARED_ALIGNED(struct tss_struct, init_tss) = INIT_TSS;
|
2012-05-03 11:03:01 +02:00
|
|
|
|
2012-03-25 23:00:04 +02: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 11:58:53 +02:00
|
|
|
|
2008-03-10 23:28:05 +01:00
|
|
|
struct kmem_cache *task_xstate_cachep;
|
2010-05-17 11:22:23 +02:00
|
|
|
EXPORT_SYMBOL_GPL(task_xstate_cachep);
|
2008-03-10 23:28:04 +01:00
|
|
|
|
2012-05-17 00:03:51 +02:00
|
|
|
/*
|
|
|
|
* this gets called so that we can store lazy state into memory and copy the
|
|
|
|
* current task into the new thread.
|
|
|
|
*/
|
2008-03-10 23:28:04 +01:00
|
|
|
int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
|
|
|
|
{
|
2010-05-06 10:45:46 +02:00
|
|
|
int ret;
|
|
|
|
|
2008-03-10 23:28:04 +01:00
|
|
|
*dst = *src;
|
2010-05-06 10:45:46 +02:00
|
|
|
if (fpu_allocated(&src->thread.fpu)) {
|
|
|
|
memset(&dst->thread.fpu, 0, sizeof(dst->thread.fpu));
|
|
|
|
ret = fpu_alloc(&dst->thread.fpu);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-08-24 23:13:02 +02:00
|
|
|
fpu_copy(dst, src);
|
2008-03-10 23:28:05 +01:00
|
|
|
}
|
2008-03-10 23:28:04 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-10 23:28:05 +01:00
|
|
|
void free_thread_xstate(struct task_struct *tsk)
|
2008-03-10 23:28:04 +01:00
|
|
|
{
|
2010-05-06 10:45:46 +02:00
|
|
|
fpu_free(&tsk->thread.fpu);
|
2008-03-10 23:28:05 +01:00
|
|
|
}
|
|
|
|
|
2012-05-05 17:05:42 +02:00
|
|
|
void arch_release_task_struct(struct task_struct *tsk)
|
2008-03-10 23:28:05 +01:00
|
|
|
{
|
2012-05-05 17:05:42 +02:00
|
|
|
free_thread_xstate(tsk);
|
2008-03-10 23:28:04 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void arch_task_cache_init(void)
|
|
|
|
{
|
|
|
|
task_xstate_cachep =
|
|
|
|
kmem_cache_create("task_xstate", xstate_size,
|
|
|
|
__alignof__(union thread_xstate),
|
kmemcheck: add mm functions
With kmemcheck enabled, the slab allocator needs to do this:
1. Tell kmemcheck to allocate the shadow memory which stores the status of
each byte in the allocation proper, e.g. whether it is initialized or
uninitialized.
2. Tell kmemcheck which parts of memory that should be marked uninitialized.
There are actually a few more states, such as "not yet allocated" and
"recently freed".
If a slab cache is set up using the SLAB_NOTRACK flag, it will never return
memory that can take page faults because of kmemcheck.
If a slab cache is NOT set up using the SLAB_NOTRACK flag, callers can still
request memory with the __GFP_NOTRACK flag. This does not prevent the page
faults from occuring, however, but marks the object in question as being
initialized so that no warnings will ever be produced for this object.
In addition to (and in contrast to) __GFP_NOTRACK, the
__GFP_NOTRACK_FALSE_POSITIVE flag indicates that the allocation should
not be tracked _because_ it would produce a false positive. Their values
are identical, but need not be so in the future (for example, we could now
enable/disable false positives with a config option).
Parts of this patch were contributed by Pekka Enberg but merged for
atomicity.
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
Signed-off-by: Pekka Enberg <penberg@cs.helsinki.fi>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
[rebased for mainline inclusion]
Signed-off-by: Vegard Nossum <vegard.nossum@gmail.com>
2008-05-31 15:56:17 +02:00
|
|
|
SLAB_PANIC | SLAB_NOTRACK, NULL);
|
2008-03-10 23:28:04 +01:00
|
|
|
}
|
2008-04-25 17:39:01 +02:00
|
|
|
|
2009-02-27 22:25:28 +01: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 13:07:21 +01:00
|
|
|
unsigned long *bp = t->io_bitmap_ptr;
|
2009-02-27 22:25:28 +01:00
|
|
|
|
2009-03-16 13:07:21 +01:00
|
|
|
if (bp) {
|
2009-02-27 22:25:28 +01:00
|
|
|
struct tss_struct *tss = &per_cpu(init_tss, get_cpu());
|
|
|
|
|
|
|
|
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 13:07:21 +01:00
|
|
|
kfree(bp);
|
2009-02-27 22:25:28 +01:00
|
|
|
}
|
2012-05-17 00:03:54 +02:00
|
|
|
|
|
|
|
drop_fpu(me);
|
2009-02-27 22:25:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void flush_thread(void)
|
|
|
|
{
|
|
|
|
struct task_struct *tsk = current;
|
|
|
|
|
2009-09-09 19:22:48 +02:00
|
|
|
flush_ptrace_hw_breakpoint(tsk);
|
2009-02-27 22:25:28 +01:00
|
|
|
memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
|
2012-08-24 23:13:02 +02:00
|
|
|
drop_init_fpu(tsk);
|
|
|
|
/*
|
|
|
|
* Free the FPU state for non xsave platforms. They get reallocated
|
|
|
|
* lazily at the first use.
|
|
|
|
*/
|
2012-09-06 23:58:52 +02:00
|
|
|
if (!use_eager_fpu())
|
2012-08-24 23:13:02 +02:00
|
|
|
free_thread_xstate(tsk);
|
2009-02-27 22:25:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hard_disable_TSC(void)
|
|
|
|
{
|
|
|
|
write_cr4(read_cr4() | X86_CR4_TSD);
|
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
write_cr4(read_cr4() & ~X86_CR4_TSD);
|
|
|
|
}
|
|
|
|
|
|
|
|
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 14:51:51 +01: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-27 22:25:28 +01: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 08:40:22 +02:00
|
|
|
propagate_user_return_notify(prev_p, next_p);
|
2009-02-27 22:25:28 +01:00
|
|
|
}
|
|
|
|
|
2008-06-09 18:35:28 +02:00
|
|
|
/*
|
|
|
|
* Idle related variables and functions
|
|
|
|
*/
|
2010-11-03 17:06:14 +01:00
|
|
|
unsigned long boot_option_idle_override = IDLE_NO_OVERRIDE;
|
2008-06-09 18:35:28 +02:00
|
|
|
EXPORT_SYMBOL(boot_option_idle_override);
|
|
|
|
|
2013-02-10 03:45:03 +01:00
|
|
|
static void (*x86_idle)(void);
|
2008-06-09 18:35:28 +02:00
|
|
|
|
2012-03-25 23:00:04 +02:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
static inline void play_dead(void)
|
|
|
|
{
|
|
|
|
BUG();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
void enter_idle(void)
|
|
|
|
{
|
2012-05-11 09:35:27 +02:00
|
|
|
this_cpu_write(is_idle, 1);
|
2012-03-25 23:00:04 +02: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-21 22:50:03 +01:00
|
|
|
void arch_cpu_idle_enter(void)
|
|
|
|
{
|
|
|
|
local_touch_nmi();
|
|
|
|
enter_idle();
|
|
|
|
}
|
2012-03-25 23:00:04 +02:00
|
|
|
|
2013-03-21 22:50:03 +01:00
|
|
|
void arch_cpu_idle_exit(void)
|
|
|
|
{
|
|
|
|
__exit_idle();
|
|
|
|
}
|
2012-03-25 23:00:04 +02:00
|
|
|
|
2013-03-21 22:50:03 +01:00
|
|
|
void arch_cpu_idle_dead(void)
|
|
|
|
{
|
|
|
|
play_dead();
|
|
|
|
}
|
2012-03-25 23:00:04 +02:00
|
|
|
|
2013-03-21 22:50:03 +01:00
|
|
|
/*
|
|
|
|
* Called from the generic idle code.
|
|
|
|
*/
|
|
|
|
void arch_cpu_idle(void)
|
|
|
|
{
|
|
|
|
if (cpuidle_idle_call())
|
|
|
|
x86_idle();
|
2013-05-02 16:21:15 +02:00
|
|
|
else
|
|
|
|
local_irq_enable();
|
2012-03-25 23:00:04 +02:00
|
|
|
}
|
|
|
|
|
2008-06-09 18:35:28 +02:00
|
|
|
/*
|
2013-03-21 22:50:03 +01:00
|
|
|
* We use this if we don't have any better idle routine..
|
2008-06-09 18:35:28 +02:00
|
|
|
*/
|
|
|
|
void default_idle(void)
|
|
|
|
{
|
2012-10-25 18:13:11 +02:00
|
|
|
trace_cpu_idle_rcuidle(1, smp_processor_id());
|
2013-03-21 22:50:03 +01:00
|
|
|
safe_halt();
|
2012-10-25 18:13:11 +02:00
|
|
|
trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
|
2008-06-09 18:35:28 +02:00
|
|
|
}
|
2011-06-14 21:45:10 +02:00
|
|
|
#ifdef CONFIG_APM_MODULE
|
2008-06-09 18:35:28 +02:00
|
|
|
EXPORT_SYMBOL(default_idle);
|
|
|
|
#endif
|
|
|
|
|
2013-02-10 05:08:07 +01:00
|
|
|
#ifdef CONFIG_XEN
|
|
|
|
bool xen_set_default_idle(void)
|
2011-11-22 00:02:02 +01:00
|
|
|
{
|
2013-02-10 03:45:03 +01:00
|
|
|
bool ret = !!x86_idle;
|
2011-11-22 00:02:02 +01:00
|
|
|
|
2013-02-10 03:45:03 +01:00
|
|
|
x86_idle = default_idle;
|
2011-11-22 00:02:02 +01:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2013-02-10 05:08:07 +01:00
|
|
|
#endif
|
2008-11-11 14:33:44 +01:00
|
|
|
void stop_this_cpu(void *dummy)
|
|
|
|
{
|
|
|
|
local_irq_disable();
|
|
|
|
/*
|
|
|
|
* Remove this CPU:
|
|
|
|
*/
|
2009-03-13 05:19:54 +01:00
|
|
|
set_cpu_online(smp_processor_id(), false);
|
2008-11-11 14:33:44 +01: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 08:28:46 +01:00
|
|
|
for (;;)
|
|
|
|
halt();
|
2008-04-25 17:39:01 +02:00
|
|
|
}
|
|
|
|
|
2011-04-01 22:59:53 +02:00
|
|
|
bool amd_e400_c1e_detected;
|
|
|
|
EXPORT_SYMBOL(amd_e400_c1e_detected);
|
2008-06-09 19:15:00 +02:00
|
|
|
|
2011-04-01 22:59:53 +02:00
|
|
|
static cpumask_var_t amd_e400_c1e_mask;
|
2008-09-22 18:54:29 +02:00
|
|
|
|
2011-04-01 22:59:53 +02:00
|
|
|
void amd_e400_remove_cpu(int cpu)
|
2008-09-22 18:54:29 +02:00
|
|
|
{
|
2011-04-01 22:59:53 +02:00
|
|
|
if (amd_e400_c1e_mask != NULL)
|
|
|
|
cpumask_clear_cpu(cpu, amd_e400_c1e_mask);
|
2008-09-22 18:54:29 +02:00
|
|
|
}
|
|
|
|
|
2008-06-09 19:15:00 +02:00
|
|
|
/*
|
2011-04-01 22:59:53 +02:00
|
|
|
* AMD Erratum 400 aware idle routine. We check for C1E active in the interrupt
|
2008-06-09 19:15:00 +02: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-01 22:59:53 +02:00
|
|
|
static void amd_e400_idle(void)
|
2008-06-09 19:15:00 +02:00
|
|
|
{
|
2011-04-01 22:59:53 +02:00
|
|
|
if (!amd_e400_c1e_detected) {
|
2008-06-09 19:15:00 +02:00
|
|
|
u32 lo, hi;
|
|
|
|
|
|
|
|
rdmsr(MSR_K8_INT_PENDING_MSG, lo, hi);
|
2010-07-27 18:53:35 +02:00
|
|
|
|
2008-06-09 19:15:00 +02:00
|
|
|
if (lo & K8_INTP_C1E_ACTIVE_MASK) {
|
2011-04-01 22:59:53 +02:00
|
|
|
amd_e400_c1e_detected = true;
|
2008-11-18 01:11:37 +01:00
|
|
|
if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
|
2008-09-18 21:12:10 +02:00
|
|
|
mark_tsc_unstable("TSC halt in AMD C1E");
|
2012-05-22 04:50:07 +02:00
|
|
|
pr_info("System has AMD C1E enabled\n");
|
2008-06-09 19:15:00 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-01 22:59:53 +02:00
|
|
|
if (amd_e400_c1e_detected) {
|
2008-06-09 19:15:00 +02:00
|
|
|
int cpu = smp_processor_id();
|
|
|
|
|
2011-04-01 22:59:53 +02:00
|
|
|
if (!cpumask_test_cpu(cpu, amd_e400_c1e_mask)) {
|
|
|
|
cpumask_set_cpu(cpu, amd_e400_c1e_mask);
|
2008-06-17 09:12:03 +02:00
|
|
|
/*
|
2009-08-17 23:34:59 +02:00
|
|
|
* Force broadcast so ACPI can not interfere.
|
2008-06-17 09:12:03 +02:00
|
|
|
*/
|
2008-06-09 19:15:00 +02:00
|
|
|
clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_FORCE,
|
|
|
|
&cpu);
|
2012-05-22 04:50:07 +02:00
|
|
|
pr_info("Switch to broadcast mode on CPU%d\n", cpu);
|
2008-06-09 19:15:00 +02:00
|
|
|
}
|
|
|
|
clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER, &cpu);
|
2008-06-17 09:12:03 +02:00
|
|
|
|
2008-06-09 19:15:00 +02:00
|
|
|
default_idle();
|
2008-06-17 09:12:03 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The switch back from broadcast mode needs to be
|
|
|
|
* called with interrupts disabled.
|
|
|
|
*/
|
2013-09-11 12:43:13 +02:00
|
|
|
local_irq_disable();
|
|
|
|
clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT, &cpu);
|
|
|
|
local_irq_enable();
|
2008-06-09 19:15:00 +02:00
|
|
|
} else
|
|
|
|
default_idle();
|
|
|
|
}
|
|
|
|
|
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 00:23:59 +02:00
|
|
|
void select_idle_routine(const struct cpuinfo_x86 *c)
|
2008-04-25 17:39:01 +02:00
|
|
|
{
|
2009-01-27 17:07:08 +01:00
|
|
|
#ifdef CONFIG_SMP
|
2013-03-21 22:50:03 +01:00
|
|
|
if (boot_option_idle_override == IDLE_POLL && smp_num_siblings > 1)
|
2012-05-22 04:50:07 +02:00
|
|
|
pr_warn_once("WARNING: polling idle and HT enabled, performance may degrade\n");
|
2008-04-25 17:39:01 +02:00
|
|
|
#endif
|
2013-03-21 22:50:03 +01:00
|
|
|
if (x86_idle || boot_option_idle_override == IDLE_POLL)
|
2008-06-09 16:59:53 +02:00
|
|
|
return;
|
|
|
|
|
2013-03-20 15:07:28 +01:00
|
|
|
if (cpu_has_bug(c, X86_BUG_AMD_APIC_C1E)) {
|
2010-07-28 19:09:31 +02:00
|
|
|
/* E400: APIC timer interrupt does not wake up CPU from C1e */
|
2012-05-22 04:50:07 +02:00
|
|
|
pr_info("using AMD E400 aware idle routine\n");
|
2013-02-10 03:45:03 +01:00
|
|
|
x86_idle = amd_e400_idle;
|
2008-06-09 16:59:53 +02:00
|
|
|
} else
|
2013-02-10 03:45:03 +01:00
|
|
|
x86_idle = default_idle;
|
2008-04-25 17:39:01 +02:00
|
|
|
}
|
|
|
|
|
2011-04-01 22:59:53 +02:00
|
|
|
void __init init_amd_e400_c1e_mask(void)
|
2009-03-17 05:20:34 +01:00
|
|
|
{
|
2011-04-01 22:59:53 +02:00
|
|
|
/* If we're using amd_e400_idle, we need to allocate amd_e400_c1e_mask. */
|
2013-02-10 03:45:03 +01:00
|
|
|
if (x86_idle == amd_e400_idle)
|
2011-04-01 22:59:53 +02:00
|
|
|
zalloc_cpumask_var(&amd_e400_c1e_mask, GFP_KERNEL);
|
2009-03-17 05:20:34 +01:00
|
|
|
}
|
|
|
|
|
2008-04-25 17:39:01 +02:00
|
|
|
static int __init idle_setup(char *str)
|
|
|
|
{
|
2008-07-05 13:53:36 +02:00
|
|
|
if (!str)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-04-25 17:39:01 +02:00
|
|
|
if (!strcmp(str, "poll")) {
|
2012-05-22 04:50:07 +02:00
|
|
|
pr_info("using polling idle threads\n");
|
2010-11-03 17:06:14 +01:00
|
|
|
boot_option_idle_override = IDLE_POLL;
|
2013-03-21 22:50:03 +01:00
|
|
|
cpu_idle_poll_ctrl(true);
|
2010-11-03 17:06:14 +01:00
|
|
|
} else if (!strcmp(str, "halt")) {
|
2008-06-24 11:58:53 +02: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 03:45:03 +01:00
|
|
|
x86_idle = default_idle;
|
2010-11-03 17:06:14 +01:00
|
|
|
boot_option_idle_override = IDLE_HALT;
|
2008-06-24 12:01:09 +02: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 17:06:14 +01:00
|
|
|
boot_option_idle_override = IDLE_NOMWAIT;
|
2008-06-24 11:58:53 +02:00
|
|
|
} else
|
2008-04-25 17:39:01 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("idle", idle_setup);
|
|
|
|
|
2009-05-12 04:05:28 +02: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;
|
|
|
|
}
|
|
|
|
|