riscv: entry: set a0 = -ENOSYS only when syscall != -1
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
@@ -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
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_AUDITwith EAFNOSUPPORT, afterf0bddf50586d, we will get ENOSYS instead. We got same result with commit9c2598d43510("riscv:
entry: Save a0 priorsyscall_enter_from_user_mode()").After analysing code, we think that
regs->a0=-ENOSYSshould 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 ofsyscall_enter_from_user_mode, and then is compared withNR_syscallsafter converted to ulong (so it will beULONG_MAX). The condition syscall <NR_syscallswill always be false, soregs->a0=-ENOSYSis always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccompRET_ERRNOrule.
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
Hi,
Quoted 54 lines · Celeste Liu
When we test seccomp with 6.4 kernel, we found errno has wrong value. If we deny
NETLINK_AUDITwith EAFNOSUPPORT, afterf0bddf50586d, we will get ENOSYS instead. We got same result with commit9c2598d43510("riscv:
entry: Save a0 priorsyscall_enter_from_user_mode()").After analysing code, we think that
regs->a0=-ENOSYSshould 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 ofsyscall_enter_from_user_mode, and then is compared withNR_syscallsafter converted to ulong (so it will beULONG_MAX). The condition syscall <NR_syscallswill always be false, soregs->a0=-ENOSYSis always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccompRET_ERRNOrule.Fixes f0bddf50586d ("riscv: entry: Convert to generic entry")Reported-by Felix Yan <[email protected]>Co-developed-by Ruizhe Pan <[email protected]>Signed-off-by Ruizhe Pan <[email protected]>Co-developed-by Shiqi Zhang <[email protected]>Signed-off-by Shiqi Zhang <[email protected]>Signed-off-by Celeste Liu <[email protected]>Tested-by Felix Yan <[email protected]>Tested-by Emil Renner Berthing <[email protected]>Reviewed-by Björn Töpel <[email protected]>Reviewed-by Guo Ren <[email protected]>---
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 ENOSYSarch/riscv/kernel/traps.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)arch/riscv/kernel/traps.c +1
-1@@ -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
-2syscall =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
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_AUDITwith EAFNOSUPPORT, afterf0bddf50586d, we will get ENOSYS instead. We got same result with commit9c2598d43510("riscv:
entry: Save a0 priorsyscall_enter_from_user_mode()").After analysing code, we think that
regs->a0=-ENOSYSshould 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 ofsyscall_enter_from_user_mode, and then is compared withNR_syscallsafter converted to ulong (so it will beULONG_MAX). The condition syscall <NR_syscallswill always be false, soregs->a0=-ENOSYSis always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccompRET_ERRNOrule.Fixes f0bddf50586d ("riscv: entry: Convert to generic entry")Reported-by Felix Yan <[email protected]>Co-developed-by Ruizhe Pan <[email protected]>Signed-off-by Ruizhe Pan <[email protected]>Co-developed-by Shiqi Zhang <[email protected]>Signed-off-by Shiqi Zhang <[email protected]>Signed-off-by Celeste Liu <[email protected]>Tested-by Felix Yan <[email protected]>Tested-by Emil Renner Berthing <[email protected]>Reviewed-by Björn Töpel <[email protected]>Reviewed-by Guo Ren <[email protected]>---
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 ENOSYSarch/riscv/kernel/traps.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)arch/riscv/kernel/traps.c +3
-3@@ -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
-0syscall_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
-ENOSYSand 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
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."
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.
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_AUDITwith EAFNOSUPPORT, afterf0bddf50586d, we will get ENOSYS instead. We got same result with commit9c2598d43510("riscv:
entry: Save a0 priorsyscall_enter_from_user_mode()").After analysing code, we think that
regs->a0=-ENOSYSshould 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 ofsyscall_enter_from_user_mode, and then is compared withNR_syscallsafter converted to ulong (so it will beULONG_MAX). The condition syscall <NR_syscallswill always be false, soregs->a0=-ENOSYSis always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccompRET_ERRNOrule.Fixes f0bddf50586d ("riscv: entry: Convert to generic entry")Reported-by Felix Yan <[email protected]>Co-developed-by Ruizhe Pan <[email protected]>Signed-off-by Ruizhe Pan <[email protected]>Co-developed-by Shiqi Zhang <[email protected]>Signed-off-by Shiqi Zhang <[email protected]>Signed-off-by Celeste Liu <[email protected]>Tested-by Felix Yan <[email protected]>Tested-by Emil Renner Berthing <[email protected]>Reviewed-by Björn Töpel <[email protected]>Reviewed-by Guo Ren <[email protected]>---
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 ENOSYSarch/riscv/kernel/traps.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)arch/riscv/kernel/traps.c +3
-3@@ -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
-0syscall_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
-ENOSYSand 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.
Not reverting, but a fix to make sure that a0 is initialized to -ENOSYS, e.g.:
--8<--
arch/riscv/kernel/traps.c +2 -2
@@ -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
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_AUDITwith EAFNOSUPPORT, afterf0bddf50586d, we will get ENOSYS instead. We got same result with commit9c2598d43510("riscv:
entry: Save a0 priorsyscall_enter_from_user_mode()").After analysing code, we think that
regs->a0=-ENOSYSshould 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 ofsyscall_enter_from_user_mode, and then is compared withNR_syscallsafter converted to ulong (so it will beULONG_MAX). The condition syscall <NR_syscallswill always be false, soregs->a0=-ENOSYSis always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccompRET_ERRNOrule.Fixes f0bddf50586d ("riscv: entry: Convert to generic entry")Reported-by Felix Yan <[email protected]>Co-developed-by Ruizhe Pan <[email protected]>Signed-off-by Ruizhe Pan <[email protected]>Co-developed-by Shiqi Zhang <[email protected]>Signed-off-by Shiqi Zhang <[email protected]>Signed-off-by Celeste Liu <[email protected]>Tested-by Felix Yan <[email protected]>Tested-by Emil Renner Berthing <[email protected]>Reviewed-by Björn Töpel <[email protected]>Reviewed-by Guo Ren <[email protected]>---
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 ENOSYSarch/riscv/kernel/traps.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)arch/riscv/kernel/traps.c +3
-3@@ -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
-0syscall_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
-ENOSYSand 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.
Not reverting, but a fix to make sure that a0 is initialized to
-ENOSYS, e.g.:--8<--
arch/riscv/kernel/traps.c +0
-0
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
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_AUDITwith EAFNOSUPPORT, afterf0bddf50586d, we will get ENOSYS instead. We got same result with commit9c2598d43510("riscv:
entry: Save a0 priorsyscall_enter_from_user_mode()").After analysing code, we think that
regs->a0=-ENOSYSshould 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 ofsyscall_enter_from_user_mode, and then is compared withNR_syscallsafter converted to ulong (so it will beULONG_MAX). The condition syscall <NR_syscallswill always be false, soregs->a0=-ENOSYSis always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccompRET_ERRNOrule.Fixes f0bddf50586d ("riscv: entry: Convert to generic entry")Reported-by Felix Yan <[email protected]>Co-developed-by Ruizhe Pan <[email protected]>Signed-off-by Ruizhe Pan <[email protected]>Co-developed-by Shiqi Zhang <[email protected]>Signed-off-by Shiqi Zhang <[email protected]>Signed-off-by Celeste Liu <[email protected]>Tested-by Felix Yan <[email protected]>Tested-by Emil Renner Berthing <[email protected]>Reviewed-by Björn Töpel <[email protected]>Reviewed-by Guo Ren <[email protected]>---
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 ENOSYSarch/riscv/kernel/traps.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)arch/riscv/kernel/traps.c +3
-3@@ -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
-0syscall_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
-ENOSYSand 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.
Not reverting, but a fix to make sure that a0 is initialized to
-ENOSYS, e.g.:--8<--
arch/riscv/kernel/traps.c +0
-0@@ -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
-0regs->epc +=4 ; regs->orig_a0 = regs->a0; + regs->a0 = -ENOSYS ;Given that struct
user_regs_structdoesn't haveorig_a0, wouldn't this clobber a0 too early so that the tracer will get-ENOSYSin place of the first syscall argument?
No, that's ok. It's handled by various wrappers where the arguments are pulled out.
Björn
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_AUDITwith EAFNOSUPPORT, afterf0bddf50586d, we will get ENOSYS instead. We got same result with commit9c2598d43510("riscv:
entry: Save a0 priorsyscall_enter_from_user_mode()").After analysing code, we think that
regs->a0=-ENOSYSshould 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 ofsyscall_enter_from_user_mode, and then is compared withNR_syscallsafter converted to ulong (so it will beULONG_MAX). The condition syscall <NR_syscallswill always be false, soregs->a0=-ENOSYSis always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccompRET_ERRNOrule.Fixes f0bddf50586d ("riscv: entry: Convert to generic entry")Reported-by Felix Yan <[email protected]>Co-developed-by Ruizhe Pan <[email protected]>Signed-off-by Ruizhe Pan <[email protected]>Co-developed-by Shiqi Zhang <[email protected]>Signed-off-by Shiqi Zhang <[email protected]>Signed-off-by Celeste Liu <[email protected]>Tested-by Felix Yan <[email protected]>Tested-by Emil Renner Berthing <[email protected]>Reviewed-by Björn Töpel <[email protected]>Reviewed-by Guo Ren <[email protected]>---
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 ENOSYSarch/riscv/kernel/traps.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)arch/riscv/kernel/traps.c +3
-3@@ -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
-0syscall_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
-ENOSYSand 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
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@@ -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
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_AUDITwith EAFNOSUPPORT, afterf0bddf50586d, we will get ENOSYS instead. We got same result with commit9c2598d43510("riscv:
entry: Save a0 priorsyscall_enter_from_user_mode()").After analysing code, we think that
regs->a0=-ENOSYSshould 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 ofsyscall_enter_from_user_mode, and then is compared withNR_syscallsafter converted to ulong (so it will beULONG_MAX). The condition syscall <NR_syscallswill always be false, soregs->a0=-ENOSYSis always executed. It covered a0 set by seccomp, so we always get ENOSYS when match seccompRET_ERRNOrule.Fixes f0bddf50586d ("riscv: entry: Convert to generic entry")Reported-by Felix Yan <[email protected]>Co-developed-by Ruizhe Pan <[email protected]>Signed-off-by Ruizhe Pan <[email protected]>Co-developed-by Shiqi Zhang <[email protected]>Signed-off-by Shiqi Zhang <[email protected]>Signed-off-by Celeste Liu <[email protected]>Tested-by Felix Yan <[email protected]>Tested-by Emil Renner Berthing <[email protected]>Reviewed-by Björn Töpel <[email protected]>Reviewed-by Guo Ren <[email protected]>---
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 ENOSYSarch/riscv/kernel/traps.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)arch/riscv/kernel/traps.c +3
-3@@ -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
-0syscall_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
-ENOSYSand 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.
Not reverting, but a fix to make sure that a0 is initialized to
-ENOSYS, e.g.:--8<--
arch/riscv/kernel/traps.c +2
-3@@ -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