Skip to contentSkip to conversation

lib/math/rational.c: Fix divide by zero

PATCH In review Trent Piepho 3 participants 6 messages May 25, 2021 – May 26, 2021 Library code

lore
Share & tools
lore
#0 lore raw

PATCH v3 1/2 lib/math/rational.c: Fix divide by zero

If the input is out of the range of the allowed values, either larger than the largest value or closer to zero than the smallest non-zero allowed value, then a division by zero would occur.

In the case of input too large, the division by zero will occur on the first iteration. The best result (largest allowed value) will be found by always choosing the semi-convergent and excluding the denominator based limit when finding it.

In the case of the input too small, the division by zero will occur on the second iteration. The numerator based semi-convergent should not be calculated to avoid the division by zero. But the semi-convergent vs previous convergent test is still needed, which effectively chooses between 0 (the previous convergent) vs the smallest allowed fraction (best semi-convergent) as the result.

Fixes 323dd2c3ed0 ("lib/math/rational.c: fix possible incorrect result from rational fractions helper")
---
 lib/math/rational.c | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)
lib/math/rational.c +11 -5
index 9781d521963d..c0ab51d8fbb9 100644
@@ -12,6 +12,7 @@
 #include <linux/compiler.h>
 #include <linux/export.h>
 #include <linux/minmax.h>
+#include <linux/limits.h>
 
 /*
  * calculate best rational approximation for a given fraction
@@ -78,13 +79,18 @@ void rational_best_approximation(
 		 * found below as 't'.
 		 */
 		if ((n2 > max_numerator) || (d2 > max_denominator)) {
-			unsigned long t = min((max_numerator - n0) / n1,
-					      (max_denominator - d0) / d1);
+			unsigned long t = ULONG_MAX;
 
-			/* This tests if the semi-convergent is closer
-			 * than the previous convergent.
+			if (d1)
+				t = (max_denominator - d0) / d1;
+			if (n1)
+				t = min(t, (max_numerator - n0) / n1);
+
+			/* This tests if the semi-convergent is closer than the previous
+			 * convergent.  If d1 is zero there is no previous convergent as this
+			 * is the 1st iteration, so always choose the semi-convergent.
 			 */
-			if (2u * t > a || (2u * t == a && d0 * dp > d1 * d)) {
+			if (!d1 || 2u * t > a || (2u * t == a && d0 * dp > d1 * d)) {
 				n1 = n0 + t * n1;
 				d1 = d0 + t * d1;
 			}
Signature · 1 line
2.26.2
#1 lore raw

PATCH v3 2/2 lib/math/rational: Add Kunit test cases

Adds a number of test cases that cover a range of possible code paths.

---
Changes from v2:
Rename file to follow new kunit naming convention Fix whitespace issues
Remove unicode characters
Add more testcases

 lib/Kconfig.debug         | 12 ++++++++
 lib/math/Makefile         |  1 +
 lib/math/rational_kunit.c | 60 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+)
 create mode 100644 lib/math/rational_kunit.c
lib/Kconfig.debug +12 -0
index 678c13967580..6c0e66a7d416 100644
@@ -2429,6 +2429,18 @@ config BITS_TEST
 
 	  If unsure, say N.
 
+config RATIONAL_KUNIT_TEST
+	tristate "KUnit test for rational.c" if !KUNIT_ALL_TESTS
+	depends on KUNIT
+	select RATIONAL
+	default KUNIT_ALL_TESTS
+	help
+	  This builds the rational math unit test.
+	  For more information on KUnit and unit tests in general please refer
+	  to the KUnit documentation in Documentation/dev-tools/kunit/.
+
+	  If unsure, say N.
+
 config TEST_UDELAY
 	tristate "udelay test driver"
 	help
lib/math/Makefile +1 -0
index 7456edb864fc..de7d16ca3cf5 100644
@@ -6,3 +6,4 @@ obj-$(CONFIG_PRIME_NUMBERS)	+= prime_numbers.o
 obj-$(CONFIG_RATIONAL)		+= rational.o
 
 obj-$(CONFIG_TEST_DIV64)	+= test_div64.o
+obj-$(CONFIG_RATIONAL_KUNIT_TEST) += rational_kunit.o
lib/math/rational_kunit.c new file +59 -0

59 lines not on this page · raw message

Signature · 1 line
2.26.2
Reviewed-by on v3 2/2
#2 lore raw

Re: [PATCH v3 2/2] lib/math/rational: Add Kunit test cases

Quoted 4 lines · Trent Piepho

Adds a number of test cases that cover a range of possible code paths.

LGTM, thanks!

Quoted 113 lines

---
Changes from v2:
Rename file to follow new kunit naming convention Fix whitespace issues
Remove unicode characters
Add more testcases

 lib/Kconfig.debug         | 12 ++++++++
 lib/math/Makefile         |  1 +
 lib/math/rational_kunit.c | 60 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+)
 create mode 100644 lib/math/rational_kunit.c
lib/Kconfig.debug +12 -0
index 678c13967580..6c0e66a7d416 100644
@@ -2429,6 +2429,18 @@ config BITS_TEST
 
          If unsure, say N.
 
