Skip to contentSkip to conversation

syscalls/waitid10: Fix on ARM, PPC and possibly others

PATCH In review Cyril Hrubis 4 participants 9 messages Mar 10, 2022 – Apr 19, 2022

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 syscalls/waitid10: Fix on ARM, PPC and possibly others

While integer division by zero does trap on x86_64 and causes the SIGFPE signal to be delivered it's not the case on all architecutes. At least on ARM and PPC64LE division by zero simply returns undefined result instead.

This patch adds raise(SIGFPE) at the end of the child as a fallback to make sure the process is killed with the right signal on all architectures.

---
 testcases/kernel/syscalls/waitid/waitid10.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
testcases/kernel/syscalls/waitid/waitid10.c +4 -1
index 869ef18bd..8c351d120 100644
@@ -28,7 +28,10 @@ static void run(void)
 		volatile int a, zero = 0;
 
 		a = 1 / zero;
-		exit(a);
+
+		tst_res(TINFO, "Division by zero didn't trap, raising SIGFPE");
+
+		raise(SIGFPE);
 	}
 
 	TST_EXP_PASS(waitid(P_ALL, 0, infop, WEXITED));
Signature · 5 lines
2.34.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#1 lore raw

Hi!

Quoted 19 lines

While integer division by zero does trap on x86_64 and causes the SIGFPE signal to be delivered it's not the case on all architecutes. At least on ARM and PPC64LE division by zero simply returns undefined result instead.

This patch adds raise(SIGFPE) at the end of the child as a fallback to make sure the process is killed with the right signal on all architectures.

---
 testcases/kernel/syscalls/waitid/waitid10.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
testcases/kernel/syscalls/waitid/waitid10.c +0 -0
index 869ef18bd..8c351d120 100644

testcases/kernel/syscalls/waitid/waitid10.c static void run(void) · line 32

Quoted 6 lines
testcases/kernel/syscalls/waitid/waitid10.c +2 -1
@@ -28,7 +28,10 @@ static void run(void)
 		volatile int a, zero = 0;
 
 		a = 1 / zero;
-		exit(a);
+
+		tst_res(TINFO, "Division by zero didn't trap, raising SIGFPE");

This patch inroduces 'set but not used' warning for the a variable so maybe the message should look like:

		tst_res(TINFO, "1/0 = %i raising SIGFPE", a);
Quoted 10 lines
testcases/kernel/syscalls/waitid/waitid10.c +1 -0
+		raise(SIGFPE);
 	}
 
 	TST_EXP_PASS(waitid(P_ALL, 0, infop, WEXITED));
Signature · 5 lines
2.34.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#2 lore raw

Hello,

Quoted 5 lines · Cyril Hrubis

Hi!

Quoted 4 lines

While integer division by zero does trap on x86_64 and causes the SIGFPE signal to be delivered it's not the case on all architecutes. At least on ARM and PPC64LE division by zero simply returns undefined result instead.

Nit picking: even with this patch we are still testing undefined behaviour.

There are six signals that can be delivered as a consequence of a hardware exception: SIGBUS, SIGEMT, SIGFPE, SIGILL, SIGSEGV, and SIGTRAP. Which of these signals is delivered, for any given hard- ware exception, is not documented and does not always make sense.

If dividing by zero produces SIGEMT then it's still valid according to the specification. FPE does stand for floating point exception, but we are dividing integers.

Quoted 25 lines
Quoted 15 lines

This patch adds raise(SIGFPE) at the end of the child as a fallback to make sure the process is killed with the right signal on all architectures.

---
 testcases/kernel/syscalls/waitid/waitid10.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
testcases/kernel/syscalls/waitid/waitid10.c +0 -0
index 869ef18bd..8c351d120 100644

testcases/kernel/syscalls/waitid/waitid10.c static void run(void) · line 32

Quoted 6 lines
testcases/kernel/syscalls/waitid/waitid10.c +2 -1
@@ -28,7 +28,10 @@ static void run(void)
 		volatile int a, zero = 0;
 
 		a = 1 / zero;
-		exit(a);
+
+		tst_res(TINFO, "Division by zero didn't trap, raising SIGFPE");

This patch inroduces 'set but not used' warning for the a variable so maybe the message should look like:

Quoted 3 lines
		tst_res(TINFO, "1/0 = %i raising SIGFPE", a);

testcases/kernel/syscalls/waitid/waitid10.c static void run(void) · line 34

Quoted 1 line
testcases/kernel/syscalls/waitid/waitid10.c +1 -0
+		raise(SIGFPE);

I'm wondering if we should branch on the architecture. If it's x86[_64] then we only do divide by zero as it's reasonable to think that if the signal is not raised then this is a bug.

Quoted 13 lines
Quoted 9 lines
testcases/kernel/syscalls/waitid/waitid10.c +0 -0
 	}
 
 	TST_EXP_PASS(waitid(P_ALL, 0, infop, WEXITED));
Signature · 5 lines
2.34.1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
Signature · 2 lines
Cyril Hrubis
[email protected]
Signature · 5 lines
Thank you,
Richard.

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#3 lore raw

Hi!

