entry: Consolidate and rework syscall entry handling

add_random_kstack_offset() is invoked before syscall_enter_from_user_mode() establishes state. That's wrong because add_random_kstack_offset() calls into instrumentable code.

Move it after syscall_enter_from_user_mode() to ensure that state is correctly established.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Michael Ellerman <[email protected]>

Cc Shrikanth Hegde <[email protected]>

Cc [email protected]

---
  arch/powerpc/kernel/syscall.c |    2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)

add_random_kstack_offset() is invoked before syscall_enter_from_user_mode() establishes state. That's wrong because add_random_kstack_offset() calls into instrumentable code.

Move it after syscall_enter_from_user_mode() to ensure that state is correctly established.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Michael Ellerman <[email protected]>

Cc Shrikanth Hegde <[email protected]>

Cc [email protected]

---
 arch/powerpc/kernel/syscall.c |    2 +-

 1 file changed, 1 insertion(+), 1 deletion(-)

arch/powerpc/kernel/syscall.c +0 -0

@@ -19,8 +19,8 @@ notrace long system_call_exception(struc
  	long ret;
  	syscall_fn f;

arch/powerpc/kernel/syscall.c +0 -1

-	add_random_kstack_offset();

  r0 = syscall_enter_from_user_mode(regs, r0);

arch/powerpc/kernel/syscall.c +1 -0

+	add_random_kstack_offset();

  if (unlikely(r0 >= NR_syscalls)) {
  if (unlikely(trap_is_unsupported_scv(regs))) {

add_random_kstack_offset() is invoked before syscall_enter_from_user_mode() establishes state. That's wrong because add_random_kstack_offset() calls into instrumentable code.

Move it after syscall_enter_from_user_mode() to ensure that state is correctly established.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Michael Ellerman <[email protected]>

Cc Shrikanth Hegde <[email protected]>

Cc [email protected]

---
 arch/powerpc/kernel/syscall.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

arch/powerpc/kernel/syscall.c +0 -0

 	if (unlikely(r0 >= NR_syscalls)) {
 		if (unlikely(trap_is_unsupported_scv(regs))) {
 

add_random_kstack_offset() is invoked before syscall_enter_from_user_mode() establishes state. That's wrong because add_random_kstack_offset() calls into instrumentable code.

Move it after syscall_enter_from_user_mode() to ensure that state is correctly established.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Michael Ellerman <[email protected]>

Cc Shrikanth Hegde <[email protected]>

Cc [email protected]

---
  arch/powerpc/kernel/syscall.c |    2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)

add_random_kstack_offset() is invoked before syscall_enter_from_user_mode() establishes state. That's wrong because add_random_kstack_offset() calls into instrumentable code.

Move it after syscall_enter_from_user_mode() to ensure that state is correctly established.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Michael Ellerman <[email protected]>

Cc Shrikanth Hegde <[email protected]>

Cc [email protected]

add_random_kstack_offset() uses get/put_cpu_var() which is pointless overhead when it is invoked from low level entry code with interrupts disabled.

Provide a irqsoff() variant, which avoids that.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Kees Cook <[email protected]>

---
 include/linux/randomize_kstack.h |   19 +++++++++++++++++++

 1 file changed, 19 insertions(+)

include/linux/randomize_kstack.h +0 -0

@@ -77,8 +77,27 @@ static __always_inline u32 get_kstack_of
  	}								\
  } while (0)

include/linux/randomize_kstack.h +18 -0

+/**
+ * add_random_kstack_offset_irqsoff - Increase stack utilization by a random offset.
+ *
+ * This should be used in the syscall entry path after user registers have been
+ * stored to the stack. Interrupts must be still disabled.
+ */
+#define add_random_kstack_offset_irqsoff()					\
+do {										\
+	lockdep_assert_irqs_disabled();						\
+	if (static_branch_maybe(CONFIG_RANDOMIZE_KSTACK_OFFSET_DEFAULT,		\
+				&randomize_kstack_offset)) {			\
+		u32 offset = prandom_u32_state(raw_cpu_ptr(&kstack_rnd_state));	\
+		u8 *ptr = __kstack_alloca(KSTACK_OFFSET_MAX(offset));		\
+		/* Keep allocation even after "ptr" loses scope. */		\
+		asm volatile("" :: "r"(ptr) : "memory");			\
+	}									\
+} while (0)
+

 #else /* CONFIG_RANDOMIZE_KSTACK_OFFSET */
 #define add_random_kstack_offset() do { } while (0)
+#define add_random_kstack_offset_irqsoff() do { } while (0)
 #endif /* CONFIG_RANDOMIZE_KSTACK_OFFSET */

 #endif

add_random_kstack_offset() uses get/put_cpu_var() which is pointless overhead when it is invoked from low level entry code with interrupts disabled.

Provide a irqsoff() variant, which avoids that.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Kees Cook <[email protected]>

---
 include/linux/randomize_kstack.h |   19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

include/linux/randomize_kstack.h +7 -0

@@ -77,8 +77,27 @@ static __always_inline u32 get_kstack_of
 	}								\
 } while (0)
 
+/**
+ * add_random_kstack_offset_irqsoff - Increase stack utilization by a random offset.
+ *
+ * This should be used in the syscall entry path after user registers have been
+ * stored to the stack. Interrupts must be still disabled.
+ */
+#define add_random_kstack_offset_irqsoff()					\

include/linux/randomize_kstack.h +2 -0

+
 #else /* CONFIG_RANDOMIZE_KSTACK_OFFSET */
 #define add_random_kstack_offset()		do { } while (0)
+#define add_random_kstack_offset_irqsoff()	do { } while (0)
 #endif /* CONFIG_RANDOMIZE_KSTACK_OFFSET */
 
 #endif

add_random_kstack_offset() uses get/put_cpu_var() which is pointless overhead when it is invoked from low level entry code with interrupts disabled.

Provide a irqsoff() variant, which avoids that.

Signed-off-by Thomas Gleixner <[email protected]>

add_random_kstack_offset() uses get/put_cpu_var() which is pointless overhead when it is invoked from low level entry code with interrupts disabled.

Provide a irqsoff() variant, which avoids that.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Kees Cook <[email protected]>

---
 include/linux/randomize_kstack.h |   19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

include/linux/randomize_kstack.h +14 -0

@@ -77,8 +77,27 @@ static __always_inline u32 get_kstack_of
 	}								\
 } while (0)
 
