1 files changed, 118 insertions, 48 deletions

diff --git a/scripts/checkpatch.pl b/scripts/checkpatch.pl
index 66cad506b8a2..61090e0ff613 100755
--- a/scripts/checkpatch.pl
+++ b/scripts/checkpatch.pl
@@ -241,8 +241,11 @@ our $Sparse	= qr{
                         __ref|
                         __rcu
                 }x;
-
-our $InitAttribute = qr{__(?:mem|cpu|dev|net_|)(?:initdata|initconst|init\b)};
+our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
+our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
+our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
+our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
+our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
 
 # Notes to $Attribute:
 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
@@ -323,7 +326,8 @@ our $logFunctions = qr{(?x:
         (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
         WARN(?:_RATELIMIT|_ONCE|)|
         panic|
-        MODULE_[A-Z_]+
+        MODULE_[A-Z_]+|
+        seq_vprintf|seq_printf|seq_puts
 )};
 
 our $signature_tags = qr{(?xi:
@@ -442,8 +446,9 @@ sub seed_camelcase_file {
                 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
                 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
                         $camelcase{$1} = 1;
-                }
-                elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*\(/) {
+                } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
+                        $camelcase{$1} = 1;
+                } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
                         $camelcase{$1} = 1;
                 }
         }
@@ -1512,6 +1517,14 @@ sub rtrim {
         return $string;
 }
 
