Skip to contentSkip to conversation

coccinelle: semantic patch to check for inappropriate do_div() calls

PATCH Superseded Wen Yang 3 participants 10 messages Jan 4, 2020 – Jan 5, 2020

Subsystems (2)

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore

Wen Yang

author
#0 lore raw

PATCH 1/1 coccinelle: semantic patch to check for inappropriate do_div() calls

do_div() does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,
do_div() truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division.
This semantic patch is inspired by Mateusz Guzik's patch:
commit b0ab99e7736a ("sched: Fix possible divide by zero in avg_atom() calculation")

Cc Julia Lawall <[email protected]>
Cc Gilles Muller <[email protected]>
Cc Nicolas Palix <[email protected]>
Cc Michal Marek <[email protected]>
Cc Matthias Maennich <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Masahiro Yamada <[email protected]>
Cc Thomas Gleixner <[email protected]>
---
 scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 scripts/coccinelle/misc/do_div.cocci
scripts/coccinelle/misc/do_div.cocci new file +66 -0
new file mode 100644
index 0000000..f1b72d1
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/// do_div() does a 64-by-32 division.
+/// When the divisor is unsigned long, u64, or s64,
+/// do_div() truncates it to 32 bits, this means it
+/// can test non-zero and be truncated to zero for division.
+///
+//# This makes an effort to find those inappropriate do_div () calls.
+//
+// Confidence: Moderate
+// Copyright: (C) 2020 Wen Yang, Alibaba.
+// Comments:
+// Options: --no-includes --include-headers
+
+virtual context
+virtual org
+virtual report
+
+@depends on context@
+expression f;
+long l;
+unsigned long ul;
+u64 ul64;
+s64 sl64;
+
+@@
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)
+
+@r depends on (org || report)@
+expression f;
+long l;
+unsigned long ul;
+position p;
+u64 ul64;
+s64 sl64;
+@@
+(
+do_div@p(f, l);
+|
+do_div@p(f, ul);
+|
+do_div@p(f, ul64);
+|
+do_div@p(f, sl64);
+)
+
+@script:python depends on org@
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.org.print_todo(p[0], msg)
+
+@script:python depends on report@
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.report.print_report(p[0], msg)
Signature · 1 line
1.8.3.1
maintainer
#1 lore raw
Quoted 85 lines · Wen Yang

do_div() does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,
do_div() truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division.
This semantic patch is inspired by Mateusz Guzik's patch:
commit b0ab99e7736a ("sched: Fix possible divide by zero in avg_atom() calculation")

Cc Julia Lawall <[email protected]>
Cc Gilles Muller <[email protected]>
Cc Nicolas Palix <[email protected]>
Cc Michal Marek <[email protected]>
Cc Matthias Maennich <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Masahiro Yamada <[email protected]>
Cc Thomas Gleixner <[email protected]>
---
 scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 scripts/coccinelle/misc/do_div.cocci
scripts/coccinelle/misc/do_div.cocci new file +56 -0
new file mode 100644
index 0000000..f1b72d1
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/// do_div() does a 64-by-32 division.
+/// When the divisor is unsigned long, u64, or s64,
+/// do_div() truncates it to 32 bits, this means it
+/// can test non-zero and be truncated to zero for division.
+///
+//# This makes an effort to find those inappropriate do_div () calls.
+//
+// Confidence: Moderate
+// Copyright: (C) 2020 Wen Yang, Alibaba.
+// Comments:
+// Options: --no-includes --include-headers
+
+virtual context
+virtual org
+virtual report
+
+@depends on context@
+expression f;
+long l;
+unsigned long ul;
+u64 ul64;
+s64 sl64;
+
+@@
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)
+
+@r depends on (org || report)@
+expression f;
+long l;
+unsigned long ul;
+position p;
+u64 ul64;
+s64 sl64;
+@@
+(
+do_div@p(f, l);
+|
+do_div@p(f, ul);
+|
+do_div@p(f, ul64);
+|
+do_div@p(f, sl64);
+)
+
+@script:python depends on org@
+p << r.p;
+@@

scripts/coccinelle/misc/do_div.cocci line 66

Quoted 10 lines
scripts/coccinelle/misc/do_div.cocci new file +10 -0
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.org.print_todo(p[0], msg)
+
+@script:python depends on report@
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.report.print_report(p[0], msg)

