Replicate the existing mul_u64_u64_div_u64() test cases with round up.
Update the shell script that verifies the table, remove the comment
markers so that it can be directly pasted into a shell.
Rename the divisor from 'c' to 'd' to match mul_u64_add_u64_div_u64().
It any tests fail then fail the module load with -EINVAL.
Signed-off-by: David Laight <david.laight.linux@gmail.com>
---
Changes for v3:
- Rename 'c' to 'd' to match mul_u64_add_u64_div_u64()
lib/math/test_mul_u64_u64_div_u64.c | 122 +++++++++++++++++-----------
1 file changed, 73 insertions(+), 49 deletions(-)
diff --git a/lib/math/test_mul_u64_u64_div_u64.c b/lib/math/test_mul_u64_u64_div_u64.c
index 58d058de4e73..ea5b703cccff 100644
--- a/lib/math/test_mul_u64_u64_div_u64.c
+++ b/lib/math/test_mul_u64_u64_div_u64.c
@@ -10,61 +10,73 @@
#include <linux/printk.h>
#include <linux/math64.h>
-typedef struct { u64 a; u64 b; u64 c; u64 result; } test_params;
+typedef struct { u64 a; u64 b; u64 d; u64 result; uint round_up;} test_params;
static test_params test_values[] = {
/* this contains many edge values followed by a couple random values */
-{ 0xb, 0x7, 0x3, 0x19 },
-{ 0xffff0000, 0xffff0000, 0xf, 0x1110eeef00000000 },
-{ 0xffffffff, 0xffffffff, 0x1, 0xfffffffe00000001 },
-{ 0xffffffff, 0xffffffff, 0x2, 0x7fffffff00000000 },
-{ 0x1ffffffff, 0xffffffff, 0x2, 0xfffffffe80000000 },
-{ 0x1ffffffff, 0xffffffff, 0x3, 0xaaaaaaa9aaaaaaab },
-{ 0x1ffffffff, 0x1ffffffff, 0x4, 0xffffffff00000000 },
-{ 0xffff000000000000, 0xffff000000000000, 0xffff000000000001, 0xfffeffffffffffff },
-{ 0x3333333333333333, 0x3333333333333333, 0x5555555555555555, 0x1eb851eb851eb851 },
-{ 0x7fffffffffffffff, 0x2, 0x3, 0x5555555555555554 },
-{ 0xffffffffffffffff, 0x2, 0x8000000000000000, 0x3 },
-{ 0xffffffffffffffff, 0x2, 0xc000000000000000, 0x2 },
-{ 0xffffffffffffffff, 0x4000000000000004, 0x8000000000000000, 0x8000000000000007 },
-{ 0xffffffffffffffff, 0x4000000000000001, 0x8000000000000000, 0x8000000000000001 },
-{ 0xffffffffffffffff, 0x8000000000000001, 0xffffffffffffffff, 0x8000000000000001 },
-{ 0xfffffffffffffffe, 0x8000000000000001, 0xffffffffffffffff, 0x8000000000000000 },
-{ 0xffffffffffffffff, 0x8000000000000001, 0xfffffffffffffffe, 0x8000000000000001 },
-{ 0xffffffffffffffff, 0x8000000000000001, 0xfffffffffffffffd, 0x8000000000000002 },
-{ 0x7fffffffffffffff, 0xffffffffffffffff, 0xc000000000000000, 0xaaaaaaaaaaaaaaa8 },
-{ 0xffffffffffffffff, 0x7fffffffffffffff, 0xa000000000000000, 0xccccccccccccccca },
-{ 0xffffffffffffffff, 0x7fffffffffffffff, 0x9000000000000000, 0xe38e38e38e38e38b },
-{ 0x7fffffffffffffff, 0x7fffffffffffffff, 0x5000000000000000, 0xccccccccccccccc9 },
-{ 0xffffffffffffffff, 0xfffffffffffffffe, 0xffffffffffffffff, 0xfffffffffffffffe },
-{ 0xe6102d256d7ea3ae, 0x70a77d0be4c31201, 0xd63ec35ab3220357, 0x78f8bf8cc86c6e18 },
-{ 0xf53bae05cb86c6e1, 0x3847b32d2f8d32e0, 0xcfd4f55a647f403c, 0x42687f79d8998d35 },
-{ 0x9951c5498f941092, 0x1f8c8bfdf287a251, 0xa3c8dc5f81ea3fe2, 0x1d887cb25900091f },
-{ 0x374fee9daa1bb2bb, 0x0d0bfbff7b8ae3ef, 0xc169337bd42d5179, 0x03bb2dbaffcbb961 },
-{ 0xeac0d03ac10eeaf0, 0x89be05dfa162ed9b, 0x92bb1679a41f0e4b, 0xdc5f5cc9e270d216 },
+{ 0xb, 0x7, 0x3, 0x19, 1 },
+{ 0xffff0000, 0xffff0000, 0xf, 0x1110eeef00000000, 0 },
+{ 0xffffffff, 0xffffffff, 0x1, 0xfffffffe00000001, 0 },
+{ 0xffffffff, 0xffffffff, 0x2, 0x7fffffff00000000, 1 },
+{ 0x1ffffffff, 0xffffffff, 0x2, 0xfffffffe80000000, 1 },
+{ 0x1ffffffff, 0xffffffff, 0x3, 0xaaaaaaa9aaaaaaab, 0 },
+{ 0x1ffffffff, 0x1ffffffff, 0x4, 0xffffffff00000000, 1 },
+{ 0xffff000000000000, 0xffff000000000000, 0xffff000000000001, 0xfffeffffffffffff, 1 },
+{ 0x3333333333333333, 0x3333333333333333, 0x5555555555555555, 0x1eb851eb851eb851, 1 },
+{ 0x7fffffffffffffff, 0x2, 0x3, 0x5555555555555554, 1 },
+{ 0xffffffffffffffff, 0x2, 0x8000000000000000, 0x3, 1 },
+{ 0xffffffffffffffff, 0x2, 0xc000000000000000, 0x2, 1 },
+{ 0xffffffffffffffff, 0x4000000000000004, 0x8000000000000000, 0x8000000000000007, 1 },
+{ 0xffffffffffffffff, 0x4000000000000001, 0x8000000000000000, 0x8000000000000001, 1 },
+{ 0xffffffffffffffff, 0x8000000000000001, 0xffffffffffffffff, 0x8000000000000001, 0 },
+{ 0xfffffffffffffffe, 0x8000000000000001, 0xffffffffffffffff, 0x8000000000000000, 1 },
+{ 0xffffffffffffffff, 0x8000000000000001, 0xfffffffffffffffe, 0x8000000000000001, 1 },
+{ 0xffffffffffffffff, 0x8000000000000001, 0xfffffffffffffffd, 0x8000000000000002, 1 },
+{ 0x7fffffffffffffff, 0xffffffffffffffff, 0xc000000000000000, 0xaaaaaaaaaaaaaaa8, 1 },
+{ 0xffffffffffffffff, 0x7fffffffffffffff, 0xa000000000000000, 0xccccccccccccccca, 1 },
+{ 0xffffffffffffffff, 0x7fffffffffffffff, 0x9000000000000000, 0xe38e38e38e38e38b, 1 },
+{ 0x7fffffffffffffff, 0x7fffffffffffffff, 0x5000000000000000, 0xccccccccccccccc9, 1 },
+{ 0xffffffffffffffff, 0xfffffffffffffffe, 0xffffffffffffffff, 0xfffffffffffffffe, 0 },
+{ 0xe6102d256d7ea3ae, 0x70a77d0be4c31201, 0xd63ec35ab3220357, 0x78f8bf8cc86c6e18, 1 },
+{ 0xf53bae05cb86c6e1, 0x3847b32d2f8d32e0, 0xcfd4f55a647f403c, 0x42687f79d8998d35, 1 },
+{ 0x9951c5498f941092, 0x1f8c8bfdf287a251, 0xa3c8dc5f81ea3fe2, 0x1d887cb25900091f, 1 },
+{ 0x374fee9daa1bb2bb, 0x0d0bfbff7b8ae3ef, 0xc169337bd42d5179, 0x03bb2dbaffcbb961, 1 },
+{ 0xeac0d03ac10eeaf0, 0x89be05dfa162ed9b, 0x92bb1679a41f0e4b, 0xdc5f5cc9e270d216, 1 },
};
/*
* The above table can be verified with the following shell script:
- *
- * #!/bin/sh
- * sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4/p' \
- * lib/math/test_mul_u64_u64_div_u64.c |
- * while read a b c r; do
- * expected=$( printf "obase=16; ibase=16; %X * %X / %X\n" $a $b $c | bc )
- * given=$( printf "%X\n" $r )
- * if [ "$expected" = "$given" ]; then
- * echo "$a * $b / $c = $r OK"
- * else
- * echo "$a * $b / $c = $r is wrong" >&2
- * echo "should be equivalent to 0x$expected" >&2
- * exit 1
- * fi
- * done
+
+#!/bin/sh
+sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4 \5/p' \
+ lib/math/test_mul_u64_u64_div_u64.c |
+while read a b d r d; do
+ expected=$( printf "obase=16; ibase=16; %X * %X / %X\n" $a $b $d | bc )
+ given=$( printf "%X\n" $r )
+ if [ "$expected" = "$given" ]; then
+ echo "$a * $b / $d = $r OK"
+ else
+ echo "$a * $b / $d = $r is wrong" >&2
+ echo "should be equivalent to 0x$expected" >&2
+ exit 1
+ fi
+ expected=$( printf "obase=16; ibase=16; (%X * %X + %X) / %X\n" $a $b $((d-1)) $d | bc )
+ given=$( printf "%X\n" $((r + d)) )
+ if [ "$expected" = "$given" ]; then
+ echo "$a * $b +/ $d = $(printf '%#x' $((r + d))) OK"
+ else
+ echo "$a * $b +/ $d = $(printf '%#x' $((r + d))) is wrong" >&2
+ echo "should be equivalent to 0x$expected" >&2
+ exit 1
+ fi
+done
+
*/
static int __init test_init(void)
{
+ int errors = 0;
+ int tests = 0;
int i;
pr_info("Starting mul_u64_u64_div_u64() test\n");
@@ -72,19 +84,31 @@ static int __init test_init(void)
for (i = 0; i < ARRAY_SIZE(test_values); i++) {
u64 a = test_values[i].a;
u64 b = test_values[i].b;
- u64 c = test_values[i].c;
+ u64 d = test_values[i].d;
u64 expected_result = test_values[i].result;
- u64 result = mul_u64_u64_div_u64(a, b, c);
+ u64 result = mul_u64_u64_div_u64(a, b, d);
+ u64 result_up = mul_u64_u64_div_u64_roundup(a, b, d);
+
+ tests += 2;
if (result != expected_result) {
- pr_err("ERROR: 0x%016llx * 0x%016llx / 0x%016llx\n", a, b, c);
+ pr_err("ERROR: 0x%016llx * 0x%016llx / 0x%016llx\n", a, b, d);
pr_err("ERROR: expected result: %016llx\n", expected_result);
pr_err("ERROR: obtained result: %016llx\n", result);
+ errors++;
+ }
+ expected_result += test_values[i].round_up;
+ if (result_up != expected_result) {
+ pr_err("ERROR: 0x%016llx * 0x%016llx +/ 0x%016llx\n", a, b, d);
+ pr_err("ERROR: expected result: %016llx\n", expected_result);
+ pr_err("ERROR: obtained result: %016llx\n", result_up);
+ errors++;
}
}
- pr_info("Completed mul_u64_u64_div_u64() test\n");
- return 0;
+ pr_info("Completed mul_u64_u64_div_u64() test, %d tests, %d errors\n",
+ tests, errors);
+ return errors ? -EINVAL : 0;
}
static void __exit test_exit(void)
--
2.39.5On Sat, 14 Jun 2025, David Laight wrote:
> Replicate the existing mul_u64_u64_div_u64() test cases with round up.
> Update the shell script that verifies the table, remove the comment
> markers so that it can be directly pasted into a shell.
>
> Rename the divisor from 'c' to 'd' to match mul_u64_add_u64_div_u64().
>
> It any tests fail then fail the module load with -EINVAL.
>
> Signed-off-by: David Laight <david.laight.linux@gmail.com>
I must withdraw my Reviewed-by here.
> /*
> * The above table can be verified with the following shell script:
> - *
> - * #!/bin/sh
> - * sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4/p' \
> - * lib/math/test_mul_u64_u64_div_u64.c |
> - * while read a b c r; do
> - * expected=$( printf "obase=16; ibase=16; %X * %X / %X\n" $a $b $c | bc )
> - * given=$( printf "%X\n" $r )
> - * if [ "$expected" = "$given" ]; then
> - * echo "$a * $b / $c = $r OK"
> - * else
> - * echo "$a * $b / $c = $r is wrong" >&2
> - * echo "should be equivalent to 0x$expected" >&2
> - * exit 1
> - * fi
> - * done
> +
> +#!/bin/sh
> +sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4 \5/p' \
> + lib/math/test_mul_u64_u64_div_u64.c |
> +while read a b d r d; do
This "read a b d r d" is wrong and that breaks the script.
Nicolas
Hello David,
On Tue, Jun 17, 2025 at 12:30:17AM -0400, Nicolas Pitre wrote:
> On Sat, 14 Jun 2025, David Laight wrote:
>
> > Replicate the existing mul_u64_u64_div_u64() test cases with round up.
> > Update the shell script that verifies the table, remove the comment
> > markers so that it can be directly pasted into a shell.
> >
> > Rename the divisor from 'c' to 'd' to match mul_u64_add_u64_div_u64().
> >
> > It any tests fail then fail the module load with -EINVAL.
> >
> > Signed-off-by: David Laight <david.laight.linux@gmail.com>
>
> I must withdraw my Reviewed-by here.
>
> > /*
> > * The above table can be verified with the following shell script:
> > - *
> > - * #!/bin/sh
> > - * sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4/p' \
> > - * lib/math/test_mul_u64_u64_div_u64.c |
> > - * while read a b c r; do
> > - * expected=$( printf "obase=16; ibase=16; %X * %X / %X\n" $a $b $c | bc )
> > - * given=$( printf "%X\n" $r )
> > - * if [ "$expected" = "$given" ]; then
> > - * echo "$a * $b / $c = $r OK"
> > - * else
> > - * echo "$a * $b / $c = $r is wrong" >&2
> > - * echo "should be equivalent to 0x$expected" >&2
> > - * exit 1
> > - * fi
> > - * done
> > +
> > +#!/bin/sh
> > +sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4 \5/p' \
> > + lib/math/test_mul_u64_u64_div_u64.c |
> > +while read a b d r d; do
>
> This "read a b d r d" is wrong and that breaks the script.
I think apart from that problem the series is fine, isn't it? Given that
I wait for some time to be able to use the mul_u64_u64_div_u64_roundup()
variant, I would very appreciate your effort to end in this patch set
going in. Do you plan to address this issue? If not, I offer to look
into it and create the next revision for this series.
Best regards
Uwe
On Thu, 18 Sep 2025 16:00:42 +0200
Uwe Kleine-König <u.kleine-koenig@baylibre.com> wrote:
> Hello David,
>
> On Tue, Jun 17, 2025 at 12:30:17AM -0400, Nicolas Pitre wrote:
> > On Sat, 14 Jun 2025, David Laight wrote:
> >
> > > Replicate the existing mul_u64_u64_div_u64() test cases with round up.
> > > Update the shell script that verifies the table, remove the comment
> > > markers so that it can be directly pasted into a shell.
> > >
> > > Rename the divisor from 'c' to 'd' to match mul_u64_add_u64_div_u64().
> > >
> > > It any tests fail then fail the module load with -EINVAL.
> > >
> > > Signed-off-by: David Laight <david.laight.linux@gmail.com>
> >
> > I must withdraw my Reviewed-by here.
> >
> > > /*
> > > * The above table can be verified with the following shell script:
> > > - *
> > > - * #!/bin/sh
> > > - * sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4/p' \
> > > - * lib/math/test_mul_u64_u64_div_u64.c |
> > > - * while read a b c r; do
> > > - * expected=$( printf "obase=16; ibase=16; %X * %X / %X\n" $a $b $c | bc )
> > > - * given=$( printf "%X\n" $r )
> > > - * if [ "$expected" = "$given" ]; then
> > > - * echo "$a * $b / $c = $r OK"
> > > - * else
> > > - * echo "$a * $b / $c = $r is wrong" >&2
> > > - * echo "should be equivalent to 0x$expected" >&2
> > > - * exit 1
> > > - * fi
> > > - * done
> > > +
> > > +#!/bin/sh
> > > +sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4 \5/p' \
> > > + lib/math/test_mul_u64_u64_div_u64.c |
> > > +while read a b d r d; do
> >
> > This "read a b d r d" is wrong and that breaks the script.
>
> I think apart from that problem the series is fine, isn't it? Given that
> I wait for some time to be able to use the mul_u64_u64_div_u64_roundup()
> variant, I would very appreciate your effort to end in this patch set
> going in. Do you plan to address this issue? If not, I offer to look
> into it and create the next revision for this series.
The series doesn't currently apply due to a conflicting change.
So does need a new version.
I did start trying to do it, but have been busy.
I'll try to find some time.
David
>
> Best regards
> Uwe
On Sat, 14 Jun 2025, David Laight wrote:
> Replicate the existing mul_u64_u64_div_u64() test cases with round up.
> Update the shell script that verifies the table, remove the comment
> markers so that it can be directly pasted into a shell.
>
> Rename the divisor from 'c' to 'd' to match mul_u64_add_u64_div_u64().
>
> It any tests fail then fail the module load with -EINVAL.
>
> Signed-off-by: David Laight <david.laight.linux@gmail.com>
Reviewed-by: Nicolas Pitre <npitre@baylibre.com>
> ---
>
> Changes for v3:
> - Rename 'c' to 'd' to match mul_u64_add_u64_div_u64()
>
> lib/math/test_mul_u64_u64_div_u64.c | 122 +++++++++++++++++-----------
> 1 file changed, 73 insertions(+), 49 deletions(-)
>
> diff --git a/lib/math/test_mul_u64_u64_div_u64.c b/lib/math/test_mul_u64_u64_div_u64.c
> index 58d058de4e73..ea5b703cccff 100644
> --- a/lib/math/test_mul_u64_u64_div_u64.c
> +++ b/lib/math/test_mul_u64_u64_div_u64.c
> @@ -10,61 +10,73 @@
> #include <linux/printk.h>
> #include <linux/math64.h>
>
> -typedef struct { u64 a; u64 b; u64 c; u64 result; } test_params;
> +typedef struct { u64 a; u64 b; u64 d; u64 result; uint round_up;} test_params;
>
> static test_params test_values[] = {
> /* this contains many edge values followed by a couple random values */
> -{ 0xb, 0x7, 0x3, 0x19 },
> -{ 0xffff0000, 0xffff0000, 0xf, 0x1110eeef00000000 },
> -{ 0xffffffff, 0xffffffff, 0x1, 0xfffffffe00000001 },
> -{ 0xffffffff, 0xffffffff, 0x2, 0x7fffffff00000000 },
> -{ 0x1ffffffff, 0xffffffff, 0x2, 0xfffffffe80000000 },
> -{ 0x1ffffffff, 0xffffffff, 0x3, 0xaaaaaaa9aaaaaaab },
> -{ 0x1ffffffff, 0x1ffffffff, 0x4, 0xffffffff00000000 },
> -{ 0xffff000000000000, 0xffff000000000000, 0xffff000000000001, 0xfffeffffffffffff },
> -{ 0x3333333333333333, 0x3333333333333333, 0x5555555555555555, 0x1eb851eb851eb851 },
> -{ 0x7fffffffffffffff, 0x2, 0x3, 0x5555555555555554 },
> -{ 0xffffffffffffffff, 0x2, 0x8000000000000000, 0x3 },
> -{ 0xffffffffffffffff, 0x2, 0xc000000000000000, 0x2 },
> -{ 0xffffffffffffffff, 0x4000000000000004, 0x8000000000000000, 0x8000000000000007 },
> -{ 0xffffffffffffffff, 0x4000000000000001, 0x8000000000000000, 0x8000000000000001 },
> -{ 0xffffffffffffffff, 0x8000000000000001, 0xffffffffffffffff, 0x8000000000000001 },
> -{ 0xfffffffffffffffe, 0x8000000000000001, 0xffffffffffffffff, 0x8000000000000000 },
> -{ 0xffffffffffffffff, 0x8000000000000001, 0xfffffffffffffffe, 0x8000000000000001 },
> -{ 0xffffffffffffffff, 0x8000000000000001, 0xfffffffffffffffd, 0x8000000000000002 },
> -{ 0x7fffffffffffffff, 0xffffffffffffffff, 0xc000000000000000, 0xaaaaaaaaaaaaaaa8 },
> -{ 0xffffffffffffffff, 0x7fffffffffffffff, 0xa000000000000000, 0xccccccccccccccca },
> -{ 0xffffffffffffffff, 0x7fffffffffffffff, 0x9000000000000000, 0xe38e38e38e38e38b },
> -{ 0x7fffffffffffffff, 0x7fffffffffffffff, 0x5000000000000000, 0xccccccccccccccc9 },
> -{ 0xffffffffffffffff, 0xfffffffffffffffe, 0xffffffffffffffff, 0xfffffffffffffffe },
> -{ 0xe6102d256d7ea3ae, 0x70a77d0be4c31201, 0xd63ec35ab3220357, 0x78f8bf8cc86c6e18 },
> -{ 0xf53bae05cb86c6e1, 0x3847b32d2f8d32e0, 0xcfd4f55a647f403c, 0x42687f79d8998d35 },
> -{ 0x9951c5498f941092, 0x1f8c8bfdf287a251, 0xa3c8dc5f81ea3fe2, 0x1d887cb25900091f },
> -{ 0x374fee9daa1bb2bb, 0x0d0bfbff7b8ae3ef, 0xc169337bd42d5179, 0x03bb2dbaffcbb961 },
> -{ 0xeac0d03ac10eeaf0, 0x89be05dfa162ed9b, 0x92bb1679a41f0e4b, 0xdc5f5cc9e270d216 },
> +{ 0xb, 0x7, 0x3, 0x19, 1 },
> +{ 0xffff0000, 0xffff0000, 0xf, 0x1110eeef00000000, 0 },
> +{ 0xffffffff, 0xffffffff, 0x1, 0xfffffffe00000001, 0 },
> +{ 0xffffffff, 0xffffffff, 0x2, 0x7fffffff00000000, 1 },
> +{ 0x1ffffffff, 0xffffffff, 0x2, 0xfffffffe80000000, 1 },
> +{ 0x1ffffffff, 0xffffffff, 0x3, 0xaaaaaaa9aaaaaaab, 0 },
> +{ 0x1ffffffff, 0x1ffffffff, 0x4, 0xffffffff00000000, 1 },
> +{ 0xffff000000000000, 0xffff000000000000, 0xffff000000000001, 0xfffeffffffffffff, 1 },
> +{ 0x3333333333333333, 0x3333333333333333, 0x5555555555555555, 0x1eb851eb851eb851, 1 },
> +{ 0x7fffffffffffffff, 0x2, 0x3, 0x5555555555555554, 1 },
> +{ 0xffffffffffffffff, 0x2, 0x8000000000000000, 0x3, 1 },
> +{ 0xffffffffffffffff, 0x2, 0xc000000000000000, 0x2, 1 },
> +{ 0xffffffffffffffff, 0x4000000000000004, 0x8000000000000000, 0x8000000000000007, 1 },
> +{ 0xffffffffffffffff, 0x4000000000000001, 0x8000000000000000, 0x8000000000000001, 1 },
> +{ 0xffffffffffffffff, 0x8000000000000001, 0xffffffffffffffff, 0x8000000000000001, 0 },
> +{ 0xfffffffffffffffe, 0x8000000000000001, 0xffffffffffffffff, 0x8000000000000000, 1 },
> +{ 0xffffffffffffffff, 0x8000000000000001, 0xfffffffffffffffe, 0x8000000000000001, 1 },
> +{ 0xffffffffffffffff, 0x8000000000000001, 0xfffffffffffffffd, 0x8000000000000002, 1 },
> +{ 0x7fffffffffffffff, 0xffffffffffffffff, 0xc000000000000000, 0xaaaaaaaaaaaaaaa8, 1 },
> +{ 0xffffffffffffffff, 0x7fffffffffffffff, 0xa000000000000000, 0xccccccccccccccca, 1 },
> +{ 0xffffffffffffffff, 0x7fffffffffffffff, 0x9000000000000000, 0xe38e38e38e38e38b, 1 },
> +{ 0x7fffffffffffffff, 0x7fffffffffffffff, 0x5000000000000000, 0xccccccccccccccc9, 1 },
> +{ 0xffffffffffffffff, 0xfffffffffffffffe, 0xffffffffffffffff, 0xfffffffffffffffe, 0 },
> +{ 0xe6102d256d7ea3ae, 0x70a77d0be4c31201, 0xd63ec35ab3220357, 0x78f8bf8cc86c6e18, 1 },
> +{ 0xf53bae05cb86c6e1, 0x3847b32d2f8d32e0, 0xcfd4f55a647f403c, 0x42687f79d8998d35, 1 },
> +{ 0x9951c5498f941092, 0x1f8c8bfdf287a251, 0xa3c8dc5f81ea3fe2, 0x1d887cb25900091f, 1 },
> +{ 0x374fee9daa1bb2bb, 0x0d0bfbff7b8ae3ef, 0xc169337bd42d5179, 0x03bb2dbaffcbb961, 1 },
> +{ 0xeac0d03ac10eeaf0, 0x89be05dfa162ed9b, 0x92bb1679a41f0e4b, 0xdc5f5cc9e270d216, 1 },
> };
>
> /*
> * The above table can be verified with the following shell script:
> - *
> - * #!/bin/sh
> - * sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4/p' \
> - * lib/math/test_mul_u64_u64_div_u64.c |
> - * while read a b c r; do
> - * expected=$( printf "obase=16; ibase=16; %X * %X / %X\n" $a $b $c | bc )
> - * given=$( printf "%X\n" $r )
> - * if [ "$expected" = "$given" ]; then
> - * echo "$a * $b / $c = $r OK"
> - * else
> - * echo "$a * $b / $c = $r is wrong" >&2
> - * echo "should be equivalent to 0x$expected" >&2
> - * exit 1
> - * fi
> - * done
> +
> +#!/bin/sh
> +sed -ne 's/^{ \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\), \+\(.*\) },$/\1 \2 \3 \4 \5/p' \
> + lib/math/test_mul_u64_u64_div_u64.c |
> +while read a b d r d; do
> + expected=$( printf "obase=16; ibase=16; %X * %X / %X\n" $a $b $d | bc )
> + given=$( printf "%X\n" $r )
> + if [ "$expected" = "$given" ]; then
> + echo "$a * $b / $d = $r OK"
> + else
> + echo "$a * $b / $d = $r is wrong" >&2
> + echo "should be equivalent to 0x$expected" >&2
> + exit 1
> + fi
> + expected=$( printf "obase=16; ibase=16; (%X * %X + %X) / %X\n" $a $b $((d-1)) $d | bc )
> + given=$( printf "%X\n" $((r + d)) )
> + if [ "$expected" = "$given" ]; then
> + echo "$a * $b +/ $d = $(printf '%#x' $((r + d))) OK"
> + else
> + echo "$a * $b +/ $d = $(printf '%#x' $((r + d))) is wrong" >&2
> + echo "should be equivalent to 0x$expected" >&2
> + exit 1
> + fi
> +done
> +
> */
>
> static int __init test_init(void)
> {
> + int errors = 0;
> + int tests = 0;
> int i;
>
> pr_info("Starting mul_u64_u64_div_u64() test\n");
> @@ -72,19 +84,31 @@ static int __init test_init(void)
> for (i = 0; i < ARRAY_SIZE(test_values); i++) {
> u64 a = test_values[i].a;
> u64 b = test_values[i].b;
> - u64 c = test_values[i].c;
> + u64 d = test_values[i].d;
> u64 expected_result = test_values[i].result;
> - u64 result = mul_u64_u64_div_u64(a, b, c);
> + u64 result = mul_u64_u64_div_u64(a, b, d);
> + u64 result_up = mul_u64_u64_div_u64_roundup(a, b, d);
> +
> + tests += 2;
>
> if (result != expected_result) {
> - pr_err("ERROR: 0x%016llx * 0x%016llx / 0x%016llx\n", a, b, c);
> + pr_err("ERROR: 0x%016llx * 0x%016llx / 0x%016llx\n", a, b, d);
> pr_err("ERROR: expected result: %016llx\n", expected_result);
> pr_err("ERROR: obtained result: %016llx\n", result);
> + errors++;
> + }
> + expected_result += test_values[i].round_up;
> + if (result_up != expected_result) {
> + pr_err("ERROR: 0x%016llx * 0x%016llx +/ 0x%016llx\n", a, b, d);
> + pr_err("ERROR: expected result: %016llx\n", expected_result);
> + pr_err("ERROR: obtained result: %016llx\n", result_up);
> + errors++;
> }
> }
>
> - pr_info("Completed mul_u64_u64_div_u64() test\n");
> - return 0;
> + pr_info("Completed mul_u64_u64_div_u64() test, %d tests, %d errors\n",
> + tests, errors);
> + return errors ? -EINVAL : 0;
> }
>
> static void __exit test_exit(void)
> --
> 2.39.5
>
>
© 2016 - 2025 Red Hat, Inc.