Quoted 14 lines
Quoted 4 lines
Quoted 4 lines

While integer division by zero does trap on x86_64 and causes the SIGFPE signal to be delivered it's not the case on all architecutes. At least on ARM and PPC64LE division by zero simply returns undefined result instead.

Nit picking: even with this patch we are still testing undefined behaviour.

There are six signals that can be delivered as a consequence of a hardware exception: SIGBUS, SIGEMT, SIGFPE, SIGILL, SIGSEGV, and SIGTRAP. Which of these signals is delivered, for any given hard- ware exception, is not documented and does not always make sense.

Quoted 3 lines

If dividing by zero produces SIGEMT then it's still valid according to the specification. FPE does stand for floating point exception, but we are dividing integers.

Actually as far as I can tell the POSIX says that for integer division by zero you shall get SIGFPE (and si_code in siginfo se tto FPE_INTDIV) if the operation traps. It seems to be pretty well defined:

https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html

Quoted 25 lines
Quoted 25 lines
Quoted 15 lines

This patch adds raise(SIGFPE) at the end of the child as a fallback to make sure the process is killed with the right signal on all architectures.

---
 testcases/kernel/syscalls/waitid/waitid10.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
testcases/kernel/syscalls/waitid/waitid10.c +0 -0
index 869ef18bd..8c351d120 100644

testcases/kernel/syscalls/waitid/waitid10.c static void run(void) · line 32

Quoted 6 lines
testcases/kernel/syscalls/waitid/waitid10.c +2 -1
@@ -28,7 +28,10 @@ static void run(void)
 		volatile int a, zero = 0;
 
 		a = 1 / zero;
-		exit(a);
+
+		tst_res(TINFO, "Division by zero didn't trap, raising SIGFPE");

This patch inroduces 'set but not used' warning for the a variable so maybe the message should look like:

Quoted 7 lines
Quoted 3 lines
		tst_res(TINFO, "1/0 = %i raising SIGFPE", a);

testcases/kernel/syscalls/waitid/waitid10.c static void run(void) · line 34

Quoted 1 line
testcases/kernel/syscalls/waitid/waitid10.c +1 -0
+		raise(SIGFPE);

I'm wondering if we should branch on the architecture. If it's x86[_64] then we only do divide by zero as it's reasonable to think that if the signal is not raised then this is a bug.

That would work too I guess.

Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
Reviewed-by
#4 lore raw

Hello,

Quoted 52 lines · Cyril Hrubis

Hi!

Quoted 14 lines
Quoted 4 lines
Quoted 4 lines

While integer division by zero does trap on x86_64 and causes the SIGFPE signal to be delivered it's not the case on all architecutes. At least on ARM and PPC64LE division by zero simply returns undefined result instead.

Nit picking: even with this patch we are still testing undefined behaviour.

There are six signals that can be delivered as a consequence of a hardware exception: SIGBUS, SIGEMT, SIGFPE, SIGILL, SIGSEGV, and SIGTRAP. Which of these signals is delivered, for any given hard- ware exception, is not documented and does not always make sense.

Quoted 3 lines

If dividing by zero produces SIGEMT then it's still valid according to the specification. FPE does stand for floating point exception, but we are dividing integers.

Actually as far as I can tell the POSIX says that for integer division by zero you shall get SIGFPE (and si_code in siginfo se tto FPE_INTDIV) if the operation traps. It seems to be pretty well defined:

https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html

Quoted 27 lines
Quoted 27 lines
Quoted 15 lines

This patch adds raise(SIGFPE) at the end of the child as a fallback to make sure the process is killed with the right signal on all architectures.

---
 testcases/kernel/syscalls/waitid/waitid10.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
testcases/kernel/syscalls/waitid/waitid10.c +0 -0
index 869ef18bd..8c351d120 100644

testcases/kernel/syscalls/waitid/waitid10.c static void run(void) · line 32

Quoted 6 lines
testcases/kernel/syscalls/waitid/waitid10.c +2 -1
@@ -28,7 +28,10 @@ static void run(void)
 		volatile int a, zero = 0;
 
 		a = 1 / zero;
-		exit(a);
+
+		tst_res(TINFO, "Division by zero didn't trap, raising SIGFPE");

This patch inroduces 'set but not used' warning for the a variable so maybe the message should look like:

		tst_res(TINFO, "1/0 = %i raising SIGFPE", a);
Quoted 7 lines
Quoted 5 lines
Quoted 1 line

testcases/kernel/syscalls/waitid/waitid10.c static void run(void) · line 34

Quoted 1 line
testcases/kernel/syscalls/waitid/waitid10.c +1 -0
+		raise(SIGFPE);

I'm wondering if we should branch on the architecture. If it's x86[_64] then we only do divide by zero as it's reasonable to think that if the signal is not raised then this is a bug.

That would work too I guess.

I would still use #ifdef to remove raise(SIGFPE) on x86. I think this makes it a more solid test on x86. As it is defined in the spec I guess you could do the divide by zero on other arches and we can review the results to see if any also raise SIGFPE.

With that:

Signature · 5 lines
Thank you,
Richard.

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#5 lore raw
In reply to Richard Palethorpe
Quoted 3 lines · Richard Palethorpe