A few small issues: You have WARNING: twice in each case, and truncation should be truncate.

Is there any generic strategy for fixing these issues?

julia
_______________________________________________
Cocci mailing list
[email protected]
https://systeme.lip6.fr/mailman/listinfo/cocci

author
#2 lore raw
Quoted 92 lines · Julia Lawall
Quoted 90 lines · Wen Yang

do_div() does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,
do_div() truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division.
This semantic patch is inspired by Mateusz Guzik's patch:
commit b0ab99e7736a ("sched: Fix possible divide by zero in avg_atom() calculation")

Cc Julia Lawall <[email protected]>
Cc Gilles Muller <[email protected]>
Cc Nicolas Palix <[email protected]>
Cc Michal Marek <[email protected]>
Cc Matthias Maennich <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Masahiro Yamada <[email protected]>
Cc Thomas Gleixner <[email protected]>
---
  scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++
  1 file changed, 66 insertions(+)

create mode 100644 scripts/coccinelle/misc/do_div.cocci

scripts/coccinelle/misc/do_div.cocci new file +61 -0
new file mode 100644
index 0000000..f1b72d1
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/// do_div() does a 64-by-32 division.
+/// When the divisor is unsigned long, u64, or s64,
+/// do_div() truncates it to 32 bits, this means it
+/// can test non-zero and be truncated to zero for division.
+///
+//# This makes an effort to find those inappropriate do_div () calls.
+//
+// Confidence: Moderate
+// Copyright: (C) 2020 Wen Yang, Alibaba.
+// Comments:
+// Options: --no-includes --include-headers
+
+virtual context
+virtual org
+virtual report
+
+@depends on context@
+expression f;
+long l;
+unsigned long ul;
+u64 ul64;
+s64 sl64;
+
+@@
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)
+
+@r depends on (org || report)@
+expression f;
+long l;
+unsigned long ul;
+position p;
+u64 ul64;
+s64 sl64;
+@@
+(
+do_div@p(f, l);
+|
+do_div@p(f, ul);
+|
+do_div@p(f, ul64);
+|
+do_div@p(f, sl64);
+)
+
+@script:python depends on org@
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.org.print_todo(p[0], msg)
+
+@script:python depends on report@
Quoted 9 lines

scripts/coccinelle/misc/do_div.cocci line 66

Quoted 5 lines
scripts/coccinelle/misc/do_div.cocci new file +5 -0
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.report.print_report(p[0], msg)

A few small issues: You have WARNING: twice in each case, and truncation should be truncate.

Thanks for your comments, we will fix it soon.

Quoted 2 lines

Is there any generic strategy for fixing these issues?

We have done some experiments, such as:
https://lkml.org/lkml/2020/1/2/1354

- avg = rec->time;
- do_div(avg, rec->counter);
+ avg = div64_ul(rec->time, rec->counter);

--> Function replacement was performed here,
and simple code cleanup was also performed.

- do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
+ stddev = div64_ul(stddev,
+ rec->counter * (rec->counter - 1) * 1000);

--> Only the function replacement is performed here (because the variable ‘stddev’ corresponds to a more complicated equation, cleaning it will reduce readability).

In addition, there are some codes that do not need to be modified:
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/net/can/dev.c#n263

So we just print a warning.
As for how to fix it, we need to analyze the code carefully.

Signature · 2 lines
Best Wishes,
Wen
maintainer
#3 lore raw
Quoted 110 lines · Wen Yang
Quoted 97 lines · Julia Lawall
Quoted 95 lines · Wen Yang

do_div() does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,
do_div() truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division. This semantic patch is inspired by Mateusz Guzik's patch:
commit b0ab99e7736a ("sched: Fix possible divide by zero in avg_atom() calculation")

Cc Julia Lawall <[email protected]>
Cc Gilles Muller <[email protected]>
Cc Nicolas Palix <[email protected]>
Cc Michal Marek <[email protected]>
Cc Matthias Maennich <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Masahiro Yamada <[email protected]>
Cc Thomas Gleixner <[email protected]>
---
  scripts/coccinelle/misc/do_div.cocci | 66
++++++++++++++++++++++++++++++++++++
  1 file changed, 66 insertions(+)

create mode 100644 scripts/coccinelle/misc/do_div.cocci

