Commit c2daa3be authored by Peter Zijlstra's avatar Peter Zijlstra Committed by Ingo Molnar
Browse files

sched, x86: Provide a per-cpu preempt_count implementation 



Convert x86 to use a per-cpu preemption count. The reason for doing so
is that accessing per-cpu variables is a lot cheaper than accessing
thread_info variables.

We still need to save/restore the actual preemption count due to
PREEMPT_ACTIVE so we place the per-cpu __preempt_count variable in the
same cache-line as the other hot __switch_to() variables such as
current_task.

NOTE: this save/restore is required even for !PREEMPT kernels as
cond_resched() also relies on preempt_count's PREEMPT_ACTIVE to ignore
task_struct::state.

Also rename thread_info::preempt_count to ensure nobody is
'accidentally' still poking at it.

Suggested-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: default avatarPeter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/n/tip-gzn5rfsf8trgjoqx8hyayy3q@git.kernel.org


Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent a233f112

arch/x86/include/asm/Kbuild

+0 −1
Original line number Diff line number Diff line
@@ -5,4 +5,3 @@ genhdr-y += unistd_64.h 
genhdr-y += unistd_x32.h



generic-y += clkdev.h
 
generic-y += preempt.h

arch/x86/include/asm/preempt.h

0 → 100644
+98 −0
Original line number Diff line number Diff line 
#ifndef __ASM_PREEMPT_H

#define __ASM_PREEMPT_H



#include <asm/rmwcc.h>

#include <asm/percpu.h>

#include <linux/thread_info.h>



DECLARE_PER_CPU(int, __preempt_count);



/*

 * We mask the PREEMPT_NEED_RESCHED bit so as not to confuse all current users

 * that think a non-zero value indicates we cannot preempt.

 */

static __always_inline int preempt_count(void)

{

	return __this_cpu_read_4(__preempt_count) & ~PREEMPT_NEED_RESCHED;

}



static __always_inline void preempt_count_set(int pc)

{

	__this_cpu_write_4(__preempt_count, pc);

}



/*

 * must be macros to avoid header recursion hell

 */

#define task_preempt_count(p) \

	(task_thread_info(p)->saved_preempt_count & ~PREEMPT_NEED_RESCHED)



#define init_task_preempt_count(p) do { \

	task_thread_info(p)->saved_preempt_count = PREEMPT_DISABLED; \

} while (0)



#define init_idle_preempt_count(p, cpu) do { \

	task_thread_info(p)->saved_preempt_count = PREEMPT_ENABLED; \

	per_cpu(__preempt_count, (cpu)) = PREEMPT_ENABLED; \

} while (0)



/*

 * We fold the NEED_RESCHED bit into the preempt count such that

 * preempt_enable() can decrement and test for needing to reschedule with a

 * single instruction.

 *

 * We invert the actual bit, so that when the decrement hits 0 we know we both

 * need to resched (the bit is cleared) and can resched (no preempt count).

 */



static __always_inline void set_preempt_need_resched(void)

{

	__this_cpu_and_4(__preempt_count, ~PREEMPT_NEED_RESCHED);

}



static __always_inline void clear_preempt_need_resched(void)

{

	__this_cpu_or_4(__preempt_count, PREEMPT_NEED_RESCHED);

}



static __always_inline bool test_preempt_need_resched(void)

{

	return !(__this_cpu_read_4(__preempt_count) & PREEMPT_NEED_RESCHED);

}



/*

 * The various preempt_count add/sub methods

 */



static __always_inline void __preempt_count_add(int val)

{

	__this_cpu_add_4(__preempt_count, val);

}



static __always_inline void __preempt_count_sub(int val)

{

	__this_cpu_add_4(__preempt_count, -val);

}



static __always_inline bool __preempt_count_dec_and_test(void)

{

	GEN_UNARY_RMWcc("decl", __preempt_count, __percpu_arg(0), "e");

}



/*

 * Returns true when we need to resched -- even if we can not.

 */

static __always_inline bool need_resched(void)

{

	return unlikely(test_preempt_need_resched());

}



/*

 * Returns true when we need to resched and can (barring IRQ state).

 */

static __always_inline bool should_resched(void)

{

	return unlikely(!__this_cpu_read_4(__preempt_count));

}



#endif /* __ASM_PREEMPT_H */

arch/x86/include/asm/thread_info.h

+2 −3
Original line number Diff line number Diff line
@@ -28,8 +28,7 @@ struct thread_info { 
	__u32			flags;		/* low level flags */

	__u32			status;		/* thread synchronous flags */

	__u32			cpu;		/* current CPU */

	int			preempt_count;	/* 0 => preemptable,

						   <0 => BUG */

	int			saved_preempt_count;

	mm_segment_t		addr_limit;

	struct restart_block    restart_block;

	void __user		*sysenter_return;
@@ -49,7 +48,7 @@ struct thread_info { 
	.exec_domain	= &default_exec_domain,	\

	.flags		= 0,			\

	.cpu		= 0,			\

	.preempt_count	= INIT_PREEMPT_COUNT,	\

	.saved_preempt_count = INIT_PREEMPT_COUNT,	\

	.addr_limit	= KERNEL_DS,		\

	.restart_block = {			\

		.fn = do_no_restart_syscall,	\

arch/x86/kernel/asm-offsets.c

+0 −1
Original line number Diff line number Diff line
@@ -32,7 +32,6 @@ void common(void) { 
	OFFSET(TI_flags, thread_info, flags);

	OFFSET(TI_status, thread_info, status);

	OFFSET(TI_addr_limit, thread_info, addr_limit);

	OFFSET(TI_preempt_count, thread_info, preempt_count);



	BLANK();

	OFFSET(crypto_tfm_ctx_offset, crypto_tfm, __crt_ctx);

arch/x86/kernel/cpu/common.c

+5 −0
Original line number Diff line number Diff line
@@ -1095,6 +1095,9 @@ DEFINE_PER_CPU(char *, irq_stack_ptr) = 


DEFINE_PER_CPU(unsigned int, irq_count) __visible = -1;



DEFINE_PER_CPU(int, __preempt_count) = INIT_PREEMPT_COUNT;

EXPORT_PER_CPU_SYMBOL(__preempt_count);



DEFINE_PER_CPU(struct task_struct *, fpu_owner_task);



/*
@@ -1169,6 +1172,8 @@ void debug_stack_reset(void) 


DEFINE_PER_CPU(struct task_struct *, current_task) = &init_task;

EXPORT_PER_CPU_SYMBOL(current_task);

DEFINE_PER_CPU(int, __preempt_count) = INIT_PREEMPT_COUNT;

EXPORT_PER_CPU_SYMBOL(__preempt_count);

DEFINE_PER_CPU(struct task_struct *, fpu_owner_task);



#ifdef CONFIG_CC_STACKPROTECTOR

CRA Git | Maintained and supported by SUSTech CRA and CCSE