I'm wondering if we should branch on the architecture. If it's x86[_64] then we only do divide by zero as it's reasonable to think that if the signal is not raised then this is a bug.

It's more likely to be a hardware bug/missing feature though. Do we really care? I'd argue that removing the division altogether and just calling raise(SIGFPE) in the child process is all we need in this particular test.

Signature · 10 lines
Martin Doucha   [email protected]
QA Engineer for Software Maintenance
SUSE LINUX, s.r.o.
CORSO IIa
Krizikova 148/34
186 00 Prague 8
Czech Republic

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#6 lore raw

Hello,

Quoted 9 lines · Martin Doucha
Quoted 3 lines · Richard Palethorpe

I'm wondering if we should branch on the architecture. If it's x86[_64] then we only do divide by zero as it's reasonable to think that if the signal is not raised then this is a bug.

It's more likely to be a hardware bug/missing feature though. Do we really care? I'd argue that removing the division altogether and just calling raise(SIGFPE) in the child process is all we need in this particular test.

I suppose it depends on if there is a substantial difference in how the signal is raised between div by zero and raise. I guess there is some configuration to trap the faulting instruction and raise a signal.

I don't have a strong opinion as, by definintion, testing undefined behaviour has uncertain results.

Signature · 5 lines
Thank you,
Richard.

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#7 lore raw

Hi!

Quoted 9 lines
Quoted 8 lines
Quoted 3 lines

I'm wondering if we should branch on the architecture. If it's x86[_64] then we only do divide by zero as it's reasonable to think that if the signal is not raised then this is a bug.

It's more likely to be a hardware bug/missing feature though. Do we really care? I'd argue that removing the division altogether and just calling raise(SIGFPE) in the child process is all we need in this particular test.

Quoted 4 lines

I suppose it depends on if there is a substantial difference in how the signal is raised between div by zero and raise. I guess there is some configuration to trap the faulting instruction and raise a signal.

I guess that in the case of division by zero we end up in the kernel interrupt handler where the kernel looks up the process that was running when the interrupt has raised then it queues the signal delivery and so on.

In the case of raise() we just do sysenter instruction which triggers different interrupt handler and the rest would be the same we queue the signal and so on.

Which is why I think that there is some value in triggering the divison by zero on architectures that enable it by default because we execute kernel interrupt handler that is rarely being executed.

Signature · 5 lines
Cyril Hrubis
[email protected]

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp
#8 lore raw
In reply to Cyril Hrubis
Quoted 3 lines · Cyril Hrubis

While integer division by zero does trap on x86_64 and causes the SIGFPE signal to be delivered it's not the case on all architecutes.

With gcc version 12.0.1 I don't get SIGFPE even on x86:
int main(void)

{
        volatile int a, zero = 0;
        a = 1 / zero;
}
   0x0000000000401020 <+0>:     movl   $0x0,-0x4(%rsp)
   0x0000000000401028 <+8>:     mov    -0x4(%rsp),%eax
   0x000000000040102c <+12>:    lea    0x1(%rax),%edx
   0x000000000040102f <+15>:    cmp    $0x2,%edx
   0x0000000000401032 <+18>:    mov    $0x0,%edx
   0x0000000000401037 <+23>:    cmova  %edx,%eax
   0x000000000040103a <+26>:    mov    %eax,-0x8(%rsp)
   0x000000000040103e <+30>:    xor    %eax,%eax
   0x0000000000401040 <+32>:    ret

It does trigger with a small modification:

@@ -25,9 +25,9 @@ static void run(void)

        pidchild = SAFE_FORK();
        if (!pidchild) {

- volatile int a, zero = 0;
+ volatile int a = 1, zero = 0;

- a = 1 / zero;

+               a = a / zero;
                exit(a);
        }
Quoted 18 lines

At least
on ARM and PPC64LE division by zero simply returns undefined result instead.

This patch adds raise(SIGFPE) at the end of the child as a fallback to make sure the process is killed with the right signal on all architectures.

---
 testcases/kernel/syscalls/waitid/waitid10.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
testcases/kernel/syscalls/waitid/waitid10.c +0 -0
index 869ef18bd..8c351d120 100644

testcases/kernel/syscalls/waitid/waitid10.c static void run(void) · line 34

Quoted 8 lines
testcases/kernel/syscalls/waitid/waitid10.c +4 -1
@@ -28,7 +28,10 @@ static void run(void)
                volatile int a, zero = 0;
 
                a = 1 / zero;
-               exit(a);
+
+               tst_res(TINFO, "Division by zero didn't trap, raising SIGFPE");
+
+               raise(SIGFPE);

I agree with Petr, that raise(SIGFPE) would be sufficient for this test.

Quoted 10 lines
testcases/kernel/syscalls/waitid/waitid10.c +0 -1
        }
 
        TST_EXP_PASS(waitid(P_ALL, 0, infop, WEXITED));
--

2.34.1

--
Mailing list info: https://lists.linux.it/listinfo/ltp

Signature · 1 line
Mailing list info: https://lists.linux.it/listinfo/ltp