Skip to contentSkip to conversation

checkpatch: fix multi-statement macro checks

RFC PATCH In review Dwaipayan Ray 3 participants 9 messages Oct 1, 2020 Checkpatch

lore
Share & tools
lore
#0 lore raw

RFC PATCH 1/1 checkpatch: fix multi-statement macro checks

Checkpatch.pl doesn't have a check for excluding while (...) {...} blocks from MULTISTATEMENT_MACRO_USE_DO_WHILE error.

For example, running checkpatch.pl on the file mm/access.c in the kernel generates the following error:

ERROR: Macros with complex values should be enclosed in parentheses
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label) \
+ while (len >= sizeof(type)) { \
+ __get_kernel_nofault(dst, src, type, err_label); \
+ dst += sizeof(type); \
+ src += sizeof(type); \
+ len -= sizeof(type); \
+ }

The error is misleading for this case. Enclosing it in parantheses doesn't make any sense.

Checkpatch already has an exception list for such common macro types. Added a new exception for while (...) {...} style blocks to the same. This effectively fixed the wrong error message.

---
 scripts/checkpatch.pl | 1 +
 1 file changed, 1 insertion(+)
scripts/checkpatch.pl +1 -0
index 72c4072307ea..c2c211374662 100755
@@ -5342,6 +5342,7 @@ sub process {
 			    $dstat !~ /^\.$Ident\s*=/ &&				# .foo =
 			    $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&		# stringification #foo
 			    $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&	# do {...} while (...); // do {...} while (...)
+			    $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ &&		# while (...) {...}
 			    $dstat !~ /^for\s*$Constant$/ &&				# for (...)
 			    $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&	# for (...) bar()
 			    $dstat !~ /^do\s*{/ &&					# do {...
Signature · 6 lines
2.27.0

_______________________________________________
Linux-kernel-mentees mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/linux-kernel-mentees
#1 lore raw
Quoted 15 lines · Dwaipayan Ray

Checkpatch.pl doesn't have a check for excluding while (...) {...} blocks from MULTISTATEMENT_MACRO_USE_DO_WHILE error.

For example, running checkpatch.pl on the file mm/access.c in the kernel generates the following error:

ERROR: Macros with complex values should be enclosed in parentheses

(quoted diff) +7 -0
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label)	\
+	while (len >= sizeof(type)) {					\
+		__get_kernel_nofault(dst, src, type, err_label);	\
+		dst += sizeof(type);					\
+		src += sizeof(type);					\
+		len -= sizeof(type);					\
+	}
Quoted 1 line

The error is misleading for this case. Enclosing it in parantheses

s/parantheses/parentheses/

In my previous review, I already pointed that spelling mistake; was there a mess-up with sending out the new patch?

I will start running a quick evaluation...

Quoted 27 lines

doesn't make any sense.

Checkpatch already has an exception list for such common macro types. Added a new exception for while (...) {...} style blocks to the same. This effectively fixed the wrong error message.

---
 scripts/checkpatch.pl | 1 +
 1 file changed, 1 insertion(+)
scripts/checkpatch.pl +1 -0
index 72c4072307ea..c2c211374662 100755
@@ -5342,6 +5342,7 @@ sub process {
 			    $dstat !~ /^\.$Ident\s*=/ &&				# .foo =
 			    $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&		# stringification #foo
 			    $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&	# do {...} while (...); // do {...} while (...)
+			    $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ &&		# while (...) {...}
 			    $dstat !~ /^for\s*$Constant$/ &&				# for (...)
 			    $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&	# for (...) bar()
 			    $dstat !~ /^do\s*{/ &&					# do {...
Signature · 1 line
2.27.0
maintainer
#2 lore raw
In reply to Dwaipayan Ray
Quoted 15 lines · Dwaipayan Ray

Checkpatch.pl doesn't have a check for excluding while (...) {...} blocks from MULTISTATEMENT_MACRO_USE_DO_WHILE error.

For example, running checkpatch.pl on the file mm/access.c in the kernel generates the following error:

ERROR: Macros with complex values should be enclosed in parentheses

(quoted diff) +7 -0
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label)	\
+	while (len >= sizeof(type)) {					\
+		__get_kernel_nofault(dst, src, type, err_label);	\
+		dst += sizeof(type);					\
+		src += sizeof(type);					\
+		len -= sizeof(type);					\
+	}
Quoted 2 lines

The error is misleading for this case. Enclosing it in parantheses doesn't make any sense.

OK

Quoted 3 lines

Checkpatch already has an exception list for such common macro types. Added a new exception for while (...) {...} style blocks to the same. This effectively fixed the wrong error message.

[]

scripts/checkpatch.pl

Quoted 1 line
scripts/checkpatch.pl +0 -0

[]

scripts/checkpatch.pl sub process { · line 5345

Quoted 5 lines
scripts/checkpatch.pl +1 -0
@@ -5342,6 +5342,7 @@ sub process {
 			    $dstat !~ /^\.$Ident\s*=/ &&				# .foo =
 			    $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&		# stringification #foo
 			    $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&	# do {...} while (...); // do {...} while (...)
+			    $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ &&		# while (...) {...}

Did you try to output $dstat for some matching cases? What was the $dstat value for the cases you tried?

#3 lore raw
Quoted 28 lines · Joe Perches
Quoted 15 lines · Dwaipayan Ray

Checkpatch.pl doesn't have a check for excluding while (...) {...} blocks from MULTISTATEMENT_MACRO_USE_DO_WHILE error.

For example, running checkpatch.pl on the file mm/access.c in the kernel generates the following error:

ERROR: Macros with complex values should be enclosed in parentheses

(quoted diff) +7 -0
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label)        \
+     while (len >= sizeof(type)) {                                   \
+             __get_kernel_nofault(dst, src, type, err_label);        \
+             dst += sizeof(type);                                    \
+             src += sizeof(type);                                    \
+             len -= sizeof(type);                                    \
+     }
Quoted 2 lines

The error is misleading for this case. Enclosing it in parantheses doesn't make any sense.

OK

Quoted 3 lines

Checkpatch already has an exception list for such common macro types. Added a new exception for while (...) {...} style blocks to the same. This effectively fixed the wrong error message.

[]

scripts/checkpatch.pl

Quoted 1 line
scripts/checkpatch.pl +0 -0

[]

Quoted 10 lines

scripts/checkpatch.pl sub process { · line 5345

Quoted 5 lines
scripts/checkpatch.pl +1 -0
@@ -5342,6 +5342,7 @@ sub process {
                          $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
                          $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
                          $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
+                         $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ &&           # while (...) {...}

Did you try to output $dstat for some matching cases? What was the $dstat value for the cases you tried?

Hi,
I did check $dstat values.

For example on file mm/maccess.c, there were two such macros:

Case 1:

$ctx:
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label) \
+ while (len >= sizeof(type)) { \
+ __get_kernel_nofault(dst, src, type, err_label); \
+ dst += sizeof(type); \
+ src += sizeof(type); \
+ len -= sizeof(type); \
+ }

$dstat:
while 1 1

Case 2:

$ctx:
+#define copy_to_kernel_nofault_loop(dst, src, len, type, err_label) \
+ while (len >= sizeof(type)) { \
+ __put_kernel_nofault(dst, src, type, err_label); \
+ dst += sizeof(type); \
+ src += sizeof(type); \
+ len -= sizeof(type); \
+ }

$dstat:
while 1 1

Thanks,
Dwaipayan.

maintainer
#4 lore raw
Quoted 25 lines · Dwaipayan Ray
Quoted 24 lines · Joe Perches
Quoted 15 lines · Dwaipayan Ray

Checkpatch.pl doesn't have a check for excluding while (...) {...} blocks from MULTISTATEMENT_MACRO_USE_DO_WHILE error.

For example, running checkpatch.pl on the file mm/access.c in the kernel generates the following error:

ERROR: Macros with complex values should be enclosed in parentheses

(quoted diff) +7 -0
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label)        \
+     while (len >= sizeof(type)) {                                   \
+             __get_kernel_nofault(dst, src, type, err_label);        \
+             dst += sizeof(type);                                    \
+             src += sizeof(type);                                    \
+             len -= sizeof(type);                                    \
+     }
Quoted 2 lines

The error is misleading for this case. Enclosing it in parantheses doesn't make any sense.

OK

Quoted 3 lines

Checkpatch already has an exception list for such common macro types. Added a new exception for while (...) {...} style blocks to the same. This effectively fixed the wrong error message.

Quoted 8 lines
Quoted 8 lines

[]

scripts/checkpatch.pl

Quoted 1 line
scripts/checkpatch.pl +0 -0

[]

scripts/checkpatch.pl sub process { · line 5345

Quoted 5 lines
scripts/checkpatch.pl +1 -0
@@ -5342,6 +5342,7 @@ sub process {
                          $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
                          $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
                          $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
+                         $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ &&           # while (...) {...}

Note the \s*

                                                              ^
Quoted 20 lines
Quoted 4 lines

Did you try to output $dstat for some matching cases? What was the $dstat value for the cases you tried?

Hi,
I did check $dstat values.

For example on file mm/maccess.c, there were two such macros:

Case 1:

$ctx:
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label) \
+ while (len >= sizeof(type)) { \
+ __get_kernel_nofault(dst, src, type, err_label); \
+ dst += sizeof(type); \
+ src += sizeof(type); \
+ len -= sizeof(type); \
+ }

Quoted 2 lines

$dstat:
while 1 1

And perhaps this test should use \s+ instead.
What is $dstat with a #define like:

#define foo(bar,baz)while(bar){bar--;baz++;}

(no spaces anywhere bot the required one after define

Quoted 17 lines

Case 2:

$ctx:
+#define copy_to_kernel_nofault_loop(dst, src, len, type, err_label) \
+ while (len >= sizeof(type)) { \
+ __put_kernel_nofault(dst, src, type, err_label); \
+ dst += sizeof(type); \
+ src += sizeof(type); \
+ len -= sizeof(type); \
+ }

$dstat:
while 1 1

Thanks,
Dwaipayan.

#5 lore raw
Quoted 62 lines · Joe Perches
Quoted 25 lines · Dwaipayan Ray
Quoted 24 lines · Joe Perches
Quoted 15 lines · Dwaipayan Ray

Checkpatch.pl doesn't have a check for excluding while (...) {...} blocks from MULTISTATEMENT_MACRO_USE_DO_WHILE error.

For example, running checkpatch.pl on the file mm/access.c in the kernel generates the following error:

ERROR: Macros with complex values should be enclosed in parentheses

(quoted diff) +7 -0
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label)        \
+     while (len >= sizeof(type)) {                                   \
+             __get_kernel_nofault(dst, src, type, err_label);        \
+             dst += sizeof(type);                                    \
+             src += sizeof(type);                                    \
+             len -= sizeof(type);                                    \
+     }
Quoted 2 lines

The error is misleading for this case. Enclosing it in parantheses doesn't make any sense.

OK

Quoted 3 lines

Checkpatch already has an exception list for such common macro types. Added a new exception for while (...) {...} style blocks to the same. This effectively fixed the wrong error message.

Quoted 8 lines
Quoted 8 lines

[]

scripts/checkpatch.pl

Quoted 1 line
scripts/checkpatch.pl +0 -0

[]

scripts/checkpatch.pl sub process { · line 5345

Quoted 5 lines
scripts/checkpatch.pl +1 -0
@@ -5342,6 +5342,7 @@ sub process {
                          $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
                          $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
                          $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
+                         $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ &&           # while (...) {...}

Note the \s*

                                                              ^
Quoted 20 lines
Quoted 4 lines

Did you try to output $dstat for some matching cases? What was the $dstat value for the cases you tried?

Hi,
I did check $dstat values.

For example on file mm/maccess.c, there were two such macros:

Case 1:

$ctx:
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label) \
+ while (len >= sizeof(type)) { \
+ __get_kernel_nofault(dst, src, type, err_label); \
+ dst += sizeof(type); \
+ src += sizeof(type); \
+ len -= sizeof(type); \
+ }

Quoted 2 lines

$dstat:
while 1 1

Quoted 7 lines

And perhaps this test should use \s+ instead.
What is $dstat with a #define like:

#define foo(bar,baz)while(bar){bar--;baz++;}

(no spaces anywhere bot the required one after define

In this case, $dstat is: while11

So, if \s+ is used, it won't match with this. I ran checkpatch on it and some other condition seems to match, so it is excluded from the error.

However, if the macro is like:

#define foo(bar,baz)while(bar) {bar--;baz++;}
(one space after condition)

$dstat is: while1 1
(space after first 1)
and the same error is again emitted.

So I think \s* works better since there can be
0 or more whitespaces between them.

Thanks,
Dwaipayan.

maintainer
#6 lore raw
Quoted 81 lines · Dwaipayan Ray
Quoted 61 lines · Joe Perches
Quoted 25 lines · Dwaipayan Ray
Quoted 24 lines · Joe Perches
Quoted 15 lines · Dwaipayan Ray

Checkpatch.pl doesn't have a check for excluding while (...) {...} blocks from MULTISTATEMENT_MACRO_USE_DO_WHILE error.

For example, running checkpatch.pl on the file mm/access.c in the kernel generates the following error:

ERROR: Macros with complex values should be enclosed in parentheses

(quoted diff) +7 -0
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label)        \
+     while (len >= sizeof(type)) {                                   \
+             __get_kernel_nofault(dst, src, type, err_label);        \
+             dst += sizeof(type);                                    \
+             src += sizeof(type);                                    \
+             len -= sizeof(type);                                    \
+     }
Quoted 2 lines

The error is misleading for this case. Enclosing it in parantheses doesn't make any sense.

OK

Quoted 3 lines

Checkpatch already has an exception list for such common macro types. Added a new exception for while (...) {...} style blocks to the same. This effectively fixed the wrong error message.

Quoted 8 lines
Quoted 8 lines

[]

scripts/checkpatch.pl

Quoted 1 line
scripts/checkpatch.pl +0 -0

[]

scripts/checkpatch.pl sub process { · line 5345

Quoted 5 lines
scripts/checkpatch.pl +1 -0
@@ -5342,6 +5342,7 @@ sub process {
                          $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
                          $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
                          $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
+                         $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ &&           # while (...) {...}

Note the \s*

                                                              ^
Quoted 20 lines
Quoted 4 lines

Did you try to output $dstat for some matching cases? What was the $dstat value for the cases you tried?

Hi,
I did check $dstat values.

For example on file mm/maccess.c, there were two such macros:

Case 1:

$ctx:
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label) \
+ while (len >= sizeof(type)) { \
+ __get_kernel_nofault(dst, src, type, err_label); \
+ dst += sizeof(type); \
+ src += sizeof(type); \
+ len -= sizeof(type); \
+ }

Quoted 2 lines

$dstat:
while 1 1

Quoted 7 lines

And perhaps this test should use \s+ instead.
What is $dstat with a #define like:

#define foo(bar,baz)while(bar){bar--;baz++;}

(no spaces anywhere bot the required one after define

In this case, $dstat is: while11

So, if \s+ is used, it won't match with this. I ran checkpatch on it and some other condition seems to match, so it is excluded from the error.

However, if the macro is like:

#define foo(bar,baz)while(bar) {bar--;baz++;}
(one space after condition)

Quoted 6 lines

$dstat is: while1 1
(space after first 1)
and the same error is again emitted.

So I think \s* works better since there can be
0 or more whitespaces between them.

All I'm trying to point out to you is that $Constant\s*$Constant isn't a proper test as the first $Constant will pull the test entire sequence of digits and the second $Constant will not be met.

It may take some conversion of the collapsing of the dstat block to work appropriately

			# Flatten any parentheses and braces
			while ($dstat =~ s/\([^\(\)]*\)/1/ ||
			       $dstat =~ s/\{[^\{\}]*\}/1/ ||
			       $dstat =~ s/.\[[^\[\]]*\]/1/)
			{
			}

Maybe the /1/ should be / 1 / but I didn't look to see what happens to the exclusion tests below that.

maintainer
#7 lore raw
Quoted 105 lines · Joe Perches
Quoted 81 lines · Dwaipayan Ray
Quoted 61 lines · Joe Perches
Quoted 25 lines · Dwaipayan Ray
Quoted 24 lines · Joe Perches
Quoted 15 lines · Dwaipayan Ray

Checkpatch.pl doesn't have a check for excluding while (...) {...} blocks from MULTISTATEMENT_MACRO_USE_DO_WHILE error.

For example, running checkpatch.pl on the file mm/access.c in the kernel generates the following error:

ERROR: Macros with complex values should be enclosed in parentheses

(quoted diff) +7 -0
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label)        \
+     while (len >= sizeof(type)) {                                   \
+             __get_kernel_nofault(dst, src, type, err_label);        \
+             dst += sizeof(type);                                    \
+             src += sizeof(type);                                    \
+             len -= sizeof(type);                                    \
+     }
Quoted 2 lines

The error is misleading for this case. Enclosing it in parantheses doesn't make any sense.

OK

Quoted 3 lines

Checkpatch already has an exception list for such common macro types. Added a new exception for while (...) {...} style blocks to the same. This effectively fixed the wrong error message.

Quoted 8 lines
Quoted 8 lines

[]

scripts/checkpatch.pl

Quoted 1 line
scripts/checkpatch.pl +0 -0

[]

scripts/checkpatch.pl sub process { · line 5345

Quoted 5 lines
scripts/checkpatch.pl +1 -0
@@ -5342,6 +5342,7 @@ sub process {
                          $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
                          $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
                          $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
+                         $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ &&           # while (...) {...}

Note the \s*

                                                              ^
Quoted 20 lines
Quoted 4 lines

Did you try to output $dstat for some matching cases? What was the $dstat value for the cases you tried?

Hi,
I did check $dstat values.

For example on file mm/maccess.c, there were two such macros:

Case 1:

$ctx:
+#define copy_from_kernel_nofault_loop(dst, src, len, type, err_label) \
+ while (len >= sizeof(type)) { \
+ __get_kernel_nofault(dst, src, type, err_label); \
+ dst += sizeof(type); \
+ src += sizeof(type); \
+ len -= sizeof(type); \
+ }

Quoted 2 lines

$dstat:
while 1 1

Quoted 7 lines

And perhaps this test should use \s+ instead.
What is $dstat with a #define like:

#define foo(bar,baz)while(bar){bar--;baz++;}

(no spaces anywhere bot the required one after define

In this case, $dstat is: while11

So, if \s+ is used, it won't match with this. I ran checkpatch on it and some other condition seems to match, so it is excluded from the error.

However, if the macro is like:

#define foo(bar,baz)while(bar) {bar--;baz++;}
(one space after condition)

Quoted 6 lines

$dstat is: while1 1
(space after first 1)
and the same error is again emitted.

So I think \s* works better since there can be
0 or more whitespaces between them.

All I'm trying to point out to you is that $Constant\s*$Constant isn't a proper test as the first $Constant will pull the test entire sequence of digits and the second $Constant will not be met.

It may take some conversion of the collapsing of the dstat block to work appropriately

			# Flatten any parentheses and braces
			while ($dstat =~ s/\([^\(\)]*\)/1/ ||
			       $dstat =~ s/\{[^\{\}]*\}/1/ ||
			       $dstat =~ s/.\[[^\[\]]*\]/1/)
			{
			}
Quoted 2 lines

Maybe the /1/ should be / 1 / but I didn't look to see what happens to the exclusion tests below that.

I think your patch would work well enough if the /1/ bits here were simply changed to /1u/.

1 is a $Constant as it's just a number.
11 though is also a $Constant.
1u is also a $Constant but it stops the acquisition of digits that 11 would not and the sequence of "while1u1u" should match your newly introduced test of $Constant\s*$Constant as "while11" would not match.

Quoted 1 line
#8 lore raw
Quoted 22 lines
Quoted 16 lines

All I'm trying to point out to you is that $Constant\s*$Constant isn't a proper test as the first $Constant will pull the test entire sequence of digits and the second $Constant will not be met.

It may take some conversion of the collapsing of the dstat block to work appropriately

                      # Flatten any parentheses and braces
                      while ($dstat =~ s/\([^\(\)]*\)/1/ ||
                             $dstat =~ s/\{[^\{\}]*\}/1/ ||
                             $dstat =~ s/.\[[^\[\]]*\]/1/)
                      {
                      }
Quoted 2 lines

Maybe the /1/ should be / 1 / but I didn't look to see what happens to the exclusion tests below that.

I think your patch would work well enough if the /1/ bits here were simply changed to /1u/.

Quoted 8 lines

1 is a $Constant as it's just a number.
11 though is also a $Constant.
1u is also a $Constant but it stops the acquisition of digits that 11 would not and the sequence of "while1u1u" should match your newly introduced test of $Constant\s*$Constant as "while11" would not match.

Hi,
That's an amazing idea! I tried it and this time it seems to detect it properly. Also this fixes the similar case in for(...) {...}.

It should not have any side effects also for other checks. Pretty amazing.

I will rewrite the patch with your suggestion and send it back.

Thanks,
Dwaipayan.
_______________________________________________
Linux-kernel-mentees mailing list
[email protected]
https://lists.linuxfoundation.org/mailman/listinfo/linux-kernel-mentees