1 files changed, 158 insertions, 25 deletions

diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index a3b9782441f9..de639eeeed50 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -323,17 +323,22 @@ sub build_types {
                   }x;
         $Type   = qr{
                         $NonptrType
-                        (?:[\s\*]+\s*const|[\s\*]+|(?:\s*\[\s*\])+)?
+                        (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*|\[\])+|(?:\s*\[\s*\])+)?
                         (?:\s+$Inline|\s+$Modifier)*
                   }x;
         $Declare        = qr{(?:$Storage\s+)?$Type};
 }
 build_types();
 
-our $match_balanced_parentheses = qr/(\((?:[^\(\)]+|(-1))*\))/;
 
 our $Typecast   = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
-our $LvalOrFunc = qr{($Lval)\s*($match_balanced_parentheses{0,1})\s*};
+
+# Using $balanced_parens, $LvalOrFunc, or $FuncArg
+# requires at least perl version v5.10.0
+# Any use must be runtime checked with $^V
+
+our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
+our $LvalOrFunc = qr{($Lval)\s*($balanced_parens{0,1})\s*};
 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
 
 sub deparenthesize {
@@ -1330,6 +1335,36 @@ sub check_absolute_file {
         }
 }
 
+sub pos_last_openparen {
+        my ($line) = @_;
+
+        my $pos = 0;
+
+        my $opens = $line =~ tr/\(/\(/;
+        my $closes = $line =~ tr/\)/\)/;
+
+        my $last_openparen = 0;
+
+        if (($opens == 0) || ($closes >= $opens)) {
+                return -1;
+        }
+
+        my $len = length($line);
+
+        for ($pos = 0; $pos < $len; $pos++) {
+                my $string = substr($line, $pos);
+                if ($string =~ /^($FuncArg|$balanced_parens)/) {
+                        $pos += length($1) - 1;
+                } elsif (substr($line, $pos, 1) eq '(') {
+                        $last_openparen = $pos;
+                } elsif (index($string, '(') == -1) {
+                        last;
+                }
+        }
+
+        return $last_openparen + 1;
+}
+
 sub process {
         my $filename = shift;
 
@@ -1737,6 +1772,21 @@ sub process {
                              "line over 80 characters\n" . $herecurr);
                 }
 