scripts/coccinelle/misc/do_div.cocci new file +58 -0
new file mode 100644
index 0000000..f1b72d1
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/// do_div() does a 64-by-32 division.
+/// When the divisor is unsigned long, u64, or s64,
+/// do_div() truncates it to 32 bits, this means it
+/// can test non-zero and be truncated to zero for division.
+///
+//# This makes an effort to find those inappropriate do_div () calls.
+//
+// Confidence: Moderate
+// Copyright: (C) 2020 Wen Yang, Alibaba.
+// Comments:
+// Options: --no-includes --include-headers
+
+virtual context
+virtual org
+virtual report
+
+@depends on context@
+expression f;
+long l;
+unsigned long ul;
+u64 ul64;
+s64 sl64;
+
+@@
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)
+
+@r depends on (org || report)@
+expression f;
+long l;
+unsigned long ul;
+position p;
+u64 ul64;
+s64 sl64;
+@@
+(
+do_div@p(f, l);
+|
+do_div@p(f, ul);
+|
+do_div@p(f, ul64);
+|
+do_div@p(f, sl64);
+)
+
+@script:python depends on org@
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may

truncation the divisor to 32-bit"

scripts/coccinelle/misc/do_div.cocci new file +4 -0
+coccilib.org.print_todo(p[0], msg)
+
+@script:python depends on report@
+p << r.p;
Quoted 9 lines
Quoted 5 lines

+@@

scripts/coccinelle/misc/do_div.cocci new file +2 -0
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may

truncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)

A few small issues: You have WARNING: twice in each case, and truncation should be truncate.

Quoted 7 lines

Thanks for your comments, we will fix it soon.

Quoted 2 lines

Is there any generic strategy for fixing these issues?

We have done some experiments, such as:
https://lkml.org/lkml/2020/1/2/1354

Thanks. Actually, I would appreciate knowing about such experiments when the semantic patch is submitted, since eg in this case I am not really an expert in this issue.

Quoted 14 lines
(quoted diff) +3 -5
-	avg = rec->time;
-	do_div(avg, rec->counter);
+	avg = div64_ul(rec->time, rec->counter);
 
--> Function replacement was performed here,
    and simple code cleanup was also performed.
 
 
-		do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
+		stddev = div64_ul(stddev,
+				  rec->counter * (rec->counter - 1) * 1000);
 
--> Only the function replacement is performed here (because the variable
Quoted 2 lines

‘stddev’ corresponds to a more complicated equation, cleaning it will reduce readability).

Would it be reasonable to extend the warning to say "consider using div64_ul instead"? Or do you think it is obvious to everyone?

Quoted 2 lines

In addition, there are some codes that do not need to be modified:
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/net/can/dev.c#n263

Would it be worth having a special case for constants and checking whether the value is obviously safe and no warning is needed?

thanks,
julia

Quoted 9 lines

So we just print a warning.
As for how to fix it, we need to analyze the code carefully.

--
Best Wishes,
Wen

author
#4 lore raw
Quoted 137 lines · Julia Lawall
Quoted 110 lines · Wen Yang
Quoted 97 lines · Julia Lawall
Quoted 95 lines · Wen Yang

do_div() does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,
do_div() truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division. This semantic patch is inspired by Mateusz Guzik's patch:
commit b0ab99e7736a ("sched: Fix possible divide by zero in avg_atom() calculation")

Cc Julia Lawall <[email protected]>
Cc Gilles Muller <[email protected]>
Cc Nicolas Palix <[email protected]>
Cc Michal Marek <[email protected]>
Cc Matthias Maennich <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Masahiro Yamada <[email protected]>
Cc Thomas Gleixner <[email protected]>
---
   scripts/coccinelle/misc/do_div.cocci | 66
++++++++++++++++++++++++++++++++++++
   1 file changed, 66 insertions(+)

create mode 100644 scripts/coccinelle/misc/do_div.cocci