+sub string_find_replace {
+        my ($string, $find, $replace) = @_;
+
+        $string =~ s/$find/$replace/g;
+
+        return $string;
+}
+
 sub tabify {
         my ($leading) = @_;
 
@@ -1612,6 +1625,8 @@ sub process {
         my @setup_docs = ();
         my $setup_docs = 0;
 
+        my $camelcase_file_seeded = 0;
+
         sanitise_line_reset();
         my $line;
         foreach my $rawline (@rawlines) {
@@ -1754,11 +1769,11 @@ sub process {
                 # extract the filename as it passes
                 if ($line =~ /^diff --git.*?(\S+)$/) {
                         $realfile = $1;
-                        $realfile =~ s@^([^/]*)/@@;
+                        $realfile =~ s@^([^/]*)/@@ if (!$file);
                         $in_commit_log = 0;
                 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
                         $realfile = $1;
-                        $realfile =~ s@^([^/]*)/@@;
+                        $realfile =~ s@^([^/]*)/@@ if (!$file);
                         $in_commit_log = 0;
 
                         $p1_prefix = $1;
@@ -1947,6 +1962,18 @@ sub process {
                         $rpt_cleaners = 1;
                 }
 
+# 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/) {
+                        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)
+                }
+
 # check for Kconfig help text having a real description
 # Only applies when adding the entry originally, after that we do not have
 # sufficient context to determine whether it is indeed long enough.
@@ -2838,7 +2865,7 @@ sub process {
                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
                                 =>|->|<<|>>|<|>|=|!|~|
                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
-                                \?|:
+                                \?:|\?|:
                         }x;
                         my @elements = split(/($ops|;)/, $opline);
 
@@ -3061,15 +3088,13 @@ sub process {
                                                 $ok = 1;
                                         }
 
-                                        # Ignore ?:
-                                        if (($opv eq ':O' && $ca =~ /\?$/) ||
-                                            ($op eq '?' && $cc =~ /^:/)) {
-                                                $ok = 1;
-                                        }
-
+                                        # messages are ERROR, but ?: are CHK
                                         if ($ok == 0) {
-                                                if (ERROR("SPACING",
-                                                          "spaces required around that '$op' $at\n" . $hereptr)) {
+                                                my $msg_type = \&ERROR;
+                                                $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
+
+                                                if (&{$msg_type}("SPACING",
+                                                                 "spaces required around that '$op' $at\n" . $hereptr)) {
                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
                                                         if (defined $fix_elements[$n + 2]) {
                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
@@ -3208,21 +3233,10 @@ sub process {
                 }
 
 # Return is not a function.
-                if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {
+                if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
                         my $spacing = $1;
-                        my $value = $2;
-
-                        # Flatten any parentheses
-                        $value =~ s/\(/ \(/g;
-                        $value =~ s/\)/\) /g;
-                        while ($value =~ s/\[[^\[\]]*\]/1/ ||
-                               $value !~ /(?:$Ident|-?$Constant)\s*
-                                             $Compare\s*
-                                             (?:$Ident|-?$Constant)/x &&
-                               $value =~ s/\([^\(\)]*\)/1/) {
-                        }
-#print "value<$value>\n";
-                        if ($value =~ /^\s*(?:$Ident|-?$Constant)\s*$/) {
+                        if ($^V && $^V ge 5.10.0 &&
+                            $stat =~ /^.\s*return\s*$balanced_parens\s*;\s*$/) {
                                 ERROR("RETURN_PARENTHESES",
                                       "return is not a function, parentheses are not required\n" . $herecurr);
 
@@ -3231,6 +3245,7 @@ sub process {
                                       "space required before the open parenthesis '('\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;
@@ -3396,7 +3411,13 @@ sub process {
                                 while ($var =~ m{($Ident)}g) {
                                         my $word = $1;
                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
-                                        seed_camelcase_includes() if ($check);
+                                        if ($check) {
+                                                seed_camelcase_includes();
+                                                if (!$file && !$camelcase_file_seeded) {
+                                                        seed_camelcase_file($realfile);
+                                                        $camelcase_file_seeded = 1;
+                                                }
+                                        }
                                         if (!defined $camelcase{$word}) {
                                                 $camelcase{$word} = 1;
                                                 CHK("CAMELCASE",
@@ -3725,14 +3746,6 @@ sub process {
                         }
                 }
 
-sub string_find_replace {
-        my ($string, $find, $replace) = @_;
-
-        $string =~ s/$find/$replace/g;
-
-        return $string;
-}
-
 # check for bad placement of section $InitAttribute (e.g.: __initdata)
                 if ($line =~ /(\b$InitAttribute\b)/) {
                         my $attr = $1;
@@ -3751,6 +3764,35 @@ sub string_find_replace {
                         }
                 }
 
+# check for $InitAttributeData (ie: __initdata) with const
+                if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
+                        my $attr = $1;
+                        $attr =~ /($InitAttributePrefix)(.*)/;
+                        my $attr_prefix = $1;
+                        my $attr_type = $2;
+                        if (ERROR("INIT_ATTRIBUTE",
+                                  "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
+                            $fix) {
+                                $fixed[$linenr - 1] =~
+                                    s/$InitAttributeData/${attr_prefix}initconst/;
+                        }
+                }
+
+# check for $InitAttributeConst (ie: __initconst) without const
+                if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
+                        my $attr = $1;
+                        if (ERROR("INIT_ATTRIBUTE",
+                                  "Use of $attr requires a separate use of const\n" . $herecurr) &&
+                            $fix) {
+                                my $lead = $fixed[$linenr - 1] =~
+                                    /(^\+\s*(?:static\s+))/;
+                                $lead = rtrim($1);
+                                $lead = "$lead " if ($lead !~ /^\+$/);
+                                $lead = "${lead}const ";
+                                $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
+                        }
+                }
+
 # prefer usleep_range over udelay
                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
                         # ignore udelay's < 10, however
@@ -3810,8 +3852,8 @@ sub string_find_replace {
 # check for memory barriers without a comment.
                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
                         if (!ctx_has_comment($first_line, $linenr)) {
-                                CHK("MEMORY_BARRIER",
-                                    "memory barrier without comment\n" . $herecurr);
+                                WARN("MEMORY_BARRIER",
+                                     "memory barrier without comment\n" . $herecurr);
                         }
                 }
 # check of hardware specific defines
@@ -3835,7 +3877,8 @@ sub string_find_replace {
                 }
 
 # Check for __inline__ and __inline, prefer inline
-                if ($line =~ /\b(__inline__|__inline)\b/) {
+                if ($realfile !~ m@\binclude/uapi/@ &&
+                    $line =~ /\b(__inline__|__inline)\b/) {
                         if (WARN("INLINE",
                                  "plain inline is preferred over $1\n" . $herecurr) &&
                             $fix) {
@@ -3845,19 +3888,22 @@ sub string_find_replace {
                 }
 
 # Check for __attribute__ packed, prefer __packed
-                if ($line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
+                if ($realfile !~ m@\binclude/uapi/@ &&
+                    $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
                         WARN("PREFER_PACKED",
                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
                 }
 
 # Check for __attribute__ aligned, prefer __aligned
-                if ($line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
+                if ($realfile !~ m@\binclude/uapi/@ &&
+                    $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
                         WARN("PREFER_ALIGNED",
                              "__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/) {
+                if ($realfile !~ m@\binclude/uapi/@ &&
+                    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
                         if (WARN("PREFER_PRINTF",
                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
                             $fix) {
@@ -3867,7 +3913,8 @@ sub string_find_replace {
                 }
 
 # Check for __attribute__ format(scanf, prefer __scanf
-                if ($line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
+                if ($realfile !~ m@\binclude/uapi/@ &&
+                    $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
                         if (WARN("PREFER_SCANF",
                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
                             $fix) {
@@ -3903,9 +3950,9 @@ sub string_find_replace {
                 }
 
 # check for seq_printf uses that could be seq_puts
-                if ($line =~ /\bseq_printf\s*\(/) {
+                if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
                         my $fmt = get_quoted_string($line, $rawline);
-                        if ($fmt !~ /[^\\]\%/) {
+                        if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
                                 if (WARN("PREFER_SEQ_PUTS",
                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
                                     $fix) {
@@ -3972,6 +4019,23 @@ sub string_find_replace {
                         }
                 }
 
+# check for naked sscanf
+                if ($^V && $^V ge 5.10.0 &&
+                    defined $stat &&
+                    $stat =~ /\bsscanf\b/ &&
+                    ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
+                     $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
+                     $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
+                        my $lc = $stat =~ tr@\n@@;
+                        $lc = $lc + $linenr;
+                        my $stat_real = raw_line($linenr, 0);
+                        for (my $count = $linenr + 1; $count <= $lc; $count++) {
+                                $stat_real = $stat_real . "\n" . raw_line($count, 0);
+                        }
+                        WARN("NAKED_SSCANF",
+                             "unchecked sscanf return value\n" . "$here\n$stat_real\n");
+                }
+
 # check for new externs in .h files.
                 if ($realfile =~ /\.h$/ &&
                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
@@ -4190,6 +4254,12 @@ sub string_find_replace {
                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
                 }
 
+# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
+                if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
+                        ERROR("DEFINE_ARCH_HAS",
+                              "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
+                }
+
 # check for %L{u,d,i} in strings
                 my $string;
                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {