Merge remote-tracking branch 'linus/master' into x86/urgent

1 files changed, 138 insertions, 98 deletions

diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 8fda3b3f7be8..e3bfcbe8a520 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -227,7 +227,7 @@ our $Inline	= qr{inline|__always_inline|noinline};
 our $Member     = qr{->$Ident|\.$Ident|\[[^]]*\]};
 our $Lval       = qr{$Ident(?:$Member)*};
 
-our $Constant   = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
+our $Constant   = qr{(?i:(?:[0-9]+|0x[0-9a-f]+)[ul]*)};
 our $Assignment = qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
 our $Compare    = qr{<=|>=|==|!=|<|>};
 our $Operators  = qr{
@@ -315,7 +315,7 @@ sub build_types {
         $NonptrType     = qr{
                         (?:$Modifier\s+|const\s+)*
                         (?:
-                                (?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)|
+                                (?:typeof|__typeof__)\s*\([^\)]*\)|
                                 (?:$typeTypedefs\b)|
                                 (?:${all}\b)
                         )
@@ -334,6 +334,7 @@ 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*};
+our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
 
 sub deparenthesize {
         my ($string) = @_;
@@ -676,6 +677,10 @@ sub ctx_statement_block {
                         if ($off >= $len) {
                                 last;
                         }
+                        if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
+                                $level++;
+                                $type = '#';
+                        }
                 }
                 $p = $c;
                 $c = substr($blk, $off, 1);
@@ -738,6 +743,13 @@ sub ctx_statement_block {
                                 last;
                         }
                 }
+                # Preprocessor commands end at the newline unless escaped.
+                if ($type eq '#' && $c eq "\n" && $p ne "\\") {
+                        $level--;
+                        $type = '';
+                        $off++;
+                        last;
+                }
                 $off++;
         }
         # We are truly at the end, so shuffle to the next line.
@@ -1020,7 +1032,7 @@ sub annotate_values {
                 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
                         print "CAST($1)\n" if ($dbg_values > 1);
                         push(@av_paren_type, $type);
-                        $type = 'C';
+                        $type = 'c';
 
                 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
                         print "DECLARE($1)\n" if ($dbg_values > 1);
@@ -1212,7 +1224,9 @@ sub possible {
                         case|
                         else|
                         asm|__asm__|
-                        do
+                        do|
+                        \#|
+                        \#\#|
                 )(?:\s|$)|
                 ^(?:typedef|struct|enum)\b
             )}x;