+config RATIONAL_KUNIT_TEST
+       tristate "KUnit test for rational.c" if !KUNIT_ALL_TESTS
+       depends on KUNIT
+       select RATIONAL
+       default KUNIT_ALL_TESTS
+       help
+         This builds the rational math unit test.
+         For more information on KUnit and unit tests in general please refer
+         to the KUnit documentation in Documentation/dev-tools/kunit/.
+
+         If unsure, say N.
+
 config TEST_UDELAY
        tristate "udelay test driver"
        help
lib/math/Makefile +1 -0
index 7456edb864fc..de7d16ca3cf5 100644
@@ -6,3 +6,4 @@ obj-$(CONFIG_PRIME_NUMBERS)     += prime_numbers.o
 obj-$(CONFIG_RATIONAL)         += rational.o
 
 obj-$(CONFIG_TEST_DIV64)       += test_div64.o
+obj-$(CONFIG_RATIONAL_KUNIT_TEST) += rational_kunit.o
lib/math/rational_kunit.c new file +59 -1
new file mode 100644
index 000000000000..439b06fdfe66
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <kunit/test.h>
+
+#include <linux/rational.h>
+
+struct rational_test_param {
+       unsigned long num, den;
+       unsigned long max_num, max_den;
+       unsigned long exp_num, exp_den;
+
+       const char *name;
+};
+
+static const struct rational_test_param test_parameters[] = {
+       { 1230, 10,     100, 20,        100, 1,    "Exceeds bounds, semi-convergent term > half last term" },
+       { 34567, 100,   120, 20,        120, 1,    "Exceeds bounds, semi-convergent term < half last term" },
+       { 1, 30,        100, 10,        0, 1,      "Closest to zero" },
+       { 1, 19,        100, 10,        1, 10,     "Closest to smallest non-zero" },
+       { 1155, 7735,   255, 255,       33, 221,   "Exact answer" },
+       { 27, 32,       16, 16,         11, 13,    "Convergent" },
+       { 67, 54,       17, 18,         5, 4,      "Convergent, semiconvergent term half convergent term" },
+       { 453, 182,     60, 60,         57, 23,    "Semiconvergent, semiconvergent term half convergent term" },
+       { 87, 32,       70, 32,         68, 25,    "Semiconvergent, numerator limit" },
+       { 14533, 4626,  15000, 2400,    7433, 2366, "Semiconvergent, demominator limit" },
+};
+
+static void get_desc(const struct rational_test_param *param, char *desc)
+{
+       strscpy(desc, param->name, KUNIT_PARAM_DESC_SIZE);
+}
+
+/* Creates function rational_gen_params */
+KUNIT_ARRAY_PARAM(rational, test_parameters, get_desc);
+
+static void rational_test(struct kunit *test)
+{
+       const struct rational_test_param *param =
+               (const struct rational_test_param *)test->param_value;
+       unsigned long n = 0, d = 0;
+
+       rational_best_approximation(param->num, param->den, param->max_num, param->max_den, &n, &d);
+       KUNIT_EXPECT_EQ(test, n, param->exp_num);
+       KUNIT_EXPECT_EQ(test, d, param->exp_den);
+}
+
+static struct kunit_case rational_test_cases[] = {
+       KUNIT_CASE_PARAM(rational_test, rational_gen_params),
+       {}
+};
+
+static struct kunit_suite rational_test_suite = {
+       .name = "rational",
+       .test_cases = rational_test_cases,
+};
+
+kunit_test_suites(&rational_test_suite);
+
+MODULE_LICENSE("GPL v2");
--

2.26.2

#3 lore raw
In reply to Trent Piepho
Quoted 9 lines · Trent Piepho

If the input is out of the range of the allowed values, either larger than the largest value or closer to zero than the smallest non-zero allowed value, then a division by zero would occur.

In the case of input too large, the division by zero will occur on the first iteration. The best result (largest allowed value) will be found by always choosing the semi-convergent and excluding the denominator based limit when finding it.

Quoted 6 lines

In the case of the input too small, the division by zero will occur on the second iteration. The numerator based semi-convergent should not be calculated to avoid the division by zero. But the semi-convergent vs previous convergent test is still needed, which effectively chooses between 0 (the previous convergent) vs the smallest allowed fraction (best semi-convergent) as the result.

What has been changed that you haven't applied my Rb tag?

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#4 lore raw
Quoted 10 lines · Andy Shevchenko
Quoted 9 lines · Trent Piepho

If the input is out of the range of the allowed values, either larger than the largest value or closer to zero than the smallest non-zero allowed value, then a division by zero would occur.

In the case of input too large, the division by zero will occur on the first iteration. The best result (largest allowed value) will be found by always choosing the semi-convergent and excluding the denominator based limit when finding it.

Quoted 8 lines
Quoted 6 lines

In the case of the input too small, the division by zero will occur on the second iteration. The numerator based semi-convergent should not be calculated to avoid the division by zero. But the semi-convergent vs previous convergent test is still needed, which effectively chooses between 0 (the previous convergent) vs the smallest allowed fraction (best semi-convergent) as the result.

What has been changed that you haven't applied my Rb tag?

Note, the b4 tool can easily collect them for you from previous thread.

Signature · 2 lines
With Best Regards,
Andy Shevchenko
#5 lore raw
In reply to Andy Shevchenko
Quoted 2 lines · Andy Shevchenko

What has been changed that you haven't applied my Rb tag?

I think I thought that was for patch 2, which changed (slightly). Patch 1 is unchanged and should have collected Rb.