scripts/coccinelle/misc/do_div.cocci new file +58 -0
new file mode 100644
index 0000000..f1b72d1
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/// do_div() does a 64-by-32 division.
+/// When the divisor is unsigned long, u64, or s64,
+/// do_div() truncates it to 32 bits, this means it
+/// can test non-zero and be truncated to zero for division.
+///
+//# This makes an effort to find those inappropriate do_div () calls.
+//
+// Confidence: Moderate
+// Copyright: (C) 2020 Wen Yang, Alibaba.
+// Comments:
+// Options: --no-includes --include-headers
+
+virtual context
+virtual org
+virtual report
+
+@depends on context@
+expression f;
+long l;
+unsigned long ul;
+u64 ul64;
+s64 sl64;
+
+@@
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)
+
+@r depends on (org || report)@
+expression f;
+long l;
+unsigned long ul;
+position p;
+u64 ul64;
+s64 sl64;
+@@
+(
+do_div@p(f, l);
+|
+do_div@p(f, ul);
+|
+do_div@p(f, ul64);
+|
+do_div@p(f, sl64);
+)
+
+@script:python depends on org@
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may

truncation the divisor to 32-bit"

scripts/coccinelle/misc/do_div.cocci new file +4 -0
+coccilib.org.print_todo(p[0], msg)
+
+@script:python depends on report@
+p << r.p;
Quoted 9 lines
Quoted 5 lines

+@@

scripts/coccinelle/misc/do_div.cocci new file +2 -0
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may

truncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)

A few small issues: You have WARNING: twice in each case, and truncation should be truncate.

Quoted 7 lines

Thanks for your comments, we will fix it soon.

Quoted 2 lines

Is there any generic strategy for fixing these issues?

We have done some experiments, such as:
https://lkml.org/lkml/2020/1/2/1354

Thanks. Actually, I would appreciate knowing about such experiments when the semantic patch is submitted, since eg in this case I am not really an expert in this issue.

Quoted 13 lines
(quoted diff) +3 -4
-	avg = rec->time;
-	do_div(avg, rec->counter);
+	avg = div64_ul(rec->time, rec->counter);
 
--> Function replacement was performed here,
     and simple code cleanup was also performed.
 
 
-		do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
+		stddev = div64_ul(stddev,
+				  rec->counter * (rec->counter - 1) * 1000);
Quoted 7 lines
Quoted 3 lines

--> Only the function replacement is performed here (because the variable ‘stddev’ corresponds to a more complicated equation, cleaning it will reduce readability).

Would it be reasonable to extend the warning to say "consider using div64_ul instead"? Or do you think it is obvious to everyone?

Thank you for your comments.
We plan to modify it as follows:
msg="WARNING: do_div() does a 64-by-32 division, please consider using div64_ul, div64_long, div64_u64 or div64_s64 instead."

Quoted 6 lines
Quoted 2 lines

In addition, there are some codes that do not need to be modified:
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/net/can/dev.c#n263

Would it be worth having a special case for constants and checking whether the value is obviously safe and no warning is needed?

Thanks.
This is very valuable in reducing false positives, and we'll try to implement it.

--
Best Wishes,
Wen

Quoted 10 lines
Quoted 9 lines

So we just print a warning.
As for how to fix it, we need to analyze the code carefully.

--
Best Wishes,
Wen

maintainer
#5 lore raw

--- Please note the new email address ---

Quoted 149 lines · Wen Yang
Quoted 137 lines · Julia Lawall
Quoted 110 lines · Wen Yang
Quoted 97 lines · Julia Lawall
Quoted 95 lines · Wen Yang

do_div() does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,
do_div() truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division. This semantic patch is inspired by Mateusz Guzik's patch:
commit b0ab99e7736a ("sched: Fix possible divide by zero in avg_atom() calculation")

Cc Julia Lawall <[email protected]>
Cc Gilles Muller <[email protected]>
Cc Nicolas Palix <[email protected]>
Cc Michal Marek <[email protected]>
Cc Matthias Maennich <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Masahiro Yamada <[email protected]>
Cc Thomas Gleixner <[email protected]>
---
   scripts/coccinelle/misc/do_div.cocci | 66
++++++++++++++++++++++++++++++++++++
   1 file changed, 66 insertions(+)

create mode 100644 scripts/coccinelle/misc/do_div.cocci

