Add some test for get_count_order/long in test_bitops.c.
Signed-off-by: Wei Yang <[email protected]>
---
v2: merge the test into test_bitops.c
---
lib/Kconfig.debug | 10 +++++-----
lib/test_bitops.c | 40 ++++++++++++++++++++++++++++++++++++++--
2 files changed, 43 insertions(+), 7 deletions(-)
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index f80d5609798f..512111a72e34 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -1987,15 +1987,15 @@ config TEST_LKM
If unsure, say N.
config TEST_BITOPS
- tristate "Test module for compilation of clear_bit/set_bit operations"
+ tristate "Test module for compilation of bitops operations"
depends on m
help
This builds the "test_bitops" module that is much like the
TEST_LKM module except that it does a basic exercise of the
- clear_bit and set_bit macros to make sure there are no compiler
- warnings from C=1 sparse checker or -Wextra compilations. It has
- no dependencies and doesn't run or load unless explicitly requested
- by name. for example: modprobe test_bitops.
+ set/clear_bit macros and get_count_order/long to make sure there are
+ no compiler warnings from C=1 sparse checker or -Wextra
+ compilations. It has no dependencies and doesn't run or load unless
+ explicitly requested by name. for example: modprobe test_bitops.
If unsure, say N.
diff --git a/lib/test_bitops.c b/lib/test_bitops.c
index fd50b3ae4a14..702d5973a5b6 100644
--- a/lib/test_bitops.c
+++ b/lib/test_bitops.c
@@ -9,7 +9,11 @@
#include <linux/module.h>
#include <linux/printk.h>
-/* a tiny module only meant to test set/clear_bit */
+/* a tiny module only meant to test
+ *
+ * set/clear_bit
+ * get_count_order/long
+ */
/* use an enum because thats the most common BITMAP usage */
enum bitops_fun {
@@ -24,6 +28,26 @@ enum bitops_fun {
static DECLARE_BITMAP(g_bitmap, BITOPS_LENGTH);
+unsigned int order_comb[][2] = {
+ {0x00000003, 2},
+ {0x00000004, 2},
+ {0x00001fff, 13},
+ {0x00002000, 13},
+ {0x50000000, 31},
+ {0x80000000, 31},
+ {0x80003000, 32},
+};
+
+unsigned long order_comb_long[][2] = {
+ {0x0000000300000000, 34},
+ {0x0000000400000000, 34},
+ {0x00001fff00000000, 45},
+ {0x0000200000000000, 45},
+ {0x5000000000000000, 63},
+ {0x8000000000000000, 63},
+ {0x8000300000000000, 64},
+};
+
static int __init test_bitops_startup(void)
{
pr_warn("Loaded test module\n");
@@ -32,6 +56,18 @@ static int __init test_bitops_startup(void)
set_bit(BITOPS_11, g_bitmap);
set_bit(BITOPS_31, g_bitmap);
set_bit(BITOPS_88, g_bitmap);
+
+ for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
+ if (order_comb[i][1] != get_count_order(order_comb[i][0]))
+ pr_warn("get_count_order wrong for %x\n",
+ order_comb[i][0]); }
+
+ for (i = 0; i < ARRAY_SIZE(order_comb_long); i++) {
+ if (order_comb_long[i][1] !=
+ get_count_order_long(order_comb_long[i][0]))
+ pr_warn("get_count_order_long wrong for %lx\n",
+ order_comb_long[i][0]); }
+
return 0;
}
@@ -55,6 +91,6 @@ static void __exit test_bitops_unstartup(void)
module_init(test_bitops_startup);
module_exit(test_bitops_unstartup);
-MODULE_AUTHOR("Jesse Brandeburg <[email protected]>");
+MODULE_AUTHOR("Jesse Brandeburg <[email protected]>, Wei Yang <[email protected]>");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Bit testing module");
--
2.23.0
On Tue, Jun 02, 2020 at 10:37:28PM +0000, Wei Yang wrote:
> Add some test for get_count_order/long in test_bitops.c.
Thanks! LGTM,
Reviewed-by: Andy Shevchenko <[email protected]>
Note, we can have as many MODULE_AUTHOR() lines as we want.
> Signed-off-by: Wei Yang <[email protected]>
>
> ---
> v2: merge the test into test_bitops.c
> ---
> lib/Kconfig.debug | 10 +++++-----
> lib/test_bitops.c | 40 ++++++++++++++++++++++++++++++++++++++--
> 2 files changed, 43 insertions(+), 7 deletions(-)
>
> diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
> index f80d5609798f..512111a72e34 100644
> --- a/lib/Kconfig.debug
> +++ b/lib/Kconfig.debug
> @@ -1987,15 +1987,15 @@ config TEST_LKM
> If unsure, say N.
>
> config TEST_BITOPS
> - tristate "Test module for compilation of clear_bit/set_bit operations"
> + tristate "Test module for compilation of bitops operations"
> depends on m
> help
> This builds the "test_bitops" module that is much like the
> TEST_LKM module except that it does a basic exercise of the
> - clear_bit and set_bit macros to make sure there are no compiler
> - warnings from C=1 sparse checker or -Wextra compilations. It has
> - no dependencies and doesn't run or load unless explicitly requested
> - by name. for example: modprobe test_bitops.
> + set/clear_bit macros and get_count_order/long to make sure there are
> + no compiler warnings from C=1 sparse checker or -Wextra
> + compilations. It has no dependencies and doesn't run or load unless
> + explicitly requested by name. for example: modprobe test_bitops.
>
> If unsure, say N.
>
> diff --git a/lib/test_bitops.c b/lib/test_bitops.c
> index fd50b3ae4a14..702d5973a5b6 100644
> --- a/lib/test_bitops.c
> +++ b/lib/test_bitops.c
> @@ -9,7 +9,11 @@
> #include <linux/module.h>
> #include <linux/printk.h>
>
> -/* a tiny module only meant to test set/clear_bit */
> +/* a tiny module only meant to test
> + *
> + * set/clear_bit
> + * get_count_order/long
> + */
>
> /* use an enum because thats the most common BITMAP usage */
> enum bitops_fun {
> @@ -24,6 +28,26 @@ enum bitops_fun {
>
> static DECLARE_BITMAP(g_bitmap, BITOPS_LENGTH);
>
> +unsigned int order_comb[][2] = {
> + {0x00000003, 2},
> + {0x00000004, 2},
> + {0x00001fff, 13},
> + {0x00002000, 13},
> + {0x50000000, 31},
> + {0x80000000, 31},
> + {0x80003000, 32},
> +};
> +
> +unsigned long order_comb_long[][2] = {
> + {0x0000000300000000, 34},
> + {0x0000000400000000, 34},
> + {0x00001fff00000000, 45},
> + {0x0000200000000000, 45},
> + {0x5000000000000000, 63},
> + {0x8000000000000000, 63},
> + {0x8000300000000000, 64},
> +};
> +
> static int __init test_bitops_startup(void)
> {
> pr_warn("Loaded test module\n");
> @@ -32,6 +56,18 @@ static int __init test_bitops_startup(void)
> set_bit(BITOPS_11, g_bitmap);
> set_bit(BITOPS_31, g_bitmap);
> set_bit(BITOPS_88, g_bitmap);
> +
> + for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
> + if (order_comb[i][1] != get_count_order(order_comb[i][0]))
> + pr_warn("get_count_order wrong for %x\n",
> + order_comb[i][0]); }
> +
> + for (i = 0; i < ARRAY_SIZE(order_comb_long); i++) {
> + if (order_comb_long[i][1] !=
> + get_count_order_long(order_comb_long[i][0]))
> + pr_warn("get_count_order_long wrong for %lx\n",
> + order_comb_long[i][0]); }
> +
> return 0;
> }
>
> @@ -55,6 +91,6 @@ static void __exit test_bitops_unstartup(void)
> module_init(test_bitops_startup);
> module_exit(test_bitops_unstartup);
>
> -MODULE_AUTHOR("Jesse Brandeburg <[email protected]>");
> +MODULE_AUTHOR("Jesse Brandeburg <[email protected]>, Wei Yang <[email protected]>");
> MODULE_LICENSE("GPL");
> MODULE_DESCRIPTION("Bit testing module");
> --
> 2.23.0
>
--
With Best Regards,
Andy Shevchenko
On Wed, Jun 03, 2020 at 12:18:02PM +0300, Andy Shevchenko wrote:
>On Tue, Jun 02, 2020 at 10:37:28PM +0000, Wei Yang wrote:
>> Add some test for get_count_order/long in test_bitops.c.
>
>Thanks! LGTM,
>Reviewed-by: Andy Shevchenko <[email protected]>
>
>Note, we can have as many MODULE_AUTHOR() lines as we want.
>
Ah, got it.
>> Signed-off-by: Wei Yang <[email protected]>
>>
>> ---
>> v2: merge the test into test_bitops.c
>> ---
>> lib/Kconfig.debug | 10 +++++-----
>> lib/test_bitops.c | 40 ++++++++++++++++++++++++++++++++++++++--
>> 2 files changed, 43 insertions(+), 7 deletions(-)
>>
>> diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
>> index f80d5609798f..512111a72e34 100644
>> --- a/lib/Kconfig.debug
>> +++ b/lib/Kconfig.debug
>> @@ -1987,15 +1987,15 @@ config TEST_LKM
>> If unsure, say N.
>>
>> config TEST_BITOPS
>> - tristate "Test module for compilation of clear_bit/set_bit operations"
>> + tristate "Test module for compilation of bitops operations"
>> depends on m
>> help
>> This builds the "test_bitops" module that is much like the
>> TEST_LKM module except that it does a basic exercise of the
>> - clear_bit and set_bit macros to make sure there are no compiler
>> - warnings from C=1 sparse checker or -Wextra compilations. It has
>> - no dependencies and doesn't run or load unless explicitly requested
>> - by name. for example: modprobe test_bitops.
>> + set/clear_bit macros and get_count_order/long to make sure there are
>> + no compiler warnings from C=1 sparse checker or -Wextra
>> + compilations. It has no dependencies and doesn't run or load unless
>> + explicitly requested by name. for example: modprobe test_bitops.
>>
>> If unsure, say N.
>>
>> diff --git a/lib/test_bitops.c b/lib/test_bitops.c
>> index fd50b3ae4a14..702d5973a5b6 100644
>> --- a/lib/test_bitops.c
>> +++ b/lib/test_bitops.c
>> @@ -9,7 +9,11 @@
>> #include <linux/module.h>
>> #include <linux/printk.h>
>>
>> -/* a tiny module only meant to test set/clear_bit */
>> +/* a tiny module only meant to test
>> + *
>> + * set/clear_bit
>> + * get_count_order/long
>> + */
>>
>> /* use an enum because thats the most common BITMAP usage */
>> enum bitops_fun {
>> @@ -24,6 +28,26 @@ enum bitops_fun {
>>
>> static DECLARE_BITMAP(g_bitmap, BITOPS_LENGTH);
>>
>> +unsigned int order_comb[][2] = {
>> + {0x00000003, 2},
>> + {0x00000004, 2},
>> + {0x00001fff, 13},
>> + {0x00002000, 13},
>> + {0x50000000, 31},
>> + {0x80000000, 31},
>> + {0x80003000, 32},
>> +};
>> +
>> +unsigned long order_comb_long[][2] = {
>> + {0x0000000300000000, 34},
>> + {0x0000000400000000, 34},
>> + {0x00001fff00000000, 45},
>> + {0x0000200000000000, 45},
>> + {0x5000000000000000, 63},
>> + {0x8000000000000000, 63},
>> + {0x8000300000000000, 64},
>> +};
>> +
>> static int __init test_bitops_startup(void)
>> {
>> pr_warn("Loaded test module\n");
>> @@ -32,6 +56,18 @@ static int __init test_bitops_startup(void)
>> set_bit(BITOPS_11, g_bitmap);
>> set_bit(BITOPS_31, g_bitmap);
>> set_bit(BITOPS_88, g_bitmap);
>> +
>> + for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
>> + if (order_comb[i][1] != get_count_order(order_comb[i][0]))
>> + pr_warn("get_count_order wrong for %x\n",
>> + order_comb[i][0]); }
>> +
>> + for (i = 0; i < ARRAY_SIZE(order_comb_long); i++) {
>> + if (order_comb_long[i][1] !=
>> + get_count_order_long(order_comb_long[i][0]))
>> + pr_warn("get_count_order_long wrong for %lx\n",
>> + order_comb_long[i][0]); }
>> +
>> return 0;
>> }
>>
>> @@ -55,6 +91,6 @@ static void __exit test_bitops_unstartup(void)
>> module_init(test_bitops_startup);
>> module_exit(test_bitops_unstartup);
>>
>> -MODULE_AUTHOR("Jesse Brandeburg <[email protected]>");
>> +MODULE_AUTHOR("Jesse Brandeburg <[email protected]>, Wei Yang <[email protected]>");
>> MODULE_LICENSE("GPL");
>> MODULE_DESCRIPTION("Bit testing module");
>> --
>> 2.23.0
>>
>
>--
>With Best Regards,
>Andy Shevchenko
>
--
Wei Yang
Help you, Help me
Hi Wei,
On Wed, Jun 3, 2020 at 1:11 AM Wei Yang <[email protected]> wrote:
> Add some test for get_count_order/long in test_bitops.c.
>
> Signed-off-by: Wei Yang <[email protected]>
Thanks for your patch, which is now commit 7851d6639caeea40 ("lib:
test get_count_order/long in test_bitops.c") in linux-next.
> --- a/lib/test_bitops.c
> +++ b/lib/test_bitops.c
> @@ -24,6 +28,26 @@ enum bitops_fun {
>
> static DECLARE_BITMAP(g_bitmap, BITOPS_LENGTH);
>
> +unsigned int order_comb[][2] = {
> + {0x00000003, 2},
> + {0x00000004, 2},
> + {0x00001fff, 13},
> + {0x00002000, 13},
> + {0x50000000, 31},
> + {0x80000000, 31},
> + {0x80003000, 32},
> +};
> +
> +unsigned long order_comb_long[][2] = {
> + {0x0000000300000000, 34},
> + {0x0000000400000000, 34},
> + {0x00001fff00000000, 45},
> + {0x0000200000000000, 45},
> + {0x5000000000000000, 63},
> + {0x8000000000000000, 63},
> + {0x8000300000000000, 64},
> +};
[email protected] reported for m68k-allmodconfig:
lib/test_bitops.c:42:3: error: unsigned conversion from 'long long
int' to 'long unsigned int' changes value from '12884901888' to '0'
[-Werror=overflow]
lib/test_bitops.c:43:3: error: unsigned conversion from 'long long
int' to 'long unsigned int' changes value from '17179869184' to '0'
[-Werror=overflow]
lib/test_bitops.c:44:3: error: unsigned conversion from 'long long
int' to 'long unsigned int' changes value from '35180077121536' to '0'
[-Werror=overflow]
lib/test_bitops.c:45:3: error: unsigned conversion from 'long long
int' to 'long unsigned int' changes value from '35184372088832' to '0'
[-Werror=overflow]
lib/test_bitops.c:46:3: error: unsigned conversion from 'long long
int' to 'long unsigned int' changes value from '5764607523034234880'
to '0' [-Werror=overflow]
lib/test_bitops.c:47:3: error: conversion from 'long long unsigned
int' to 'long unsigned int' changes value from '9223372036854775808'
to '0' [-Werror=overflow]
lib/test_bitops.c:48:3: error: conversion from 'long long unsigned
int' to 'long unsigned int' changes value from '9223424813412909056'
to '0' [-Werror=overflow]
Indeed, on 32-bit, none of these values fit in unsigned long.
> static int __init test_bitops_startup(void)
> {
> pr_warn("Loaded test module\n");
> @@ -32,6 +56,18 @@ static int __init test_bitops_startup(void)
> set_bit(BITOPS_11, g_bitmap);
> set_bit(BITOPS_31, g_bitmap);
> set_bit(BITOPS_88, g_bitmap);
> +
> + for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
> + if (order_comb[i][1] != get_count_order(order_comb[i][0]))
> + pr_warn("get_count_order wrong for %x\n",
> + order_comb[i][0]); }
> +
> + for (i = 0; i < ARRAY_SIZE(order_comb_long); i++) {
> + if (order_comb_long[i][1] !=
> + get_count_order_long(order_comb_long[i][0]))
> + pr_warn("get_count_order_long wrong for %lx\n",
> + order_comb_long[i][0]); }
> +
> return 0;
BTW, shouldn't get_count_order_long() be tested with the values in
order_comb[], too?
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
On Thu, Jun 04, 2020 at 01:50:13PM +0200, Geert Uytterhoeven wrote:
>Hi Wei,
>
>On Wed, Jun 3, 2020 at 1:11 AM Wei Yang <[email protected]> wrote:
>> Add some test for get_count_order/long in test_bitops.c.
>>
>> Signed-off-by: Wei Yang <[email protected]>
>
>Thanks for your patch, which is now commit 7851d6639caeea40 ("lib:
>test get_count_order/long in test_bitops.c") in linux-next.
>
>> --- a/lib/test_bitops.c
>> +++ b/lib/test_bitops.c
>
>> @@ -24,6 +28,26 @@ enum bitops_fun {
>>
>> static DECLARE_BITMAP(g_bitmap, BITOPS_LENGTH);
>>
>> +unsigned int order_comb[][2] = {
>> + {0x00000003, 2},
>> + {0x00000004, 2},
>> + {0x00001fff, 13},
>> + {0x00002000, 13},
>> + {0x50000000, 31},
>> + {0x80000000, 31},
>> + {0x80003000, 32},
>> +};
>> +
>> +unsigned long order_comb_long[][2] = {
>> + {0x0000000300000000, 34},
>> + {0x0000000400000000, 34},
>> + {0x00001fff00000000, 45},
>> + {0x0000200000000000, 45},
>> + {0x5000000000000000, 63},
>> + {0x8000000000000000, 63},
>> + {0x8000300000000000, 64},
>> +};
>
>[email protected] reported for m68k-allmodconfig:
>
>lib/test_bitops.c:42:3: error: unsigned conversion from 'long long
>int' to 'long unsigned int' changes value from '12884901888' to '0'
>[-Werror=overflow]
>lib/test_bitops.c:43:3: error: unsigned conversion from 'long long
>int' to 'long unsigned int' changes value from '17179869184' to '0'
>[-Werror=overflow]
>lib/test_bitops.c:44:3: error: unsigned conversion from 'long long
>int' to 'long unsigned int' changes value from '35180077121536' to '0'
>[-Werror=overflow]
>lib/test_bitops.c:45:3: error: unsigned conversion from 'long long
>int' to 'long unsigned int' changes value from '35184372088832' to '0'
>[-Werror=overflow]
>lib/test_bitops.c:46:3: error: unsigned conversion from 'long long
>int' to 'long unsigned int' changes value from '5764607523034234880'
>to '0' [-Werror=overflow]
>lib/test_bitops.c:47:3: error: conversion from 'long long unsigned
>int' to 'long unsigned int' changes value from '9223372036854775808'
>to '0' [-Werror=overflow]
>lib/test_bitops.c:48:3: error: conversion from 'long long unsigned
>int' to 'long unsigned int' changes value from '9223424813412909056'
>to '0' [-Werror=overflow]
>
>Indeed, on 32-bit, none of these values fit in unsigned long.
>
Hmm... I didn't test on 32bit platform. Sorry for that.
>> static int __init test_bitops_startup(void)
>> {
>> pr_warn("Loaded test module\n");
>> @@ -32,6 +56,18 @@ static int __init test_bitops_startup(void)
>> set_bit(BITOPS_11, g_bitmap);
>> set_bit(BITOPS_31, g_bitmap);
>> set_bit(BITOPS_88, g_bitmap);
>> +
>> + for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
>> + if (order_comb[i][1] != get_count_order(order_comb[i][0]))
>> + pr_warn("get_count_order wrong for %x\n",
>> + order_comb[i][0]); }
>> +
>> + for (i = 0; i < ARRAY_SIZE(order_comb_long); i++) {
>> + if (order_comb_long[i][1] !=
>> + get_count_order_long(order_comb_long[i][0]))
>> + pr_warn("get_count_order_long wrong for %lx\n",
>> + order_comb_long[i][0]); }
>> +
>> return 0;
>
>BTW, shouldn't get_count_order_long() be tested with the values in
>order_comb[], too?
>
You mean
{0x0000000000000003, 2},
{0x0000000000000004, 2},
{0x0000000000001fff, 13},
{0x0000000000002000, 13},
{0x0000000050000000, 31},
{0x0000000080000000, 31},
{0x0000000080003000, 32},
>Gr{oetje,eeting}s,
>
> Geert
>
>--
>Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
>
>In personal conversations with technical people, I call myself a hacker. But
>when I'm talking to journalists I just say "programmer" or something like that.
> -- Linus Torvalds
--
Wei Yang
Help you, Help me
Hi Wei,
On Thu, Jun 4, 2020 at 2:28 PM Wei Yang <[email protected]> wrote:
> On Thu, Jun 04, 2020 at 01:50:13PM +0200, Geert Uytterhoeven wrote:
> >On Wed, Jun 3, 2020 at 1:11 AM Wei Yang <[email protected]> wrote:
> >> Add some test for get_count_order/long in test_bitops.c.
> >>
> >> Signed-off-by: Wei Yang <[email protected]>
> >
> >Thanks for your patch, which is now commit 7851d6639caeea40 ("lib:
> >test get_count_order/long in test_bitops.c") in linux-next.
> >
> >> --- a/lib/test_bitops.c
> >> +++ b/lib/test_bitops.c
> >
> >> @@ -24,6 +28,26 @@ enum bitops_fun {
> >>
> >> static DECLARE_BITMAP(g_bitmap, BITOPS_LENGTH);
> >>
> >> +unsigned int order_comb[][2] = {
> >> + {0x00000003, 2},
> >> + {0x00000004, 2},
> >> + {0x00001fff, 13},
> >> + {0x00002000, 13},
> >> + {0x50000000, 31},
> >> + {0x80000000, 31},
> >> + {0x80003000, 32},
> >> +};
> >> +
> >> +unsigned long order_comb_long[][2] = {
> >> + {0x0000000300000000, 34},
> >> + {0x0000000400000000, 34},
> >> + {0x00001fff00000000, 45},
> >> + {0x0000200000000000, 45},
> >> + {0x5000000000000000, 63},
> >> + {0x8000000000000000, 63},
> >> + {0x8000300000000000, 64},
> >> +};
> >
> >[email protected] reported for m68k-allmodconfig:
> >
> >lib/test_bitops.c:42:3: error: unsigned conversion from 'long long
> >int' to 'long unsigned int' changes value from '12884901888' to '0'
> >[-Werror=overflow]
> >lib/test_bitops.c:43:3: error: unsigned conversion from 'long long
> >int' to 'long unsigned int' changes value from '17179869184' to '0'
> >[-Werror=overflow]
> >lib/test_bitops.c:44:3: error: unsigned conversion from 'long long
> >int' to 'long unsigned int' changes value from '35180077121536' to '0'
> >[-Werror=overflow]
> >lib/test_bitops.c:45:3: error: unsigned conversion from 'long long
> >int' to 'long unsigned int' changes value from '35184372088832' to '0'
> >[-Werror=overflow]
> >lib/test_bitops.c:46:3: error: unsigned conversion from 'long long
> >int' to 'long unsigned int' changes value from '5764607523034234880'
> >to '0' [-Werror=overflow]
> >lib/test_bitops.c:47:3: error: conversion from 'long long unsigned
> >int' to 'long unsigned int' changes value from '9223372036854775808'
> >to '0' [-Werror=overflow]
> >lib/test_bitops.c:48:3: error: conversion from 'long long unsigned
> >int' to 'long unsigned int' changes value from '9223424813412909056'
> >to '0' [-Werror=overflow]
> >
> >Indeed, on 32-bit, none of these values fit in unsigned long.
> >
>
> Hmm... I didn't test on 32bit platform. Sorry for that.
>
> >> static int __init test_bitops_startup(void)
> >> {
> >> pr_warn("Loaded test module\n");
> >> @@ -32,6 +56,18 @@ static int __init test_bitops_startup(void)
> >> set_bit(BITOPS_11, g_bitmap);
> >> set_bit(BITOPS_31, g_bitmap);
> >> set_bit(BITOPS_88, g_bitmap);
> >> +
> >> + for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
> >> + if (order_comb[i][1] != get_count_order(order_comb[i][0]))
> >> + pr_warn("get_count_order wrong for %x\n",
> >> + order_comb[i][0]); }
> >> +
> >> + for (i = 0; i < ARRAY_SIZE(order_comb_long); i++) {
> >> + if (order_comb_long[i][1] !=
> >> + get_count_order_long(order_comb_long[i][0]))
> >> + pr_warn("get_count_order_long wrong for %lx\n",
> >> + order_comb_long[i][0]); }
> >> +
> >> return 0;
> >
> >BTW, shouldn't get_count_order_long() be tested with the values in
> >order_comb[], too?
> >
>
> You mean
>
> {0x0000000000000003, 2},
> {0x0000000000000004, 2},
> {0x0000000000001fff, 13},
> {0x0000000000002000, 13},
> {0x0000000050000000, 31},
> {0x0000000080000000, 31},
> {0x0000000080003000, 32},
Yes, those values. And those should work with get_count_order_long()
on both 32-bit and 64-bit.
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
On Thu, Jun 04, 2020 at 02:51:40PM +0200, Geert Uytterhoeven wrote:
>Hi Wei,
>
>On Thu, Jun 4, 2020 at 2:28 PM Wei Yang <[email protected]> wrote:
[...]
>>
>> You mean
>>
>> {0x0000000000000003, 2},
>> {0x0000000000000004, 2},
>> {0x0000000000001fff, 13},
>> {0x0000000000002000, 13},
>> {0x0000000050000000, 31},
>> {0x0000000080000000, 31},
>> {0x0000000080003000, 32},
>
>Yes, those values. And those should work with get_count_order_long()
>on both 32-bit and 64-bit.
Hi, Geert
To be frank, I am afraid I lack some of the skill to achieve this. Maybe you
could give some guide.
get_count_order_long() takes one parameter, which is of type unsigned long.
This one has different size on 32bit and 64bit platform. On 32bit platform,
those value would be truncated.
Would you mind giving me a hint on this?
What we may achieve is like the implementation of fls_long(). This one check
the size of unsigned long on running, and choose different function. We could
use ifdef to check the size of unsigned long and use different data to feed
get_count_order_long(). But I don't find a way to feed get_count_order_long()
with 64bit data on 32bit platform.
>
>Gr{oetje,eeting}s,
>
> Geert
>
>--
>Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
>
>In personal conversations with technical people, I call myself a hacker. But
>when I'm talking to journalists I just say "programmer" or something like that.
> -- Linus Torvalds
--
Wei Yang
Help you, Help me
On Fri, 5 Jun 2020 23:06:10 +0000 Wei Yang <[email protected]> wrote:
> On Thu, Jun 04, 2020 at 02:51:40PM +0200, Geert Uytterhoeven wrote:
> >Hi Wei,
> >
> >On Thu, Jun 4, 2020 at 2:28 PM Wei Yang <[email protected]> wrote:
> [...]
> >>
> >> You mean
> >>
> >> {0x0000000000000003, 2},
> >> {0x0000000000000004, 2},
> >> {0x0000000000001fff, 13},
> >> {0x0000000000002000, 13},
> >> {0x0000000050000000, 31},
> >> {0x0000000080000000, 31},
> >> {0x0000000080003000, 32},
> >
> >Yes, those values. And those should work with get_count_order_long()
> >on both 32-bit and 64-bit.
Geert meant "no, the values in order_comb[]" :)
We have a table of numbers in order_comb[] so we may as well feed them
into get_count_order_long() (as well as get_count_order()) just for a
bit more testing.
So how about the below? order_comb_long[] just can't be used on 32-bit
machines because their longs are 32-bit. If we had a
get_count_order_u64() then we could use it.
I haven't runtime tested this - could you please do so?
static unsigned int order_comb[][2] = {
{0x00000003, 2},
{0x00000004, 2},
{0x00001fff, 13},
{0x00002000, 13},
{0x50000000, 31},
{0x80000000, 31},
{0x80003000, 32},
};
#ifdef CONFIG_64BIT
static unsigned long order_comb_long[][2] = {
{0x0000000300000000, 34},
{0x0000000400000000, 34},
{0x00001fff00000000, 45},
{0x0000200000000000, 45},
{0x5000000000000000, 63},
{0x8000000000000000, 63},
{0x8000300000000000, 64},
};
#endif
static int __init test_bitops_startup(void)
{
int i;
pr_warn("Loaded test module\n");
set_bit(BITOPS_4, g_bitmap);
set_bit(BITOPS_7, g_bitmap);
set_bit(BITOPS_11, g_bitmap);
set_bit(BITOPS_31, g_bitmap);
set_bit(BITOPS_88, g_bitmap);
for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
if (order_comb[i][1] != get_count_order(order_comb[i][0]))
pr_warn("get_count_order wrong for %x\n",
order_comb[i][0]);
}
for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
if (order_comb[i][1] != get_count_order_long(order_comb[i][0]))
pr_warn("get_count_order_long wrong for %x\n",
order_comb[i][0]);
}
#ifdef CONFIG_64BIT
for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
if (order_comb_long[i][1] !=
get_count_order_long(order_comb_long[i][0]))
pr_warn("get_count_order_long wrong for %lx\n",
order_comb_long[i][0]);
}
#endif
return 0;
}
From: Andrew Morton <[email protected]>
Subject: lib-test-get_count_order-long-in-test_bitopsc-fix
Cc: Andy Shevchenko <[email protected]>
Cc: Christian Brauner <[email protected]>
Cc: Wei Yang <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
---
lib/test_bitops.c | 23 +++++++++++++++++------
1 file changed, 17 insertions(+), 6 deletions(-)
--- a/lib/test_bitops.c~lib-test-get_count_order-long-in-test_bitopsc-fix
+++ a/lib/test_bitops.c
@@ -28,7 +28,7 @@ enum bitops_fun {
static DECLARE_BITMAP(g_bitmap, BITOPS_LENGTH);
-unsigned int order_comb[][2] = {
+static unsigned int order_comb[][2] = {
{0x00000003, 2},
{0x00000004, 2},
{0x00001fff, 13},
@@ -38,7 +38,8 @@ unsigned int order_comb[][2] = {
{0x80003000, 32},
};
-unsigned long order_comb_long[][2] = {
+#ifdef CONFIG_64BIT
+static unsigned long order_comb_long[][2] = {
{0x0000000300000000, 34},
{0x0000000400000000, 34},
{0x00001fff00000000, 45},
@@ -47,6 +48,7 @@ unsigned long order_comb_long[][2] = {
{0x8000000000000000, 63},
{0x8000300000000000, 64},
};
+#endif
static int __init test_bitops_startup(void)
{
@@ -62,14 +64,23 @@ static int __init test_bitops_startup(vo
for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
if (order_comb[i][1] != get_count_order(order_comb[i][0]))
pr_warn("get_count_order wrong for %x\n",
- order_comb[i][0]); }
+ order_comb[i][0]);
+ }
- for (i = 0; i < ARRAY_SIZE(order_comb_long); i++) {
+ for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
+ if (order_comb[i][1] != get_count_order_long(order_comb[i][0]))
+ pr_warn("get_count_order_long wrong for %x\n",
+ order_comb[i][0]);
+ }
+
+#ifdef CONFIG_64BIT
+ for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
if (order_comb_long[i][1] !=
get_count_order_long(order_comb_long[i][0]))
pr_warn("get_count_order_long wrong for %lx\n",
- order_comb_long[i][0]); }
-
+ order_comb_long[i][0]);
+ }
+#endif
return 0;
}
_
On Fri, Jun 05, 2020 at 05:16:29PM -0700, Andrew Morton wrote:
>On Fri, 5 Jun 2020 23:06:10 +0000 Wei Yang <[email protected]> wrote:
>
>> On Thu, Jun 04, 2020 at 02:51:40PM +0200, Geert Uytterhoeven wrote:
>> >Hi Wei,
>> >
>> >On Thu, Jun 4, 2020 at 2:28 PM Wei Yang <[email protected]> wrote:
>> [...]
>> >>
>> >> You mean
>> >>
>> >> {0x0000000000000003, 2},
>> >> {0x0000000000000004, 2},
>> >> {0x0000000000001fff, 13},
>> >> {0x0000000000002000, 13},
>> >> {0x0000000050000000, 31},
>> >> {0x0000000080000000, 31},
>> >> {0x0000000080003000, 32},
>> >
>> >Yes, those values. And those should work with get_count_order_long()
>> >on both 32-bit and 64-bit.
>
>Geert meant "no, the values in order_comb[]" :)
>
>We have a table of numbers in order_comb[] so we may as well feed them
>into get_count_order_long() (as well as get_count_order()) just for a
>bit more testing.
>
>So how about the below? order_comb_long[] just can't be used on 32-bit
>machines because their longs are 32-bit. If we had a
>get_count_order_u64() then we could use it.
>
>I haven't runtime tested this - could you please do so?
>
>
>static unsigned int order_comb[][2] = {
> {0x00000003, 2},
> {0x00000004, 2},
> {0x00001fff, 13},
> {0x00002000, 13},
> {0x50000000, 31},
> {0x80000000, 31},
> {0x80003000, 32},
>};
>
>#ifdef CONFIG_64BIT
>static unsigned long order_comb_long[][2] = {
> {0x0000000300000000, 34},
> {0x0000000400000000, 34},
> {0x00001fff00000000, 45},
> {0x0000200000000000, 45},
> {0x5000000000000000, 63},
> {0x8000000000000000, 63},
> {0x8000300000000000, 64},
>};
>#endif
>
>static int __init test_bitops_startup(void)
>{
> int i;
>
> pr_warn("Loaded test module\n");
> set_bit(BITOPS_4, g_bitmap);
> set_bit(BITOPS_7, g_bitmap);
> set_bit(BITOPS_11, g_bitmap);
> set_bit(BITOPS_31, g_bitmap);
> set_bit(BITOPS_88, g_bitmap);
>
> for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
> if (order_comb[i][1] != get_count_order(order_comb[i][0]))
> pr_warn("get_count_order wrong for %x\n",
> order_comb[i][0]);
> }
>
> for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
> if (order_comb[i][1] != get_count_order_long(order_comb[i][0]))
> pr_warn("get_count_order_long wrong for %x\n",
> order_comb[i][0]);
> }
>
>#ifdef CONFIG_64BIT
> for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
> if (order_comb_long[i][1] !=
> get_count_order_long(order_comb_long[i][0]))
> pr_warn("get_count_order_long wrong for %lx\n",
> order_comb_long[i][0]);
> }
>#endif
> return 0;
>}
>
>
>From: Andrew Morton <[email protected]>
>Subject: lib-test-get_count_order-long-in-test_bitopsc-fix
>
>Cc: Andy Shevchenko <[email protected]>
>Cc: Christian Brauner <[email protected]>
>Cc: Wei Yang <[email protected]>
>Signed-off-by: Andrew Morton <[email protected]>
>---
>
> lib/test_bitops.c | 23 +++++++++++++++++------
> 1 file changed, 17 insertions(+), 6 deletions(-)
>
>--- a/lib/test_bitops.c~lib-test-get_count_order-long-in-test_bitopsc-fix
>+++ a/lib/test_bitops.c
>@@ -28,7 +28,7 @@ enum bitops_fun {
>
> static DECLARE_BITMAP(g_bitmap, BITOPS_LENGTH);
>
>-unsigned int order_comb[][2] = {
>+static unsigned int order_comb[][2] = {
> {0x00000003, 2},
> {0x00000004, 2},
> {0x00001fff, 13},
>@@ -38,7 +38,8 @@ unsigned int order_comb[][2] = {
> {0x80003000, 32},
> };
>
>-unsigned long order_comb_long[][2] = {
>+#ifdef CONFIG_64BIT
>+static unsigned long order_comb_long[][2] = {
> {0x0000000300000000, 34},
> {0x0000000400000000, 34},
> {0x00001fff00000000, 45},
>@@ -47,6 +48,7 @@ unsigned long order_comb_long[][2] = {
> {0x8000000000000000, 63},
> {0x8000300000000000, 64},
> };
>+#endif
>
> static int __init test_bitops_startup(void)
> {
>@@ -62,14 +64,23 @@ static int __init test_bitops_startup(vo
> for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
> if (order_comb[i][1] != get_count_order(order_comb[i][0]))
> pr_warn("get_count_order wrong for %x\n",
>- order_comb[i][0]); }
>+ order_comb[i][0]);
>+ }
>
>- for (i = 0; i < ARRAY_SIZE(order_comb_long); i++) {
>+ for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
>+ if (order_comb[i][1] != get_count_order_long(order_comb[i][0]))
>+ pr_warn("get_count_order_long wrong for %x\n",
>+ order_comb[i][0]);
>+ }
>+
>+#ifdef CONFIG_64BIT
>+ for (i = 0; i < ARRAY_SIZE(order_comb); i++) {
^
I am afraid this one should be order_comb_long?
The test on 64bit machine pass. Since I don't have a 32bit machine by hand,
Geert, would you mind have a try on 32bit machine?
> if (order_comb_long[i][1] !=
> get_count_order_long(order_comb_long[i][0]))
> pr_warn("get_count_order_long wrong for %lx\n",
>- order_comb_long[i][0]); }
>-
>+ order_comb_long[i][0]);
>+ }
>+#endif
> return 0;
> }
>
>_
--
Wei Yang
Help you, Help me
On Mon, Jun 08, 2020 at 10:31:12PM +0000, Wei Yang wrote:
> On Fri, Jun 05, 2020 at 05:16:29PM -0700, Andrew Morton wrote:
...
> The test on 64bit machine pass. Since I don't have a 32bit machine by hand,
Out of curiosity what that machine is?
> Geert, would you mind have a try on 32bit machine?
--
With Best Regards,
Andy Shevchenko
On Tue, Jun 09, 2020 at 12:16:49PM +0300, Andy Shevchenko wrote:
>On Mon, Jun 08, 2020 at 10:31:12PM +0000, Wei Yang wrote:
>> On Fri, Jun 05, 2020 at 05:16:29PM -0700, Andrew Morton wrote:
>
>...
>
>> The test on 64bit machine pass. Since I don't have a 32bit machine by hand,
>
>Out of curiosity what that machine is?
>
It is a Intel Xeon Gold CPU.
>> Geert, would you mind have a try on 32bit machine?
>
>--
>With Best Regards,
>Andy Shevchenko
>
--
Wei Yang
Help you, Help me
On Wed, Jun 10, 2020 at 2:06 AM Wei Yang <[email protected]> wrote:
> On Tue, Jun 09, 2020 at 12:16:49PM +0300, Andy Shevchenko wrote:
> >On Mon, Jun 08, 2020 at 10:31:12PM +0000, Wei Yang wrote:
> >> On Fri, Jun 05, 2020 at 05:16:29PM -0700, Andrew Morton wrote:
> >
> >...
> >
> >> The test on 64bit machine pass. Since I don't have a 32bit machine by hand,
> >
> >Out of curiosity what that machine is?
> >
>
> It is a Intel Xeon Gold CPU.
I suppose it's x86 (and not ia64).
In this case you can always build an i386 configuration and test on a
32-bit "machine".
--
With Best Regards,
Andy Shevchenko
On Wed, Jun 10, 2020 at 01:17:28PM +0300, Andy Shevchenko wrote:
>On Wed, Jun 10, 2020 at 2:06 AM Wei Yang <[email protected]> wrote:
>> On Tue, Jun 09, 2020 at 12:16:49PM +0300, Andy Shevchenko wrote:
>> >On Mon, Jun 08, 2020 at 10:31:12PM +0000, Wei Yang wrote:
>> >> On Fri, Jun 05, 2020 at 05:16:29PM -0700, Andrew Morton wrote:
>> >
>> >...
>> >
>> >> The test on 64bit machine pass. Since I don't have a 32bit machine by hand,
>> >
>> >Out of curiosity what that machine is?
>> >
>>
>> It is a Intel Xeon Gold CPU.
>
>I suppose it's x86 (and not ia64).
>In this case you can always build an i386 configuration and test on a
>32-bit "machine".
>
Yes, you are right. While last time I tried to run a 32bit guest, it took me a
lot of time to setup. If my understanding is correct, to run on a 32bit
machine, we not only need the kernel but a whole 32bit system. This means I
need to re-install a 32bit system. And I found many distro doesn't support
32bit system any more.
Do you have a better way to setup the environment?
>--
>With Best Regards,
>Andy Shevchenko
--
Wei Yang
Help you, Help me
On Thu, Jun 11, 2020 at 1:06 AM Wei Yang <[email protected]> wrote:
> On Wed, Jun 10, 2020 at 01:17:28PM +0300, Andy Shevchenko wrote:
> >On Wed, Jun 10, 2020 at 2:06 AM Wei Yang <[email protected]> wrote:
> >> On Tue, Jun 09, 2020 at 12:16:49PM +0300, Andy Shevchenko wrote:
> >> >On Mon, Jun 08, 2020 at 10:31:12PM +0000, Wei Yang wrote:
> >> >> On Fri, Jun 05, 2020 at 05:16:29PM -0700, Andrew Morton wrote:
> >> >
> >> >...
> >> >
> >> >> The test on 64bit machine pass. Since I don't have a 32bit machine by hand,
> >> >
> >> >Out of curiosity what that machine is?
> >> >
> >>
> >> It is a Intel Xeon Gold CPU.
> >
> >I suppose it's x86 (and not ia64).
> >In this case you can always build an i386 configuration and test on a
> >32-bit "machine".
> >
>
> Yes, you are right. While last time I tried to run a 32bit guest, it took me a
> lot of time to setup. If my understanding is correct, to run on a 32bit
> machine, we not only need the kernel but a whole 32bit system. This means I
> need to re-install a 32bit system. And I found many distro doesn't support
> 32bit system any more.
>
> Do you have a better way to setup the environment?
Yes, BuildRoot is your friend. I have a branch [1] to make it suitable
to create bootable images for x86 machines. There is a quick
instructions what it does provide.
[1]: https://github.com/andy-shev/buildroot/tree/intel/board/intel/common
--
With Best Regards,
Andy Shevchenko
On Thu, Jun 11, 2020 at 10:25:07AM +0300, Andy Shevchenko wrote:
>On Thu, Jun 11, 2020 at 1:06 AM Wei Yang <[email protected]> wrote:
>> On Wed, Jun 10, 2020 at 01:17:28PM +0300, Andy Shevchenko wrote:
>> >On Wed, Jun 10, 2020 at 2:06 AM Wei Yang <[email protected]> wrote:
>> >> On Tue, Jun 09, 2020 at 12:16:49PM +0300, Andy Shevchenko wrote:
>> >> >On Mon, Jun 08, 2020 at 10:31:12PM +0000, Wei Yang wrote:
>> >> >> On Fri, Jun 05, 2020 at 05:16:29PM -0700, Andrew Morton wrote:
>> >> >
>> >> >...
>> >> >
>> >> >> The test on 64bit machine pass. Since I don't have a 32bit machine by hand,
>> >> >
>> >> >Out of curiosity what that machine is?
>> >> >
>> >>
>> >> It is a Intel Xeon Gold CPU.
>> >
>> >I suppose it's x86 (and not ia64).
>> >In this case you can always build an i386 configuration and test on a
>> >32-bit "machine".
>> >
>>
>> Yes, you are right. While last time I tried to run a 32bit guest, it took me a
>> lot of time to setup. If my understanding is correct, to run on a 32bit
>> machine, we not only need the kernel but a whole 32bit system. This means I
>> need to re-install a 32bit system. And I found many distro doesn't support
>> 32bit system any more.
>>
>> Do you have a better way to setup the environment?
>
>Yes, BuildRoot is your friend. I have a branch [1] to make it suitable
>to create bootable images for x86 machines. There is a quick
>instructions what it does provide.
>
>[1]: https://github.com/andy-shev/buildroot/tree/intel/board/intel/common
>
Many thanks for your instruction. I will take a look into this.
>--
>With Best Regards,
>Andy Shevchenko
--
Wei Yang
Help you, Help me