1 files changed, 181 insertions, 23 deletions

diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 9c9810030377..464dcef79b35 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -29,6 +29,7 @@ my $mailback = 0;
 my $summary_file = 0;
 my $show_types = 0;
 my $fix = 0;
+my $fix_inplace = 0;
 my $root;
 my %debug;
 my %camelcase = ();
@@ -76,6 +77,9 @@ Options:
                              "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
                              with potential errors corrected to the preferred
                              checkpatch style
+  --fix-inplace              EXPERIMENTAL - may create horrible results
+                             Is the same as --fix, but overwrites the input
+                             file.  It's your fault if there's no backup or git
   --ignore-perl-version      override checking of perl version.  expect
                              runtime errors.
   -h, --help, --version      display this help and exit
@@ -131,6 +135,7 @@ GetOptions(
         'mailback!'     => \$mailback,
         'summary-file!' => \$summary_file,
         'fix!'          => \$fix,
+        'fix-inplace!'  => \$fix_inplace,
         'ignore-perl-version!' => \$ignore_perl_version,
         'debug=s'       => \%debug,
         'test-only=s'   => \$tst_only,
@@ -140,6 +145,8 @@ GetOptions(
 
 help(0) if ($help);
 
+$fix = 1 if ($fix_inplace);
+
 my $exit = 0;
 
 if ($^V && $^V lt $minimum_perl_version) {
@@ -464,7 +471,7 @@ sub seed_camelcase_includes {
 
         $camelcase_seeded = 1;
 
-        if (-d ".git") {
+        if (-e ".git") {
                 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
                 chomp $git_last_include_commit;
                 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
@@ -492,7 +499,7 @@ sub seed_camelcase_includes {
                 return;
         }
 
-        if (-d ".git") {
+        if (-e ".git") {
                 $files = `git ls-files "include/*.h"`;
                 @include_files = split('\n', $files);
         }
@@ -1963,15 +1970,14 @@ sub process {
                 }
 
 # Check for FSF mailing addresses.
-                if ($rawline =~ /You should have received a copy/ ||
-                    $rawline =~ /write to the Free Software/ ||
-                    $rawline =~ /59 Temple Place/ ||
-                    $rawline =~ /51 Franklin Street/) {
+                if ($rawline =~ /\bwrite to the Free/i ||
+                    $rawline =~ /\b59\s+Temple\s+Pl/i ||
+                    $rawline =~ /\b51\s+Franklin\s+St/i) {
                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
                         my $msg_type = \&ERROR;
                         $msg_type = \&CHK if ($file);
                         &{$msg_type}("FSF_MAILING_ADDRESS",
-                                "Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.\n" . $herevet)
+                                     "Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.\n" . $herevet)
                 }
 
 # check for Kconfig help text having a real description
@@ -2034,6 +2040,33 @@ sub process {
                              "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
                 }
 
+# check for DT compatible documentation
+                if (defined $root && $realfile =~ /\.dts/ &&
+                    $rawline =~ /^\+\s*compatible\s*=/) {
+                        my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
+
+                        foreach my $compat (@compats) {
+                                my $compat2 = $compat;
+                                my $dt_path =  $root . "/Documentation/devicetree/bindings/";
+                                $compat2 =~ s/\,[a-z]*\-/\,<\.\*>\-/;
+                                `grep -Erq "$compat|$compat2" $dt_path`;
+                                if ( $? >> 8 ) {
+                                        WARN("UNDOCUMENTED_DT_STRING",
+                                             "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
+                                }
+
+                                my $vendor = $compat;
+                                my $vendor_path = $dt_path . "vendor-prefixes.txt";
+                                next if (! -f $vendor_path);
+                                $vendor =~ s/^([a-zA-Z0-9]+)\,.*/$1/;
+                                `grep -Eq "$vendor" $vendor_path`;
+                                if ( $? >> 8 ) {
+                                        WARN("UNDOCUMENTED_DT_STRING",
+                                             "DT compatible string vendor \"$vendor\" appears un-documented -- check $vendor_path\n" . $herecurr);
+                                }
+                        }
+                }
+
 # check we are in a valid source file if not then ignore this hunk
                 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
 
@@ -2049,16 +2082,12 @@ sub process {
                 }
 
 # 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).
+# to grep for the string.  Make exceptions when the previous string ends in a
+# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
+# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
                 if ($line =~ /^\+\s*"/ &&
                     $prevline =~ /"\s*$/ &&
-                    $prevline =~ /\(/ &&
-                    $prevrawline !~ /\\n(?:\\t)*"\s*$/) {
+                    $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
                         WARN("SPLIT_STRING",
                              "quoted string split across lines\n" . $hereprev);
                 }
@@ -2115,8 +2144,10 @@ sub process {
                         if (WARN("SPACE_BEFORE_TAB",
                                 "please, no space before tabs\n" . $herevet) &&
                             $fix) {
-                                $fixed[$linenr - 1] =~
-                                    s/(^\+.*) +\t/$1\t/;
+                                while ($fixed[$linenr - 1] =~
+                                           s/(^\+.*) {8,8}+\t/$1\t\t/) {}
+                                while ($fixed[$linenr - 1] =~
+                                           s/(^\+.*) +\t/$1\t/) {}
                         }
                 }
 
@@ -2634,10 +2665,22 @@ sub process {
                                 $herecurr);
                }
 
-# check for declarations of struct pci_device_id
-                if ($line =~ /\bstruct\s+pci_device_id\s+\w+\s*\[\s*\]\s*\=\s*\{/) {
-                        WARN("DEFINE_PCI_DEVICE_TABLE",
-                             "Use DEFINE_PCI_DEVICE_TABLE for struct pci_device_id\n" . $herecurr);
+# check for function declarations without arguments like "int foo()"
+                if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
+                        if (ERROR("FUNCTION_WITHOUT_ARGS",
+                                  "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
+                            $fix) {
+                                $fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
+                        }
+                }
+
+# check for uses of DEFINE_PCI_DEVICE_TABLE
+                if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
+                        if (WARN("DEFINE_PCI_DEVICE_TABLE",
+                                 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
+                            $fix) {
+                                $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
+                        }
                 }
 
 # check for new typedefs, only function parameters and sparse annotations
@@ -2802,6 +2845,65 @@ sub process {
                         }
                 }
 
+# Function pointer declarations
+# check spacing between type, funcptr, and args
+# canonical declaration is "type (*funcptr)(args...)"
+#
+# the $Declare variable will capture all spaces after the type
+# so check it for trailing missing spaces or multiple spaces
+                if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)$Ident(\s*)\)(\s*)\(/) {
+                        my $declare = $1;
+                        my $pre_pointer_space = $2;
+                        my $post_pointer_space = $3;
+                        my $funcname = $4;
+                        my $post_funcname_space = $5;
+                        my $pre_args_space = $6;
+
+                        if ($declare !~ /\s$/) {
+                                WARN("SPACING",
+                                     "missing space after return type\n" . $herecurr);
+                        }
+
+# unnecessary space "type  (*funcptr)(args...)"
+                        elsif ($declare =~ /\s{2,}$/) {
+                                WARN("SPACING",
+                                     "Multiple spaces after return type\n" . $herecurr);
+                        }
+
+# unnecessary space "type ( *funcptr)(args...)"
+                        if (defined $pre_pointer_space &&
+                            $pre_pointer_space =~ /^\s/) {
+                                WARN("SPACING",
+                                     "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
+                        }
+
+# unnecessary space "type (* funcptr)(args...)"
+                        if (defined $post_pointer_space &&
+                            $post_pointer_space =~ /^\s/) {
+                                WARN("SPACING",
+                                     "Unnecessary space before function pointer name\n" . $herecurr);
+                        }
+
+# unnecessary space "type (*funcptr )(args...)"
+                        if (defined $post_funcname_space &&
+                            $post_funcname_space =~ /^\s/) {
+                                WARN("SPACING",
+                                     "Unnecessary space after function pointer name\n" . $herecurr);
+                        }
+
+# unnecessary space "type (*funcptr) (args...)"
+                        if (defined $pre_args_space &&
+                            $pre_args_space =~ /^\s/) {
+                                WARN("SPACING",
+                                     "Unnecessary space before function pointer arguments\n" . $herecurr);
+                        }
+
+                        if (show_type("SPACING") && $fix) {
+                                $fixed[$linenr - 1] =~
+                                    s/^(.\s*$Declare)\(\s*\*\s*($Ident)\s*\)\s*\(/rtrim($1) . " " . "\(\*$2\)\("/ex;
+                        }
+                }
+
 # check for spacing round square brackets; allowed:
 #  1. with a type on the left -- int [] a;
 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
@@ -3122,7 +3224,7 @@ sub process {
                 }
 
 # check for whitespace before a non-naked semicolon
-                if ($line =~ /^\+.*\S\s+;/) {
+                if ($line =~ /^\+.*\S\s+;\s*$/) {
                         if (WARN("SPACING",
                                  "space prohibited before semicolon\n" . $herecurr) &&
                             $fix) {
@@ -3246,6 +3348,20 @@ sub process {
                         }
                 }
 
+# if statements using unnecessary parentheses - ie: if ((foo == bar))
+                if ($^V && $^V ge 5.10.0 &&
+                    $line =~ /\bif\s*((?:\(\s*){2,})/) {
+                        my $openparens = $1;
+                        my $count = $openparens =~ tr@\(@\(@;
+                        my $msg = "";
+                        if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
+                                my $comp = $4;  #Not $1 because of $LvalOrFunc
+                                $msg = " - maybe == should be = ?" if ($comp eq "==");
+                                WARN("UNNECESSARY_PARENTHESES",
+                                     "Unnecessary parentheses$msg\n" . $herecurr);
+                        }
+                }
+
 # Return of what appears to be an errno should normally be -'ve
                 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
                         my $name = $1;
@@ -3980,6 +4096,16 @@ sub process {
                         }
                 }
 
+# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
+                if ($^V && $^V ge 5.10.0 &&
+                    $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
+                        if (WARN("PREFER_ETHER_ADDR_COPY",
+                                 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
+                            $fix) {
+                                $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
+                        }
+                }
+
 # typecasts on min/max could be min_t/max_t
                 if ($^V && $^V ge 5.10.0 &&
                     defined $stat &&
@@ -4114,6 +4240,12 @@ sub process {
                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
                 }
 
+# check for GFP_NOWAIT use
+                if ($line =~ /\b__GFP_NOFAIL\b/) {
+                        WARN("__GFP_NOFAIL",
+                             "Use of __GFP_NOFAIL is deprecated, no new users should be added\n" . $herecurr);
+                }
+
 # check for multiple semicolons
                 if ($line =~ /;\s*;\s*$/) {
                         if (WARN("ONE_SEMICOLON",
@@ -4123,6 +4255,31 @@ sub process {
                         }
                 }
 
+# check for case / default statements not preceeded by break/fallthrough/switch
+                if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
+                        my $has_break = 0;
+                        my $has_statement = 0;
+                        my $count = 0;
+                        my $prevline = $linenr;
+                        while ($prevline > 1 && $count < 3 && !$has_break) {
+                                $prevline--;
+                                my $rline = $rawlines[$prevline - 1];
+                                my $fline = $lines[$prevline - 1];
+                                last if ($fline =~ /^\@\@/);
+                                next if ($fline =~ /^\-/);
+                                next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
+                                $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
+                                next if ($fline =~ /^.[\s$;]*$/);
+                                $has_statement = 1;
+                                $count++;
+                                $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
+                        }
+                        if (!$has_break && $has_statement) {
+                                WARN("MISSING_BREAK",
+                                     "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
+                        }
+                }
+
 # check for switch/default statements without a break;
                 if ($^V && $^V ge 5.10.0 &&
                     defined $stat &&
@@ -4358,7 +4515,8 @@ sub process {
         hash_show_words(\%ignore_type, "Ignored");
 
         if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
-                my $newfile = $filename . ".EXPERIMENTAL-checkpatch-fixes";
+                my $newfile = $filename;
+                $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
                 my $linecount = 0;
                 my $f;