Skip to contentSkip to conversation

riscv: entry: set a0 = -ENOSYS only when syscall != -1

PATCH Applied Celeste Liu 5 participants 11 messages Aug 1, 2023 – Jun 27, 2024 RISC-V

lore
Share & tools
lore
#0 lore raw

PATCH v5 1/1 riscv: entry: set a0 = -ENOSYS only when syscall != -1

When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny NETLINK_AUDIT with EAFNOSUPPORT, after f0bddf50586d, we will get ENOSYS instead. We got same result with commit 9c2598d43510 ("riscv:
entry: Save a0 prior syscall_enter_from_user_mode()").

After analysing code, we think that regs->a0 = -ENOSYS should only be executed when syscall != -1. In __seccomp_filter, when seccomp rejected this syscall with specified errno, they will set a0 to return number as syscall ABI, and then return -1. This return number is finally pass as return number of syscall_enter_from_user_mode, and then is compared with NR_syscalls after converted to ulong (so it will be ULONG_MAX). The condition syscall < NR_syscalls will always be false, so regs->a0 = -ENOSYS is always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccomp RET_ERRNO rule.

---

v4 -> v5: add Tested-by Emil Renner Berthing <[email protected]> v3 -> v4: use long instead of ulong to reduce type cast and avoid
implementation-defined behavior, and make the judgment of syscall invalid more explicit
v2 -> v3: use if-statement instead of set default value,
clarify the type of syscall
v1 -> v2: added explanation on why always got ENOSYS

 arch/riscv/kernel/traps.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
arch/riscv/kernel/traps.c +3 -3
index f910dfccbf5d2..729f79c97e2bf 100644
@@ -297,7 +297,7 @@ asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 {
 	if (user_mode(regs)) {
-		ulong syscall = regs->a7;
+		long syscall = regs->a7;
 
 		regs->epc += 4;
 		regs->orig_a0 = regs->a0;
@@ -306,9 +306,9 @@ asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 
 		syscall = syscall_enter_from_user_mode(regs, syscall);
 
-		if (syscall < NR_syscalls)
+		if (syscall >= 0 && syscall < NR_syscalls)
 			syscall_handler(regs, syscall);
-		else
+		else if (syscall != -1)
 			regs->a0 = -ENOSYS;
 
 		syscall_exit_to_user_mode(regs);
Signature · 1 line
2.41.0
#1 lore raw
This patch was applied to riscv/linux.git (fixes) by Palmer Dabbelt <[email protected]>:

Hello:

This patch was applied to riscv/linux.git (fixes)
by Palmer Dabbelt <[email protected]>:

Quoted 15 lines · On Tue, 1 Aug 2023 22:15:16 +0800 you wrote:

When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny NETLINK_AUDIT with EAFNOSUPPORT, after f0bddf50586d, we will get ENOSYS instead. We got same result with commit 9c2598d43510 ("riscv:
entry: Save a0 prior syscall_enter_from_user_mode()").

After analysing code, we think that regs->a0 = -ENOSYS should only be executed when syscall != -1. In __seccomp_filter, when seccomp rejected this syscall with specified errno, they will set a0 to return number as syscall ABI, and then return -1. This return number is finally pass as return number of syscall_enter_from_user_mode, and then is compared with NR_syscalls after converted to ulong (so it will be ULONG_MAX). The condition syscall < NR_syscalls will always be false, so regs->a0 = -ENOSYS is always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccomp RET_ERRNO rule.

Quoted 1 line

[...]

Here is the summary with links:
- [v5] riscv: entry: set a0 = -ENOSYS only when syscall != -1

    https://git.kernel.org/riscv/c/52449c17bdd1

You are awesome, thank you!

Signature · 9 lines
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html



_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
#2 lore raw
In reply to Celeste Liu

Hi,

Quoted 54 lines · Celeste Liu

When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny NETLINK_AUDIT with EAFNOSUPPORT, after f0bddf50586d, we will get ENOSYS instead. We got same result with commit 9c2598d43510 ("riscv:
entry: Save a0 prior syscall_enter_from_user_mode()").

After analysing code, we think that regs->a0 = -ENOSYS should only be executed when syscall != -1. In __seccomp_filter, when seccomp rejected this syscall with specified errno, they will set a0 to return number as syscall ABI, and then return -1. This return number is finally pass as return number of syscall_enter_from_user_mode, and then is compared with NR_syscalls after converted to ulong (so it will be ULONG_MAX). The condition syscall < NR_syscalls will always be false, so regs->a0 = -ENOSYS is always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccomp RET_ERRNO rule.

---

v4 -> v5: add Tested-by Emil Renner Berthing <[email protected]> v3 -> v4: use long instead of ulong to reduce type cast and avoid
implementation-defined behavior, and make the judgment of syscall invalid more explicit
v2 -> v3: use if-statement instead of set default value,
clarify the type of syscall
v1 -> v2: added explanation on why always got ENOSYS

 arch/riscv/kernel/traps.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
arch/riscv/kernel/traps.c +1 -1
index f910dfccbf5d2..729f79c97e2bf 100644
@@ -297,7 +297,7 @@ asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 {
 	if (user_mode(regs)) {
-		ulong syscall = regs->a7;
+		long syscall = regs->a7;
 
 		regs->epc += 4;
 		regs->orig_a0 = regs->a0;
@@ -306,9 +306,9 @@ asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 

arch/riscv/kernel/traps.c asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs) · line 314

Quoted 10 lines
arch/riscv/kernel/traps.c +2 -2
 		syscall = syscall_enter_from_user_mode(regs, syscall);
 
-		if (syscall < NR_syscalls)
+		if (syscall >= 0 && syscall < NR_syscalls)
 			syscall_handler(regs, syscall);
-		else
+		else if (syscall != -1)
 			regs->a0 = -ENOSYS;
 
 		syscall_exit_to_user_mode(regs);

Unfortunately, this change introduced a regression: it broke strace syscall tampering on riscv. When the tracer changes syscall number to -1, the kernel fails to initialize a0 with -ENOSYS and subsequently fails to return the error code of the failed syscall to userspace.

I wish you were running strace test suite before changing this part of the kernel. Now I'm going to apply a workaround [1] in strace, but please note that riscv seems to be the only linux architecture where such a workaround is currently required.

There was a similar kernel bug once on parisc, but it was fixed [2] several years ago by commit b7dc5a071ddf.

[1] https://github.com/strace/strace/commit/c3ae2b27732952663a3600269884e363cb77a024
[2] https://git.kernel.org/torvalds/c/b7dc5a071ddf69c0350396b203cba32fe5bab510

Signature · 6 lines
ldv

_______________________________________________
linux-riscv mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-riscv
#3 lore raw
Quoted 66 lines · Dmitry V. Levin

Hi,

Quoted 63 lines · Celeste Liu

When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny NETLINK_AUDIT with EAFNOSUPPORT, after f0bddf50586d, we will get ENOSYS instead. We got same result with commit 9c2598d43510 ("riscv:
entry: Save a0 prior syscall_enter_from_user_mode()").

After analysing code, we think that regs->a0 = -ENOSYS should only be executed when syscall != -1. In __seccomp_filter, when seccomp rejected this syscall with specified errno, they will set a0 to return number as syscall ABI, and then return -1. This return number is finally pass as return number of syscall_enter_from_user_mode, and then is compared with NR_syscalls after converted to ulong (so it will be ULONG_MAX). The condition syscall < NR_syscalls will always be false, so regs->a0 = -ENOSYS is always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccomp RET_ERRNO rule.

---

v4 -> v5: add Tested-by Emil Renner Berthing <[email protected]> v3 -> v4: use long instead of ulong to reduce type cast and avoid
implementation-defined behavior, and make the judgment of syscall invalid more explicit
v2 -> v3: use if-statement instead of set default value,
clarify the type of syscall
v1 -> v2: added explanation on why always got ENOSYS

 arch/riscv/kernel/traps.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
arch/riscv/kernel/traps.c +3 -3
index f910dfccbf5d2..729f79c97e2bf 100644
@@ -297,7 +297,7 @@ asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 {
 	if (user_mode(regs)) {
-		ulong syscall = regs->a7;
+		long syscall = regs->a7;
 
 		regs->epc += 4;
 		regs->orig_a0 = regs->a0;
@@ -306,9 +306,9 @@ asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 
 		syscall = syscall_enter_from_user_mode(regs, syscall);
 
-		if (syscall < NR_syscalls)
+		if (syscall >= 0 && syscall < NR_syscalls)
 			syscall_handler(regs, syscall);
-		else
+		else if (syscall != -1)
 			regs->a0 = -ENOSYS;
 
Quoted 6 lines

arch/riscv/kernel/traps.c asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs) · line 314

Quoted 1 line
arch/riscv/kernel/traps.c +0 -0
 		syscall_exit_to_user_mode(regs);

Unfortunately, this change introduced a regression: it broke strace syscall tampering on riscv. When the tracer changes syscall number to -1, the kernel fails to initialize a0 with -ENOSYS and subsequently fails to return the error code of the failed syscall to userspace.

In the patch v2, we actually do the right thing. But as Björn Töpel's suggestion and we found cast long to ulong is implementation-defined behavior in C, so we change it to current form. So revert this patch and apply patch v2 should fix this issue. Patch v2 uses ths same way with other architectures.

[1]: https://lore.kernel.org/all/[email protected]/

Quoted 13 lines

I wish you were running strace test suite before changing this part of the kernel. Now I'm going to apply a workaround [1] in strace, but please note that riscv seems to be the only linux architecture where such a workaround is currently required.

There was a similar kernel bug once on parisc, but it was fixed [2] several years ago by commit b7dc5a071ddf.

[1] https://github.com/strace/strace/commit/c3ae2b27732952663a3600269884e363cb77a024
[2] https://git.kernel.org/torvalds/c/b7dc5a071ddf69c0350396b203cba32fe5bab510

#4 lore raw
Quoted 2 lines · Celeste Liu

suggestion and we found cast long to ulong is implementation-defined behavior in C

There is nothing implementaton-defined in a long to ulong conversion.

Signature · 3 lines
Andreas Schwab, SUSE Labs, [email protected]
GPG Key fingerprint = 0196 BAD8 1CE9 1970 F4BE  1748 E4D4 88E3 0EEA B9D7
"And now for something completely different."
#5 lore raw
Quoted 7 lines · Andreas Schwab
Quoted 2 lines · Celeste Liu

suggestion and we found cast long to ulong is implementation-defined behavior in C

There is nothing implementaton-defined in a long to ulong conversion.

Ok, I misremembered. long to ulong is modulo arithmetic but ulong to long is implementation-defined behavior. There is no type cast issue.

#6 lore raw
In reply to Celeste Liu
Quoted 76 lines · Celeste Liu
Quoted 66 lines · Dmitry V. Levin

Hi,

Quoted 63 lines · Celeste Liu

When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny NETLINK_AUDIT with EAFNOSUPPORT, after f0bddf50586d, we will get ENOSYS instead. We got same result with commit 9c2598d43510 ("riscv:
entry: Save a0 prior syscall_enter_from_user_mode()").

After analysing code, we think that regs->a0 = -ENOSYS should only be executed when syscall != -1. In __seccomp_filter, when seccomp rejected this syscall with specified errno, they will set a0 to return number as syscall ABI, and then return -1. This return number is finally pass as return number of syscall_enter_from_user_mode, and then is compared with NR_syscalls after converted to ulong (so it will be ULONG_MAX). The condition syscall < NR_syscalls will always be false, so regs->a0 = -ENOSYS is always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccomp RET_ERRNO rule.

---

v4 -> v5: add Tested-by Emil Renner Berthing <[email protected]> v3 -> v4: use long instead of ulong to reduce type cast and avoid
implementation-defined behavior, and make the judgment of syscall invalid more explicit
v2 -> v3: use if-statement instead of set default value,
clarify the type of syscall
v1 -> v2: added explanation on why always got ENOSYS

 arch/riscv/kernel/traps.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
arch/riscv/kernel/traps.c +3 -3
index f910dfccbf5d2..729f79c97e2bf 100644
@@ -297,7 +297,7 @@ asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 {
     if (user_mode(regs)) {
-            ulong syscall = regs->a7;
+            long syscall = regs->a7;
 
             regs->epc += 4;
             regs->orig_a0 = regs->a0;
@@ -306,9 +306,9 @@ asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 
             syscall = syscall_enter_from_user_mode(regs, syscall);
 
-            if (syscall < NR_syscalls)
+            if (syscall >= 0 && syscall < NR_syscalls)
                     syscall_handler(regs, syscall);
-            else
+            else if (syscall != -1)
                     regs->a0 = -ENOSYS;
 
Quoted 6 lines

arch/riscv/kernel/traps.c asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs) · line 314

Quoted 1 line
arch/riscv/kernel/traps.c +0 -0
             syscall_exit_to_user_mode(regs);

Unfortunately, this change introduced a regression: it broke strace syscall tampering on riscv. When the tracer changes syscall number to -1, the kernel fails to initialize a0 with -ENOSYS and subsequently fails to return the error code of the failed syscall to userspace.

Quoted 7 lines

In the patch v2, we actually do the right thing. But as Björn Töpel's suggestion and we found cast long to ulong is implementation-defined behavior in C, so we change it to current form. So revert this patch and apply patch v2 should fix this issue. Patch v2 uses ths same way with other architectures.

[1]: https://lore.kernel.org/all/[email protected]/

Not reverting, but a fix to make sure that a0 is initialized to -ENOSYS, e.g.:

--8<--

arch/riscv/kernel/traps.c +2 -2
index 05a16b1f0aee..51ebfd23e007 100644
@@ -319,6 +319,7 @@ void do_trap_ecall_u(struct pt_regs *regs)
 
  regs->epc += 4;
  regs->orig_a0 = regs->a0;
+ regs->a0 = -ENOSYS;
 
  riscv_v_vstate_discard(regs);
 
@@ -328,8 +329,7 @@ void do_trap_ecall_u(struct pt_regs *regs)
 
  if (syscall >= 0 && syscall < NR_syscalls)
  syscall_handler(regs, syscall);
- else if (syscall != -1)
- regs->a0 = -ENOSYS;
+
  /*
  * Ultimately, this value will get limited by KSTACK_OFFSET_MAX(),
  * so the maximum stack offset is 1k bytes (10 bits).

--8<--

Celeste, do you want to cook that fix properly?

Björn

#7 lore raw
Quoted 92 lines · Björn Töpel
Quoted 75 lines · Celeste Liu
Quoted 66 lines · Dmitry V. Levin

Hi,

Quoted 63 lines · Celeste Liu

When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny NETLINK_AUDIT with EAFNOSUPPORT, after f0bddf50586d, we will get ENOSYS instead. We got same result with commit 9c2598d43510 ("riscv:
entry: Save a0 prior syscall_enter_from_user_mode()").

After analysing code, we think that regs->a0 = -ENOSYS should only be executed when syscall != -1. In __seccomp_filter, when seccomp rejected this syscall with specified errno, they will set a0 to return number as syscall ABI, and then return -1. This return number is finally pass as return number of syscall_enter_from_user_mode, and then is compared with NR_syscalls after converted to ulong (so it will be ULONG_MAX). The condition syscall < NR_syscalls will always be false, so regs->a0 = -ENOSYS is always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccomp RET_ERRNO rule.

---

v4 -> v5: add Tested-by Emil Renner Berthing <[email protected]> v3 -> v4: use long instead of ulong to reduce type cast and avoid
implementation-defined behavior, and make the judgment of syscall invalid more explicit
v2 -> v3: use if-statement instead of set default value,
clarify the type of syscall
v1 -> v2: added explanation on why always got ENOSYS

 arch/riscv/kernel/traps.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
arch/riscv/kernel/traps.c +3 -3
index f910dfccbf5d2..729f79c97e2bf 100644
@@ -297,7 +297,7 @@ asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 {
     if (user_mode(regs)) {
-            ulong syscall = regs->a7;
+            long syscall = regs->a7;
 
             regs->epc += 4;
             regs->orig_a0 = regs->a0;
@@ -306,9 +306,9 @@ asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 
             syscall = syscall_enter_from_user_mode(regs, syscall);
 
-            if (syscall < NR_syscalls)
+            if (syscall >= 0 && syscall < NR_syscalls)
                     syscall_handler(regs, syscall);
-            else
+            else if (syscall != -1)
                     regs->a0 = -ENOSYS;
 
Quoted 6 lines

arch/riscv/kernel/traps.c asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs) · line 314

Quoted 1 line
arch/riscv/kernel/traps.c +0 -0
             syscall_exit_to_user_mode(regs);

Unfortunately, this change introduced a regression: it broke strace syscall tampering on riscv. When the tracer changes syscall number to -1, the kernel fails to initialize a0 with -ENOSYS and subsequently fails to return the error code of the failed syscall to userspace.

Quoted 7 lines

In the patch v2, we actually do the right thing. But as Björn Töpel's suggestion and we found cast long to ulong is implementation-defined behavior in C, so we change it to current form. So revert this patch and apply patch v2 should fix this issue. Patch v2 uses ths same way with other architectures.

[1]: https://lore.kernel.org/all/[email protected]/

Not reverting, but a fix to make sure that a0 is initialized to -ENOSYS, e.g.:

--8<--

arch/riscv/kernel/traps.c +0 -0
index 05a16b1f0aee..51ebfd23e007 100644

arch/riscv/kernel/traps.c void do_trap_ecall_u(struct pt_regs *regs) · line 322

Quoted 4 lines
arch/riscv/kernel/traps.c +1 -0
@@ -319,6 +319,7 @@ void do_trap_ecall_u(struct pt_regs *regs)
 
  regs->epc += 4;
  regs->orig_a0 = regs->a0;
+ regs->a0 = -ENOSYS;

Given that struct user_regs_struct doesn't have orig_a0, wouldn't this clobber a0 too early so that the tracer will get -ENOSYS in place of the first syscall argument?

Signature · 1 line
ldv
#8 lore raw
Quoted 95 lines · Dmitry V. Levin
Quoted 93 lines · Björn Töpel
Quoted 75 lines · Celeste Liu
Quoted 66 lines · Dmitry V. Levin

Hi,

Quoted 63 lines · Celeste Liu

When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny NETLINK_AUDIT with EAFNOSUPPORT, after f0bddf50586d, we will get ENOSYS instead. We got same result with commit 9c2598d43510 ("riscv:
entry: Save a0 prior syscall_enter_from_user_mode()").

After analysing code, we think that regs->a0 = -ENOSYS should only be executed when syscall != -1. In __seccomp_filter, when seccomp rejected this syscall with specified errno, they will set a0 to return number as syscall ABI, and then return -1. This return number is finally pass as return number of syscall_enter_from_user_mode, and then is compared with NR_syscalls after converted to ulong (so it will be ULONG_MAX). The condition syscall < NR_syscalls will always be false, so regs->a0 = -ENOSYS is always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccomp RET_ERRNO rule.

---

v4 -> v5: add Tested-by Emil Renner Berthing <[email protected]> v3 -> v4: use long instead of ulong to reduce type cast and avoid
implementation-defined behavior, and make the judgment of syscall invalid more explicit
v2 -> v3: use if-statement instead of set default value,
clarify the type of syscall
v1 -> v2: added explanation on why always got ENOSYS

 arch/riscv/kernel/traps.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
arch/riscv/kernel/traps.c +3 -3
index f910dfccbf5d2..729f79c97e2bf 100644
@@ -297,7 +297,7 @@ asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 {
     if (user_mode(regs)) {
-            ulong syscall = regs->a7;
+            long syscall = regs->a7;
 
             regs->epc += 4;
             regs->orig_a0 = regs->a0;
@@ -306,9 +306,9 @@ asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 
             syscall = syscall_enter_from_user_mode(regs, syscall);
 
-            if (syscall < NR_syscalls)
+            if (syscall >= 0 && syscall < NR_syscalls)
                     syscall_handler(regs, syscall);
-            else
+            else if (syscall != -1)
                     regs->a0 = -ENOSYS;
 
Quoted 6 lines

arch/riscv/kernel/traps.c asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs) · line 314

Quoted 1 line
arch/riscv/kernel/traps.c +0 -0
             syscall_exit_to_user_mode(regs);

Unfortunately, this change introduced a regression: it broke strace syscall tampering on riscv. When the tracer changes syscall number to -1, the kernel fails to initialize a0 with -ENOSYS and subsequently fails to return the error code of the failed syscall to userspace.

Quoted 7 lines

In the patch v2, we actually do the right thing. But as Björn Töpel's suggestion and we found cast long to ulong is implementation-defined behavior in C, so we change it to current form. So revert this patch and apply patch v2 should fix this issue. Patch v2 uses ths same way with other architectures.

[1]: https://lore.kernel.org/all/[email protected]/

Not reverting, but a fix to make sure that a0 is initialized to -ENOSYS, e.g.:

--8<--

arch/riscv/kernel/traps.c +0 -0
index 05a16b1f0aee..51ebfd23e007 100644
@@ -319,6 +319,7 @@ void do_trap_ecall_u(struct pt_regs *regs)
 
Quoted 7 lines

arch/riscv/kernel/traps.c void do_trap_ecall_u(struct pt_regs *regs) · line 322

Quoted 3 lines
arch/riscv/kernel/traps.c +1 -0
  regs->epc += 4;
  regs->orig_a0 = regs->a0;
+ regs->a0 = -ENOSYS;

Given that struct user_regs_struct doesn't have orig_a0, wouldn't this clobber a0 too early so that the tracer will get -ENOSYS in place of the first syscall argument?

No, that's ok. It's handled by various wrappers where the arguments are pulled out.

Björn

#9 lore raw
In reply to Björn Töpel
Quoted 83 lines · Björn Töpel
Quoted 82 lines · Celeste Liu
Quoted 66 lines · Dmitry V. Levin

Hi,

Quoted 63 lines · Celeste Liu

When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny NETLINK_AUDIT with EAFNOSUPPORT, after f0bddf50586d, we will get ENOSYS instead. We got same result with commit 9c2598d43510 ("riscv:
entry: Save a0 prior syscall_enter_from_user_mode()").

After analysing code, we think that regs->a0 = -ENOSYS should only be executed when syscall != -1. In __seccomp_filter, when seccomp rejected this syscall with specified errno, they will set a0 to return number as syscall ABI, and then return -1. This return number is finally pass as return number of syscall_enter_from_user_mode, and then is compared with NR_syscalls after converted to ulong (so it will be ULONG_MAX). The condition syscall < NR_syscalls will always be false, so regs->a0 = -ENOSYS is always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccomp RET_ERRNO rule.

---

v4 -> v5: add Tested-by Emil Renner Berthing <[email protected]> v3 -> v4: use long instead of ulong to reduce type cast and avoid
implementation-defined behavior, and make the judgment of syscall invalid more explicit
v2 -> v3: use if-statement instead of set default value,
clarify the type of syscall
v1 -> v2: added explanation on why always got ENOSYS

 arch/riscv/kernel/traps.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
arch/riscv/kernel/traps.c +3 -3
index f910dfccbf5d2..729f79c97e2bf 100644
@@ -297,7 +297,7 @@ asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 {
     if (user_mode(regs)) {
-            ulong syscall = regs->a7;
+            long syscall = regs->a7;
 
             regs->epc += 4;
             regs->orig_a0 = regs->a0;
@@ -306,9 +306,9 @@ asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 
             syscall = syscall_enter_from_user_mode(regs, syscall);
 
-            if (syscall < NR_syscalls)
+            if (syscall >= 0 && syscall < NR_syscalls)
                     syscall_handler(regs, syscall);
-            else
+            else if (syscall != -1)
                     regs->a0 = -ENOSYS;
 
Quoted 6 lines

arch/riscv/kernel/traps.c asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs) · line 314

Quoted 1 line
arch/riscv/kernel/traps.c +0 -0
             syscall_exit_to_user_mode(regs);

Unfortunately, this change introduced a regression: it broke strace syscall tampering on riscv. When the tracer changes syscall number to -1, the kernel fails to initialize a0 with -ENOSYS and subsequently fails to return the error code of the failed syscall to userspace.

In the patch v2, we actually do the right thing. But as Björn Töpel's suggestion and we found cast long to ulong is implementation-defined behavior in C, so we change it to current form. So revert this patch and apply patch v2 should fix this issue. Patch v2 uses ths same way with other architectures.

Quoted 3 lines
Quoted 1 line

[1]: https://lore.kernel.org/all/[email protected]/

Not reverting, but a fix to make sure that a0 is initialized to -ENOSYS, e.g.:

Oh. I just want to describe what change we need, not to say actual 'git revert'.

Quoted 15 lines

--8<--

arch/riscv/kernel/traps.c +1 -0
index 05a16b1f0aee..51ebfd23e007 100644
@@ -319,6 +319,7 @@ void do_trap_ecall_u(struct pt_regs *regs)
 
  regs->epc += 4;
  regs->orig_a0 = regs->a0;
+ regs->a0 = -ENOSYS;
 
  riscv_v_vstate_discard(regs);
 

arch/riscv/kernel/traps.c void do_trap_ecall_u(struct pt_regs *regs)

Quoted 10 lines
arch/riscv/kernel/traps.c +1 -3
@@ -328,8 +329,7 @@ void do_trap_ecall_u(struct pt_regs *regs)
 
  if (syscall >= 0 && syscall < NR_syscalls)
  syscall_handler(regs, syscall);
- else if (syscall != -1)
- regs->a0 = -ENOSYS;
+
  /*
  * Ultimately, this value will get limited by KSTACK_OFFSET_MAX(),
  * so the maximum stack offset is 1k bytes (10 bits).
--8<--

This is also what I think.

Quoted 1 line

Celeste, do you want to cook that fix properly?

Yeah. I will sent patch to mail list soon.

Quoted 3 lines

Björn

#10 lore raw
In reply to Björn Töpel
Quoted 112 lines · Björn Töpel
Quoted 76 lines · Celeste Liu
Quoted 66 lines · Dmitry V. Levin

Hi,

Quoted 63 lines · Celeste Liu

When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny NETLINK_AUDIT with EAFNOSUPPORT, after f0bddf50586d, we will get ENOSYS instead. We got same result with commit 9c2598d43510 ("riscv:
entry: Save a0 prior syscall_enter_from_user_mode()").

After analysing code, we think that regs->a0 = -ENOSYS should only be executed when syscall != -1. In __seccomp_filter, when seccomp rejected this syscall with specified errno, they will set a0 to return number as syscall ABI, and then return -1. This return number is finally pass as return number of syscall_enter_from_user_mode, and then is compared with NR_syscalls after converted to ulong (so it will be ULONG_MAX). The condition syscall < NR_syscalls will always be false, so regs->a0 = -ENOSYS is always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccomp RET_ERRNO rule.

---

v4 -> v5: add Tested-by Emil Renner Berthing <[email protected]> v3 -> v4: use long instead of ulong to reduce type cast and avoid
implementation-defined behavior, and make the judgment of syscall invalid more explicit
v2 -> v3: use if-statement instead of set default value,
clarify the type of syscall
v1 -> v2: added explanation on why always got ENOSYS

 arch/riscv/kernel/traps.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
arch/riscv/kernel/traps.c +3 -3
index f910dfccbf5d2..729f79c97e2bf 100644
@@ -297,7 +297,7 @@ asmlinkage __visible __trap_section void do_trap_break(struct pt_regs *regs)
 asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 {
     if (user_mode(regs)) {
-            ulong syscall = regs->a7;
+            long syscall = regs->a7;
 
             regs->epc += 4;
             regs->orig_a0 = regs->a0;
@@ -306,9 +306,9 @@ asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs)
 
             syscall = syscall_enter_from_user_mode(regs, syscall);
 
-            if (syscall < NR_syscalls)
+            if (syscall >= 0 && syscall < NR_syscalls)
                     syscall_handler(regs, syscall);
-            else
+            else if (syscall != -1)
                     regs->a0 = -ENOSYS;
 
Quoted 6 lines

arch/riscv/kernel/traps.c asmlinkage __visible __trap_section void do_trap_ecall_u(struct pt_regs *regs) · line 314

Quoted 1 line
arch/riscv/kernel/traps.c +0 -0
             syscall_exit_to_user_mode(regs);

Unfortunately, this change introduced a regression: it broke strace syscall tampering on riscv. When the tracer changes syscall number to -1, the kernel fails to initialize a0 with -ENOSYS and subsequently fails to return the error code of the failed syscall to userspace.

Quoted 7 lines

In the patch v2, we actually do the right thing. But as Björn Töpel's suggestion and we found cast long to ulong is implementation-defined behavior in C, so we change it to current form. So revert this patch and apply patch v2 should fix this issue. Patch v2 uses ths same way with other architectures.

[1]: https://lore.kernel.org/all/[email protected]/

Not reverting, but a fix to make sure that a0 is initialized to -ENOSYS, e.g.:

--8<--

arch/riscv/kernel/traps.c +2 -3
index 05a16b1f0aee..51ebfd23e007 100644
@@ -319,6 +319,7 @@ void do_trap_ecall_u(struct pt_regs *regs)
 
  regs->epc += 4;
  regs->orig_a0 = regs->a0;
+ regs->a0 = -ENOSYS;
 
  riscv_v_vstate_discard(regs);
 
@@ -328,8 +329,7 @@ void do_trap_ecall_u(struct pt_regs *regs)
 
  if (syscall >= 0 && syscall < NR_syscalls)
  syscall_handler(regs, syscall);
- else if (syscall != -1)
- regs->a0 = -ENOSYS;
+
  /*
  * Ultimately, this value will get limited by KSTACK_OFFSET_MAX(),
  * so the maximum stack offset is 1k bytes (10 bits).
--8<--
Quoted 1 line

Celeste, do you want to cook that fix properly?

Patch has been sent.

https://lore.kernel.org/all/[email protected]/

And linux-riscv mail list problably has some issue: there are two copies of patch, orginal one and another one with linux-riscv foot.

Quoted 3 lines

Björn