@@ -1359,6 +1373,7 @@ sub process {
         my %suppress_ifbraces;
         my %suppress_whiletrailers;
         my %suppress_export;
+        my $suppress_statement = 0;
 
         # Pre-scan the patch sanitizing the lines.
         # Pre-scan the patch looking for any __setup documentation.
@@ -1468,6 +1483,7 @@ sub process {
                         %suppress_ifbraces = ();
                         %suppress_whiletrailers = ();
                         %suppress_export = ();
+                        $suppress_statement = 0;
                         next;
 
 # track the line number as we move through the hunk, note that
@@ -1504,9 +1520,11 @@ sub process {
                 if ($line =~ /^diff --git.*?(\S+)$/) {
                         $realfile = $1;
                         $realfile =~ s@^([^/]*)/@@;
+                        $in_commit_log = 0;
                 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
                         $realfile = $1;
                         $realfile =~ s@^([^/]*)/@@;
+                        $in_commit_log = 0;
 
                         $p1_prefix = $1;
                         if (!$file && $tree && $p1_prefix ne '' &&
@@ -1546,7 +1564,8 @@ sub process {
                 }
 
 # Check signature styles
-                if ($line =~ /^(\s*)($signature_tags)(\s*)(.*)/) {
+                if (!$in_header_lines &&
+                    $line =~ /^(\s*)($signature_tags)(\s*)(.*)/) {
                         my $space_before = $1;
                         my $sign_off = $2;
                         my $space_after = $3;
@@ -1623,7 +1642,7 @@ sub process {
 # Check if it's the start of a commit log
 # (not a header line and we haven't seen the patch filename)
                 if ($in_header_lines && $realfile =~ /^$/ &&
-                    $rawline !~ /^(commit\b|from\b|\w+:).+$/i) {
+                    $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) {
                         $in_header_lines = 0;
                         $in_commit_log = 1;
                 }
@@ -1655,19 +1674,26 @@ sub process {
 # Only applies when adding the entry originally, after that we do not have
 # sufficient context to determine whether it is indeed long enough.
                 if ($realfile =~ /Kconfig/ &&
-                    $line =~ /\+\s*(?:---)?help(?:---)?$/) {
+                    $line =~ /.\s*config\s+/) {
                         my $length = 0;
                         my $cnt = $realcnt;
                         my $ln = $linenr + 1;
                         my $f;
+                        my $is_start = 0;
                         my $is_end = 0;
-                        while ($cnt > 0 && defined $lines[$ln - 1]) {
+                        for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
                                 $f = $lines[$ln - 1];
                                 $cnt-- if ($lines[$ln - 1] !~ /^-/);
                                 $is_end = $lines[$ln - 1] =~ /^\+/;
-                                $ln++;
 
                                 next if ($f =~ /^-/);
+
+                                if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) {
+                                        $is_start = 1;
+                                } elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {
+                                        $length = -1;
+                                }
+
                                 $f =~ s/^.//;
                                 $f =~ s/#.*//;
                                 $f =~ s/^\s+//;
@@ -1679,8 +1705,8 @@ sub process {
                                 $length++;
                         }
                         WARN("CONFIG_DESCRIPTION",
-                             "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_end && $length < 4);
-                        #print "is_end<$is_end> length<$length>\n";
+                             "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
+                        #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
                 }
 
                 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
@@ -1792,12 +1818,24 @@ sub process {
 # Check for potential 'bare' types
                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
                     $realline_next);
-                if ($realcnt && $line =~ /.\s*\S/) {
+#print "LINE<$line>\n";
+                if ($linenr >= $suppress_statement &&
+                    $realcnt && $line =~ /.\s*\S/) {
                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
                                 ctx_statement_block($linenr, $realcnt, 0);
                         $stat =~ s/\n./\n /g;
                         $cond =~ s/\n./\n /g;
 
+#print "linenr<$linenr> <$stat>\n";
+                        # If this statement has no statement boundaries within
+                        # it there is no point in retrying a statement scan
+                        # until we hit end of it.
+                        my $frag = $stat; $frag =~ s/;+\s*$//;
+                        if ($frag !~ /(?:{|;)/) {
+#print "skip<$line_nr_next>\n";
+                                $suppress_statement = $line_nr_next;
+                        }
+
                         # Find the real next line.
                         $realline_next = $line_nr_next;
                         if (defined $realline_next &&
@@ -1923,6 +1961,9 @@ sub process {
 
 # Check relative indent for conditionals and blocks.
                 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
+                        ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
+                                ctx_statement_block($linenr, $realcnt, 0)
+                                        if (!defined $stat);
                         my ($s, $c) = ($stat, $cond);
 
                         substr($s, 0, length($c), '');
@@ -2090,7 +2131,7 @@ sub process {
                         #   XXX(foo);
                         #   EXPORT_SYMBOL(something_foo);
                         my $name = $1;
-                        if ($stat =~ /^.([A-Z_]+)\s*\(\s*($Ident)/ &&
+                        if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
                             $name =~ /^${Ident}_$2/) {
 #print "FOO C name<$name>\n";
                                 $suppress_export{$realline_next} = 1;
@@ -2168,8 +2209,9 @@ sub process {
 
 # * goes on variable not on type
                 # (char*[ const])
-                if ($line =~ m{\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\)}) {
-                        my ($from, $to) = ($1, $1);
+                while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
+                        #print "AA<$1>\n";
+                        my ($from, $to) = ($2, $2);
 
                         # Should start with a space.
                         $to =~ s/^(\S)/ $1/;
@@ -2184,8 +2226,10 @@ sub process {
                                 ERROR("POINTER_LOCATION",
                                       "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr);
                         }
-                } elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) {
-                        my ($from, $to, $ident) = ($1, $1, $2);
+                }
+                while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
+                        #print "BB<$1>\n";
+                        my ($from, $to, $ident) = ($2, $2, $3);
 
                         # Should start with a space.
                         $to =~ s/^(\S)/ $1/;
@@ -2568,7 +2612,7 @@ sub process {
                         # Flatten any parentheses
                         $value =~ s/\(/ \(/g;
                         $value =~ s/\)/\) /g;
-                        while ($value =~ s/\[[^\{\}]*\]/1/ ||
+                        while ($value =~ s/\[[^\[\]]*\]/1/ ||
                                $value !~ /(?:$Ident|-?$Constant)\s*
                                              $Compare\s*
                                              (?:$Ident|-?$Constant)/x &&
@@ -2593,28 +2637,6 @@ sub process {
                         }
                 }
 
-# typecasts on min/max could be min_t/max_t
-                if ($line =~ /^\+(?:.*?)\b(min|max)\s*\($Typecast{0,1}($LvalOrFunc)\s*,\s*$Typecast{0,1}($LvalOrFunc)\s*\)/) {
-                        if (defined $2 || defined $8) {
-                                my $call = $1;
-                                my $cast1 = deparenthesize($2);
-                                my $arg1 = $3;
-                                my $cast2 = deparenthesize($8);
-                                my $arg2 = $9;
-                                my $cast;
-
-                                if ($cast1 ne "" && $cast2 ne "") {
-                                        $cast = "$cast1 or $cast2";
-                                } elsif ($cast1 ne "") {
-                                        $cast = $cast1;
-                                } else {
-                                        $cast = $cast2;
-                                }
-                                WARN("MINMAX",
-                                     "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . $herecurr);
-                        }
-                }
-
 # Need a space before open parenthesis after if, while etc
                 if ($line=~/\b(if|while|for|switch)\(/) {
                         ERROR("SPACING", "space required before the open parenthesis '('\n" . $herecurr);
@@ -2623,6 +2645,9 @@ sub process {
 # Check for illegal assignment in if conditional -- and check for trailing
 # statements after the conditional.
                 if ($line =~ /do\s*(?!{)/) {
+                        ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
+                                ctx_statement_block($linenr, $realcnt, 0)
+                                        if (!defined $stat);
                         my ($stat_next) = ctx_statement_block($line_nr_next,
                                                 $remain_next, $off_next);
                         $stat_next =~ s/\n./\n /g;
@@ -2778,47 +2803,13 @@ sub process {
                         my $cnt = $realcnt;
                         my ($off, $dstat, $dcond, $rest);
                         my $ctx = '';
-
-                        my $args = defined($1);
-
-                        # Find the end of the macro and limit our statement
-                        # search to that.
-                        while ($cnt > 0 && defined $lines[$ln - 1] &&
-                                $lines[$ln - 1] =~ /^(?:-|..*\\$)/)
-                        {
-                                $ctx .= $rawlines[$ln - 1] . "\n";
-                                $cnt-- if ($lines[$ln - 1] !~ /^-/);
-                                $ln++;
-                        }
-                        $ctx .= $rawlines[$ln - 1];
-
                         ($dstat, $dcond, $ln, $cnt, $off) =
-                                ctx_statement_block($linenr, $ln - $linenr + 1, 0);
+                                ctx_statement_block($linenr, $realcnt, 0);
+                        $ctx = $dstat;
                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
 
-                        # Extract the remainder of the define (if any) and
-                        # rip off surrounding spaces, and trailing \'s.
-                        $rest = '';
-                        while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) {
-                                #print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";
-                                if ($off != 0 || $lines[$ln - 1] !~ /^-/) {
-                                        $rest .= substr($lines[$ln - 1], $off) . "\n";
-                                        $cnt--;
-                                }
-                                $ln++;
-                                $off = 0;
-                        }
-                        $rest =~ s/\\\n.//g;
-                        $rest =~ s/^\s*//s;
-                        $rest =~ s/\s*$//s;
-
-                        # Clean up the original statement.
-                        if ($args) {
-                                substr($dstat, 0, length($dcond), '');
-                        } else {
-                                $dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;
-                        }
+                        $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
                         $dstat =~ s/$;//g;
                         $dstat =~ s/\\\n.//g;
                         $dstat =~ s/^\s*//s;
@@ -2827,7 +2818,7 @@ sub process {
                         # Flatten any parentheses and braces
                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
-                               $dstat =~ s/\[[^\{\}]*\]/1/)
+                               $dstat =~ s/\[[^\[\]]*\]/1/)
                         {
                         }
 
@@ -2844,23 +2835,32 @@ sub process {
                                 ^\"|\"$
                         }x;
                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
-                        if ($rest ne '' && $rest ne ',') {
-                                if ($rest !~ /while\s*\(/ &&
-                                    $dstat !~ /$exceptions/)
-                                {
-                                        ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
-                                              "Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
+                        if ($dstat ne '' &&
+                            $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
+                            $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
+                            $dstat !~ /^(?:$Ident|-?$Constant)$/ &&                     # 10 // foo()
+                            $dstat !~ /$exceptions/ &&
+                            $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
+                            $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
+                            $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
+                            $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
+                            $dstat !~ /^do\s*{/ &&                                      # do {...
+                            $dstat !~ /^\({/)                                           # ({...
+                        {
+                                $ctx =~ s/\n*$//;
+                                my $herectx = $here . "\n";
+                                my $cnt = statement_rawlines($ctx);
+
+                                for (my $n = 0; $n < $cnt; $n++) {
+                                        $herectx .= raw_line($linenr, $n) . "\n";
                                 }
 
-                        } elsif ($ctx !~ /;/) {
-                                if ($dstat ne '' &&
-                                    $dstat !~ /^(?:$Ident|-?$Constant)$/ &&
-                                    $dstat !~ /$exceptions/ &&
-                                    $dstat !~ /^\.$Ident\s*=/ &&
-                                    $dstat =~ /$Operators/)
-                                {
+                                if ($dstat =~ /;/) {
+                                        ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
+                                              "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
+                                } else {
                                         ERROR("COMPLEX_MACRO",
-                                              "Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
+                                              "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
                                 }
                         }
                 }
@@ -3111,6 +3111,12 @@ sub process {
                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
                 }
 
+# Check for __attribute__ format(printf, prefer __printf
+                if ($line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
+                        WARN("PREFER_PRINTF",
+                             "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr);
+                }
+
 # check for sizeof(&)
                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
                         WARN("SIZEOF_ADDRESS",
@@ -3123,6 +3129,46 @@ sub process {
                              "Avoid line continuations in quoted strings\n" . $herecurr);
                 }
 
+# Check for misused memsets
+                if (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;
+
+                        if ($ms_size =~ /^(0x|)0$/i) {
+                                ERROR("MEMSET",
+                                      "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
+                        } elsif ($ms_size =~ /^(0x|)1$/i) {
+                                WARN("MEMSET",
+                                     "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
+                        }
+                }
+
+# typecasts on min/max could be min_t/max_t
+                if (defined $stat &&
+                    $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
+                        if (defined $2 || defined $8) {
+                                my $call = $1;
+                                my $cast1 = deparenthesize($2);
+                                my $arg1 = $3;
+                                my $cast2 = deparenthesize($8);
+                                my $arg2 = $9;
+                                my $cast;
+
+                                if ($cast1 ne "" && $cast2 ne "") {
+                                        $cast = "$cast1 or $cast2";
+                                } elsif ($cast1 ne "") {
+                                        $cast = $cast1;
+                                } else {
+                                        $cast = $cast2;
+                                }
+                                WARN("MINMAX",
+                                     "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
+                        }
+                }
+
 # check for new externs in .c files.
                 if ($realfile =~ /\.c$/ && defined $stat &&
                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
@@ -3294,12 +3340,6 @@ sub process {
                         WARN("EXPORTED_WORLD_WRITABLE",
                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
                 }
-
-                # Check for memset with swapped arguments
-                if ($line =~ /memset.*\,(\ |)(0x|)0(\ |0|)\);/) {
-                        ERROR("MEMSET",
-                              "memset size is 3rd argument, not the second.\n" . $herecurr);
-                }
         }
 
         # If we have no input at all, then there is nothing to report on