+/**
+ * add_random_kstack_offset_irqsoff - Increase stack utilization by a random offset.
+ *
+ * This should be used in the syscall entry path after user registers have been
+ * stored to the stack. Interrupts must be still disabled.
+ */
+#define add_random_kstack_offset_irqsoff()					\
+do {										\
+	lockdep_assert_irqs_disabled();						\
+	if (static_branch_maybe(CONFIG_RANDOMIZE_KSTACK_OFFSET_DEFAULT,		\
+				&randomize_kstack_offset)) {			\
+		u32 offset = prandom_u32_state(raw_cpu_ptr(&kstack_rnd_state));	\
+		u8 *ptr = __kstack_alloca(KSTACK_OFFSET_MAX(offset));		\
+		/* Keep allocation even after "ptr" loses scope. */		\

_______________________________________________
linux-snps-arc mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-snps-arc

Randomizing the syscall stack can only happen after state is established via enter_from_user_mode() or syscall_enter_from_user_mode(). The earlier it happens the better.

Provide two new macros to consolidate that:

  - enter_from_user_mode_randomize_stack()

	enter_from_user_mode();
	add_random_kstack_offset_irqsoff();

  - syscall_enter_from_user_mode_randomize_stack()

	enter_from_user_mode_randomize_stack();
	syscall_enter_from_user_mode_work();

to reduce boiler plate code.

Those are macros and not inline functions as the latter would limit the stack randomization scope to the inline function itself.

Signed-off-by Thomas Gleixner <[email protected]>

---
 include/linux/entry-common.h |   56 +++++++++++++++++++++++++++++++++++++++++++

 1 file changed, 56 insertions(+)

include/linux/entry-common.h +1 -0

@@ -6,6 +6,7 @@
  #include <linux/irq-entry-common.h>
  #include <linux/livepatch.h>
  #include <linux/ptrace.h>
+#include <linux/randomize_kstack.h>
  #include <linux/resume_user_mode.h>
  #include <linux/seccomp.h>
  #include <linux/sched.h>

@@ -150,6 +151,61 @@ static __always_inline long syscall_ente
  }

 /**
+ * enter_from_user_mode_randomize_stack - Establish state and add stack randomization
+ *   before invoking syscall_enter_from_user_mode_work()
+ * @regs: Pointer to currents pt_regs

+ *
+ * Invoked from architecture specific syscall entry code with interrupts
+ * disabled. The calling code has to be non-instrumentable. When the function
+ * returns all state is correct, interrupts are still disabled and the
+ * subsequent functions can be instrumented.
+ *
+ * Implemented as a macro so that the stack randomization is effective
+ * throughout the function in which it is invoked. An inline would only make it
+ * effective in the scope of the inline function.
+ */

include/linux/entry-common.h +2 -0

+#define enter_from_user_mode_randomize_stack(regs)			\
+do {									\

+ * @syscall: The syscall number
+ *
+ * Invoked from architecture specific syscall entry code with interrupts
+ * disabled. The calling code has to be non-instrumentable. When the
+ * function returns all state is correct, interrupts are enabled and the
+ * subsequent functions can be instrumented.
+ *
+ * This is the combination of enter_from_user_mode_randomize_stack() and
+ * syscall_enter_from_user_mode_work() to be used when there is no
+ * architecture specific work to be done between the two.
+ *
+ * Returns: The original or a modified syscall number. See
+ * syscall_enter_from_user_mode_work() for further explanation.
+ *
+ * Implemented as a macro to make stack randomization effective in the calling
+ * scope.
+ */

include/linux/entry-common.h +13 -0

+#define syscall_enter_from_user_mode_randomize_stack(regs, syscall)	\
+({									\
+	enter_from_user_mode_randomize_stack(regs);			\
+									\
+	instrumentation_begin();					\
+	local_irq_enable();						\
+	long _ret = syscall_enter_from_user_mode_work(regs, syscall);	\
+	instrumentation_end();						\
+									\
+	_ret;								\
+})
+
+/**

  * syscall_enter_from_user_mode - Establish state and check and handle work
  *   before invoking a syscall
  * @regs: Pointer to currents pt_regs

Randomizing the syscall stack can only happen after state is established via enter_from_user_mode() or syscall_enter_from_user_mode(). The earlier it happens the better.

Provide two new macros to consolidate that:

- enter_from_user_mode_randomize_stack()

	enter_from_user_mode();
	add_random_kstack_offset_irqsoff();

- syscall_enter_from_user_mode_randomize_stack()

	enter_from_user_mode_randomize_stack();
	syscall_enter_from_user_mode_work();

to reduce boiler plate code.

Those are macros and not inline functions as the latter would limit the stack randomization scope to the inline function itself.

Signed-off-by Thomas Gleixner <[email protected]>

---
 include/linux/entry-common.h |   56 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

include/linux/entry-common.h +44 -0

@@ -6,6 +6,7 @@
 #include <linux/irq-entry-common.h>
 #include <linux/livepatch.h>
 #include <linux/ptrace.h>
+#include <linux/randomize_kstack.h>
 #include <linux/resume_user_mode.h>
 #include <linux/seccomp.h>
 #include <linux/sched.h>

@@ -150,6 +151,61 @@ static __always_inline long syscall_ente
 }
 
 /**
+ * enter_from_user_mode_randomize_stack - Establish state and add stack randomization
+ *					  before invoking syscall_enter_from_user_mode_work()
+ * @regs:	Pointer to currents pt_regs
+ *
+ * Invoked from architecture specific syscall entry code with interrupts
+ * disabled. The calling code has to be non-instrumentable. When the function
+ * returns all state is correct, interrupts are still disabled and the
+ * subsequent functions can be instrumented.
+ *
+ * Implemented as a macro so that the stack randomization is effective
+ * throughout the function in which it is invoked. An inline would only make it
+ * effective in the scope of the inline function.
+ */
+#define enter_from_user_mode_randomize_stack(regs)			\
+do {									\
+	enter_from_user_mode(regs);					\
+	instrumentation_begin();					\
+	add_random_kstack_offset_irqsoff();				\
+	instrumentation_end();						\
+} while (0)
+
+/**
+ * syscall_enter_from_user_mode_randomize_stack - Establish state and check and handle work
+ *						  before invoking a syscall
+ * @regs:	Pointer to currents pt_regs
+ * @syscall:	The syscall number
+ *
+ * Invoked from architecture specific syscall entry code with interrupts
+ * disabled. The calling code has to be non-instrumentable. When the
+ * function returns all state is correct, interrupts are enabled and the
+ * subsequent functions can be instrumented.
+ *
+ * This is the combination of enter_from_user_mode_randomize_stack() and
+ * syscall_enter_from_user_mode_work() to be used when there is no
+ * architecture specific work to be done between the two.
+ *
+ * Returns: The original or a modified syscall number. See
+ * syscall_enter_from_user_mode_work() for further explanation.
+ *
+ * Implemented as a macro to make stack randomization effective in the calling
+ * scope.
+ */
+#define syscall_enter_from_user_mode_randomize_stack(regs, syscall)	\

include/linux/entry-common.h +2 -0

+
+/**
  * syscall_enter_from_user_mode - Establish state and check and handle work
  *				  before invoking a syscall
  * @regs:	Pointer to currents pt_regs

Randomizing the syscall stack can only happen after state is established via enter_from_user_mode() or syscall_enter_from_user_mode(). The earlier it happens the better.

Provide two new macros to consolidate that:

- enter_from_user_mode_randomize_stack()

	enter_from_user_mode();
	add_random_kstack_offset_irqsoff();

- syscall_enter_from_user_mode_randomize_stack()

	enter_from_user_mode_randomize_stack();
	syscall_enter_from_user_mode_work();

to reduce boiler plate code.

Those are macros and not inline functions as the latter would limit the stack randomization scope to the inline function itself.

Signed-off-by Thomas Gleixner <[email protected]>

---
 include/linux/entry-common.h |   56 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

include/linux/entry-common.h +11 -0

@@ -6,6 +6,7 @@
 #include <linux/irq-entry-common.h>
 #include <linux/livepatch.h>
 #include <linux/ptrace.h>
+#include <linux/randomize_kstack.h>
 #include <linux/resume_user_mode.h>
 #include <linux/seccomp.h>
 #include <linux/sched.h>

@@ -150,6 +151,61 @@ static __always_inline long syscall_ente
 }
 
 /**
+ * enter_from_user_mode_randomize_stack - Establish state and add stack randomization
+ *					  before invoking syscall_enter_from_user_mode_work()
+ * @regs:	Pointer to currents pt_regs
+ *
+ * Invoked from architecture specific syscall entry code with interrupts
+ * disabled. The calling code has to be non-instrumentable. When the function
+ * returns all state is correct, interrupts are still disabled and the
+ * subsequent functions can be instrumented.
+ *
+ * Implemented as a macro so that the stack randomization is effective

include/linux/entry-common.h +35 -0

+
+/**
+ * syscall_enter_from_user_mode_randomize_stack - Establish state and check and handle work
+ *						  before invoking a syscall
+ * @regs:	Pointer to currents pt_regs
+ * @syscall:	The syscall number
+ *
+ * Invoked from architecture specific syscall entry code with interrupts
+ * disabled. The calling code has to be non-instrumentable. When the
+ * function returns all state is correct, interrupts are enabled and the
+ * subsequent functions can be instrumented.
+ *
+ * This is the combination of enter_from_user_mode_randomize_stack() and
+ * syscall_enter_from_user_mode_work() to be used when there is no
+ * architecture specific work to be done between the two.
+ *
+ * Returns: The original or a modified syscall number. See
+ * syscall_enter_from_user_mode_work() for further explanation.
+ *
+ * Implemented as a macro to make stack randomization effective in the calling
+ * scope.
+ */
+#define syscall_enter_from_user_mode_randomize_stack(regs, syscall)	\
+({									\
+	enter_from_user_mode_randomize_stack(regs);			\
+									\
+	instrumentation_begin();					\
+	local_irq_enable();						\
+	long _ret = syscall_enter_from_user_mode_work(regs, syscall);	\
+	instrumentation_end();						\
+									\
+	_ret;								\
+})
+
+/**
  * syscall_enter_from_user_mode - Establish state and check and handle work
  *				  before invoking a syscall
  * @regs:	Pointer to currents pt_regs

Randomizing the syscall stack can only happen after state is established via enter_from_user_mode() or syscall_enter_from_user_mode(). The earlier it happens the better.

Provide two new macros to consolidate that:

   - enter_from_user_mode_randomize_stack()
	enter_from_user_mode();
	add_random_kstack_offset_irqsoff();

   - syscall_enter_from_user_mode_randomize_stack()
	enter_from_user_mode_randomize_stack();
	syscall_enter_from_user_mode_work();

to reduce boiler plate code.

Those are macros and not inline functions as the latter would limit the stack randomization scope to the inline function itself.

Signed-off-by Thomas Gleixner <[email protected]>

---
  include/linux/entry-common.h |   56 +++++++++++++++++++++++++++++++++++++++++++
  1 file changed, 56 insertions(+)

Randomizing the syscall stack can only happen after state is established via enter_from_user_mode() or syscall_enter_from_user_mode(). The earlier it happens the better.

Provide two new macros to consolidate that:

- enter_from_user_mode_randomize_stack()

	enter_from_user_mode();
	add_random_kstack_offset_irqsoff();

- syscall_enter_from_user_mode_randomize_stack()

	enter_from_user_mode_randomize_stack();
	syscall_enter_from_user_mode_work();

to reduce boiler plate code.

Those are macros and not inline functions as the latter would limit the stack randomization scope to the inline function itself.

Signed-off-by Thomas Gleixner <[email protected]>

---
 include/linux/entry-common.h |   56 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

include/linux/entry-common.h +49 -0

@@ -6,6 +6,7 @@
 #include <linux/irq-entry-common.h>
 #include <linux/livepatch.h>
 #include <linux/ptrace.h>
+#include <linux/randomize_kstack.h>
 #include <linux/resume_user_mode.h>
 #include <linux/seccomp.h>
 #include <linux/sched.h>

@@ -150,6 +151,61 @@ static __always_inline long syscall_ente
 }
 
 /**
+ * enter_from_user_mode_randomize_stack - Establish state and add stack randomization
+ *					  before invoking syscall_enter_from_user_mode_work()
+ * @regs:	Pointer to currents pt_regs
+ *
+ * Invoked from architecture specific syscall entry code with interrupts
+ * disabled. The calling code has to be non-instrumentable. When the function
+ * returns all state is correct, interrupts are still disabled and the
+ * subsequent functions can be instrumented.
+ *
+ * Implemented as a macro so that the stack randomization is effective
+ * throughout the function in which it is invoked. An inline would only make it
+ * effective in the scope of the inline function.
+ */
+#define enter_from_user_mode_randomize_stack(regs)			\
+do {									\
+	enter_from_user_mode(regs);					\
+	instrumentation_begin();					\
+	add_random_kstack_offset_irqsoff();				\
+	instrumentation_end();						\
+} while (0)
+
+/**
+ * syscall_enter_from_user_mode_randomize_stack - Establish state and check and handle work
+ *						  before invoking a syscall
+ * @regs:	Pointer to currents pt_regs
+ * @syscall:	The syscall number
+ *
+ * Invoked from architecture specific syscall entry code with interrupts
+ * disabled. The calling code has to be non-instrumentable. When the
+ * function returns all state is correct, interrupts are enabled and the
+ * subsequent functions can be instrumented.
+ *
+ * This is the combination of enter_from_user_mode_randomize_stack() and
+ * syscall_enter_from_user_mode_work() to be used when there is no
+ * architecture specific work to be done between the two.
+ *
+ * Returns: The original or a modified syscall number. See
+ * syscall_enter_from_user_mode_work() for further explanation.
+ *
+ * Implemented as a macro to make stack randomization effective in the calling
+ * scope.
+ */
+#define syscall_enter_from_user_mode_randomize_stack(regs, syscall)	\
+({									\
+	enter_from_user_mode_randomize_stack(regs);			\
+									\
+	instrumentation_begin();					\
+	local_irq_enable();						\

_______________________________________________
linux-snps-arc mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-snps-arc

Randomizing the syscall stack can only happen after state is established via enter_from_user_mode() or syscall_enter_from_user_mode(). The earlier it happens the better.

Provide two new macros to consolidate that:

- enter_from_user_mode_randomize_stack()

	enter_from_user_mode();
	add_random_kstack_offset_irqsoff();

- syscall_enter_from_user_mode_randomize_stack()

	enter_from_user_mode_randomize_stack();
	syscall_enter_from_user_mode_work();

to reduce boiler plate code.

Those are macros and not inline functions as the latter would limit the stack randomization scope to the inline function itself.

Can anyone *please* find out what the actual security requirements are for the syscall randomization offset?

The original checkin, 39218ff4c625 ("stack: Optionally randomize kernel stack offset each syscall") indicates that it is fundamental that the stack offset is applied *after* pt_regs pushing, but that isn't documented anywhere in the kernel sources as far as I can tell.

However, I have also come to understand that there are further, undocumented constraints; at least at one point I was told that "the offset should not be stored in memory while running in the kernel", which seems more than a bit odd.

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Huacai Chen <[email protected]>

Cc [email protected]

---
 arch/loongarch/kernel/syscall.c |    5 +----

 1 file changed, 1 insertion(+), 4 deletions(-)

arch/loongarch/kernel/syscall.c +0 -1

@@ -11,7 +11,6 @@
  #include <linux/linkage.h>
  #include <linux/nospec.h>
  #include <linux/objtool.h>
-#include <linux/randomize_kstack.h>
  #include <linux/syscalls.h>
  #include <linux/unistd.h>

arch/loongarch/kernel/syscall.c +0 -0

@@ -70,9 +69,7 @@ void noinstr __no_stack_protector do_sys
  	regs->orig_a0 = regs->regs[4];
  	regs->regs[4] = -ENOSYS;

arch/loongarch/kernel/syscall.c +1 -3

-	nr = syscall_enter_from_user_mode(regs, nr);
-
-	add_random_kstack_offset();
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);

  if (nr < NR_syscalls) {
  syscall_fn = sys_call_table[array_index_nospec(nr, NR_syscalls)];

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Huacai Chen <[email protected]>

Cc [email protected]

---
 arch/loongarch/kernel/syscall.c |    5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

arch/loongarch/kernel/syscall.c +0 -1

@@ -11,7 +11,6 @@
 #include <linux/linkage.h>
 #include <linux/nospec.h>
 #include <linux/objtool.h>
-#include <linux/randomize_kstack.h>
 #include <linux/syscalls.h>
 #include <linux/unistd.h>
 

arch/loongarch/kernel/syscall.c +0 -0

 	if (nr < NR_syscalls) {
 		syscall_fn = sys_call_table[array_index_nospec(nr, NR_syscalls)];
 

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Huacai Chen <[email protected]>

Cc [email protected]

---
  arch/loongarch/kernel/syscall.c |    5 +----
  1 file changed, 1 insertion(+), 4 deletions(-)

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Huacai Chen <[email protected]>

Cc [email protected]

---
 arch/loongarch/kernel/syscall.c |    5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

arch/loongarch/kernel/syscall.c +0 -1

@@ -11,7 +11,6 @@
 #include <linux/linkage.h>
 #include <linux/nospec.h>
 #include <linux/objtool.h>
-#include <linux/randomize_kstack.h>
 #include <linux/syscalls.h>
 #include <linux/unistd.h>
 

_______________________________________________
linux-snps-arc mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-snps-arc

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Michael Ellerman <[email protected]>

Cc Shrikanth Hegde <[email protected]>

Cc [email protected]

---
 arch/powerpc/kernel/syscall.c |    4 +---

 1 file changed, 1 insertion(+), 3 deletions(-)

arch/powerpc/kernel/syscall.c +0 -0

@@ -2,7 +2,6 @@

 #include <linux/compat.h>
 #include <linux/context_tracking.h>
-#include <linux/randomize_kstack.h>
 #include <linux/entry-common.h>

 #include <asm/interrupt.h>

arch/powerpc/kernel/syscall.c +0 -0

@@ -19,8 +18,7 @@ notrace long system_call_exception(struc
  	long ret;
  	syscall_fn f;

arch/powerpc/kernel/syscall.c +1 -2

-	r0 = syscall_enter_from_user_mode(regs, r0);
-	add_random_kstack_offset();
+	r0 = syscall_enter_from_user_mode_randomize_stack(regs, r0);

  if (unlikely(r0 >= NR_syscalls)) {
  if (unlikely(trap_is_unsupported_scv(regs))) {

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Michael Ellerman <[email protected]>

Cc Shrikanth Hegde <[email protected]>

Cc [email protected]

---
 arch/powerpc/kernel/syscall.c |    4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

arch/powerpc/kernel/syscall.c +0 -1

@@ -2,7 +2,6 @@
 
 #include <linux/compat.h>
 #include <linux/context_tracking.h>
-#include <linux/randomize_kstack.h>
 #include <linux/entry-common.h>
 
 #include <asm/interrupt.h>

arch/powerpc/kernel/syscall.c +0 -0

 	if (unlikely(r0 >= NR_syscalls)) {
 		if (unlikely(trap_is_unsupported_scv(regs))) {
 

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Michael Ellerman <[email protected]>

Cc Shrikanth Hegde <[email protected]>

Cc [email protected]

---
  arch/powerpc/kernel/syscall.c |    4 +---
  1 file changed, 1 insertion(+), 3 deletions(-)

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Michael Ellerman <[email protected]>

Cc Shrikanth Hegde <[email protected]>

Cc [email protected]

---
 arch/powerpc/kernel/syscall.c |    4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

arch/powerpc/kernel/syscall.c +0 -1

@@ -2,7 +2,6 @@
 
 #include <linux/compat.h>
 #include <linux/context_tracking.h>
-#include <linux/randomize_kstack.h>
 #include <linux/entry-common.h>
 
 #include <asm/interrupt.h>

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Paul Walmsley <[email protected]>

Cc Palmer Dabbelt <[email protected]>

Cc [email protected]

---
 arch/riscv/kernel/traps.c |    5 +----

 1 file changed, 1 insertion(+), 4 deletions(-)

arch/riscv/kernel/traps.c +0 -1

@@ -7,7 +7,6 @@
  #include <linux/kernel.h>
  #include <linux/init.h>
  #include <linux/irqflags.h>
-#include <linux/randomize_kstack.h>
  #include <linux/sched.h>
  #include <linux/sched/debug.h>
  #include <linux/sched/signal.h>

@@ -333,9 +332,7 @@ void do_trap_ecall_u(struct pt_regs *reg

  riscv_v_vstate_discard(regs);

arch/riscv/kernel/traps.c +1 -3

-		syscall = syscall_enter_from_user_mode(regs, syscall);
-
-		add_random_kstack_offset();
+		syscall = syscall_enter_from_user_mode_randomize_stack(regs, syscall);

  if (syscall >= 0 && syscall < NR_syscalls) { syscall = array_index_nospec(syscall, NR_syscalls);

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Paul Walmsley <[email protected]>

Cc Palmer Dabbelt <[email protected]>

Cc [email protected]

---
 arch/riscv/kernel/traps.c |    5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

arch/riscv/kernel/traps.c +0 -1

@@ -7,7 +7,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/irqflags.h>
-#include <linux/randomize_kstack.h>
 #include <linux/sched.h>
 #include <linux/sched/debug.h>
 #include <linux/sched/signal.h>

arch/riscv/kernel/traps.c +0 -0

 		if (syscall >= 0 && syscall < NR_syscalls) {
 			syscall = array_index_nospec(syscall, NR_syscalls);
 

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Paul Walmsley <[email protected]>

Cc Palmer Dabbelt <[email protected]>

Cc [email protected]

---
  arch/riscv/kernel/traps.c |    5 +----
  1 file changed, 1 insertion(+), 4 deletions(-)

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Paul Walmsley <[email protected]>

Cc Palmer Dabbelt <[email protected]>

Cc [email protected]

---
 arch/riscv/kernel/traps.c |    5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

arch/riscv/kernel/traps.c +0 -1

@@ -7,7 +7,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/irqflags.h>
-#include <linux/randomize_kstack.h>
 #include <linux/sched.h>
 #include <linux/sched/debug.h>
 #include <linux/sched/signal.h>

syscall_enter_from_user_mode_randomize_stack() replaces syscall_enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset().

The advantage is that it applies the stack randomization right after enter_from_user_mode() and thereby avoids the overhead of get/put_cpu_var() as that code is invoked with interrupts disabled.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Paul Walmsley <[email protected]>

Cc Palmer Dabbelt <[email protected]>

Cc [email protected]

---
 arch/riscv/kernel/traps.c |    5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

arch/riscv/kernel/traps.c +0 -1

@@ -7,7 +7,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/irqflags.h>
-#include <linux/randomize_kstack.h>
 #include <linux/sched.h>
 #include <linux/sched/debug.h>
 #include <linux/sched/signal.h>

enter_from_user_mode_randomize_stack() replaces enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset_irqsoff().

As a bonus this avoids the overhead of get/put_cpu_var() in add_random_kstack_offset().

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Sven Schnelle <[email protected]>

Cc [email protected]

---
 arch/s390/kernel/syscall.c |    4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

enter_from_user_mode_randomize_stack() replaces enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset_irqsoff().

As a bonus this avoids the overhead of get/put_cpu_var() in add_random_kstack_offset().

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Sven Schnelle <[email protected]>

Cc [email protected]

---
 arch/s390/kernel/syscall.c |    4 ++--

 1 file changed, 2 insertions(+), 2 deletions(-)

arch/s390/kernel/syscall.c +0 -0

@@ -97,8 +97,8 @@ void noinstr __do_syscall(struct pt_regs
  {
  	unsigned long nr;

arch/s390/kernel/syscall.c +2 -2

-	enter_from_user_mode(regs);
-	add_random_kstack_offset();
+	enter_from_user_mode_randomize_stack(regs);
+

  regs->psw = get_lowcore()->svc_old_psw; regs->int_code = get_lowcore()->svc_int_code; update_timer_sys();

enter_from_user_mode_randomize_stack() replaces enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset_irqsoff().

As a bonus this avoids the overhead of get/put_cpu_var() in add_random_kstack_offset().

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Sven Schnelle <[email protected]>

Cc [email protected]

---
 arch/s390/kernel/syscall.c |    4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

arch/s390/kernel/syscall.c +1 -0

+
 	regs->psw = get_lowcore()->svc_old_psw;
 	regs->int_code = get_lowcore()->svc_int_code;
 	update_timer_sys();

enter_from_user_mode_randomize_stack() replaces enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset_irqsoff().

As a bonus this avoids the overhead of get/put_cpu_var() in add_random_kstack_offset().

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Sven Schnelle <[email protected]>

Cc [email protected]

---
 arch/s390/kernel/syscall.c |    4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

arch/s390/kernel/syscall.c +1 -0

+
 	regs->psw = get_lowcore()->svc_old_psw;
 	regs->int_code = get_lowcore()->svc_int_code;
 	update_timer_sys();

Quoted 21 lines · Thomas Gleixner

enter_from_user_mode_randomize_stack() replaces enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset_irqsoff().

As a bonus this avoids the overhead of get/put_cpu_var() in add_random_kstack_offset().

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Sven Schnelle <[email protected]>

Cc [email protected]

---
  arch/s390/kernel/syscall.c |    4 ++--
  1 file changed, 2 insertions(+), 2 deletions(-)

arch/s390/kernel/syscall.c +0 -0

@@ -97,8 +97,8 @@ void noinstr __do_syscall(struct pt_regs
  {
  	unsigned long nr;
 

arch/s390/kernel/syscall.c void noinstr __do_syscall(struct pt_regs · line 100

Quoted 3 lines

arch/s390/kernel/syscall.c +1 -2

-	enter_from_user_mode(regs);
-	add_random_kstack_offset();
+	enter_from_user_mode_randomize_stack(regs);

The #include <linux/randomize_kstack.h> can be removed.

enter_from_user_mode_randomize_stack() replaces enter_from_user_mode() and the subsequent invocation of add_random_kstack_offset_irqsoff().

As a bonus this avoids the overhead of get/put_cpu_var() in add_random_kstack_offset().

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc Sven Schnelle <[email protected]>

Cc [email protected]

---
 arch/s390/kernel/syscall.c |    4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

These functions integrate the stack randomization.

syscall_enter_from_user_mode_randomize_stack() has the advantage that the randomization happens early right after enter_from_user_mode().

In both cases also the overhead of get/put_cpu_var() in add_random_kstack_offset() is avoided.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc [email protected]

---
 arch/x86/entry/syscall_32.c         |   19 +++++-------------- arch/x86/entry/syscall_64.c         |    3 +-- arch/x86/include/asm/entry-common.h |    1 -

 3 files changed, 6 insertions(+), 17 deletions(-)

arch/x86/entry/syscall_32.c +1 -1

@@ -142,10 +142,9 @@ static __always_inline bool int80_is_ext
  	 * int80_is_external() below which calls into the APIC driver.
  	 * Identical for soft and external interrupts.
  	 */
-	enter_from_user_mode(regs);
+	enter_from_user_mode_randomize_stack(regs);

  instrumentation_begin();

arch/x86/entry/syscall_32.c +0 -1

-	add_random_kstack_offset();

  /* Validate that this is a soft interrupt to the extent possible */ if (unlikely(int80_is_external()))

arch/x86/entry/syscall_32.c +0 -0

@@ -210,11 +209,9 @@ DEFINE_FREDENTRY_RAW(int80_emulation)
  {
  	int nr;

arch/x86/entry/syscall_32.c +1 -1

-	enter_from_user_mode(regs);
+	enter_from_user_mode_randomize_stack(regs);

  instrumentation_begin();

arch/x86/entry/syscall_32.c +0 -2

-	add_random_kstack_offset();
-

  /*
  * FRED pushed 0 into regs::orig_ax and regs::ax contains the
  * syscall number.

arch/x86/entry/syscall_32.c +2 -1

@@ -252,10 +249,10 @@ DEFINE_FREDENTRY_RAW(int80_emulation)
  	 * orig_ax, the int return value truncates it. This matches
  	 * the semantics of syscall_get_nr().
  	 */
-	nr = syscall_enter_from_user_mode(regs, nr);
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);
+
  	instrumentation_begin();

arch/x86/entry/syscall_32.c +0 -1

-	add_random_kstack_offset();

  do_syscall_32_irqs_on(regs, nr);

  instrumentation_end();

arch/x86/entry/syscall_32.c +0 -0

@@ -268,15 +265,9 @@ static noinstr bool __do_fast_syscall_32
  	int nr = syscall_32_enter(regs);
  	int res;

arch/x86/entry/syscall_32.c +1 -6

-	/*
-	 * This cannot use syscall_enter_from_user_mode() as it has to
-	 * fetch EBP before invoking any of the syscall entry work
-	 * functions.
-	 */
-	enter_from_user_mode(regs);
+	enter_from_user_mode_randomize_stack(regs);

  instrumentation_begin();

arch/x86/entry/syscall_32.c +0 -1

-	add_random_kstack_offset();

  local_irq_enable();
  /* Fetch EBP from where the vDSO stashed it. */ if (IS_ENABLED(CONFIG_X86_64)) {

arch/x86/entry/syscall_64.c +1 -1

@@ -86,10 +86,9 @@ static __always_inline bool do_syscall_x
  /* Returns true to return using SYSRET, or false to use IRET */
  __visible noinstr bool do_syscall_64(struct pt_regs *regs, int nr)
  {
-	nr = syscall_enter_from_user_mode(regs, nr);
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);

  instrumentation_begin();

arch/x86/entry/syscall_64.c +0 -1

-	add_random_kstack_offset();

  if (!do_syscall_x64(regs, nr) && !do_syscall_x32(regs, nr) && nr != -1) { /* Invalid system call, but still a system call. */

arch/x86/include/asm/entry-common.h +0 -0

@@ -2,7 +2,6 @@
  #ifndef _ASM_X86_ENTRY_COMMON_H
  #define _ASM_X86_ENTRY_COMMON_H

-#include <linux/randomize_kstack.h>
 #include <linux/user-return-notifier.h>

 #include <asm/nospec-branch.h>

These functions integrate the stack randomization.

syscall_enter_from_user_mode_randomize_stack() has the advantage that the randomization happens early right after enter_from_user_mode().

In both cases also the overhead of get/put_cpu_var() in add_random_kstack_offset() is avoided.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc [email protected]

---
 arch/x86/entry/syscall_32.c         |   19 +++++--------------
 arch/x86/entry/syscall_64.c         |    3 +--
 arch/x86/include/asm/entry-common.h |    1 -
 3 files changed, 6 insertions(+), 17 deletions(-)

arch/x86/entry/syscall_32.c +5 -14

@@ -142,10 +142,9 @@ static __always_inline bool int80_is_ext
 	 * int80_is_external() below which calls into the APIC driver.
 	 * Identical for soft and external interrupts.
 	 */
-	enter_from_user_mode(regs);
+	enter_from_user_mode_randomize_stack(regs);
 
 	instrumentation_begin();
-	add_random_kstack_offset();
 
 	/* Validate that this is a soft interrupt to the extent possible */
 	if (unlikely(int80_is_external()))

@@ -210,11 +209,9 @@ DEFINE_FREDENTRY_RAW(int80_emulation)
 {
 	int nr;
 
-	enter_from_user_mode(regs);
+	enter_from_user_mode_randomize_stack(regs);
 
 	instrumentation_begin();
-	add_random_kstack_offset();
-
 	/*
 	 * FRED pushed 0 into regs::orig_ax and regs::ax contains the
 	 * syscall number.

@@ -252,10 +249,10 @@ DEFINE_FREDENTRY_RAW(int80_emulation)
 	 * orig_ax, the int return value truncates it. This matches
 	 * the semantics of syscall_get_nr().
 	 */
-	nr = syscall_enter_from_user_mode(regs, nr);
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);
+
 	instrumentation_begin();
 
-	add_random_kstack_offset();
 	do_syscall_32_irqs_on(regs, nr);
 
 	instrumentation_end();

@@ -268,15 +265,9 @@ static noinstr bool __do_fast_syscall_32
 	int nr = syscall_32_enter(regs);
 	int res;
 
-	/*
-	 * This cannot use syscall_enter_from_user_mode() as it has to
-	 * fetch EBP before invoking any of the syscall entry work
-	 * functions.
-	 */
-	enter_from_user_mode(regs);
+	enter_from_user_mode_randomize_stack(regs);
 
 	instrumentation_begin();
-	add_random_kstack_offset();
 	local_irq_enable();
 	/* Fetch EBP from where the vDSO stashed it. */
 	if (IS_ENABLED(CONFIG_X86_64)) {

arch/x86/entry/syscall_64.c +1 -2

@@ -86,10 +86,9 @@ static __always_inline bool do_syscall_x
 /* Returns true to return using SYSRET, or false to use IRET */
 __visible noinstr bool do_syscall_64(struct pt_regs *regs, int nr)
 {
-	nr = syscall_enter_from_user_mode(regs, nr);
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);
 
 	instrumentation_begin();
-	add_random_kstack_offset();
 
 	if (!do_syscall_x64(regs, nr) && !do_syscall_x32(regs, nr) && nr != -1) {
 		/* Invalid system call, but still a system call. */

arch/x86/include/asm/entry-common.h +0 -1

@@ -2,7 +2,6 @@
 #ifndef _ASM_X86_ENTRY_COMMON_H
 #define _ASM_X86_ENTRY_COMMON_H
 
-#include <linux/randomize_kstack.h>
 #include <linux/user-return-notifier.h>
 
 #include <asm/nospec-branch.h>

These functions integrate the stack randomization.

syscall_enter_from_user_mode_randomize_stack() has the advantage that the randomization happens early right after enter_from_user_mode().

In both cases also the overhead of get/put_cpu_var() in add_random_kstack_offset() is avoided.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc [email protected]

---
  arch/x86/entry/syscall_32.c         |   19 +++++--------------
  arch/x86/entry/syscall_64.c         |    3 +--
  arch/x86/include/asm/entry-common.h |    1 -
  3 files changed, 6 insertions(+), 17 deletions(-)

These functions integrate the stack randomization.

syscall_enter_from_user_mode_randomize_stack() has the advantage that the randomization happens early right after enter_from_user_mode().

In both cases also the overhead of get/put_cpu_var() in add_random_kstack_offset() is avoided.

No functional change.

Signed-off-by Thomas Gleixner <[email protected]>

Cc [email protected]

---
 arch/x86/entry/syscall_32.c         |   19 +++++--------------
 arch/x86/entry/syscall_64.c         |    3 +--
 arch/x86/include/asm/entry-common.h |    1 -
 3 files changed, 6 insertions(+), 17 deletions(-)

arch/x86/entry/syscall_32.c +5 -14

@@ -142,10 +142,9 @@ static __always_inline bool int80_is_ext
 	 * int80_is_external() below which calls into the APIC driver.
 	 * Identical for soft and external interrupts.
 	 */
-	enter_from_user_mode(regs);
+	enter_from_user_mode_randomize_stack(regs);
 
 	instrumentation_begin();
-	add_random_kstack_offset();
 
 	/* Validate that this is a soft interrupt to the extent possible */
 	if (unlikely(int80_is_external()))

@@ -210,11 +209,9 @@ DEFINE_FREDENTRY_RAW(int80_emulation)
 {
 	int nr;
 
-	enter_from_user_mode(regs);
+	enter_from_user_mode_randomize_stack(regs);
 
 	instrumentation_begin();
-	add_random_kstack_offset();
-
 	/*
 	 * FRED pushed 0 into regs::orig_ax and regs::ax contains the
 	 * syscall number.

@@ -252,10 +249,10 @@ DEFINE_FREDENTRY_RAW(int80_emulation)
 	 * orig_ax, the int return value truncates it. This matches
 	 * the semantics of syscall_get_nr().
 	 */
-	nr = syscall_enter_from_user_mode(regs, nr);
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);
+
 	instrumentation_begin();
 
-	add_random_kstack_offset();
 	do_syscall_32_irqs_on(regs, nr);
 
 	instrumentation_end();

@@ -268,15 +265,9 @@ static noinstr bool __do_fast_syscall_32
 	int nr = syscall_32_enter(regs);
 	int res;
 
-	/*
-	 * This cannot use syscall_enter_from_user_mode() as it has to
-	 * fetch EBP before invoking any of the syscall entry work
-	 * functions.
-	 */
-	enter_from_user_mode(regs);
+	enter_from_user_mode_randomize_stack(regs);
 
 	instrumentation_begin();
-	add_random_kstack_offset();
 	local_irq_enable();
 	/* Fetch EBP from where the vDSO stashed it. */
 	if (IS_ENABLED(CONFIG_X86_64)) {

arch/x86/entry/syscall_64.c +1 -2

@@ -86,10 +86,9 @@ static __always_inline bool do_syscall_x
 /* Returns true to return using SYSRET, or false to use IRET */
 __visible noinstr bool do_syscall_64(struct pt_regs *regs, int nr)
 {
-	nr = syscall_enter_from_user_mode(regs, nr);
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);
 
 	instrumentation_begin();
-	add_random_kstack_offset();
 
 	if (!do_syscall_x64(regs, nr) && !do_syscall_x32(regs, nr) && nr != -1) {
 		/* Invalid system call, but still a system call. */

All architecture use either:

    nr = enter_from_user_mode_randomize_stack(regs, nr);

or

    enter_from_user_mode_randomize_stack(regs); nr = syscall_enter_from_user_mode_work(regs, nr);

Remove the now unused function.

Signed-off-by Thomas Gleixner <[email protected]>

---
 Documentation/core-api/entry.rst |   17 +++++++++------- include/linux/entry-common.h     |   40 +++------------------------------------ include/linux/irq-entry-common.h |    6 ++---

 3 files changed, 17 insertions(+), 46 deletions(-)

Documentation/core-api/entry.rst +1 -1

@@ -68,7 +68,7 @@ low-level C code must not be instrumente
    noinstr void syscall(struct pt_regs *regs, int nr)
    {
  	arch_syscall_enter(regs);
-	nr = syscall_enter_from_user_mode(regs, nr);
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);

  instrumentation_begin();
  if (!invoke_syscall(regs, nr) && nr != -1)

Documentation/core-api/entry.rst +0 -0

@@ -78,12 +78,14 @@ low-level C code must not be instrumente
  	syscall_exit_to_user_mode(regs);
    }

Documentation/core-api/entry.rst +3 -2

-syscall_enter_from_user_mode() first invokes enter_from_user_mode() which
-establishes state in the following order:
+syscall_enter_from_user_mode_randomize_stack() first invokes
+enter_from_user_mode_randomize_stack() which establishes state in the
+following order:

   * Lockdep
   * RCU / Context tracking
   * Tracing
+  * Apply stack randomization

 and then invokes the various entry work functions like ptrace, seccomp, audit, syscall tracing, etc. After all that is done, the instrumentable invoke_syscall

Documentation/core-api/entry.rst +0 -0

@@ -99,10 +101,11 @@ that it invokes exit_to_user_mode() whic
    * RCU / Context tracking
    * Lockdep

Documentation/core-api/entry.rst +5 -4

-syscall_enter_from_user_mode() and syscall_exit_to_user_mode() are also
-available as fine grained subfunctions in cases where the architecture code
-has to do extra work between the various steps. In such cases it has to
-ensure that enter_from_user_mode() is called first on entry and
+syscall_enter_from_user_mode_randomize_stack() and
+syscall_exit_to_user_mode() are also available as fine grained subfunctions
+in cases where the architecture code has to do extra work between the
+various steps. In such cases it has to ensure that
+enter_from_user_mode_randomize_stack() is called first on entry and

 exit_to_user_mode() is called last on exit.

 Do not nest syscalls. Nested syscalls will cause RCU and/or context tracking

include/linux/entry-common.h +0 -0

@@ -19,7 +19,7 @@
  #endif

 /*
- * SYSCALL_WORK flags handled in syscall_enter_from_user_mode()
+ * SYSCALL_WORK flags handled in syscall_enter_from_user_mode_work() */
 #define SYSCALL_WORK_ENTER (SYSCALL_WORK_SECCOMP | \
  SYSCALL_WORK_SYSCALL_TRACEPOINT | \

include/linux/entry-common.h +0 -0

@@ -205,42 +205,10 @@ do {									\
  	_ret;								\
  })

include/linux/entry-common.h +0 -32

-/**
- * syscall_enter_from_user_mode - Establish state and check and handle work
- *				  before invoking a syscall
- * @regs:	Pointer to currents pt_regs
- * @syscall:	The syscall number
- *
- * Invoked from architecture specific syscall entry code with interrupts
- * disabled. The calling code has to be non-instrumentable. When the
- * function returns all state is correct, interrupts are enabled and the
- * subsequent functions can be instrumented.
- *
- * This is the combination of enter_from_user_mode() and
- * syscall_enter_from_user_mode_work() to be used when there is no
- * architecture specific work to be done between the two.
- *
- * Returns: The original or a modified syscall number. See
- * syscall_enter_from_user_mode_work() for further explanation.
- */
-static __always_inline long syscall_enter_from_user_mode(struct pt_regs *regs, long syscall)
-{
-	long ret;
-
-	enter_from_user_mode(regs);
-
-	instrumentation_begin();
-	local_irq_enable();
-	ret = syscall_enter_from_user_mode_work(regs, syscall);
-	instrumentation_end();
-
-	return ret;
-}
-

 /*
- * If SYSCALL_EMU is set, then the only reason to report is when
- * SINGLESTEP is set (i.e. PTRACE_SYSEMU_SINGLESTEP).  This syscall
- * instruction has been already reported in syscall_enter_from_user_mode().
+ * If SYSCALL_EMU is set, then the only reason to report is when SINGLESTEP is
+ * set (i.e. PTRACE_SYSEMU_SINGLESTEP).  This syscall instruction has been
+ * already reported in syscall_enter_from_user_mode_work().
  */
 static __always_inline bool report_single_step(unsigned long work) {

include/linux/irq-entry-common.h +2 -0

+ * non-instrumentable section. Use __always_inline so the compiler cannot push
+ * it out of line and make it instrumentable.
   */
  static __always_inline void arch_enter_from_user_mode(struct pt_regs *regs);

Quoted 3 lines · Thomas Gleixner

All architecture use either:

    nr = enter_from_user_mode_randomize_stack(regs, nr);

You probably mean syscall_enter_from_user_mode_randomize_stack.

include/linux/irq-entry-common.h line 52

Quoted 12 lines

 static __always_inline bool report_single_step(unsigned long work) {

include/linux/irq-entry-common.h +1 -3

@@ -49,9 +49,9 @@
   * Defaults to an empty implementation. Can be replaced by architecture
   * specific code.
   *
- * Invoked from syscall_enter_from_user_mode() in the non-instrumentable
- * section. Use __always_inline so the compiler cannot push it out of line
- * and make it instrumentable.
+ * Invoked from enter_from_user_mode_syscall_and_randomize_stack() in the

                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Probably syscall_enter_from_user_mode_randomize_stack()? But the reality is it's only ever invoked from enter_from_user_mode(), which is below in the same file (include/linux/irq-entry-common.h).

All architecture use either:

    nr = enter_from_user_mode_randomize_stack(regs, nr);

or

    enter_from_user_mode_randomize_stack(regs);
    nr = syscall_enter_from_user_mode_work(regs, nr);

Remove the now unused function.

Signed-off-by Thomas Gleixner <[email protected]>

---
 Documentation/core-api/entry.rst |   17 +++++++++-------
 include/linux/entry-common.h     |   40 +++------------------------------------
 include/linux/irq-entry-common.h |    6 ++---
 3 files changed, 17 insertions(+), 46 deletions(-)

Documentation/core-api/entry.rst +10 -7

@@ -68,7 +68,7 @@ low-level C code must not be instrumente
   noinstr void syscall(struct pt_regs *regs, int nr)
   {
 	arch_syscall_enter(regs);
-	nr = syscall_enter_from_user_mode(regs, nr);
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);
 
 	instrumentation_begin();
 	if (!invoke_syscall(regs, nr) && nr != -1)

@@ -78,12 +78,14 @@ low-level C code must not be instrumente
 	syscall_exit_to_user_mode(regs);
   }
 
-syscall_enter_from_user_mode() first invokes enter_from_user_mode() which
-establishes state in the following order:
+syscall_enter_from_user_mode_randomize_stack() first invokes
+enter_from_user_mode_randomize_stack() which establishes state in the
+following order:
 
   * Lockdep
   * RCU / Context tracking
   * Tracing
+  * Apply stack randomization
 
 and then invokes the various entry work functions like ptrace, seccomp, audit,
 syscall tracing, etc. After all that is done, the instrumentable invoke_syscall

@@ -99,10 +101,11 @@ that it invokes exit_to_user_mode() whic
   * RCU / Context tracking
   * Lockdep
 
-syscall_enter_from_user_mode() and syscall_exit_to_user_mode() are also
-available as fine grained subfunctions in cases where the architecture code
-has to do extra work between the various steps. In such cases it has to
-ensure that enter_from_user_mode() is called first on entry and
+syscall_enter_from_user_mode_randomize_stack() and
+syscall_exit_to_user_mode() are also available as fine grained subfunctions
+in cases where the architecture code has to do extra work between the
+various steps. In such cases it has to ensure that
+enter_from_user_mode_randomize_stack() is called first on entry and
 exit_to_user_mode() is called last on exit.
 
 Do not nest syscalls. Nested syscalls will cause RCU and/or context tracking

include/linux/entry-common.h +4 -36

@@ -19,7 +19,7 @@
 #endif
 
 /*
- * SYSCALL_WORK flags handled in syscall_enter_from_user_mode()
+ * SYSCALL_WORK flags handled in syscall_enter_from_user_mode_work()
  */
 #define SYSCALL_WORK_ENTER	(SYSCALL_WORK_SECCOMP |			\
 				 SYSCALL_WORK_SYSCALL_TRACEPOINT |	\

@@ -205,42 +205,10 @@ do {									\
 	_ret;								\
 })
 
-/**
- * syscall_enter_from_user_mode - Establish state and check and handle work
- *				  before invoking a syscall
- * @regs:	Pointer to currents pt_regs
- * @syscall:	The syscall number
- *
- * Invoked from architecture specific syscall entry code with interrupts
- * disabled. The calling code has to be non-instrumentable. When the
- * function returns all state is correct, interrupts are enabled and the
- * subsequent functions can be instrumented.
- *
- * This is the combination of enter_from_user_mode() and
- * syscall_enter_from_user_mode_work() to be used when there is no
- * architecture specific work to be done between the two.
- *
- * Returns: The original or a modified syscall number. See
- * syscall_enter_from_user_mode_work() for further explanation.
- */
-static __always_inline long syscall_enter_from_user_mode(struct pt_regs *regs, long syscall)
-{
-	long ret;
-
-	enter_from_user_mode(regs);
-
-	instrumentation_begin();
-	local_irq_enable();
-	ret = syscall_enter_from_user_mode_work(regs, syscall);
-	instrumentation_end();
-
-	return ret;
-}
-
 /*
- * If SYSCALL_EMU is set, then the only reason to report is when
- * SINGLESTEP is set (i.e. PTRACE_SYSEMU_SINGLESTEP).  This syscall
- * instruction has been already reported in syscall_enter_from_user_mode().
+ * If SYSCALL_EMU is set, then the only reason to report is when SINGLESTEP is
+ * set (i.e. PTRACE_SYSEMU_SINGLESTEP).  This syscall instruction has been
+ * already reported in syscall_enter_from_user_mode_work().
  */
 static __always_inline bool report_single_step(unsigned long work)
 {

include/linux/irq-entry-common.h +0 -0

  */
 static __always_inline void arch_enter_from_user_mode(struct pt_regs *regs);
 

All architecture use either:

    nr = enter_from_user_mode_randomize_stack(regs, nr);

or

    enter_from_user_mode_randomize_stack(regs);
    nr = syscall_enter_from_user_mode_work(regs, nr);

Remove the now unused function.

Signed-off-by Thomas Gleixner <[email protected]>

---
 Documentation/core-api/entry.rst |   17 +++++++++-------
 include/linux/entry-common.h     |   40 +++------------------------------------
 include/linux/irq-entry-common.h |    6 ++---
 3 files changed, 17 insertions(+), 46 deletions(-)

Documentation/core-api/entry.rst +10 -7

@@ -68,7 +68,7 @@ low-level C code must not be instrumente
   noinstr void syscall(struct pt_regs *regs, int nr)
   {
 	arch_syscall_enter(regs);
-	nr = syscall_enter_from_user_mode(regs, nr);
+	nr = syscall_enter_from_user_mode_randomize_stack(regs, nr);
 
 	instrumentation_begin();
 	if (!invoke_syscall(regs, nr) && nr != -1)

@@ -78,12 +78,14 @@ low-level C code must not be instrumente
 	syscall_exit_to_user_mode(regs);
   }
 
-syscall_enter_from_user_mode() first invokes enter_from_user_mode() which
-establishes state in the following order:
+syscall_enter_from_user_mode_randomize_stack() first invokes
+enter_from_user_mode_randomize_stack() which establishes state in the
+following order:
 
   * Lockdep
   * RCU / Context tracking
   * Tracing
+  * Apply stack randomization
 
 and then invokes the various entry work functions like ptrace, seccomp, audit,
 syscall tracing, etc. After all that is done, the instrumentable invoke_syscall

@@ -99,10 +101,11 @@ that it invokes exit_to_user_mode() whic
   * RCU / Context tracking
   * Lockdep
 
-syscall_enter_from_user_mode() and syscall_exit_to_user_mode() are also
-available as fine grained subfunctions in cases where the architecture code
-has to do extra work between the various steps. In such cases it has to
-ensure that enter_from_user_mode() is called first on entry and
+syscall_enter_from_user_mode_randomize_stack() and
+syscall_exit_to_user_mode() are also available as fine grained subfunctions
+in cases where the architecture code has to do extra work between the
+various steps. In such cases it has to ensure that
+enter_from_user_mode_randomize_stack() is called first on entry and
 exit_to_user_mode() is called last on exit.
 
 Do not nest syscalls. Nested syscalls will cause RCU and/or context tracking

include/linux/entry-common.h +4 -36

@@ -19,7 +19,7 @@
 #endif
 
 /*
- * SYSCALL_WORK flags handled in syscall_enter_from_user_mode()
+ * SYSCALL_WORK flags handled in syscall_enter_from_user_mode_work()
  */
 #define SYSCALL_WORK_ENTER	(SYSCALL_WORK_SECCOMP |			\
 				 SYSCALL_WORK_SYSCALL_TRACEPOINT |	\

@@ -205,42 +205,10 @@ do {									\
 	_ret;								\
 })
 
-/**
- * syscall_enter_from_user_mode - Establish state and check and handle work
- *				  before invoking a syscall
- * @regs:	Pointer to currents pt_regs
- * @syscall:	The syscall number
- *
- * Invoked from architecture specific syscall entry code with interrupts
- * disabled. The calling code has to be non-instrumentable. When the
- * function returns all state is correct, interrupts are enabled and the
- * subsequent functions can be instrumented.
- *
- * This is the combination of enter_from_user_mode() and
- * syscall_enter_from_user_mode_work() to be used when there is no
- * architecture specific work to be done between the two.
- *
- * Returns: The original or a modified syscall number. See
- * syscall_enter_from_user_mode_work() for further explanation.
- */
-static __always_inline long syscall_enter_from_user_mode(struct pt_regs *regs, long syscall)
-{
-	long ret;
-
-	enter_from_user_mode(regs);
-
-	instrumentation_begin();
-	local_irq_enable();
-	ret = syscall_enter_from_user_mode_work(regs, syscall);
-	instrumentation_end();
-
-	return ret;
-}
-
 /*
- * If SYSCALL_EMU is set, then the only reason to report is when
- * SINGLESTEP is set (i.e. PTRACE_SYSEMU_SINGLESTEP).  This syscall
- * instruction has been already reported in syscall_enter_from_user_mode().
+ * If SYSCALL_EMU is set, then the only reason to report is when SINGLESTEP is
+ * set (i.e. PTRACE_SYSEMU_SINGLESTEP).  This syscall instruction has been
+ * already reported in syscall_enter_from_user_mode_work().
  */
 static __always_inline bool report_single_step(unsigned long work)
 {

include/linux/irq-entry-common.h +0 -0

@@ -49,9 +49,9 @@
  * Defaults to an empty implementation. Can be replaced by architecture
  * specific code.