scripts/coccinelle/misc/do_div.cocci new file +58 -0
new file mode 100644
index 0000000..f1b72d1
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/// do_div() does a 64-by-32 division.
+/// When the divisor is unsigned long, u64, or s64,
+/// do_div() truncates it to 32 bits, this means it
+/// can test non-zero and be truncated to zero for division.
+///
+//# This makes an effort to find those inappropriate do_div () calls.
+//
+// Confidence: Moderate
+// Copyright: (C) 2020 Wen Yang, Alibaba.
+// Comments:
+// Options: --no-includes --include-headers
+
+virtual context
+virtual org
+virtual report
+
+@depends on context@
+expression f;
+long l;
+unsigned long ul;
+u64 ul64;
+s64 sl64;
+
+@@
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)
+
+@r depends on (org || report)@
+expression f;
+long l;
+unsigned long ul;
+position p;
+u64 ul64;
+s64 sl64;
+@@
+(
+do_div@p(f, l);
+|
+do_div@p(f, ul);
+|
+do_div@p(f, ul64);
+|
+do_div@p(f, sl64);
+)
+
+@script:python depends on org@
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may

truncation the divisor to 32-bit"

scripts/coccinelle/misc/do_div.cocci new file +4 -0
+coccilib.org.print_todo(p[0], msg)
+
+@script:python depends on report@
+p << r.p;
Quoted 9 lines
Quoted 5 lines

+@@

scripts/coccinelle/misc/do_div.cocci new file +2 -0
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may

truncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)

A few small issues: You have WARNING: twice in each case, and truncation should be truncate.

Quoted 7 lines

Thanks for your comments, we will fix it soon.

Quoted 2 lines

Is there any generic strategy for fixing these issues?

We have done some experiments, such as:
https://lkml.org/lkml/2020/1/2/1354

Thanks. Actually, I would appreciate knowing about such experiments when the semantic patch is submitted, since eg in this case I am not really an expert in this issue.

Quoted 13 lines
(quoted diff) +3 -4
-	avg = rec->time;
-	do_div(avg, rec->counter);
+	avg = div64_ul(rec->time, rec->counter);
 
--> Function replacement was performed here,
     and simple code cleanup was also performed.
 
 
-		do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
+		stddev = div64_ul(stddev,
+				  rec->counter * (rec->counter - 1) * 1000);
Quoted 8 lines
Quoted 4 lines

--> Only the function replacement is performed here (because the variable ‘stddev’ corresponds to a more complicated equation, cleaning it will reduce
readability).

Would it be reasonable to extend the warning to say "consider using div64_ul instead"? Or do you think it is obvious to everyone?

Quoted 4 lines

Thank you for your comments.
We plan to modify it as follows:
msg="WARNING: do_div() does a 64-by-32 division, please consider using div64_ul, div64_long, div64_u64 or div64_s64 instead."

This message seems helpful, thanks.

julia

Quoted 26 lines
Quoted 7 lines
Quoted 3 lines

In addition, there are some codes that do not need to be modified:
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/net/can/dev.c#n263

Would it be worth having a special case for constants and checking whether the value is obviously safe and no warning is needed?

Thanks.
This is very valuable in reducing false positives, and we'll try to implement it.

--
Best Wishes,
Wen

Quoted 10 lines
Quoted 9 lines

So we just print a warning.
As for how to fix it, we need to analyze the code carefully.

--
Best Wishes,
Wen

maintainer
#6 lore raw
In reply to Wen Yang

--- Please note the new email address ---

Quoted 4 lines · Wen Yang

do_div() does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64, do_div() truncates it to 32 bits, this means it can test non-zero and be truncated to zero for division.

Would it be worth having a specific warning message for the long/unsigned long case? If the target architecture has 32 bit longs then the warning can be immediately ignored.

julia

Quoted 95 lines

This semantic patch is inspired by Mateusz Guzik's patch:
commit b0ab99e7736a ("sched: Fix possible divide by zero in avg_atom() calculation")

Cc Julia Lawall <[email protected]>
Cc Gilles Muller <[email protected]>
Cc Nicolas Palix <[email protected]>
Cc Michal Marek <[email protected]>
Cc Matthias Maennich <[email protected]>
Cc Greg Kroah-Hartman <[email protected]>
Cc Masahiro Yamada <[email protected]>
Cc Thomas Gleixner <[email protected]>
---
 scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 scripts/coccinelle/misc/do_div.cocci