+# Check for user-visible strings broken across lines, which breaks the ability
+# to grep for the string.  Limited to strings used as parameters (those
+# following an open parenthesis), which almost completely eliminates false
+# positives, as well as warning only once per parameter rather than once per
+# line of the string.  Make an exception when the previous string ends in a
+# newline (multiple lines in one string constant) or \n\t (common in inline
+# assembly to indent the instruction on the following line).
+                if ($line =~ /^\+\s*"/ &&
+                    $prevline =~ /"\s*$/ &&
+                    $prevline =~ /\(/ &&
+                    $prevrawline !~ /\\n(?:\\t)*"\s*$/) {
+                        WARN("SPLIT_STRING",
+                             "quoted string split across lines\n" . $hereprev);
+                }
+
 # check for spaces before a quoted newline
                 if ($rawline =~ /^.*\".*\s\\n/) {
                         WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
@@ -1783,6 +1833,48 @@ sub process {
                              "please, no space before tabs\n" . $herevet);
                 }
 
+# check for && or || at the start of a line
+                if ($rawline =~ /^\+\s*(&&|\|\|)/) {
+                        CHK("LOGICAL_CONTINUATIONS",
+                            "Logical continuations should be on the previous line\n" . $hereprev);
+                }
+
+# check multi-line statement indentation matches previous line
+                if ($^V && $^V ge 5.10.0 &&
+                    $prevline =~ /^\+(\t*)(if \(|$Ident\().*(\&\&|\|\||,)\s*$/) {
+                        $prevline =~ /^\+(\t*)(.*)$/;
+                        my $oldindent = $1;
+                        my $rest = $2;
+
+                        my $pos = pos_last_openparen($rest);
+                        if ($pos >= 0) {
+                                $line =~ /^\+([ \t]*)/;
+                                my $newindent = $1;
+
+                                my $goodtabindent = $oldindent .
+                                        "\t" x ($pos / 8) .
+                                        " "  x ($pos % 8);
+                                my $goodspaceindent = $oldindent . " "  x $pos;
+
+                                if ($newindent ne $goodtabindent &&
+                                    $newindent ne $goodspaceindent) {
+                                        CHK("PARENTHESIS_ALIGNMENT",
+                                            "Alignment should match open parenthesis\n" . $hereprev);
+                                }
+                        }
+                }
+
+                if ($line =~ /^\+.*\*[ \t]*\)[ \t]+/) {
+                        CHK("SPACING",
+                            "No space is necessary after a cast\n" . $hereprev);
+                }
+
+                if ($rawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
+                    $prevrawline =~ /^\+[ \t]*$/) {
+                        CHK("BLOCK_COMMENT_STYLE",
+                            "Don't begin block comments with only a /* line, use /* comment...\n" . $hereprev);
+                }
+
 # check for spaces at the beginning of a line.
 # Exceptions:
 #  1) within comments
@@ -2325,7 +2417,7 @@ sub process {
                         my ($where, $prefix) = ($-[1], $1);
                         if ($prefix !~ /$Type\s+$/ &&
                             ($where != 0 || $prefix !~ /^.\s+$/) &&
-                            $prefix !~ /{\s+$/) {
+                            $prefix !~ /[{,]\s+$/) {
                                 ERROR("BRACKET_SPACE",
                                       "space prohibited before open square bracket '['\n" . $herecurr);
                         }
@@ -2828,6 +2920,12 @@ sub process {
                         {
                         }
 
+                        # Flatten any obvious string concatentation.
+                        while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
+                               $dstat =~ s/$Ident\s*("X*")/$1/)
+                        {
+                        }
+
                         my $exceptions = qr{
                                 $Declare|
                                 module_param_named|
@@ -2844,7 +2942,8 @@ sub process {
                         if ($dstat ne '' &&
                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
-                            $dstat !~ /^(?:$Ident|-?$Constant)$/ &&                     # 10 // foo()
+                            $dstat !~ /^[!~-]?(?:$Ident|$Constant)$/ &&         # 10 // foo() // !foo // ~foo // -foo
+                            $dstat !~ /^'X'$/ &&                                        # character constants
                             $dstat !~ /$exceptions/ &&
                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
@@ -2888,7 +2987,8 @@ sub process {
                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
                         if ($#chunks > 0 && $level == 0) {
-                                my $allowed = 0;
+                                my @allowed = ();
+                                my $allow = 0;
                                 my $seen = 0;
                                 my $herectx = $here . "\n";
                                 my $ln = $linenr - 1;
@@ -2899,6 +2999,7 @@ sub process {
                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
                                         my $offset = statement_rawlines($whitespace) - 1;
 
+                                        $allowed[$allow] = 0;
                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
 
                                         # We have looked at and allowed this specific line.
@@ -2911,23 +3012,34 @@ sub process {
 
                                         $seen++ if ($block =~ /^\s*{/);
 
-                                        #print "cond<$cond> block<$block> allowed<$allowed>\n";
+                                        #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
                                         if (statement_lines($cond) > 1) {
                                                 #print "APW: ALLOWED: cond<$cond>\n";
-                                                $allowed = 1;
+                                                $allowed[$allow] = 1;
                                         }
                                         if ($block =~/\b(?:if|for|while)\b/) {
                                                 #print "APW: ALLOWED: block<$block>\n";
-                                                $allowed = 1;
+                                                $allowed[$allow] = 1;
                                         }
                                         if (statement_block_size($block) > 1) {
                                                 #print "APW: ALLOWED: lines block<$block>\n";
-                                                $allowed = 1;
+                                                $allowed[$allow] = 1;
                                         }
+                                        $allow++;
                                 }
-                                if ($seen && !$allowed) {
-                                        WARN("BRACES",
-                                             "braces {} are not necessary for any arm of this statement\n" . $herectx);
+                                if ($seen) {
+                                        my $sum_allowed = 0;
+                                        foreach (@allowed) {
+                                                $sum_allowed += $_;
+                                        }
+                                        if ($sum_allowed == 0) {
+                                                WARN("BRACES",
+                                                     "braces {} are not necessary for any arm of this statement\n" . $herectx);
+                                        } elsif ($sum_allowed != $allow &&
+                                                 $seen != $allow) {
+                                                CHK("BRACES",
+                                                    "braces {} should be used on all arms of this statement\n" . $herectx);
+                                        }
                                 }
                         }
                 }
@@ -3123,6 +3235,12 @@ sub process {
                              "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr);
                 }
 
+# Check for __attribute__ format(scanf, prefer __scanf
+                if ($line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
+                        WARN("PREFER_SCANF",
+                             "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr);
+                }
+
 # check for sizeof(&)
                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
                         WARN("SIZEOF_ADDRESS",
@@ -3136,12 +3254,13 @@ sub process {
                 }
 
 # Check for misused memsets
-                if (defined $stat &&
+                if ($^V && $^V ge 5.10.0 &&
+                    defined $stat &&
                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
 
                         my $ms_addr = $2;
-                        my $ms_val = $8;
-                        my $ms_size = $14;
+                        my $ms_val = $7;
+                        my $ms_size = $12;
 
                         if ($ms_size =~ /^(0x|)0$/i) {
                                 ERROR("MEMSET",
@@ -3153,17 +3272,18 @@ sub process {
                 }
 
 # typecasts on min/max could be min_t/max_t
-                if (defined $stat &&
+                if ($^V && $^V ge 5.10.0 &&
+                    defined $stat &&
                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
-                        if (defined $2 || defined $8) {
+                        if (defined $2 || defined $7) {
                                 my $call = $1;
                                 my $cast1 = deparenthesize($2);
                                 my $arg1 = $3;
-                                my $cast2 = deparenthesize($8);
-                                my $arg2 = $9;
+                                my $cast2 = deparenthesize($7);
+                                my $arg2 = $8;
                                 my $cast;
 
-                                if ($cast1 ne "" && $cast2 ne "") {
+                                if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
                                         $cast = "$cast1 or $cast2";
                                 } elsif ($cast1 ne "") {
                                         $cast = $cast1;
@@ -3233,22 +3353,30 @@ sub process {
                              "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr);
                 }
 
+# check for use of yield()
+                if ($line =~ /\byield\s*\(\s*\)/) {
+                        WARN("YIELD",
+                             "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
+                }
+
 # check for semaphores initialized locked
                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
                         WARN("CONSIDER_COMPLETION",
                              "consider using a completion\n" . $herecurr);
-
                 }
+
 # recommend kstrto* over simple_strto* and strict_strto*
                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
                         WARN("CONSIDER_KSTRTO",
                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
                 }
+
 # check for __initcall(), use device_initcall() explicitly please
                 if ($line =~ /^.\s*__initcall\s*\(/) {
                         WARN("USE_DEVICE_INITCALL",
                              "please use device_initcall() instead of __initcall()\n" . $herecurr);
                 }
+
 # check for various ops structs, ensure they are const.
                 my $struct_ops = qr{acpi_dock_ops|
                                 address_space_operations|
@@ -3385,6 +3513,12 @@ sub process {
         }
 
         if ($quiet == 0) {
+
+                if ($^V lt 5.10.0) {
+                        print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
+                        print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
+                }
+
                 # If there were whitespace errors which cleanpatch can fix
                 # then suggest that.
                 if ($rpt_cleaners) {
@@ -3394,13 +3528,12 @@ sub process {
                 }
         }
 
-        if (keys %ignore_type) {
+        if ($quiet == 0 && keys %ignore_type) {
             print "NOTE: Ignored message types:";
             foreach my $ignore (sort keys %ignore_type) {
                 print " $ignore";
             }
-            print "\n";
-            print "\n" if ($quiet == 0);
+            print "\n\n";
         }
 
         if ($clean == 1 && $quiet == 0) {