scripts/coccinelle/misc/do_div.cocci new file +66 -1
new file mode 100644
index 0000000..f1b72d1
@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/// do_div() does a 64-by-32 division.
+/// When the divisor is unsigned long, u64, or s64,
+/// do_div() truncates it to 32 bits, this means it
+/// can test non-zero and be truncated to zero for division.
+///
+//# This makes an effort to find those inappropriate do_div () calls.
+//
+// Confidence: Moderate
+// Copyright: (C) 2020 Wen Yang, Alibaba.
+// Comments:
+// Options: --no-includes --include-headers
+
+virtual context
+virtual org
+virtual report
+
+@depends on context@
+expression f;
+long l;
+unsigned long ul;
+u64 ul64;
+s64 sl64;
+
+@@
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)
+
+@r depends on (org || report)@
+expression f;
+long l;
+unsigned long ul;
+position p;
+u64 ul64;
+s64 sl64;
+@@
+(
+do_div@p(f, l);
+|
+do_div@p(f, ul);
+|
+do_div@p(f, ul64);
+|
+do_div@p(f, sl64);
+)
+
+@script:python depends on org@
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.org.print_todo(p[0], msg)
+
+@script:python depends on report@
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.report.print_report(p[0], msg)
--

1.8.3.1

#7 lore raw
In reply to Wen Yang

scripts/coccinelle/misc/do_div.cocci line 16

Quoted 3 lines
scripts/coccinelle/misc/do_div.cocci new file +3 -0
+virtual context
+virtual org
+virtual report

The operation mode “patch” is not supported here.
Should the term “semantic code search” be used instead in the subject again?

scripts/coccinelle/misc/do_div.cocci line 34

Quoted 10 lines

+@@

scripts/coccinelle/misc/do_div.cocci new file +9 -0
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)

I suggest to avoid the specification of duplicate SmPL code.

+@@
+*do_div(f, \( l \| ul \| ul64 \| sl64 \) );

Will any more case distinctions become helpful?

scripts/coccinelle/misc/do_div.cocci line 66

Quoted 6 lines

+@script:python depends on report@

scripts/coccinelle/misc/do_div.cocci new file +5 -0
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.report.print_report(p[0], msg)

Please improve the message construction.

Regards,
Markus

maintainer
#8 lore raw
Quoted 6 lines · Markus Elfring

scripts/coccinelle/misc/do_div.cocci line 16

Quoted 3 lines
scripts/coccinelle/misc/do_div.cocci new file +3 -0
+virtual context
+virtual org
+virtual report

The operation mode “patch” is not supported here.
Should the term “semantic code search” be used instead in the subject again?

Doesn't matter,

Quoted 15 lines

scripts/coccinelle/misc/do_div.cocci line 34

Quoted 12 lines

+@@

scripts/coccinelle/misc/do_div.cocci new file +9 -0
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)

I suggest to avoid the specification of duplicate SmPL code.

Quoted 2 lines

+@@
+*do_div(f, \( l \| ul \| ul64 \| sl64 \) );

I don't se any point to this. The code matched will be the same in both cases. The original code is quite readable, without the ugly \( etc.

Quoted 4 lines

Will any more case distinctions become helpful?

Quoted 8 lines

scripts/coccinelle/misc/do_div.cocci line 66

Quoted 6 lines

+@script:python depends on report@

scripts/coccinelle/misc/do_div.cocci new file +5 -0
+p << r.p;
+@@
+
+msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit"
+coccilib.report.print_report(p[0], msg)

Please improve the message construction.

Please make more precise comments (I already made some suggestions, so it doesn't matter much here, but "please improve" does not provide any concrete guidance).

julia

#9 lore raw
Quoted 12 lines
Quoted 12 lines

scripts/coccinelle/misc/do_div.cocci line 34

Quoted 9 lines
scripts/coccinelle/misc/do_div.cocci new file +9 -0
+(
+* do_div(f, l);
+|
+* do_div(f, ul);
+|
+* do_div(f, ul64);
+|
+* do_div(f, sl64);
+)

I suggest to avoid the specification of duplicate SmPL code.

Quoted 4 lines
Quoted 2 lines

+@@
+*do_div(f, \( l \| ul \| ul64 \| sl64 \) );

I don't se any point to this.

Can such succinct SmPL code be occasionally desirable?

Quoted 1 line

The original code is quite readable,

Yes. - I dare to present a coding style alternative.

Quoted 1 line

without the ugly \( etc.

I wonder about this view.

Quoted 3 lines
Quoted 1 line

Please improve the message construction.

Please make more precise comments (I already made some suggestions,

Thus I omitted a repetition.

Quoted 2 lines

so it doesn't matter much here, but "please improve" does not provide any concrete guidance).

I guess that Wen Yang can know corresponding software design possibilities from previous development discussions.

Regards,
Markus