Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[linux-2.6-microblaze.git] / scripts / checkpatch.pl
1 #!/usr/bin/env perl
2 # SPDX-License-Identifier: GPL-2.0
3 #
4 # (c) 2001, Dave Jones. (the file handling bit)
5 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
6 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
7 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
8 # (c) 2010-2018 Joe Perches <joe@perches.com>
9
10 use strict;
11 use warnings;
12 use POSIX;
13 use File::Basename;
14 use Cwd 'abs_path';
15 use Term::ANSIColor qw(:constants);
16 use Encode qw(decode encode);
17
18 my $P = $0;
19 my $D = dirname(abs_path($P));
20
21 my $V = '0.32';
22
23 use Getopt::Long qw(:config no_auto_abbrev);
24
25 my $quiet = 0;
26 my $verbose = 0;
27 my %verbose_messages = ();
28 my %verbose_emitted = ();
29 my $tree = 1;
30 my $chk_signoff = 1;
31 my $chk_patch = 1;
32 my $tst_only;
33 my $emacs = 0;
34 my $terse = 0;
35 my $showfile = 0;
36 my $file = 0;
37 my $git = 0;
38 my %git_commits = ();
39 my $check = 0;
40 my $check_orig = 0;
41 my $summary = 1;
42 my $mailback = 0;
43 my $summary_file = 0;
44 my $show_types = 0;
45 my $list_types = 0;
46 my $fix = 0;
47 my $fix_inplace = 0;
48 my $root;
49 my $gitroot = $ENV{'GIT_DIR'};
50 $gitroot = ".git" if !defined($gitroot);
51 my %debug;
52 my %camelcase = ();
53 my %use_type = ();
54 my @use = ();
55 my %ignore_type = ();
56 my @ignore = ();
57 my $help = 0;
58 my $configuration_file = ".checkpatch.conf";
59 my $max_line_length = 100;
60 my $ignore_perl_version = 0;
61 my $minimum_perl_version = 5.10.0;
62 my $min_conf_desc_length = 4;
63 my $spelling_file = "$D/spelling.txt";
64 my $codespell = 0;
65 my $codespellfile = "/usr/share/codespell/dictionary.txt";
66 my $conststructsfile = "$D/const_structs.checkpatch";
67 my $docsfile = "$D/../Documentation/dev-tools/checkpatch.rst";
68 my $typedefsfile;
69 my $color = "auto";
70 my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
71 # git output parsing needs US English output, so first set backtick child process LANGUAGE
72 my $git_command ='export LANGUAGE=en_US.UTF-8; git';
73 my $tabsize = 8;
74 my ${CONFIG_} = "CONFIG_";
75
76 sub help {
77         my ($exitcode) = @_;
78
79         print << "EOM";
80 Usage: $P [OPTION]... [FILE]...
81 Version: $V
82
83 Options:
84   -q, --quiet                quiet
85   -v, --verbose              verbose mode
86   --no-tree                  run without a kernel tree
87   --no-signoff               do not check for 'Signed-off-by' line
88   --patch                    treat FILE as patchfile (default)
89   --emacs                    emacs compile window format
90   --terse                    one line per report
91   --showfile                 emit diffed file position, not input file position
92   -g, --git                  treat FILE as a single commit or git revision range
93                              single git commit with:
94                                <rev>
95                                <rev>^
96                                <rev>~n
97                              multiple git commits with:
98                                <rev1>..<rev2>
99                                <rev1>...<rev2>
100                                <rev>-<count>
101                              git merges are ignored
102   -f, --file                 treat FILE as regular source file
103   --subjective, --strict     enable more subjective tests
104   --list-types               list the possible message types
105   --types TYPE(,TYPE2...)    show only these comma separated message types
106   --ignore TYPE(,TYPE2...)   ignore various comma separated message types
107   --show-types               show the specific message type in the output
108   --max-line-length=n        set the maximum line length, (default $max_line_length)
109                              if exceeded, warn on patches
110                              requires --strict for use with --file
111   --min-conf-desc-length=n   set the min description length, if shorter, warn
112   --tab-size=n               set the number of spaces for tab (default $tabsize)
113   --root=PATH                PATH to the kernel tree root
114   --no-summary               suppress the per-file summary
115   --mailback                 only produce a report in case of warnings/errors
116   --summary-file             include the filename in summary
117   --debug KEY=[0|1]          turn on/off debugging of KEY, where KEY is one of
118                              'values', 'possible', 'type', and 'attr' (default
119                              is all off)
120   --test-only=WORD           report only warnings/errors containing WORD
121                              literally
122   --fix                      EXPERIMENTAL - may create horrible results
123                              If correctable single-line errors exist, create
124                              "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
125                              with potential errors corrected to the preferred
126                              checkpatch style
127   --fix-inplace              EXPERIMENTAL - may create horrible results
128                              Is the same as --fix, but overwrites the input
129                              file.  It's your fault if there's no backup or git
130   --ignore-perl-version      override checking of perl version.  expect
131                              runtime errors.
132   --codespell                Use the codespell dictionary for spelling/typos
133                              (default:/usr/share/codespell/dictionary.txt)
134   --codespellfile            Use this codespell dictionary
135   --typedefsfile             Read additional types from this file
136   --color[=WHEN]             Use colors 'always', 'never', or only when output
137                              is a terminal ('auto'). Default is 'auto'.
138   --kconfig-prefix=WORD      use WORD as a prefix for Kconfig symbols (default
139                              ${CONFIG_})
140   -h, --help, --version      display this help and exit
141
142 When FILE is - read standard input.
143 EOM
144
145         exit($exitcode);
146 }
147
148 sub uniq {
149         my %seen;
150         return grep { !$seen{$_}++ } @_;
151 }
152
153 sub list_types {
154         my ($exitcode) = @_;
155
156         my $count = 0;
157
158         local $/ = undef;
159
160         open(my $script, '<', abs_path($P)) or
161             die "$P: Can't read '$P' $!\n";
162
163         my $text = <$script>;
164         close($script);
165
166         my %types = ();
167         # Also catch when type or level is passed through a variable
168         while ($text =~ /(?:(\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
169                 if (defined($1)) {
170                         if (exists($types{$2})) {
171                                 $types{$2} .= ",$1" if ($types{$2} ne $1);
172                         } else {
173                                 $types{$2} = $1;
174                         }
175                 } else {
176                         $types{$2} = "UNDETERMINED";
177                 }
178         }
179
180         print("#\tMessage type\n\n");
181         if ($color) {
182                 print(" ( Color coding: ");
183                 print(RED . "ERROR" . RESET);
184                 print(" | ");
185                 print(YELLOW . "WARNING" . RESET);
186                 print(" | ");
187                 print(GREEN . "CHECK" . RESET);
188                 print(" | ");
189                 print("Multiple levels / Undetermined");
190                 print(" )\n\n");
191         }
192
193         foreach my $type (sort keys %types) {
194                 my $orig_type = $type;
195                 if ($color) {
196                         my $level = $types{$type};
197                         if ($level eq "ERROR") {
198                                 $type = RED . $type . RESET;
199                         } elsif ($level eq "WARN") {
200                                 $type = YELLOW . $type . RESET;
201                         } elsif ($level eq "CHK") {
202                                 $type = GREEN . $type . RESET;
203                         }
204                 }
205                 print(++$count . "\t" . $type . "\n");
206                 if ($verbose && exists($verbose_messages{$orig_type})) {
207                         my $message = $verbose_messages{$orig_type};
208                         $message =~ s/\n/\n\t/g;
209                         print("\t" . $message . "\n\n");
210                 }
211         }
212
213         exit($exitcode);
214 }
215
216 my $conf = which_conf($configuration_file);
217 if (-f $conf) {
218         my @conf_args;
219         open(my $conffile, '<', "$conf")
220             or warn "$P: Can't find a readable $configuration_file file $!\n";
221
222         while (<$conffile>) {
223                 my $line = $_;
224
225                 $line =~ s/\s*\n?$//g;
226                 $line =~ s/^\s*//g;
227                 $line =~ s/\s+/ /g;
228
229                 next if ($line =~ m/^\s*#/);
230                 next if ($line =~ m/^\s*$/);
231
232                 my @words = split(" ", $line);
233                 foreach my $word (@words) {
234                         last if ($word =~ m/^#/);
235                         push (@conf_args, $word);
236                 }
237         }
238         close($conffile);
239         unshift(@ARGV, @conf_args) if @conf_args;
240 }
241
242 sub load_docs {
243         open(my $docs, '<', "$docsfile")
244             or warn "$P: Can't read the documentation file $docsfile $!\n";
245
246         my $type = '';
247         my $desc = '';
248         my $in_desc = 0;
249
250         while (<$docs>) {
251                 chomp;
252                 my $line = $_;
253                 $line =~ s/\s+$//;
254
255                 if ($line =~ /^\s*\*\*(.+)\*\*$/) {
256                         if ($desc ne '') {
257                                 $verbose_messages{$type} = trim($desc);
258                         }
259                         $type = $1;
260                         $desc = '';
261                         $in_desc = 1;
262                 } elsif ($in_desc) {
263                         if ($line =~ /^(?:\s{4,}|$)/) {
264                                 $line =~ s/^\s{4}//;
265                                 $desc .= $line;
266                                 $desc .= "\n";
267                         } else {
268                                 $verbose_messages{$type} = trim($desc);
269                                 $type = '';
270                                 $desc = '';
271                                 $in_desc = 0;
272                         }
273                 }
274         }
275
276         if ($desc ne '') {
277                 $verbose_messages{$type} = trim($desc);
278         }
279         close($docs);
280 }
281
282 # Perl's Getopt::Long allows options to take optional arguments after a space.
283 # Prevent --color by itself from consuming other arguments
284 foreach (@ARGV) {
285         if ($_ eq "--color" || $_ eq "-color") {
286                 $_ = "--color=$color";
287         }
288 }
289
290 GetOptions(
291         'q|quiet+'      => \$quiet,
292         'v|verbose!'    => \$verbose,
293         'tree!'         => \$tree,
294         'signoff!'      => \$chk_signoff,
295         'patch!'        => \$chk_patch,
296         'emacs!'        => \$emacs,
297         'terse!'        => \$terse,
298         'showfile!'     => \$showfile,
299         'f|file!'       => \$file,
300         'g|git!'        => \$git,
301         'subjective!'   => \$check,
302         'strict!'       => \$check,
303         'ignore=s'      => \@ignore,
304         'types=s'       => \@use,
305         'show-types!'   => \$show_types,
306         'list-types!'   => \$list_types,
307         'max-line-length=i' => \$max_line_length,
308         'min-conf-desc-length=i' => \$min_conf_desc_length,
309         'tab-size=i'    => \$tabsize,
310         'root=s'        => \$root,
311         'summary!'      => \$summary,
312         'mailback!'     => \$mailback,
313         'summary-file!' => \$summary_file,
314         'fix!'          => \$fix,
315         'fix-inplace!'  => \$fix_inplace,
316         'ignore-perl-version!' => \$ignore_perl_version,
317         'debug=s'       => \%debug,
318         'test-only=s'   => \$tst_only,
319         'codespell!'    => \$codespell,
320         'codespellfile=s'       => \$codespellfile,
321         'typedefsfile=s'        => \$typedefsfile,
322         'color=s'       => \$color,
323         'no-color'      => \$color,     #keep old behaviors of -nocolor
324         'nocolor'       => \$color,     #keep old behaviors of -nocolor
325         'kconfig-prefix=s'      => \${CONFIG_},
326         'h|help'        => \$help,
327         'version'       => \$help
328 ) or help(1);
329
330 help(0) if ($help);
331
332 die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file || $fix));
333 die "$P: --verbose cannot be used with --terse\n" if ($verbose && $terse);
334
335 if ($color =~ /^[01]$/) {
336         $color = !$color;
337 } elsif ($color =~ /^always$/i) {
338         $color = 1;
339 } elsif ($color =~ /^never$/i) {
340         $color = 0;
341 } elsif ($color =~ /^auto$/i) {
342         $color = (-t STDOUT);
343 } else {
344         die "$P: Invalid color mode: $color\n";
345 }
346
347 load_docs() if ($verbose);
348 list_types(0) if ($list_types);
349
350 $fix = 1 if ($fix_inplace);
351 $check_orig = $check;
352
353 my $exit = 0;
354
355 my $perl_version_ok = 1;
356 if ($^V && $^V lt $minimum_perl_version) {
357         $perl_version_ok = 0;
358         printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
359         exit(1) if (!$ignore_perl_version);
360 }
361
362 #if no filenames are given, push '-' to read patch from stdin
363 if ($#ARGV < 0) {
364         push(@ARGV, '-');
365 }
366
367 # skip TAB size 1 to avoid additional checks on $tabsize - 1
368 die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);
369
370 sub hash_save_array_words {
371         my ($hashRef, $arrayRef) = @_;
372
373         my @array = split(/,/, join(',', @$arrayRef));
374         foreach my $word (@array) {
375                 $word =~ s/\s*\n?$//g;
376                 $word =~ s/^\s*//g;
377                 $word =~ s/\s+/ /g;
378                 $word =~ tr/[a-z]/[A-Z]/;
379
380                 next if ($word =~ m/^\s*#/);
381                 next if ($word =~ m/^\s*$/);
382
383                 $hashRef->{$word}++;
384         }
385 }
386
387 sub hash_show_words {
388         my ($hashRef, $prefix) = @_;
389
390         if (keys %$hashRef) {
391                 print "\nNOTE: $prefix message types:";
392                 foreach my $word (sort keys %$hashRef) {
393                         print " $word";
394                 }
395                 print "\n";
396         }
397 }
398
399 hash_save_array_words(\%ignore_type, \@ignore);
400 hash_save_array_words(\%use_type, \@use);
401
402 my $dbg_values = 0;
403 my $dbg_possible = 0;
404 my $dbg_type = 0;
405 my $dbg_attr = 0;
406 for my $key (keys %debug) {
407         ## no critic
408         eval "\${dbg_$key} = '$debug{$key}';";
409         die "$@" if ($@);
410 }
411
412 my $rpt_cleaners = 0;
413
414 if ($terse) {
415         $emacs = 1;
416         $quiet++;
417 }
418
419 if ($tree) {
420         if (defined $root) {
421                 if (!top_of_kernel_tree($root)) {
422                         die "$P: $root: --root does not point at a valid tree\n";
423                 }
424         } else {
425                 if (top_of_kernel_tree('.')) {
426                         $root = '.';
427                 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
428                                                 top_of_kernel_tree($1)) {
429                         $root = $1;
430                 }
431         }
432
433         if (!defined $root) {
434                 print "Must be run from the top-level dir. of a kernel tree\n";
435                 exit(2);
436         }
437 }
438
439 my $emitted_corrupt = 0;
440
441 our $Ident      = qr{
442                         [A-Za-z_][A-Za-z\d_]*
443                         (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
444                 }x;
445 our $Storage    = qr{extern|static|asmlinkage};
446 our $Sparse     = qr{
447                         __user|
448                         __kernel|
449                         __force|
450                         __iomem|
451                         __must_check|
452                         __kprobes|
453                         __ref|
454                         __refconst|
455                         __refdata|
456                         __rcu|
457                         __private
458                 }x;
459 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
460 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
461 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
462 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
463 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
464
465 # Notes to $Attribute:
466 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
467 our $Attribute  = qr{
468                         const|
469                         volatile|
470                         __percpu|
471                         __nocast|
472                         __safe|
473                         __bitwise|
474                         __packed__|
475                         __packed2__|
476                         __naked|
477                         __maybe_unused|
478                         __always_unused|
479                         __noreturn|
480                         __used|
481                         __cold|
482                         __pure|
483                         __noclone|
484                         __deprecated|
485                         __read_mostly|
486                         __ro_after_init|
487                         __kprobes|
488                         $InitAttribute|
489                         ____cacheline_aligned|
490                         ____cacheline_aligned_in_smp|
491                         ____cacheline_internodealigned_in_smp|
492                         __weak
493                   }x;
494 our $Modifier;
495 our $Inline     = qr{inline|__always_inline|noinline|__inline|__inline__};
496 our $Member     = qr{->$Ident|\.$Ident|\[[^]]*\]};
497 our $Lval       = qr{$Ident(?:$Member)*};
498
499 our $Int_type   = qr{(?i)llu|ull|ll|lu|ul|l|u};
500 our $Binary     = qr{(?i)0b[01]+$Int_type?};
501 our $Hex        = qr{(?i)0x[0-9a-f]+$Int_type?};
502 our $Int        = qr{[0-9]+$Int_type?};
503 our $Octal      = qr{0[0-7]+$Int_type?};
504 our $String     = qr{"[X\t]*"};
505 our $Float_hex  = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
506 our $Float_dec  = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
507 our $Float_int  = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
508 our $Float      = qr{$Float_hex|$Float_dec|$Float_int};
509 our $Constant   = qr{$Float|$Binary|$Octal|$Hex|$Int};
510 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
511 our $Compare    = qr{<=|>=|==|!=|<|(?<!-)>};
512 our $Arithmetic = qr{\+|-|\*|\/|%};
513 our $Operators  = qr{
514                         <=|>=|==|!=|
515                         =>|->|<<|>>|<|>|!|~|
516                         &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
517                   }x;
518
519 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
520
521 our $BasicType;
522 our $NonptrType;
523 our $NonptrTypeMisordered;
524 our $NonptrTypeWithAttr;
525 our $Type;
526 our $TypeMisordered;
527 our $Declare;
528 our $DeclareMisordered;
529
530 our $NON_ASCII_UTF8     = qr{
531         [\xC2-\xDF][\x80-\xBF]               # non-overlong 2-byte
532         |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
533         | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
534         |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
535         |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
536         | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
537         |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
538 }x;
539
540 our $UTF8       = qr{
541         [\x09\x0A\x0D\x20-\x7E]              # ASCII
542         | $NON_ASCII_UTF8
543 }x;
544
545 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
546 our $typeOtherOSTypedefs = qr{(?x:
547         u_(?:char|short|int|long) |          # bsd
548         u(?:nchar|short|int|long)            # sysv
549 )};
550 our $typeKernelTypedefs = qr{(?x:
551         (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
552         atomic_t
553 )};
554 our $typeTypedefs = qr{(?x:
555         $typeC99Typedefs\b|
556         $typeOtherOSTypedefs\b|
557         $typeKernelTypedefs\b
558 )};
559
560 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
561
562 our $logFunctions = qr{(?x:
563         printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
564         (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
565         TP_printk|
566         WARN(?:_RATELIMIT|_ONCE|)|
567         panic|
568         MODULE_[A-Z_]+|
569         seq_vprintf|seq_printf|seq_puts
570 )};
571
572 our $allocFunctions = qr{(?x:
573         (?:(?:devm_)?
574                 (?:kv|k|v)[czm]alloc(?:_array)?(?:_node)? |
575                 kstrdup(?:_const)? |
576                 kmemdup(?:_nul)?) |
577         (?:\w+)?alloc_skb(?:_ip_align)? |
578                                 # dev_alloc_skb/netdev_alloc_skb, et al
579         dma_alloc_coherent
580 )};
581
582 our $signature_tags = qr{(?xi:
583         Signed-off-by:|
584         Co-developed-by:|
585         Acked-by:|
586         Tested-by:|
587         Reviewed-by:|
588         Reported-by:|
589         Suggested-by:|
590         To:|
591         Cc:
592 )};
593
594 our $tracing_logging_tags = qr{(?xi:
595         [=-]*> |
596         <[=-]* |
597         \[ |
598         \] |
599         start |
600         called |
601         entered |
602         entry |
603         enter |
604         in |
605         inside |
606         here |
607         begin |
608         exit |
609         end |
610         done |
611         leave |
612         completed |
613         out |
614         return |
615         [\.\!:\s]*
616 )};
617
618 sub edit_distance_min {
619         my (@arr) = @_;
620         my $len = scalar @arr;
621         if ((scalar @arr) < 1) {
622                 # if underflow, return
623                 return;
624         }
625         my $min = $arr[0];
626         for my $i (0 .. ($len-1)) {
627                 if ($arr[$i] < $min) {
628                         $min = $arr[$i];
629                 }
630         }
631         return $min;
632 }
633
634 sub get_edit_distance {
635         my ($str1, $str2) = @_;
636         $str1 = lc($str1);
637         $str2 = lc($str2);
638         $str1 =~ s/-//g;
639         $str2 =~ s/-//g;
640         my $len1 = length($str1);
641         my $len2 = length($str2);
642         # two dimensional array storing minimum edit distance
643         my @distance;
644         for my $i (0 .. $len1) {
645                 for my $j (0 .. $len2) {
646                         if ($i == 0) {
647                                 $distance[$i][$j] = $j;
648                         } elsif ($j == 0) {
649                                 $distance[$i][$j] = $i;
650                         } elsif (substr($str1, $i-1, 1) eq substr($str2, $j-1, 1)) {
651                                 $distance[$i][$j] = $distance[$i - 1][$j - 1];
652                         } else {
653                                 my $dist1 = $distance[$i][$j - 1]; #insert distance
654                                 my $dist2 = $distance[$i - 1][$j]; # remove
655                                 my $dist3 = $distance[$i - 1][$j - 1]; #replace
656                                 $distance[$i][$j] = 1 + edit_distance_min($dist1, $dist2, $dist3);
657                         }
658                 }
659         }
660         return $distance[$len1][$len2];
661 }
662
663 sub find_standard_signature {
664         my ($sign_off) = @_;
665         my @standard_signature_tags = (
666                 'Signed-off-by:', 'Co-developed-by:', 'Acked-by:', 'Tested-by:',
667                 'Reviewed-by:', 'Reported-by:', 'Suggested-by:'
668         );
669         foreach my $signature (@standard_signature_tags) {
670                 return $signature if (get_edit_distance($sign_off, $signature) <= 2);
671         }
672
673         return "";
674 }
675
676 our @typeListMisordered = (
677         qr{char\s+(?:un)?signed},
678         qr{int\s+(?:(?:un)?signed\s+)?short\s},
679         qr{int\s+short(?:\s+(?:un)?signed)},
680         qr{short\s+int(?:\s+(?:un)?signed)},
681         qr{(?:un)?signed\s+int\s+short},
682         qr{short\s+(?:un)?signed},
683         qr{long\s+int\s+(?:un)?signed},
684         qr{int\s+long\s+(?:un)?signed},
685         qr{long\s+(?:un)?signed\s+int},
686         qr{int\s+(?:un)?signed\s+long},
687         qr{int\s+(?:un)?signed},
688         qr{int\s+long\s+long\s+(?:un)?signed},
689         qr{long\s+long\s+int\s+(?:un)?signed},
690         qr{long\s+long\s+(?:un)?signed\s+int},
691         qr{long\s+long\s+(?:un)?signed},
692         qr{long\s+(?:un)?signed},
693 );
694
695 our @typeList = (
696         qr{void},
697         qr{(?:(?:un)?signed\s+)?char},
698         qr{(?:(?:un)?signed\s+)?short\s+int},
699         qr{(?:(?:un)?signed\s+)?short},
700         qr{(?:(?:un)?signed\s+)?int},
701         qr{(?:(?:un)?signed\s+)?long\s+int},
702         qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
703         qr{(?:(?:un)?signed\s+)?long\s+long},
704         qr{(?:(?:un)?signed\s+)?long},
705         qr{(?:un)?signed},
706         qr{float},
707         qr{double},
708         qr{bool},
709         qr{struct\s+$Ident},
710         qr{union\s+$Ident},
711         qr{enum\s+$Ident},
712         qr{${Ident}_t},
713         qr{${Ident}_handler},
714         qr{${Ident}_handler_fn},
715         @typeListMisordered,
716 );
717
718 our $C90_int_types = qr{(?x:
719         long\s+long\s+int\s+(?:un)?signed|
720         long\s+long\s+(?:un)?signed\s+int|
721         long\s+long\s+(?:un)?signed|
722         (?:(?:un)?signed\s+)?long\s+long\s+int|
723         (?:(?:un)?signed\s+)?long\s+long|
724         int\s+long\s+long\s+(?:un)?signed|
725         int\s+(?:(?:un)?signed\s+)?long\s+long|
726
727         long\s+int\s+(?:un)?signed|
728         long\s+(?:un)?signed\s+int|
729         long\s+(?:un)?signed|
730         (?:(?:un)?signed\s+)?long\s+int|
731         (?:(?:un)?signed\s+)?long|
732         int\s+long\s+(?:un)?signed|
733         int\s+(?:(?:un)?signed\s+)?long|
734
735         int\s+(?:un)?signed|
736         (?:(?:un)?signed\s+)?int
737 )};
738
739 our @typeListFile = ();
740 our @typeListWithAttr = (
741         @typeList,
742         qr{struct\s+$InitAttribute\s+$Ident},
743         qr{union\s+$InitAttribute\s+$Ident},
744 );
745
746 our @modifierList = (
747         qr{fastcall},
748 );
749 our @modifierListFile = ();
750
751 our @mode_permission_funcs = (
752         ["module_param", 3],
753         ["module_param_(?:array|named|string)", 4],
754         ["module_param_array_named", 5],
755         ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
756         ["proc_create(?:_data|)", 2],
757         ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
758         ["IIO_DEV_ATTR_[A-Z_]+", 1],
759         ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
760         ["SENSOR_TEMPLATE(?:_2|)", 3],
761         ["__ATTR", 2],
762 );
763
764 my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';
765
766 #Create a search pattern for all these functions to speed up a loop below
767 our $mode_perms_search = "";
768 foreach my $entry (@mode_permission_funcs) {
769         $mode_perms_search .= '|' if ($mode_perms_search ne "");
770         $mode_perms_search .= $entry->[0];
771 }
772 $mode_perms_search = "(?:${mode_perms_search})";
773
774 our %deprecated_apis = (
775         "synchronize_rcu_bh"                    => "synchronize_rcu",
776         "synchronize_rcu_bh_expedited"          => "synchronize_rcu_expedited",
777         "call_rcu_bh"                           => "call_rcu",
778         "rcu_barrier_bh"                        => "rcu_barrier",
779         "synchronize_sched"                     => "synchronize_rcu",
780         "synchronize_sched_expedited"           => "synchronize_rcu_expedited",
781         "call_rcu_sched"                        => "call_rcu",
782         "rcu_barrier_sched"                     => "rcu_barrier",
783         "get_state_synchronize_sched"           => "get_state_synchronize_rcu",
784         "cond_synchronize_sched"                => "cond_synchronize_rcu",
785 );
786
787 #Create a search pattern for all these strings to speed up a loop below
788 our $deprecated_apis_search = "";
789 foreach my $entry (keys %deprecated_apis) {
790         $deprecated_apis_search .= '|' if ($deprecated_apis_search ne "");
791         $deprecated_apis_search .= $entry;
792 }
793 $deprecated_apis_search = "(?:${deprecated_apis_search})";
794
795 our $mode_perms_world_writable = qr{
796         S_IWUGO         |
797         S_IWOTH         |
798         S_IRWXUGO       |
799         S_IALLUGO       |
800         0[0-7][0-7][2367]
801 }x;
802
803 our %mode_permission_string_types = (
804         "S_IRWXU" => 0700,
805         "S_IRUSR" => 0400,
806         "S_IWUSR" => 0200,
807         "S_IXUSR" => 0100,
808         "S_IRWXG" => 0070,
809         "S_IRGRP" => 0040,
810         "S_IWGRP" => 0020,
811         "S_IXGRP" => 0010,
812         "S_IRWXO" => 0007,
813         "S_IROTH" => 0004,
814         "S_IWOTH" => 0002,
815         "S_IXOTH" => 0001,
816         "S_IRWXUGO" => 0777,
817         "S_IRUGO" => 0444,
818         "S_IWUGO" => 0222,
819         "S_IXUGO" => 0111,
820 );
821
822 #Create a search pattern for all these strings to speed up a loop below
823 our $mode_perms_string_search = "";
824 foreach my $entry (keys %mode_permission_string_types) {
825         $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
826         $mode_perms_string_search .= $entry;
827 }
828 our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
829 our $multi_mode_perms_string_search = qr{
830         ${single_mode_perms_string_search}
831         (?:\s*\|\s*${single_mode_perms_string_search})*
832 }x;
833
834 sub perms_to_octal {
835         my ($string) = @_;
836
837         return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
838
839         my $val = "";
840         my $oval = "";
841         my $to = 0;
842         my $curpos = 0;
843         my $lastpos = 0;
844         while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
845                 $curpos = pos($string);
846                 my $match = $2;
847                 my $omatch = $1;
848                 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
849                 $lastpos = $curpos;
850                 $to |= $mode_permission_string_types{$match};
851                 $val .= '\s*\|\s*' if ($val ne "");
852                 $val .= $match;
853                 $oval .= $omatch;
854         }
855         $oval =~ s/^\s*\|\s*//;
856         $oval =~ s/\s*\|\s*$//;
857         return sprintf("%04o", $to);
858 }
859
860 our $allowed_asm_includes = qr{(?x:
861         irq|
862         memory|
863         time|
864         reboot
865 )};
866 # memory.h: ARM has a custom one
867
868 # Load common spelling mistakes and build regular expression list.
869 my $misspellings;
870 my %spelling_fix;
871
872 if (open(my $spelling, '<', $spelling_file)) {
873         while (<$spelling>) {
874                 my $line = $_;
875
876                 $line =~ s/\s*\n?$//g;
877                 $line =~ s/^\s*//g;
878
879                 next if ($line =~ m/^\s*#/);
880                 next if ($line =~ m/^\s*$/);
881
882                 my ($suspect, $fix) = split(/\|\|/, $line);
883
884                 $spelling_fix{$suspect} = $fix;
885         }
886         close($spelling);
887 } else {
888         warn "No typos will be found - file '$spelling_file': $!\n";
889 }
890
891 if ($codespell) {
892         if (open(my $spelling, '<', $codespellfile)) {
893                 while (<$spelling>) {
894                         my $line = $_;
895
896                         $line =~ s/\s*\n?$//g;
897                         $line =~ s/^\s*//g;
898
899                         next if ($line =~ m/^\s*#/);
900                         next if ($line =~ m/^\s*$/);
901                         next if ($line =~ m/, disabled/i);
902
903                         $line =~ s/,.*$//;
904
905                         my ($suspect, $fix) = split(/->/, $line);
906
907                         $spelling_fix{$suspect} = $fix;
908                 }
909                 close($spelling);
910         } else {
911                 warn "No codespell typos will be found - file '$codespellfile': $!\n";
912         }
913 }
914
915 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
916
917 sub read_words {
918         my ($wordsRef, $file) = @_;
919
920         if (open(my $words, '<', $file)) {
921                 while (<$words>) {
922                         my $line = $_;
923
924                         $line =~ s/\s*\n?$//g;
925                         $line =~ s/^\s*//g;
926
927                         next if ($line =~ m/^\s*#/);
928                         next if ($line =~ m/^\s*$/);
929                         if ($line =~ /\s/) {
930                                 print("$file: '$line' invalid - ignored\n");
931                                 next;
932                         }
933
934                         $$wordsRef .= '|' if (defined $$wordsRef);
935                         $$wordsRef .= $line;
936                 }
937                 close($file);
938                 return 1;
939         }
940
941         return 0;
942 }
943
944 my $const_structs;
945 if (show_type("CONST_STRUCT")) {
946         read_words(\$const_structs, $conststructsfile)
947             or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
948 }
949
950 if (defined($typedefsfile)) {
951         my $typeOtherTypedefs;
952         read_words(\$typeOtherTypedefs, $typedefsfile)
953             or warn "No additional types will be considered - file '$typedefsfile': $!\n";
954         $typeTypedefs .= '|' . $typeOtherTypedefs if (defined $typeOtherTypedefs);
955 }
956
957 sub build_types {
958         my $mods = "(?x:  \n" . join("|\n  ", (@modifierList, @modifierListFile)) . "\n)";
959         my $all = "(?x:  \n" . join("|\n  ", (@typeList, @typeListFile)) . "\n)";
960         my $Misordered = "(?x:  \n" . join("|\n  ", @typeListMisordered) . "\n)";
961         my $allWithAttr = "(?x:  \n" . join("|\n  ", @typeListWithAttr) . "\n)";
962         $Modifier       = qr{(?:$Attribute|$Sparse|$mods)};
963         $BasicType      = qr{
964                                 (?:$typeTypedefs\b)|
965                                 (?:${all}\b)
966                 }x;
967         $NonptrType     = qr{
968                         (?:$Modifier\s+|const\s+)*
969                         (?:
970                                 (?:typeof|__typeof__)\s*\([^\)]*\)|
971                                 (?:$typeTypedefs\b)|
972                                 (?:${all}\b)
973                         )
974                         (?:\s+$Modifier|\s+const)*
975                   }x;
976         $NonptrTypeMisordered   = qr{
977                         (?:$Modifier\s+|const\s+)*
978                         (?:
979                                 (?:${Misordered}\b)
980                         )
981                         (?:\s+$Modifier|\s+const)*
982                   }x;
983         $NonptrTypeWithAttr     = qr{
984                         (?:$Modifier\s+|const\s+)*
985                         (?:
986                                 (?:typeof|__typeof__)\s*\([^\)]*\)|
987                                 (?:$typeTypedefs\b)|
988                                 (?:${allWithAttr}\b)
989                         )
990                         (?:\s+$Modifier|\s+const)*
991                   }x;
992         $Type   = qr{
993                         $NonptrType
994                         (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
995                         (?:\s+$Inline|\s+$Modifier)*
996                   }x;
997         $TypeMisordered = qr{
998                         $NonptrTypeMisordered
999                         (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
1000                         (?:\s+$Inline|\s+$Modifier)*
1001                   }x;
1002         $Declare        = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
1003         $DeclareMisordered      = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
1004 }
1005 build_types();
1006
1007 our $Typecast   = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
1008
1009 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
1010 # requires at least perl version v5.10.0
1011 # Any use must be runtime checked with $^V
1012
1013 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
1014 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
1015 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
1016
1017 our $declaration_macros = qr{(?x:
1018         (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
1019         (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
1020         (?:SKCIPHER_REQUEST|SHASH_DESC|AHASH_REQUEST)_ON_STACK\s*\(
1021 )};
1022
1023 our %allow_repeated_words = (
1024         add => '',
1025         added => '',
1026         bad => '',
1027         be => '',
1028 );
1029
1030 sub deparenthesize {
1031         my ($string) = @_;
1032         return "" if (!defined($string));
1033
1034         while ($string =~ /^\s*\(.*\)\s*$/) {
1035                 $string =~ s@^\s*\(\s*@@;
1036                 $string =~ s@\s*\)\s*$@@;
1037         }
1038
1039         $string =~ s@\s+@ @g;
1040
1041         return $string;
1042 }
1043
1044 sub seed_camelcase_file {
1045         my ($file) = @_;
1046
1047         return if (!(-f $file));
1048
1049         local $/;
1050
1051         open(my $include_file, '<', "$file")
1052             or warn "$P: Can't read '$file' $!\n";
1053         my $text = <$include_file>;
1054         close($include_file);
1055
1056         my @lines = split('\n', $text);
1057
1058         foreach my $line (@lines) {
1059                 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
1060                 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
1061                         $camelcase{$1} = 1;
1062                 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
1063                         $camelcase{$1} = 1;
1064                 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
1065                         $camelcase{$1} = 1;
1066                 }
1067         }
1068 }
1069
1070 our %maintained_status = ();
1071
1072 sub is_maintained_obsolete {
1073         my ($filename) = @_;
1074
1075         return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
1076
1077         if (!exists($maintained_status{$filename})) {
1078                 $maintained_status{$filename} = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
1079         }
1080
1081         return $maintained_status{$filename} =~ /obsolete/i;
1082 }
1083
1084 sub is_SPDX_License_valid {
1085         my ($license) = @_;
1086
1087         return 1 if (!$tree || which("python3") eq "" || !(-x "$root/scripts/spdxcheck.py") || !(-e "$gitroot"));
1088
1089         my $root_path = abs_path($root);
1090         my $status = `cd "$root_path"; echo "$license" | scripts/spdxcheck.py -`;
1091         return 0 if ($status ne "");
1092         return 1;
1093 }
1094
1095 my $camelcase_seeded = 0;
1096 sub seed_camelcase_includes {
1097         return if ($camelcase_seeded);
1098
1099         my $files;
1100         my $camelcase_cache = "";
1101         my @include_files = ();
1102
1103         $camelcase_seeded = 1;
1104
1105         if (-e "$gitroot") {
1106                 my $git_last_include_commit = `${git_command} log --no-merges --pretty=format:"%h%n" -1 -- include`;
1107                 chomp $git_last_include_commit;
1108                 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
1109         } else {
1110                 my $last_mod_date = 0;
1111                 $files = `find $root/include -name "*.h"`;
1112                 @include_files = split('\n', $files);
1113                 foreach my $file (@include_files) {
1114                         my $date = POSIX::strftime("%Y%m%d%H%M",
1115                                                    localtime((stat $file)[9]));
1116                         $last_mod_date = $date if ($last_mod_date < $date);
1117                 }
1118                 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
1119         }
1120
1121         if ($camelcase_cache ne "" && -f $camelcase_cache) {
1122                 open(my $camelcase_file, '<', "$camelcase_cache")
1123                     or warn "$P: Can't read '$camelcase_cache' $!\n";
1124                 while (<$camelcase_file>) {
1125                         chomp;
1126                         $camelcase{$_} = 1;
1127                 }
1128                 close($camelcase_file);
1129
1130                 return;
1131         }
1132
1133         if (-e "$gitroot") {
1134                 $files = `${git_command} ls-files "include/*.h"`;
1135                 @include_files = split('\n', $files);
1136         }
1137
1138         foreach my $file (@include_files) {
1139                 seed_camelcase_file($file);
1140         }
1141
1142         if ($camelcase_cache ne "") {
1143                 unlink glob ".checkpatch-camelcase.*";
1144                 open(my $camelcase_file, '>', "$camelcase_cache")
1145                     or warn "$P: Can't write '$camelcase_cache' $!\n";
1146                 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
1147                         print $camelcase_file ("$_\n");
1148                 }
1149                 close($camelcase_file);
1150         }
1151 }
1152
1153 sub git_is_single_file {
1154         my ($filename) = @_;
1155
1156         return 0 if ((which("git") eq "") || !(-e "$gitroot"));
1157
1158         my $output = `${git_command} ls-files -- $filename 2>/dev/null`;
1159         my $count = $output =~ tr/\n//;
1160         return $count eq 1 && $output =~ m{^${filename}$};
1161 }
1162
1163 sub git_commit_info {
1164         my ($commit, $id, $desc) = @_;
1165
1166         return ($id, $desc) if ((which("git") eq "") || !(-e "$gitroot"));
1167
1168         my $output = `${git_command} log --no-color --format='%H %s' -1 $commit 2>&1`;
1169         $output =~ s/^\s*//gm;
1170         my @lines = split("\n", $output);
1171
1172         return ($id, $desc) if ($#lines < 0);
1173
1174         if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous/) {
1175 # Maybe one day convert this block of bash into something that returns
1176 # all matching commit ids, but it's very slow...
1177 #
1178 #               echo "checking commits $1..."
1179 #               git rev-list --remotes | grep -i "^$1" |
1180 #               while read line ; do
1181 #                   git log --format='%H %s' -1 $line |
1182 #                   echo "commit $(cut -c 1-12,41-)"
1183 #               done
1184         } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
1185                 $id = undef;
1186         } else {
1187                 $id = substr($lines[0], 0, 12);
1188                 $desc = substr($lines[0], 41);
1189         }
1190
1191         return ($id, $desc);
1192 }
1193
1194 $chk_signoff = 0 if ($file);
1195
1196 my @rawlines = ();
1197 my @lines = ();
1198 my @fixed = ();
1199 my @fixed_inserted = ();
1200 my @fixed_deleted = ();
1201 my $fixlinenr = -1;
1202
1203 # If input is git commits, extract all commits from the commit expressions.
1204 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
1205 die "$P: No git repository found\n" if ($git && !-e "$gitroot");
1206
1207 if ($git) {
1208         my @commits = ();
1209         foreach my $commit_expr (@ARGV) {
1210                 my $git_range;
1211                 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
1212                         $git_range = "-$2 $1";
1213                 } elsif ($commit_expr =~ m/\.\./) {
1214                         $git_range = "$commit_expr";
1215                 } else {
1216                         $git_range = "-1 $commit_expr";
1217                 }
1218                 my $lines = `${git_command} log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
1219                 foreach my $line (split(/\n/, $lines)) {
1220                         $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
1221                         next if (!defined($1) || !defined($2));
1222                         my $sha1 = $1;
1223                         my $subject = $2;
1224                         unshift(@commits, $sha1);
1225                         $git_commits{$sha1} = $subject;
1226                 }
1227         }
1228         die "$P: no git commits after extraction!\n" if (@commits == 0);
1229         @ARGV = @commits;
1230 }
1231
1232 my $vname;
1233 $allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
1234 for my $filename (@ARGV) {
1235         my $FILE;
1236         my $is_git_file = git_is_single_file($filename);
1237         my $oldfile = $file;
1238         $file = 1 if ($is_git_file);
1239         if ($git) {
1240                 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
1241                         die "$P: $filename: git format-patch failed - $!\n";
1242         } elsif ($file) {
1243                 open($FILE, '-|', "diff -u /dev/null $filename") ||
1244                         die "$P: $filename: diff failed - $!\n";
1245         } elsif ($filename eq '-') {
1246                 open($FILE, '<&STDIN');
1247         } else {
1248                 open($FILE, '<', "$filename") ||
1249                         die "$P: $filename: open failed - $!\n";
1250         }
1251         if ($filename eq '-') {
1252                 $vname = 'Your patch';
1253         } elsif ($git) {
1254                 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1255         } else {
1256                 $vname = $filename;
1257         }
1258         while (<$FILE>) {
1259                 chomp;
1260                 push(@rawlines, $_);
1261                 $vname = qq("$1") if ($filename eq '-' && $_ =~ m/^Subject:\s+(.+)/i);
1262         }
1263         close($FILE);
1264
1265         if ($#ARGV > 0 && $quiet == 0) {
1266                 print '-' x length($vname) . "\n";
1267                 print "$vname\n";
1268                 print '-' x length($vname) . "\n";
1269         }
1270
1271         if (!process($filename)) {
1272                 $exit = 1;
1273         }
1274         @rawlines = ();
1275         @lines = ();
1276         @fixed = ();
1277         @fixed_inserted = ();
1278         @fixed_deleted = ();
1279         $fixlinenr = -1;
1280         @modifierListFile = ();
1281         @typeListFile = ();
1282         build_types();
1283         $file = $oldfile if ($is_git_file);
1284 }
1285
1286 if (!$quiet) {
1287         hash_show_words(\%use_type, "Used");
1288         hash_show_words(\%ignore_type, "Ignored");
1289
1290         if (!$perl_version_ok) {
1291                 print << "EOM"
1292
1293 NOTE: perl $^V is not modern enough to detect all possible issues.
1294       An upgrade to at least perl $minimum_perl_version is suggested.
1295 EOM
1296         }
1297         if ($exit) {
1298                 print << "EOM"
1299
1300 NOTE: If any of the errors are false positives, please report
1301       them to the maintainer, see CHECKPATCH in MAINTAINERS.
1302 EOM
1303         }
1304 }
1305
1306 exit($exit);
1307
1308 sub top_of_kernel_tree {
1309         my ($root) = @_;
1310
1311         my @tree_check = (
1312                 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1313                 "README", "Documentation", "arch", "include", "drivers",
1314                 "fs", "init", "ipc", "kernel", "lib", "scripts",
1315         );
1316
1317         foreach my $check (@tree_check) {
1318                 if (! -e $root . '/' . $check) {
1319                         return 0;
1320                 }
1321         }
1322         return 1;
1323 }
1324
1325 sub parse_email {
1326         my ($formatted_email) = @_;
1327
1328         my $name = "";
1329         my $quoted = "";
1330         my $name_comment = "";
1331         my $address = "";
1332         my $comment = "";
1333
1334         if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1335                 $name = $1;
1336                 $address = $2;
1337                 $comment = $3 if defined $3;
1338         } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1339                 $address = $1;
1340                 $comment = $2 if defined $2;
1341         } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1342                 $address = $1;
1343                 $comment = $2 if defined $2;
1344                 $formatted_email =~ s/\Q$address\E.*$//;
1345                 $name = $formatted_email;
1346                 $name = trim($name);
1347                 $name =~ s/^\"|\"$//g;
1348                 # If there's a name left after stripping spaces and
1349                 # leading quotes, and the address doesn't have both
1350                 # leading and trailing angle brackets, the address
1351                 # is invalid. ie:
1352                 #   "joe smith joe@smith.com" bad
1353                 #   "joe smith <joe@smith.com" bad
1354                 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1355                         $name = "";
1356                         $address = "";
1357                         $comment = "";
1358                 }
1359         }
1360
1361         # Extract comments from names excluding quoted parts
1362         # "John D. (Doe)" - Do not extract
1363         if ($name =~ s/\"(.+)\"//) {
1364                 $quoted = $1;
1365         }
1366         while ($name =~ s/\s*($balanced_parens)\s*/ /) {
1367                 $name_comment .= trim($1);
1368         }
1369         $name =~ s/^[ \"]+|[ \"]+$//g;
1370         $name = trim("$quoted $name");
1371
1372         $address = trim($address);
1373         $address =~ s/^\<|\>$//g;
1374         $comment = trim($comment);
1375
1376         if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1377                 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1378                 $name = "\"$name\"";
1379         }
1380
1381         return ($name, $name_comment, $address, $comment);
1382 }
1383
1384 sub format_email {
1385         my ($name, $name_comment, $address, $comment) = @_;
1386
1387         my $formatted_email;
1388
1389         $name =~ s/^[ \"]+|[ \"]+$//g;
1390         $address = trim($address);
1391         $address =~ s/(?:\.|\,|\")+$//; ##trailing commas, dots or quotes
1392
1393         if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1394                 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1395                 $name = "\"$name\"";
1396         }
1397
1398         $name_comment = trim($name_comment);
1399         $name_comment = " $name_comment" if ($name_comment ne "");
1400         $comment = trim($comment);
1401         $comment = " $comment" if ($comment ne "");
1402
1403         if ("$name" eq "") {
1404                 $formatted_email = "$address";
1405         } else {
1406                 $formatted_email = "$name$name_comment <$address>";
1407         }
1408         $formatted_email .= "$comment";
1409         return $formatted_email;
1410 }
1411
1412 sub reformat_email {
1413         my ($email) = @_;
1414
1415         my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
1416         return format_email($email_name, $name_comment, $email_address, $comment);
1417 }
1418
1419 sub same_email_addresses {
1420         my ($email1, $email2) = @_;
1421
1422         my ($email1_name, $name1_comment, $email1_address, $comment1) = parse_email($email1);
1423         my ($email2_name, $name2_comment, $email2_address, $comment2) = parse_email($email2);
1424
1425         return $email1_name eq $email2_name &&
1426                $email1_address eq $email2_address &&
1427                $name1_comment eq $name2_comment &&
1428                $comment1 eq $comment2;
1429 }
1430
1431 sub which {
1432         my ($bin) = @_;
1433
1434         foreach my $path (split(/:/, $ENV{PATH})) {
1435                 if (-e "$path/$bin") {
1436                         return "$path/$bin";
1437                 }
1438         }
1439
1440         return "";
1441 }
1442
1443 sub which_conf {
1444         my ($conf) = @_;
1445
1446         foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1447                 if (-e "$path/$conf") {
1448                         return "$path/$conf";
1449                 }
1450         }
1451
1452         return "";
1453 }
1454
1455 sub expand_tabs {
1456         my ($str) = @_;
1457
1458         my $res = '';
1459         my $n = 0;
1460         for my $c (split(//, $str)) {
1461                 if ($c eq "\t") {
1462                         $res .= ' ';
1463                         $n++;
1464                         for (; ($n % $tabsize) != 0; $n++) {
1465                                 $res .= ' ';
1466                         }
1467                         next;
1468                 }
1469                 $res .= $c;
1470                 $n++;
1471         }
1472
1473         return $res;
1474 }
1475 sub copy_spacing {
1476         (my $res = shift) =~ tr/\t/ /c;
1477         return $res;
1478 }
1479
1480 sub line_stats {
1481         my ($line) = @_;
1482
1483         # Drop the diff line leader and expand tabs
1484         $line =~ s/^.//;
1485         $line = expand_tabs($line);
1486
1487         # Pick the indent from the front of the line.
1488         my ($white) = ($line =~ /^(\s*)/);
1489
1490         return (length($line), length($white));
1491 }
1492
1493 my $sanitise_quote = '';
1494
1495 sub sanitise_line_reset {
1496         my ($in_comment) = @_;
1497
1498         if ($in_comment) {
1499                 $sanitise_quote = '*/';
1500         } else {
1501                 $sanitise_quote = '';
1502         }
1503 }
1504 sub sanitise_line {
1505         my ($line) = @_;
1506
1507         my $res = '';
1508         my $l = '';
1509
1510         my $qlen = 0;
1511         my $off = 0;
1512         my $c;
1513
1514         # Always copy over the diff marker.
1515         $res = substr($line, 0, 1);
1516
1517         for ($off = 1; $off < length($line); $off++) {
1518                 $c = substr($line, $off, 1);
1519
1520                 # Comments we are whacking completely including the begin
1521                 # and end, all to $;.
1522                 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1523                         $sanitise_quote = '*/';
1524
1525                         substr($res, $off, 2, "$;$;");
1526                         $off++;
1527                         next;
1528                 }
1529                 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1530                         $sanitise_quote = '';
1531                         substr($res, $off, 2, "$;$;");
1532                         $off++;
1533                         next;
1534                 }
1535                 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1536                         $sanitise_quote = '//';
1537
1538                         substr($res, $off, 2, $sanitise_quote);
1539                         $off++;
1540                         next;
1541                 }
1542
1543                 # A \ in a string means ignore the next character.
1544                 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1545                     $c eq "\\") {
1546                         substr($res, $off, 2, 'XX');
1547                         $off++;
1548                         next;
1549                 }
1550                 # Regular quotes.
1551                 if ($c eq "'" || $c eq '"') {
1552                         if ($sanitise_quote eq '') {
1553                                 $sanitise_quote = $c;
1554
1555                                 substr($res, $off, 1, $c);
1556                                 next;
1557                         } elsif ($sanitise_quote eq $c) {
1558                                 $sanitise_quote = '';
1559                         }
1560                 }
1561
1562                 #print "c<$c> SQ<$sanitise_quote>\n";
1563                 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1564                         substr($res, $off, 1, $;);
1565                 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1566                         substr($res, $off, 1, $;);
1567                 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1568                         substr($res, $off, 1, 'X');
1569                 } else {
1570                         substr($res, $off, 1, $c);
1571                 }
1572         }
1573
1574         if ($sanitise_quote eq '//') {
1575                 $sanitise_quote = '';
1576         }
1577
1578         # The pathname on a #include may be surrounded by '<' and '>'.
1579         if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1580                 my $clean = 'X' x length($1);
1581                 $res =~ s@\<.*\>@<$clean>@;
1582
1583         # The whole of a #error is a string.
1584         } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1585                 my $clean = 'X' x length($1);
1586                 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1587         }
1588
1589         if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1590                 my $match = $1;
1591                 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1592         }
1593
1594         return $res;
1595 }
1596
1597 sub get_quoted_string {
1598         my ($line, $rawline) = @_;
1599
1600         return "" if (!defined($line) || !defined($rawline));
1601         return "" if ($line !~ m/($String)/g);
1602         return substr($rawline, $-[0], $+[0] - $-[0]);
1603 }
1604
1605 sub ctx_statement_block {
1606         my ($linenr, $remain, $off) = @_;
1607         my $line = $linenr - 1;
1608         my $blk = '';
1609         my $soff = $off;
1610         my $coff = $off - 1;
1611         my $coff_set = 0;
1612
1613         my $loff = 0;
1614
1615         my $type = '';
1616         my $level = 0;
1617         my @stack = ();
1618         my $p;
1619         my $c;
1620         my $len = 0;
1621
1622         my $remainder;
1623         while (1) {
1624                 @stack = (['', 0]) if ($#stack == -1);
1625
1626                 #warn "CSB: blk<$blk> remain<$remain>\n";
1627                 # If we are about to drop off the end, pull in more
1628                 # context.
1629                 if ($off >= $len) {
1630                         for (; $remain > 0; $line++) {
1631                                 last if (!defined $lines[$line]);
1632                                 next if ($lines[$line] =~ /^-/);
1633                                 $remain--;
1634                                 $loff = $len;
1635                                 $blk .= $lines[$line] . "\n";
1636                                 $len = length($blk);
1637                                 $line++;
1638                                 last;
1639                         }
1640                         # Bail if there is no further context.
1641                         #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1642                         if ($off >= $len) {
1643                                 last;
1644                         }
1645                         if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1646                                 $level++;
1647                                 $type = '#';
1648                         }
1649                 }
1650                 $p = $c;
1651                 $c = substr($blk, $off, 1);
1652                 $remainder = substr($blk, $off);
1653
1654                 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1655
1656                 # Handle nested #if/#else.
1657                 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1658                         push(@stack, [ $type, $level ]);
1659                 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1660                         ($type, $level) = @{$stack[$#stack - 1]};
1661                 } elsif ($remainder =~ /^#\s*endif\b/) {
1662                         ($type, $level) = @{pop(@stack)};
1663                 }
1664
1665                 # Statement ends at the ';' or a close '}' at the
1666                 # outermost level.
1667                 if ($level == 0 && $c eq ';') {
1668                         last;
1669                 }
1670
1671                 # An else is really a conditional as long as its not else if
1672                 if ($level == 0 && $coff_set == 0 &&
1673                                 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1674                                 $remainder =~ /^(else)(?:\s|{)/ &&
1675                                 $remainder !~ /^else\s+if\b/) {
1676                         $coff = $off + length($1) - 1;
1677                         $coff_set = 1;
1678                         #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1679                         #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1680                 }
1681
1682                 if (($type eq '' || $type eq '(') && $c eq '(') {
1683                         $level++;
1684                         $type = '(';
1685                 }
1686                 if ($type eq '(' && $c eq ')') {
1687                         $level--;
1688                         $type = ($level != 0)? '(' : '';
1689
1690                         if ($level == 0 && $coff < $soff) {
1691                                 $coff = $off;
1692                                 $coff_set = 1;
1693                                 #warn "CSB: mark coff<$coff>\n";
1694                         }
1695                 }
1696                 if (($type eq '' || $type eq '{') && $c eq '{') {
1697                         $level++;
1698                         $type = '{';
1699                 }
1700                 if ($type eq '{' && $c eq '}') {
1701                         $level--;
1702                         $type = ($level != 0)? '{' : '';
1703
1704                         if ($level == 0) {
1705                                 if (substr($blk, $off + 1, 1) eq ';') {
1706                                         $off++;
1707                                 }
1708                                 last;
1709                         }
1710                 }
1711                 # Preprocessor commands end at the newline unless escaped.
1712                 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1713                         $level--;
1714                         $type = '';
1715                         $off++;
1716                         last;
1717                 }
1718                 $off++;
1719         }
1720         # We are truly at the end, so shuffle to the next line.
1721         if ($off == $len) {
1722                 $loff = $len + 1;
1723                 $line++;
1724                 $remain--;
1725         }
1726
1727         my $statement = substr($blk, $soff, $off - $soff + 1);
1728         my $condition = substr($blk, $soff, $coff - $soff + 1);
1729
1730         #warn "STATEMENT<$statement>\n";
1731         #warn "CONDITION<$condition>\n";
1732
1733         #print "coff<$coff> soff<$off> loff<$loff>\n";
1734
1735         return ($statement, $condition,
1736                         $line, $remain + 1, $off - $loff + 1, $level);
1737 }
1738
1739 sub statement_lines {
1740         my ($stmt) = @_;
1741
1742         # Strip the diff line prefixes and rip blank lines at start and end.
1743         $stmt =~ s/(^|\n)./$1/g;
1744         $stmt =~ s/^\s*//;
1745         $stmt =~ s/\s*$//;
1746
1747         my @stmt_lines = ($stmt =~ /\n/g);
1748
1749         return $#stmt_lines + 2;
1750 }
1751
1752 sub statement_rawlines {
1753         my ($stmt) = @_;
1754
1755         my @stmt_lines = ($stmt =~ /\n/g);
1756
1757         return $#stmt_lines + 2;
1758 }
1759
1760 sub statement_block_size {
1761         my ($stmt) = @_;
1762
1763         $stmt =~ s/(^|\n)./$1/g;
1764         $stmt =~ s/^\s*{//;
1765         $stmt =~ s/}\s*$//;
1766         $stmt =~ s/^\s*//;
1767         $stmt =~ s/\s*$//;
1768
1769         my @stmt_lines = ($stmt =~ /\n/g);
1770         my @stmt_statements = ($stmt =~ /;/g);
1771
1772         my $stmt_lines = $#stmt_lines + 2;
1773         my $stmt_statements = $#stmt_statements + 1;
1774
1775         if ($stmt_lines > $stmt_statements) {
1776                 return $stmt_lines;
1777         } else {
1778                 return $stmt_statements;
1779         }
1780 }
1781
1782 sub ctx_statement_full {
1783         my ($linenr, $remain, $off) = @_;
1784         my ($statement, $condition, $level);
1785
1786         my (@chunks);
1787
1788         # Grab the first conditional/block pair.
1789         ($statement, $condition, $linenr, $remain, $off, $level) =
1790                                 ctx_statement_block($linenr, $remain, $off);
1791         #print "F: c<$condition> s<$statement> remain<$remain>\n";
1792         push(@chunks, [ $condition, $statement ]);
1793         if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1794                 return ($level, $linenr, @chunks);
1795         }
1796
1797         # Pull in the following conditional/block pairs and see if they
1798         # could continue the statement.
1799         for (;;) {
1800                 ($statement, $condition, $linenr, $remain, $off, $level) =
1801                                 ctx_statement_block($linenr, $remain, $off);
1802                 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1803                 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1804                 #print "C: push\n";
1805                 push(@chunks, [ $condition, $statement ]);
1806         }
1807
1808         return ($level, $linenr, @chunks);
1809 }
1810
1811 sub ctx_block_get {
1812         my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1813         my $line;
1814         my $start = $linenr - 1;
1815         my $blk = '';
1816         my @o;
1817         my @c;
1818         my @res = ();
1819
1820         my $level = 0;
1821         my @stack = ($level);
1822         for ($line = $start; $remain > 0; $line++) {
1823                 next if ($rawlines[$line] =~ /^-/);
1824                 $remain--;
1825
1826                 $blk .= $rawlines[$line];
1827
1828                 # Handle nested #if/#else.
1829                 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1830                         push(@stack, $level);
1831                 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1832                         $level = $stack[$#stack - 1];
1833                 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1834                         $level = pop(@stack);
1835                 }
1836
1837                 foreach my $c (split(//, $lines[$line])) {
1838                         ##print "C<$c>L<$level><$open$close>O<$off>\n";
1839                         if ($off > 0) {
1840                                 $off--;
1841                                 next;
1842                         }
1843
1844                         if ($c eq $close && $level > 0) {
1845                                 $level--;
1846                                 last if ($level == 0);
1847                         } elsif ($c eq $open) {
1848                                 $level++;
1849                         }
1850                 }
1851
1852                 if (!$outer || $level <= 1) {
1853                         push(@res, $rawlines[$line]);
1854                 }
1855
1856                 last if ($level == 0);
1857         }
1858
1859         return ($level, @res);
1860 }
1861 sub ctx_block_outer {
1862         my ($linenr, $remain) = @_;
1863
1864         my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1865         return @r;
1866 }
1867 sub ctx_block {
1868         my ($linenr, $remain) = @_;
1869
1870         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1871         return @r;
1872 }
1873 sub ctx_statement {
1874         my ($linenr, $remain, $off) = @_;
1875
1876         my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1877         return @r;
1878 }
1879 sub ctx_block_level {
1880         my ($linenr, $remain) = @_;
1881
1882         return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1883 }
1884 sub ctx_statement_level {
1885         my ($linenr, $remain, $off) = @_;
1886
1887         return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1888 }
1889
1890 sub ctx_locate_comment {
1891         my ($first_line, $end_line) = @_;
1892
1893         # If c99 comment on the current line, or the line before or after
1894         my ($current_comment) = ($rawlines[$end_line - 1] =~ m@^\+.*(//.*$)@);
1895         return $current_comment if (defined $current_comment);
1896         ($current_comment) = ($rawlines[$end_line - 2] =~ m@^[\+ ].*(//.*$)@);
1897         return $current_comment if (defined $current_comment);
1898         ($current_comment) = ($rawlines[$end_line] =~ m@^[\+ ].*(//.*$)@);
1899         return $current_comment if (defined $current_comment);
1900
1901         # Catch a comment on the end of the line itself.
1902         ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1903         return $current_comment if (defined $current_comment);
1904
1905         # Look through the context and try and figure out if there is a
1906         # comment.
1907         my $in_comment = 0;
1908         $current_comment = '';
1909         for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1910                 my $line = $rawlines[$linenr - 1];
1911                 #warn "           $line\n";
1912                 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1913                         $in_comment = 1;
1914                 }
1915                 if ($line =~ m@/\*@) {
1916                         $in_comment = 1;
1917                 }
1918                 if (!$in_comment && $current_comment ne '') {
1919                         $current_comment = '';
1920                 }
1921                 $current_comment .= $line . "\n" if ($in_comment);
1922                 if ($line =~ m@\*/@) {
1923                         $in_comment = 0;
1924                 }
1925         }
1926
1927         chomp($current_comment);
1928         return($current_comment);
1929 }
1930 sub ctx_has_comment {
1931         my ($first_line, $end_line) = @_;
1932         my $cmt = ctx_locate_comment($first_line, $end_line);
1933
1934         ##print "LINE: $rawlines[$end_line - 1 ]\n";
1935         ##print "CMMT: $cmt\n";
1936
1937         return ($cmt ne '');
1938 }
1939
1940 sub raw_line {
1941         my ($linenr, $cnt) = @_;
1942
1943         my $offset = $linenr - 1;
1944         $cnt++;
1945
1946         my $line;
1947         while ($cnt) {
1948                 $line = $rawlines[$offset++];
1949                 next if (defined($line) && $line =~ /^-/);
1950                 $cnt--;
1951         }
1952
1953         return $line;
1954 }
1955
1956 sub get_stat_real {
1957         my ($linenr, $lc) = @_;
1958
1959         my $stat_real = raw_line($linenr, 0);
1960         for (my $count = $linenr + 1; $count <= $lc; $count++) {
1961                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
1962         }
1963
1964         return $stat_real;
1965 }
1966
1967 sub get_stat_here {
1968         my ($linenr, $cnt, $here) = @_;
1969
1970         my $herectx = $here . "\n";
1971         for (my $n = 0; $n < $cnt; $n++) {
1972                 $herectx .= raw_line($linenr, $n) . "\n";
1973         }
1974
1975         return $herectx;
1976 }
1977
1978 sub cat_vet {
1979         my ($vet) = @_;
1980         my ($res, $coded);
1981
1982         $res = '';
1983         while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1984                 $res .= $1;
1985                 if ($2 ne '') {
1986                         $coded = sprintf("^%c", unpack('C', $2) + 64);
1987                         $res .= $coded;
1988                 }
1989         }
1990         $res =~ s/$/\$/;
1991
1992         return $res;
1993 }
1994
1995 my $av_preprocessor = 0;
1996 my $av_pending;
1997 my @av_paren_type;
1998 my $av_pend_colon;
1999
2000 sub annotate_reset {
2001         $av_preprocessor = 0;
2002         $av_pending = '_';
2003         @av_paren_type = ('E');
2004         $av_pend_colon = 'O';
2005 }
2006
2007 sub annotate_values {
2008         my ($stream, $type) = @_;
2009
2010         my $res;
2011         my $var = '_' x length($stream);
2012         my $cur = $stream;
2013
2014         print "$stream\n" if ($dbg_values > 1);
2015
2016         while (length($cur)) {
2017                 @av_paren_type = ('E') if ($#av_paren_type < 0);
2018                 print " <" . join('', @av_paren_type) .
2019                                 "> <$type> <$av_pending>" if ($dbg_values > 1);
2020                 if ($cur =~ /^(\s+)/o) {
2021                         print "WS($1)\n" if ($dbg_values > 1);
2022                         if ($1 =~ /\n/ && $av_preprocessor) {
2023                                 $type = pop(@av_paren_type);
2024                                 $av_preprocessor = 0;
2025                         }
2026
2027                 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
2028                         print "CAST($1)\n" if ($dbg_values > 1);
2029                         push(@av_paren_type, $type);
2030                         $type = 'c';
2031
2032                 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
2033                         print "DECLARE($1)\n" if ($dbg_values > 1);
2034                         $type = 'T';
2035
2036                 } elsif ($cur =~ /^($Modifier)\s*/) {
2037                         print "MODIFIER($1)\n" if ($dbg_values > 1);
2038                         $type = 'T';
2039
2040                 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
2041                         print "DEFINE($1,$2)\n" if ($dbg_values > 1);
2042                         $av_preprocessor = 1;
2043                         push(@av_paren_type, $type);
2044                         if ($2 ne '') {
2045                                 $av_pending = 'N';
2046                         }
2047                         $type = 'E';
2048
2049                 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
2050                         print "UNDEF($1)\n" if ($dbg_values > 1);
2051                         $av_preprocessor = 1;
2052                         push(@av_paren_type, $type);
2053
2054                 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
2055                         print "PRE_START($1)\n" if ($dbg_values > 1);
2056                         $av_preprocessor = 1;
2057
2058                         push(@av_paren_type, $type);
2059                         push(@av_paren_type, $type);
2060                         $type = 'E';
2061
2062                 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
2063                         print "PRE_RESTART($1)\n" if ($dbg_values > 1);
2064                         $av_preprocessor = 1;
2065
2066                         push(@av_paren_type, $av_paren_type[$#av_paren_type]);
2067
2068                         $type = 'E';
2069
2070                 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
2071                         print "PRE_END($1)\n" if ($dbg_values > 1);
2072
2073                         $av_preprocessor = 1;
2074
2075                         # Assume all arms of the conditional end as this
2076                         # one does, and continue as if the #endif was not here.
2077                         pop(@av_paren_type);
2078                         push(@av_paren_type, $type);
2079                         $type = 'E';
2080
2081                 } elsif ($cur =~ /^(\\\n)/o) {
2082                         print "PRECONT($1)\n" if ($dbg_values > 1);
2083
2084                 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
2085                         print "ATTR($1)\n" if ($dbg_values > 1);
2086                         $av_pending = $type;
2087                         $type = 'N';
2088
2089                 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
2090                         print "SIZEOF($1)\n" if ($dbg_values > 1);
2091                         if (defined $2) {
2092                                 $av_pending = 'V';
2093                         }
2094                         $type = 'N';
2095
2096                 } elsif ($cur =~ /^(if|while|for)\b/o) {
2097                         print "COND($1)\n" if ($dbg_values > 1);
2098                         $av_pending = 'E';
2099                         $type = 'N';
2100
2101                 } elsif ($cur =~/^(case)/o) {
2102                         print "CASE($1)\n" if ($dbg_values > 1);
2103                         $av_pend_colon = 'C';
2104                         $type = 'N';
2105
2106                 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
2107                         print "KEYWORD($1)\n" if ($dbg_values > 1);
2108                         $type = 'N';
2109
2110                 } elsif ($cur =~ /^(\()/o) {
2111                         print "PAREN('$1')\n" if ($dbg_values > 1);
2112                         push(@av_paren_type, $av_pending);
2113                         $av_pending = '_';
2114                         $type = 'N';
2115
2116                 } elsif ($cur =~ /^(\))/o) {
2117                         my $new_type = pop(@av_paren_type);
2118                         if ($new_type ne '_') {
2119                                 $type = $new_type;
2120                                 print "PAREN('$1') -> $type\n"
2121                                                         if ($dbg_values > 1);
2122                         } else {
2123                                 print "PAREN('$1')\n" if ($dbg_values > 1);
2124                         }
2125
2126                 } elsif ($cur =~ /^($Ident)\s*\(/o) {
2127                         print "FUNC($1)\n" if ($dbg_values > 1);
2128                         $type = 'V';
2129                         $av_pending = 'V';
2130
2131                 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
2132                         if (defined $2 && $type eq 'C' || $type eq 'T') {
2133                                 $av_pend_colon = 'B';
2134                         } elsif ($type eq 'E') {
2135                                 $av_pend_colon = 'L';
2136                         }
2137                         print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
2138                         $type = 'V';
2139
2140                 } elsif ($cur =~ /^($Ident|$Constant)/o) {
2141                         print "IDENT($1)\n" if ($dbg_values > 1);
2142                         $type = 'V';
2143
2144                 } elsif ($cur =~ /^($Assignment)/o) {
2145                         print "ASSIGN($1)\n" if ($dbg_values > 1);
2146                         $type = 'N';
2147
2148                 } elsif ($cur =~/^(;|{|})/) {
2149                         print "END($1)\n" if ($dbg_values > 1);
2150                         $type = 'E';
2151                         $av_pend_colon = 'O';
2152
2153                 } elsif ($cur =~/^(,)/) {
2154                         print "COMMA($1)\n" if ($dbg_values > 1);
2155                         $type = 'C';
2156
2157                 } elsif ($cur =~ /^(\?)/o) {
2158                         print "QUESTION($1)\n" if ($dbg_values > 1);
2159                         $type = 'N';
2160
2161                 } elsif ($cur =~ /^(:)/o) {
2162                         print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
2163
2164                         substr($var, length($res), 1, $av_pend_colon);
2165                         if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
2166                                 $type = 'E';
2167                         } else {
2168                                 $type = 'N';
2169                         }
2170                         $av_pend_colon = 'O';
2171
2172                 } elsif ($cur =~ /^(\[)/o) {
2173                         print "CLOSE($1)\n" if ($dbg_values > 1);
2174                         $type = 'N';
2175
2176                 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
2177                         my $variant;
2178
2179                         print "OPV($1)\n" if ($dbg_values > 1);
2180                         if ($type eq 'V') {
2181                                 $variant = 'B';
2182                         } else {
2183                                 $variant = 'U';
2184                         }
2185
2186                         substr($var, length($res), 1, $variant);
2187                         $type = 'N';
2188
2189                 } elsif ($cur =~ /^($Operators)/o) {
2190                         print "OP($1)\n" if ($dbg_values > 1);
2191                         if ($1 ne '++' && $1 ne '--') {
2192                                 $type = 'N';
2193                         }
2194
2195                 } elsif ($cur =~ /(^.)/o) {
2196                         print "C($1)\n" if ($dbg_values > 1);
2197                 }
2198                 if (defined $1) {
2199                         $cur = substr($cur, length($1));
2200                         $res .= $type x length($1);
2201                 }
2202         }
2203
2204         return ($res, $var);
2205 }
2206
2207 sub possible {
2208         my ($possible, $line) = @_;
2209         my $notPermitted = qr{(?:
2210                 ^(?:
2211                         $Modifier|
2212                         $Storage|
2213                         $Type|
2214                         DEFINE_\S+
2215                 )$|
2216                 ^(?:
2217                         goto|
2218                         return|
2219                         case|
2220                         else|
2221                         asm|__asm__|
2222                         do|
2223                         \#|
2224                         \#\#|
2225                 )(?:\s|$)|
2226                 ^(?:typedef|struct|enum)\b
2227             )}x;
2228         warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
2229         if ($possible !~ $notPermitted) {
2230                 # Check for modifiers.
2231                 $possible =~ s/\s*$Storage\s*//g;
2232                 $possible =~ s/\s*$Sparse\s*//g;
2233                 if ($possible =~ /^\s*$/) {
2234
2235                 } elsif ($possible =~ /\s/) {
2236                         $possible =~ s/\s*$Type\s*//g;
2237                         for my $modifier (split(' ', $possible)) {
2238                                 if ($modifier !~ $notPermitted) {
2239                                         warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
2240                                         push(@modifierListFile, $modifier);
2241                                 }
2242                         }
2243
2244                 } else {
2245                         warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
2246                         push(@typeListFile, $possible);
2247                 }
2248                 build_types();
2249         } else {
2250                 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
2251         }
2252 }
2253
2254 my $prefix = '';
2255
2256 sub show_type {
2257         my ($type) = @_;
2258
2259         $type =~ tr/[a-z]/[A-Z]/;
2260
2261         return defined $use_type{$type} if (scalar keys %use_type > 0);
2262
2263         return !defined $ignore_type{$type};
2264 }
2265
2266 sub report {
2267         my ($level, $type, $msg) = @_;
2268
2269         if (!show_type($type) ||
2270             (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
2271                 return 0;
2272         }
2273         my $output = '';
2274         if ($color) {
2275                 if ($level eq 'ERROR') {
2276                         $output .= RED;
2277                 } elsif ($level eq 'WARNING') {
2278                         $output .= YELLOW;
2279                 } else {
2280                         $output .= GREEN;
2281                 }
2282         }
2283         $output .= $prefix . $level . ':';
2284         if ($show_types) {
2285                 $output .= BLUE if ($color);
2286                 $output .= "$type:";
2287         }
2288         $output .= RESET if ($color);
2289         $output .= ' ' . $msg . "\n";
2290
2291         if ($showfile) {
2292                 my @lines = split("\n", $output, -1);
2293                 splice(@lines, 1, 1);
2294                 $output = join("\n", @lines);
2295         }
2296
2297         if ($terse) {
2298                 $output = (split('\n', $output))[0] . "\n";
2299         }
2300
2301         if ($verbose && exists($verbose_messages{$type}) &&
2302             !exists($verbose_emitted{$type})) {
2303                 $output .= $verbose_messages{$type} . "\n\n";
2304                 $verbose_emitted{$type} = 1;
2305         }
2306
2307         push(our @report, $output);
2308
2309         return 1;
2310 }
2311
2312 sub report_dump {
2313         our @report;
2314 }
2315
2316 sub fixup_current_range {
2317         my ($lineRef, $offset, $length) = @_;
2318
2319         if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2320                 my $o = $1;
2321                 my $l = $2;
2322                 my $no = $o + $offset;
2323                 my $nl = $l + $length;
2324                 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2325         }
2326 }
2327
2328 sub fix_inserted_deleted_lines {
2329         my ($linesRef, $insertedRef, $deletedRef) = @_;
2330
2331         my $range_last_linenr = 0;
2332         my $delta_offset = 0;
2333
2334         my $old_linenr = 0;
2335         my $new_linenr = 0;
2336
2337         my $next_insert = 0;
2338         my $next_delete = 0;
2339
2340         my @lines = ();
2341
2342         my $inserted = @{$insertedRef}[$next_insert++];
2343         my $deleted = @{$deletedRef}[$next_delete++];
2344
2345         foreach my $old_line (@{$linesRef}) {
2346                 my $save_line = 1;
2347                 my $line = $old_line;   #don't modify the array
2348                 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) {      #new filename
2349                         $delta_offset = 0;
2350                 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) {    #new hunk
2351                         $range_last_linenr = $new_linenr;
2352                         fixup_current_range(\$line, $delta_offset, 0);
2353                 }
2354
2355                 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2356                         $deleted = @{$deletedRef}[$next_delete++];
2357                         $save_line = 0;
2358                         fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2359                 }
2360
2361                 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2362                         push(@lines, ${$inserted}{'LINE'});
2363                         $inserted = @{$insertedRef}[$next_insert++];
2364                         $new_linenr++;
2365                         fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2366                 }
2367
2368                 if ($save_line) {
2369                         push(@lines, $line);
2370                         $new_linenr++;
2371                 }
2372
2373                 $old_linenr++;
2374         }
2375
2376         return @lines;
2377 }
2378
2379 sub fix_insert_line {
2380         my ($linenr, $line) = @_;
2381
2382         my $inserted = {
2383                 LINENR => $linenr,
2384                 LINE => $line,
2385         };
2386         push(@fixed_inserted, $inserted);
2387 }
2388
2389 sub fix_delete_line {
2390         my ($linenr, $line) = @_;
2391
2392         my $deleted = {
2393                 LINENR => $linenr,
2394                 LINE => $line,
2395         };
2396
2397         push(@fixed_deleted, $deleted);
2398 }
2399
2400 sub ERROR {
2401         my ($type, $msg) = @_;
2402
2403         if (report("ERROR", $type, $msg)) {
2404                 our $clean = 0;
2405                 our $cnt_error++;
2406                 return 1;
2407         }
2408         return 0;
2409 }
2410 sub WARN {
2411         my ($type, $msg) = @_;
2412
2413         if (report("WARNING", $type, $msg)) {
2414                 our $clean = 0;
2415                 our $cnt_warn++;
2416                 return 1;
2417         }
2418         return 0;
2419 }
2420 sub CHK {
2421         my ($type, $msg) = @_;
2422
2423         if ($check && report("CHECK", $type, $msg)) {
2424                 our $clean = 0;
2425                 our $cnt_chk++;
2426                 return 1;
2427         }
2428         return 0;
2429 }
2430
2431 sub check_absolute_file {
2432         my ($absolute, $herecurr) = @_;
2433         my $file = $absolute;
2434
2435         ##print "absolute<$absolute>\n";
2436
2437         # See if any suffix of this path is a path within the tree.
2438         while ($file =~ s@^[^/]*/@@) {
2439                 if (-f "$root/$file") {
2440                         ##print "file<$file>\n";
2441                         last;
2442                 }
2443         }
2444         if (! -f _)  {
2445                 return 0;
2446         }
2447
2448         # It is, so see if the prefix is acceptable.
2449         my $prefix = $absolute;
2450         substr($prefix, -length($file)) = '';
2451
2452         ##print "prefix<$prefix>\n";
2453         if ($prefix ne ".../") {
2454                 WARN("USE_RELATIVE_PATH",
2455                      "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2456         }
2457 }
2458
2459 sub trim {
2460         my ($string) = @_;
2461
2462         $string =~ s/^\s+|\s+$//g;
2463
2464         return $string;
2465 }
2466
2467 sub ltrim {
2468         my ($string) = @_;
2469
2470         $string =~ s/^\s+//;
2471
2472         return $string;
2473 }
2474
2475 sub rtrim {
2476         my ($string) = @_;
2477
2478         $string =~ s/\s+$//;
2479
2480         return $string;
2481 }
2482
2483 sub string_find_replace {
2484         my ($string, $find, $replace) = @_;
2485
2486         $string =~ s/$find/$replace/g;
2487
2488         return $string;
2489 }
2490
2491 sub tabify {
2492         my ($leading) = @_;
2493
2494         my $source_indent = $tabsize;
2495         my $max_spaces_before_tab = $source_indent - 1;
2496         my $spaces_to_tab = " " x $source_indent;
2497
2498         #convert leading spaces to tabs
2499         1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2500         #Remove spaces before a tab
2501         1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2502
2503         return "$leading";
2504 }
2505
2506 sub pos_last_openparen {
2507         my ($line) = @_;
2508
2509         my $pos = 0;
2510
2511         my $opens = $line =~ tr/\(/\(/;
2512         my $closes = $line =~ tr/\)/\)/;
2513
2514         my $last_openparen = 0;
2515
2516         if (($opens == 0) || ($closes >= $opens)) {
2517                 return -1;
2518         }
2519
2520         my $len = length($line);
2521
2522         for ($pos = 0; $pos < $len; $pos++) {
2523                 my $string = substr($line, $pos);
2524                 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2525                         $pos += length($1) - 1;
2526                 } elsif (substr($line, $pos, 1) eq '(') {
2527                         $last_openparen = $pos;
2528                 } elsif (index($string, '(') == -1) {
2529                         last;
2530                 }
2531         }
2532
2533         return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2534 }
2535
2536 sub get_raw_comment {
2537         my ($line, $rawline) = @_;
2538         my $comment = '';
2539
2540         for my $i (0 .. (length($line) - 1)) {
2541                 if (substr($line, $i, 1) eq "$;") {
2542                         $comment .= substr($rawline, $i, 1);
2543                 }
2544         }
2545
2546         return $comment;
2547 }
2548
2549 sub exclude_global_initialisers {
2550         my ($realfile) = @_;
2551
2552         # Do not check for BPF programs (tools/testing/selftests/bpf/progs/*.c, samples/bpf/*_kern.c, *.bpf.c).
2553         return $realfile =~ m@^tools/testing/selftests/bpf/progs/.*\.c$@ ||
2554                 $realfile =~ m@^samples/bpf/.*_kern\.c$@ ||
2555                 $realfile =~ m@/bpf/.*\.bpf\.c$@;
2556 }
2557
2558 sub process {
2559         my $filename = shift;
2560
2561         my $linenr=0;
2562         my $prevline="";
2563         my $prevrawline="";
2564         my $stashline="";
2565         my $stashrawline="";
2566
2567         my $length;
2568         my $indent;
2569         my $previndent=0;
2570         my $stashindent=0;
2571
2572         our $clean = 1;
2573         my $signoff = 0;
2574         my $author = '';
2575         my $authorsignoff = 0;
2576         my $author_sob = '';
2577         my $is_patch = 0;
2578         my $is_binding_patch = -1;
2579         my $in_header_lines = $file ? 0 : 1;
2580         my $in_commit_log = 0;          #Scanning lines before patch
2581         my $has_patch_separator = 0;    #Found a --- line
2582         my $has_commit_log = 0;         #Encountered lines before patch
2583         my $commit_log_lines = 0;       #Number of commit log lines
2584         my $commit_log_possible_stack_dump = 0;
2585         my $commit_log_long_line = 0;
2586         my $commit_log_has_diff = 0;
2587         my $reported_maintainer_file = 0;
2588         my $non_utf8_charset = 0;
2589
2590         my $last_blank_line = 0;
2591         my $last_coalesced_string_linenr = -1;
2592
2593         our @report = ();
2594         our $cnt_lines = 0;
2595         our $cnt_error = 0;
2596         our $cnt_warn = 0;
2597         our $cnt_chk = 0;
2598
2599         # Trace the real file/line as we go.
2600         my $realfile = '';
2601         my $realline = 0;
2602         my $realcnt = 0;
2603         my $here = '';
2604         my $context_function;           #undef'd unless there's a known function
2605         my $in_comment = 0;
2606         my $comment_edge = 0;
2607         my $first_line = 0;
2608         my $p1_prefix = '';
2609
2610         my $prev_values = 'E';
2611
2612         # suppression flags
2613         my %suppress_ifbraces;
2614         my %suppress_whiletrailers;
2615         my %suppress_export;
2616         my $suppress_statement = 0;
2617
2618         my %signatures = ();
2619
2620         # Pre-scan the patch sanitizing the lines.
2621         # Pre-scan the patch looking for any __setup documentation.
2622         #
2623         my @setup_docs = ();
2624         my $setup_docs = 0;
2625
2626         my $camelcase_file_seeded = 0;
2627
2628         my $checklicenseline = 1;
2629
2630         sanitise_line_reset();
2631         my $line;
2632         foreach my $rawline (@rawlines) {
2633                 $linenr++;
2634                 $line = $rawline;
2635
2636                 push(@fixed, $rawline) if ($fix);
2637
2638                 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2639                         $setup_docs = 0;
2640                         if ($1 =~ m@Documentation/admin-guide/kernel-parameters.txt$@) {
2641                                 $setup_docs = 1;
2642                         }
2643                         #next;
2644                 }
2645                 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2646                         $realline=$1-1;
2647                         if (defined $2) {
2648                                 $realcnt=$3+1;
2649                         } else {
2650                                 $realcnt=1+1;
2651                         }
2652                         $in_comment = 0;
2653
2654                         # Guestimate if this is a continuing comment.  Run
2655                         # the context looking for a comment "edge".  If this
2656                         # edge is a close comment then we must be in a comment
2657                         # at context start.
2658                         my $edge;
2659                         my $cnt = $realcnt;
2660                         for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2661                                 next if (defined $rawlines[$ln - 1] &&
2662                                          $rawlines[$ln - 1] =~ /^-/);
2663                                 $cnt--;
2664                                 #print "RAW<$rawlines[$ln - 1]>\n";
2665                                 last if (!defined $rawlines[$ln - 1]);
2666                                 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2667                                     $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2668                                         ($edge) = $1;
2669                                         last;
2670                                 }
2671                         }
2672                         if (defined $edge && $edge eq '*/') {
2673                                 $in_comment = 1;
2674                         }
2675
2676                         # Guestimate if this is a continuing comment.  If this
2677                         # is the start of a diff block and this line starts
2678                         # ' *' then it is very likely a comment.
2679                         if (!defined $edge &&
2680                             $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2681                         {
2682                                 $in_comment = 1;
2683                         }
2684
2685                         ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2686                         sanitise_line_reset($in_comment);
2687
2688                 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2689                         # Standardise the strings and chars within the input to
2690                         # simplify matching -- only bother with positive lines.
2691                         $line = sanitise_line($rawline);
2692                 }
2693                 push(@lines, $line);
2694
2695                 if ($realcnt > 1) {
2696                         $realcnt-- if ($line =~ /^(?:\+| |$)/);
2697                 } else {
2698                         $realcnt = 0;
2699                 }
2700
2701                 #print "==>$rawline\n";
2702                 #print "-->$line\n";
2703
2704                 if ($setup_docs && $line =~ /^\+/) {
2705                         push(@setup_docs, $line);
2706                 }
2707         }
2708
2709         $prefix = '';
2710
2711         $realcnt = 0;
2712         $linenr = 0;
2713         $fixlinenr = -1;
2714         foreach my $line (@lines) {
2715                 $linenr++;
2716                 $fixlinenr++;
2717                 my $sline = $line;      #copy of $line
2718                 $sline =~ s/$;/ /g;     #with comments as spaces
2719
2720                 my $rawline = $rawlines[$linenr - 1];
2721                 my $raw_comment = get_raw_comment($line, $rawline);
2722
2723 # check if it's a mode change, rename or start of a patch
2724                 if (!$in_commit_log &&
2725                     ($line =~ /^ mode change [0-7]+ => [0-7]+ \S+\s*$/ ||
2726                     ($line =~ /^rename (?:from|to) \S+\s*$/ ||
2727                      $line =~ /^diff --git a\/[\w\/\.\_\-]+ b\/\S+\s*$/))) {
2728                         $is_patch = 1;
2729                 }
2730
2731 #extract the line range in the file after the patch is applied
2732                 if (!$in_commit_log &&
2733                     $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2734                         my $context = $4;
2735                         $is_patch = 1;
2736                         $first_line = $linenr + 1;
2737                         $realline=$1-1;
2738                         if (defined $2) {
2739                                 $realcnt=$3+1;
2740                         } else {
2741                                 $realcnt=1+1;
2742                         }
2743                         annotate_reset();
2744                         $prev_values = 'E';
2745
2746                         %suppress_ifbraces = ();
2747                         %suppress_whiletrailers = ();
2748                         %suppress_export = ();
2749                         $suppress_statement = 0;
2750                         if ($context =~ /\b(\w+)\s*\(/) {
2751                                 $context_function = $1;
2752                         } else {
2753                                 undef $context_function;
2754                         }
2755                         next;
2756
2757 # track the line number as we move through the hunk, note that
2758 # new versions of GNU diff omit the leading space on completely
2759 # blank context lines so we need to count that too.
2760                 } elsif ($line =~ /^( |\+|$)/) {
2761                         $realline++;
2762                         $realcnt-- if ($realcnt != 0);
2763
2764                         # Measure the line length and indent.
2765                         ($length, $indent) = line_stats($rawline);
2766
2767                         # Track the previous line.
2768                         ($prevline, $stashline) = ($stashline, $line);
2769                         ($previndent, $stashindent) = ($stashindent, $indent);
2770                         ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2771
2772                         #warn "line<$line>\n";
2773
2774                 } elsif ($realcnt == 1) {
2775                         $realcnt--;
2776                 }
2777
2778                 my $hunk_line = ($realcnt != 0);
2779
2780                 $here = "#$linenr: " if (!$file);
2781                 $here = "#$realline: " if ($file);
2782
2783                 my $found_file = 0;
2784                 # extract the filename as it passes
2785                 if ($line =~ /^diff --git.*?(\S+)$/) {
2786                         $realfile = $1;
2787                         $realfile =~ s@^([^/]*)/@@ if (!$file);
2788                         $in_commit_log = 0;
2789                         $found_file = 1;
2790                 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2791                         $realfile = $1;
2792                         $realfile =~ s@^([^/]*)/@@ if (!$file);
2793                         $in_commit_log = 0;
2794
2795                         $p1_prefix = $1;
2796                         if (!$file && $tree && $p1_prefix ne '' &&
2797                             -e "$root/$p1_prefix") {
2798                                 WARN("PATCH_PREFIX",
2799                                      "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2800                         }
2801
2802                         if ($realfile =~ m@^include/asm/@) {
2803                                 ERROR("MODIFIED_INCLUDE_ASM",
2804                                       "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2805                         }
2806                         $found_file = 1;
2807                 }
2808
2809 #make up the handle for any error we report on this line
2810                 if ($showfile) {
2811                         $prefix = "$realfile:$realline: "
2812                 } elsif ($emacs) {
2813                         if ($file) {
2814                                 $prefix = "$filename:$realline: ";
2815                         } else {
2816                                 $prefix = "$filename:$linenr: ";
2817                         }
2818                 }
2819
2820                 if ($found_file) {
2821                         if (is_maintained_obsolete($realfile)) {
2822                                 WARN("OBSOLETE",
2823                                      "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy.  No unnecessary modifications please.\n");
2824                         }
2825                         if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2826                                 $check = 1;
2827                         } else {
2828                                 $check = $check_orig;
2829                         }
2830                         $checklicenseline = 1;
2831
2832                         if ($realfile !~ /^MAINTAINERS/) {
2833                                 my $last_binding_patch = $is_binding_patch;
2834
2835                                 $is_binding_patch = () = $realfile =~ m@^(?:Documentation/devicetree/|include/dt-bindings/)@;
2836
2837                                 if (($last_binding_patch != -1) &&
2838                                     ($last_binding_patch ^ $is_binding_patch)) {
2839                                         WARN("DT_SPLIT_BINDING_PATCH",
2840                                              "DT binding docs and includes should be a separate patch. See: Documentation/devicetree/bindings/submitting-patches.rst\n");
2841                                 }
2842                         }
2843
2844                         next;
2845                 }
2846
2847                 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2848
2849                 my $hereline = "$here\n$rawline\n";
2850                 my $herecurr = "$here\n$rawline\n";
2851                 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2852
2853                 $cnt_lines++ if ($realcnt != 0);
2854
2855 # Verify the existence of a commit log if appropriate
2856 # 2 is used because a $signature is counted in $commit_log_lines
2857                 if ($in_commit_log) {
2858                         if ($line !~ /^\s*$/) {
2859                                 $commit_log_lines++;    #could be a $signature
2860                         }
2861                 } elsif ($has_commit_log && $commit_log_lines < 2) {
2862                         WARN("COMMIT_MESSAGE",
2863                              "Missing commit description - Add an appropriate one\n");
2864                         $commit_log_lines = 2;  #warn only once
2865                 }
2866
2867 # Check if the commit log has what seems like a diff which can confuse patch
2868                 if ($in_commit_log && !$commit_log_has_diff &&
2869                     (($line =~ m@^\s+diff\b.*a/([\w/]+)@ &&
2870                       $line =~ m@^\s+diff\b.*a/[\w/]+\s+b/$1\b@) ||
2871                      $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2872                      $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2873                         ERROR("DIFF_IN_COMMIT_MSG",
2874                               "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2875                         $commit_log_has_diff = 1;
2876                 }
2877
2878 # Check for incorrect file permissions
2879                 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2880                         my $permhere = $here . "FILE: $realfile\n";
2881                         if ($realfile !~ m@scripts/@ &&
2882                             $realfile !~ /\.(py|pl|awk|sh)$/) {
2883                                 ERROR("EXECUTE_PERMISSIONS",
2884                                       "do not set execute permissions for source files\n" . $permhere);
2885                         }
2886                 }
2887
2888 # Check the patch for a From:
2889                 if (decode("MIME-Header", $line) =~ /^From:\s*(.*)/) {
2890                         $author = $1;
2891                         my $curline = $linenr;
2892                         while(defined($rawlines[$curline]) && ($rawlines[$curline++] =~ /^[ \t]\s*(.*)/)) {
2893                                 $author .= $1;
2894                         }
2895                         $author = encode("utf8", $author) if ($line =~ /=\?utf-8\?/i);
2896                         $author =~ s/"//g;
2897                         $author = reformat_email($author);
2898                 }
2899
2900 # Check the patch for a signoff:
2901                 if ($line =~ /^\s*signed-off-by:\s*(.*)/i) {
2902                         $signoff++;
2903                         $in_commit_log = 0;
2904                         if ($author ne ''  && $authorsignoff != 1) {
2905                                 if (same_email_addresses($1, $author)) {
2906                                         $authorsignoff = 1;
2907                                 } else {
2908                                         my $ctx = $1;
2909                                         my ($email_name, $email_comment, $email_address, $comment1) = parse_email($ctx);
2910                                         my ($author_name, $author_comment, $author_address, $comment2) = parse_email($author);
2911
2912                                         if ($email_address eq $author_address && $email_name eq $author_name) {
2913                                                 $author_sob = $ctx;
2914                                                 $authorsignoff = 2;
2915                                         } elsif ($email_address eq $author_address) {
2916                                                 $author_sob = $ctx;
2917                                                 $authorsignoff = 3;
2918                                         } elsif ($email_name eq $author_name) {
2919                                                 $author_sob = $ctx;
2920                                                 $authorsignoff = 4;
2921
2922                                                 my $address1 = $email_address;
2923                                                 my $address2 = $author_address;
2924
2925                                                 if ($address1 =~ /(\S+)\+\S+(\@.*)/) {
2926                                                         $address1 = "$1$2";
2927                                                 }
2928                                                 if ($address2 =~ /(\S+)\+\S+(\@.*)/) {
2929                                                         $address2 = "$1$2";
2930                                                 }
2931                                                 if ($address1 eq $address2) {
2932                                                         $authorsignoff = 5;
2933                                                 }
2934                                         }
2935                                 }
2936                         }
2937                 }
2938
2939 # Check for patch separator
2940                 if ($line =~ /^---$/) {
2941                         $has_patch_separator = 1;
2942                         $in_commit_log = 0;
2943                 }
2944
2945 # Check if MAINTAINERS is being updated.  If so, there's probably no need to
2946 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2947                 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2948                         $reported_maintainer_file = 1;
2949                 }
2950
2951 # Check signature styles
2952                 if (!$in_header_lines &&
2953                     $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2954                         my $space_before = $1;
2955                         my $sign_off = $2;
2956                         my $space_after = $3;
2957                         my $email = $4;
2958                         my $ucfirst_sign_off = ucfirst(lc($sign_off));
2959
2960                         if ($sign_off !~ /$signature_tags/) {
2961                                 my $suggested_signature = find_standard_signature($sign_off);
2962                                 if ($suggested_signature eq "") {
2963                                         WARN("BAD_SIGN_OFF",
2964                                              "Non-standard signature: $sign_off\n" . $herecurr);
2965                                 } else {
2966                                         if (WARN("BAD_SIGN_OFF",
2967                                                  "Non-standard signature: '$sign_off' - perhaps '$suggested_signature'?\n" . $herecurr) &&
2968                                             $fix) {
2969                                                 $fixed[$fixlinenr] =~ s/$sign_off/$suggested_signature/;
2970                                         }
2971                                 }
2972                         }
2973                         if (defined $space_before && $space_before ne "") {
2974                                 if (WARN("BAD_SIGN_OFF",
2975                                          "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2976                                     $fix) {
2977                                         $fixed[$fixlinenr] =
2978                                             "$ucfirst_sign_off $email";
2979                                 }
2980                         }
2981                         if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2982                                 if (WARN("BAD_SIGN_OFF",
2983                                          "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2984                                     $fix) {
2985                                         $fixed[$fixlinenr] =
2986                                             "$ucfirst_sign_off $email";
2987                                 }
2988
2989                         }
2990                         if (!defined $space_after || $space_after ne " ") {
2991                                 if (WARN("BAD_SIGN_OFF",
2992                                          "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2993                                     $fix) {
2994                                         $fixed[$fixlinenr] =
2995                                             "$ucfirst_sign_off $email";
2996                                 }
2997                         }
2998
2999                         my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
3000                         my $suggested_email = format_email(($email_name, $name_comment, $email_address, $comment));
3001                         if ($suggested_email eq "") {
3002                                 ERROR("BAD_SIGN_OFF",
3003                                       "Unrecognized email address: '$email'\n" . $herecurr);
3004                         } else {
3005                                 my $dequoted = $suggested_email;
3006                                 $dequoted =~ s/^"//;
3007                                 $dequoted =~ s/" </ </;
3008                                 # Don't force email to have quotes
3009                                 # Allow just an angle bracketed address
3010                                 if (!same_email_addresses($email, $suggested_email)) {
3011                                         if (WARN("BAD_SIGN_OFF",
3012                                                  "email address '$email' might be better as '$suggested_email'\n" . $herecurr) &&
3013                                             $fix) {
3014                                                 $fixed[$fixlinenr] =~ s/\Q$email\E/$suggested_email/;
3015                                         }
3016                                 }
3017
3018                                 # Address part shouldn't have comments
3019                                 my $stripped_address = $email_address;
3020                                 $stripped_address =~ s/\([^\(\)]*\)//g;
3021                                 if ($email_address ne $stripped_address) {
3022                                         if (WARN("BAD_SIGN_OFF",
3023                                                  "address part of email should not have comments: '$email_address'\n" . $herecurr) &&
3024                                             $fix) {
3025                                                 $fixed[$fixlinenr] =~ s/\Q$email_address\E/$stripped_address/;
3026                                         }
3027                                 }
3028
3029                                 # Only one name comment should be allowed
3030                                 my $comment_count = () = $name_comment =~ /\([^\)]+\)/g;
3031                                 if ($comment_count > 1) {
3032                                         WARN("BAD_SIGN_OFF",
3033                                              "Use a single name comment in email: '$email'\n" . $herecurr);
3034                                 }
3035
3036
3037                                 # stable@vger.kernel.org or stable@kernel.org shouldn't
3038                                 # have an email name. In addition comments should strictly
3039                                 # begin with a #
3040                                 if ($email =~ /^.*stable\@(?:vger\.)?kernel\.org/i) {
3041                                         if (($comment ne "" && $comment !~ /^#.+/) ||
3042                                             ($email_name ne "")) {
3043                                                 my $cur_name = $email_name;
3044                                                 my $new_comment = $comment;
3045                                                 $cur_name =~ s/[a-zA-Z\s\-\"]+//g;
3046
3047                                                 # Remove brackets enclosing comment text
3048                                                 # and # from start of comments to get comment text
3049                                                 $new_comment =~ s/^\((.*)\)$/$1/;
3050                                                 $new_comment =~ s/^\[(.*)\]$/$1/;
3051                                                 $new_comment =~ s/^[\s\#]+|\s+$//g;
3052
3053                                                 $new_comment = trim("$new_comment $cur_name") if ($cur_name ne $new_comment);
3054                                                 $new_comment = " # $new_comment" if ($new_comment ne "");
3055                                                 my $new_email = "$email_address$new_comment";
3056
3057                                                 if (WARN("BAD_STABLE_ADDRESS_STYLE",
3058                                                          "Invalid email format for stable: '$email', prefer '$new_email'\n" . $herecurr) &&
3059                                                     $fix) {
3060                                                         $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3061                                                 }
3062                                         }
3063                                 } elsif ($comment ne "" && $comment !~ /^(?:#.+|\(.+\))$/) {
3064                                         my $new_comment = $comment;
3065
3066                                         # Extract comment text from within brackets or
3067                                         # c89 style /*...*/ comments
3068                                         $new_comment =~ s/^\[(.*)\]$/$1/;
3069                                         $new_comment =~ s/^\/\*(.*)\*\/$/$1/;
3070
3071                                         $new_comment = trim($new_comment);
3072                                         $new_comment =~ s/^[^\w]$//; # Single lettered comment with non word character is usually a typo
3073                                         $new_comment = "($new_comment)" if ($new_comment ne "");
3074                                         my $new_email = format_email($email_name, $name_comment, $email_address, $new_comment);
3075
3076                                         if (WARN("BAD_SIGN_OFF",
3077                                                  "Unexpected content after email: '$email', should be: '$new_email'\n" . $herecurr) &&
3078                                             $fix) {
3079                                                 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3080                                         }
3081                                 }
3082                         }
3083
3084 # Check for duplicate signatures
3085                         my $sig_nospace = $line;
3086                         $sig_nospace =~ s/\s//g;
3087                         $sig_nospace = lc($sig_nospace);
3088                         if (defined $signatures{$sig_nospace}) {
3089                                 WARN("BAD_SIGN_OFF",
3090                                      "Duplicate signature\n" . $herecurr);
3091                         } else {
3092                                 $signatures{$sig_nospace} = 1;
3093                         }
3094
3095 # Check Co-developed-by: immediately followed by Signed-off-by: with same name and email
3096                         if ($sign_off =~ /^co-developed-by:$/i) {
3097                                 if ($email eq $author) {
3098                                         WARN("BAD_SIGN_OFF",
3099                                               "Co-developed-by: should not be used to attribute nominal patch author '$author'\n" . "$here\n" . $rawline);
3100                                 }
3101                                 if (!defined $lines[$linenr]) {
3102                                         WARN("BAD_SIGN_OFF",
3103                                              "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline);
3104                                 } elsif ($rawlines[$linenr] !~ /^\s*signed-off-by:\s*(.*)/i) {
3105                                         WARN("BAD_SIGN_OFF",
3106                                              "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3107                                 } elsif ($1 ne $email) {
3108                                         WARN("BAD_SIGN_OFF",
3109                                              "Co-developed-by and Signed-off-by: name/email do not match \n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3110                                 }
3111                         }
3112                 }
3113
3114 # Check email subject for common tools that don't need to be mentioned
3115                 if ($in_header_lines &&
3116                     $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
3117                         WARN("EMAIL_SUBJECT",
3118                              "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
3119                 }
3120
3121 # Check for Gerrit Change-Ids not in any patch context
3122                 if ($realfile eq '' && !$has_patch_separator && $line =~ /^\s*change-id:/i) {
3123                         if (ERROR("GERRIT_CHANGE_ID",
3124                                   "Remove Gerrit Change-Id's before submitting upstream\n" . $herecurr) &&
3125                             $fix) {
3126                                 fix_delete_line($fixlinenr, $rawline);
3127                         }
3128                 }
3129
3130 # Check if the commit log is in a possible stack dump
3131                 if ($in_commit_log && !$commit_log_possible_stack_dump &&
3132                     ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
3133                      $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
3134                                         # timestamp
3135                      $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/) ||
3136                      $line =~ /^(?:\s+\w+:\s+[0-9a-fA-F]+){3,3}/ ||
3137                      $line =~ /^\s*\#\d+\s*\[[0-9a-fA-F]+\]\s*\w+ at [0-9a-fA-F]+/) {
3138                                         # stack dump address styles
3139                         $commit_log_possible_stack_dump = 1;
3140                 }
3141
3142 # Check for line lengths > 75 in commit log, warn once
3143                 if ($in_commit_log && !$commit_log_long_line &&
3144                     length($line) > 75 &&
3145                     !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
3146                                         # file delta changes
3147                       $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
3148                                         # filename then :
3149                       $line =~ /^\s*(?:Fixes:|Link:|$signature_tags)/i ||
3150                                         # A Fixes: or Link: line or signature tag line
3151                       $commit_log_possible_stack_dump)) {
3152                         WARN("COMMIT_LOG_LONG_LINE",
3153                              "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
3154                         $commit_log_long_line = 1;
3155                 }
3156
3157 # Reset possible stack dump if a blank line is found
3158                 if ($in_commit_log && $commit_log_possible_stack_dump &&
3159                     $line =~ /^\s*$/) {
3160                         $commit_log_possible_stack_dump = 0;
3161                 }
3162
3163 # Check for lines starting with a #
3164                 if ($in_commit_log && $line =~ /^#/) {
3165                         if (WARN("COMMIT_COMMENT_SYMBOL",
3166                                  "Commit log lines starting with '#' are dropped by git as comments\n" . $herecurr) &&
3167                             $fix) {
3168                                 $fixed[$fixlinenr] =~ s/^/ /;
3169                         }
3170                 }
3171
3172 # Check for git id commit length and improperly formed commit descriptions
3173                 if ($in_commit_log && !$commit_log_possible_stack_dump &&
3174                     $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink|base-commit):/i &&
3175                     $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
3176                     ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
3177                      ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
3178                       $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
3179                       $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
3180                         my $init_char = "c";
3181                         my $orig_commit = "";
3182                         my $short = 1;
3183                         my $long = 0;
3184                         my $case = 1;
3185                         my $space = 1;
3186                         my $hasdesc = 0;
3187                         my $hasparens = 0;
3188                         my $id = '0123456789ab';
3189                         my $orig_desc = "commit description";
3190                         my $description = "";
3191
3192                         if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
3193                                 $init_char = $1;
3194                                 $orig_commit = lc($2);
3195                         } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
3196                                 $orig_commit = lc($1);
3197                         }
3198
3199                         $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
3200                         $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
3201                         $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
3202                         $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
3203                         if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
3204                                 $orig_desc = $1;
3205                                 $hasparens = 1;
3206                         } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
3207                                  defined $rawlines[$linenr] &&
3208                                  $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
3209                                 $orig_desc = $1;
3210                                 $hasparens = 1;
3211                         } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
3212                                  defined $rawlines[$linenr] &&
3213                                  $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
3214                                 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
3215                                 $orig_desc = $1;
3216                                 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
3217                                 $orig_desc .= " " . $1;
3218                                 $hasparens = 1;
3219                         }
3220
3221                         ($id, $description) = git_commit_info($orig_commit,
3222                                                               $id, $orig_desc);
3223
3224                         if (defined($id) &&
3225                            ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
3226                                 ERROR("GIT_COMMIT_ID",
3227                                       "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
3228                         }
3229                 }
3230
3231 # Check for added, moved or deleted files
3232                 if (!$reported_maintainer_file && !$in_commit_log &&
3233                     ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
3234                      $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
3235                      ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
3236                       (defined($1) || defined($2))))) {
3237                         $is_patch = 1;
3238                         $reported_maintainer_file = 1;
3239                         WARN("FILE_PATH_CHANGES",
3240                              "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
3241                 }
3242
3243 # Check for adding new DT bindings not in schema format
3244                 if (!$in_commit_log &&
3245                     ($line =~ /^new file mode\s*\d+\s*$/) &&
3246                     ($realfile =~ m@^Documentation/devicetree/bindings/.*\.txt$@)) {
3247                         WARN("DT_SCHEMA_BINDING_PATCH",
3248                              "DT bindings should be in DT schema format. See: Documentation/devicetree/bindings/writing-schema.rst\n");
3249                 }
3250
3251 # Check for wrappage within a valid hunk of the file
3252                 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
3253                         ERROR("CORRUPTED_PATCH",
3254                               "patch seems to be corrupt (line wrapped?)\n" .
3255                                 $herecurr) if (!$emitted_corrupt++);
3256                 }
3257
3258 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
3259                 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
3260                     $rawline !~ m/^$UTF8*$/) {
3261                         my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
3262
3263                         my $blank = copy_spacing($rawline);
3264                         my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
3265                         my $hereptr = "$hereline$ptr\n";
3266
3267                         CHK("INVALID_UTF8",
3268                             "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
3269                 }
3270
3271 # Check if it's the start of a commit log
3272 # (not a header line and we haven't seen the patch filename)
3273                 if ($in_header_lines && $realfile =~ /^$/ &&
3274                     !($rawline =~ /^\s+(?:\S|$)/ ||
3275                       $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
3276                         $in_header_lines = 0;
3277                         $in_commit_log = 1;
3278                         $has_commit_log = 1;
3279                 }
3280
3281 # Check if there is UTF-8 in a commit log when a mail header has explicitly
3282 # declined it, i.e defined some charset where it is missing.
3283                 if ($in_header_lines &&
3284                     $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
3285                     $1 !~ /utf-8/i) {
3286                         $non_utf8_charset = 1;
3287                 }
3288
3289                 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
3290                     $rawline =~ /$NON_ASCII_UTF8/) {
3291                         WARN("UTF8_BEFORE_PATCH",
3292                             "8-bit UTF-8 used in possible commit log\n" . $herecurr);
3293                 }
3294
3295 # Check for absolute kernel paths in commit message
3296                 if ($tree && $in_commit_log) {
3297                         while ($line =~ m{(?:^|\s)(/\S*)}g) {
3298                                 my $file = $1;
3299
3300                                 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
3301                                     check_absolute_file($1, $herecurr)) {
3302                                         #
3303                                 } else {
3304                                         check_absolute_file($file, $herecurr);
3305                                 }
3306                         }
3307                 }
3308
3309 # Check for various typo / spelling mistakes
3310                 if (defined($misspellings) &&
3311                     ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
3312                         while ($rawline =~ /(?:^|[^\w\-'`])($misspellings)(?:[^\w\-'`]|$)/gi) {
3313                                 my $typo = $1;
3314                                 my $blank = copy_spacing($rawline);
3315                                 my $ptr = substr($blank, 0, $-[1]) . "^" x length($typo);
3316                                 my $hereptr = "$hereline$ptr\n";
3317                                 my $typo_fix = $spelling_fix{lc($typo)};
3318                                 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
3319                                 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
3320                                 my $msg_level = \&WARN;
3321                                 $msg_level = \&CHK if ($file);
3322                                 if (&{$msg_level}("TYPO_SPELLING",
3323                                                   "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $hereptr) &&
3324                                     $fix) {
3325                                         $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
3326                                 }
3327                         }
3328                 }
3329
3330 # check for invalid commit id
3331                 if ($in_commit_log && $line =~ /(^fixes:|\bcommit)\s+([0-9a-f]{6,40})\b/i) {
3332                         my $id;
3333                         my $description;
3334                         ($id, $description) = git_commit_info($2, undef, undef);
3335                         if (!defined($id)) {
3336                                 WARN("UNKNOWN_COMMIT_ID",
3337                                      "Unknown commit id '$2', maybe rebased or not pulled?\n" . $herecurr);
3338                         }
3339                 }
3340
3341 # check for repeated words separated by a single space
3342 # avoid false positive from list command eg, '-rw-r--r-- 1 root root'
3343                 if (($rawline =~ /^\+/ || $in_commit_log) &&
3344                     $rawline !~ /[bcCdDlMnpPs\?-][rwxsStT-]{9}/) {
3345                         pos($rawline) = 1 if (!$in_commit_log);
3346                         while ($rawline =~ /\b($word_pattern) (?=($word_pattern))/g) {
3347
3348                                 my $first = $1;
3349                                 my $second = $2;
3350                                 my $start_pos = $-[1];
3351                                 my $end_pos = $+[2];
3352                                 if ($first =~ /(?:struct|union|enum)/) {
3353                                         pos($rawline) += length($first) + length($second) + 1;
3354                                         next;
3355                                 }
3356
3357                                 next if (lc($first) ne lc($second));
3358                                 next if ($first eq 'long');
3359
3360                                 # check for character before and after the word matches
3361                                 my $start_char = '';
3362                                 my $end_char = '';
3363                                 $start_char = substr($rawline, $start_pos - 1, 1) if ($start_pos > ($in_commit_log ? 0 : 1));
3364                                 $end_char = substr($rawline, $end_pos, 1) if ($end_pos < length($rawline));
3365
3366                                 next if ($start_char =~ /^\S$/);
3367                                 next if (index(" \t.,;?!", $end_char) == -1);
3368
3369                                 # avoid repeating hex occurrences like 'ff ff fe 09 ...'
3370                                 if ($first =~ /\b[0-9a-f]{2,}\b/i) {
3371                                         next if (!exists($allow_repeated_words{lc($first)}));
3372                                 }
3373
3374                                 if (WARN("REPEATED_WORD",
3375                                          "Possible repeated word: '$first'\n" . $herecurr) &&
3376                                     $fix) {
3377                                         $fixed[$fixlinenr] =~ s/\b$first $second\b/$first/;
3378                                 }
3379                         }
3380
3381                         # if it's a repeated word on consecutive lines in a comment block
3382                         if ($prevline =~ /$;+\s*$/ &&
3383                             $prevrawline =~ /($word_pattern)\s*$/) {
3384                                 my $last_word = $1;
3385                                 if ($rawline =~ /^\+\s*\*\s*$last_word /) {
3386                                         if (WARN("REPEATED_WORD",
3387                                                  "Possible repeated word: '$last_word'\n" . $hereprev) &&
3388                                             $fix) {
3389                                                 $fixed[$fixlinenr] =~ s/(\+\s*\*\s*)$last_word /$1/;
3390                                         }
3391                                 }
3392                         }
3393                 }
3394
3395 # ignore non-hunk lines and lines being removed
3396                 next if (!$hunk_line || $line =~ /^-/);
3397
3398 #trailing whitespace
3399                 if ($line =~ /^\+.*\015/) {
3400                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3401                         if (ERROR("DOS_LINE_ENDINGS",
3402                                   "DOS line endings\n" . $herevet) &&
3403                             $fix) {
3404                                 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
3405                         }
3406                 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
3407                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3408                         if (ERROR("TRAILING_WHITESPACE",
3409                                   "trailing whitespace\n" . $herevet) &&
3410                             $fix) {
3411                                 $fixed[$fixlinenr] =~ s/\s+$//;
3412                         }
3413
3414                         $rpt_cleaners = 1;
3415                 }
3416
3417 # Check for FSF mailing addresses.
3418                 if ($rawline =~ /\bwrite to the Free/i ||
3419                     $rawline =~ /\b675\s+Mass\s+Ave/i ||
3420                     $rawline =~ /\b59\s+Temple\s+Pl/i ||
3421                     $rawline =~ /\b51\s+Franklin\s+St/i) {
3422                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3423                         my $msg_level = \&ERROR;
3424                         $msg_level = \&CHK if ($file);
3425                         &{$msg_level}("FSF_MAILING_ADDRESS",
3426                                       "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)
3427                 }
3428
3429 # check for Kconfig help text having a real description
3430 # Only applies when adding the entry originally, after that we do not have
3431 # sufficient context to determine whether it is indeed long enough.
3432                 if ($realfile =~ /Kconfig/ &&
3433                     # 'choice' is usually the last thing on the line (though
3434                     # Kconfig supports named choices), so use a word boundary
3435                     # (\b) rather than a whitespace character (\s)
3436                     $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
3437                         my $length = 0;
3438                         my $cnt = $realcnt;
3439                         my $ln = $linenr + 1;
3440                         my $f;
3441                         my $is_start = 0;
3442                         my $is_end = 0;
3443                         for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
3444                                 $f = $lines[$ln - 1];
3445                                 $cnt-- if ($lines[$ln - 1] !~ /^-/);
3446                                 $is_end = $lines[$ln - 1] =~ /^\+/;
3447
3448                                 next if ($f =~ /^-/);
3449                                 last if (!$file && $f =~ /^\@\@/);
3450
3451                                 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
3452                                         $is_start = 1;
3453                                 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
3454                                         $length = -1;
3455                                 }
3456
3457                                 $f =~ s/^.//;
3458                                 $f =~ s/#.*//;
3459                                 $f =~ s/^\s+//;
3460                                 next if ($f =~ /^$/);
3461
3462                                 # This only checks context lines in the patch
3463                                 # and so hopefully shouldn't trigger false
3464                                 # positives, even though some of these are
3465                                 # common words in help texts
3466                                 if ($f =~ /^\s*(?:config|menuconfig|choice|endchoice|
3467                                                   if|endif|menu|endmenu|source)\b/x) {
3468                                         $is_end = 1;
3469                                         last;
3470                                 }
3471                                 $length++;
3472                         }
3473                         if ($is_start && $is_end && $length < $min_conf_desc_length) {
3474                                 WARN("CONFIG_DESCRIPTION",
3475                                      "please write a paragraph that describes the config symbol fully\n" . $herecurr);
3476                         }
3477                         #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
3478                 }
3479
3480 # check MAINTAINERS entries
3481                 if ($realfile =~ /^MAINTAINERS$/) {
3482 # check MAINTAINERS entries for the right form
3483                         if ($rawline =~ /^\+[A-Z]:/ &&
3484                             $rawline !~ /^\+[A-Z]:\t\S/) {
3485                                 if (WARN("MAINTAINERS_STYLE",
3486                                          "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
3487                                     $fix) {
3488                                         $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
3489                                 }
3490                         }
3491 # check MAINTAINERS entries for the right ordering too
3492                         my $preferred_order = 'MRLSWQBCPTFXNK';
3493                         if ($rawline =~ /^\+[A-Z]:/ &&
3494                             $prevrawline =~ /^[\+ ][A-Z]:/) {
3495                                 $rawline =~ /^\+([A-Z]):\s*(.*)/;
3496                                 my $cur = $1;
3497                                 my $curval = $2;
3498                                 $prevrawline =~ /^[\+ ]([A-Z]):\s*(.*)/;
3499                                 my $prev = $1;
3500                                 my $prevval = $2;
3501                                 my $curindex = index($preferred_order, $cur);
3502                                 my $previndex = index($preferred_order, $prev);
3503                                 if ($curindex < 0) {
3504                                         WARN("MAINTAINERS_STYLE",
3505                                              "Unknown MAINTAINERS entry type: '$cur'\n" . $herecurr);
3506                                 } else {
3507                                         if ($previndex >= 0 && $curindex < $previndex) {
3508                                                 WARN("MAINTAINERS_STYLE",
3509                                                      "Misordered MAINTAINERS entry - list '$cur:' before '$prev:'\n" . $hereprev);
3510                                         } elsif ((($prev eq 'F' && $cur eq 'F') ||
3511                                                   ($prev eq 'X' && $cur eq 'X')) &&
3512                                                  ($prevval cmp $curval) > 0) {
3513                                                 WARN("MAINTAINERS_STYLE",
3514                                                      "Misordered MAINTAINERS entry - list file patterns in alphabetic order\n" . $hereprev);
3515                                         }
3516                                 }
3517                         }
3518                 }
3519
3520                 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
3521                     ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
3522                         my $flag = $1;
3523                         my $replacement = {
3524                                 'EXTRA_AFLAGS' =>   'asflags-y',
3525                                 'EXTRA_CFLAGS' =>   'ccflags-y',
3526                                 'EXTRA_CPPFLAGS' => 'cppflags-y',
3527                                 'EXTRA_LDFLAGS' =>  'ldflags-y',
3528                         };
3529
3530                         WARN("DEPRECATED_VARIABLE",
3531                              "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
3532                 }
3533
3534 # check for DT compatible documentation
3535                 if (defined $root &&
3536                         (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
3537                          ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
3538
3539                         my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
3540
3541                         my $dt_path = $root . "/Documentation/devicetree/bindings/";
3542                         my $vp_file = $dt_path . "vendor-prefixes.yaml";
3543
3544                         foreach my $compat (@compats) {
3545                                 my $compat2 = $compat;
3546                                 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
3547                                 my $compat3 = $compat;
3548                                 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
3549                                 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
3550                                 if ( $? >> 8 ) {
3551                                         WARN("UNDOCUMENTED_DT_STRING",
3552                                              "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
3553                                 }
3554
3555                                 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
3556                                 my $vendor = $1;
3557                                 `grep -Eq "\\"\\^\Q$vendor\E,\\.\\*\\":" $vp_file`;
3558                                 if ( $? >> 8 ) {
3559                                         WARN("UNDOCUMENTED_DT_STRING",
3560                                              "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
3561                                 }
3562                         }
3563                 }
3564
3565 # check for using SPDX license tag at beginning of files
3566                 if ($realline == $checklicenseline) {
3567                         if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
3568                                 $checklicenseline = 2;
3569                         } elsif ($rawline =~ /^\+/) {
3570                                 my $comment = "";
3571                                 if ($realfile =~ /\.(h|s|S)$/) {
3572                                         $comment = '/*';
3573                                 } elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
3574                                         $comment = '//';
3575                                 } elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc|yaml)$/) {
3576                                         $comment = '#';
3577                                 } elsif ($realfile =~ /\.rst$/) {
3578                                         $comment = '..';
3579                                 }
3580
3581 # check SPDX comment style for .[chsS] files
3582                                 if ($realfile =~ /\.[chsS]$/ &&
3583                                     $rawline =~ /SPDX-License-Identifier:/ &&
3584                                     $rawline !~ m@^\+\s*\Q$comment\E\s*@) {
3585                                         WARN("SPDX_LICENSE_TAG",
3586                                              "Improper SPDX comment style for '$realfile', please use '$comment' instead\n" . $herecurr);
3587                                 }
3588
3589                                 if ($comment !~ /^$/ &&
3590                                     $rawline !~ m@^\+\Q$comment\E SPDX-License-Identifier: @) {
3591                                         WARN("SPDX_LICENSE_TAG",
3592                                              "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
3593                                 } elsif ($rawline =~ /(SPDX-License-Identifier: .*)/) {
3594                                         my $spdx_license = $1;
3595                                         if (!is_SPDX_License_valid($spdx_license)) {
3596                                                 WARN("SPDX_LICENSE_TAG",
3597                                                      "'$spdx_license' is not supported in LICENSES/...\n" . $herecurr);
3598                                         }
3599                                         if ($realfile =~ m@^Documentation/devicetree/bindings/@ &&
3600                                             not $spdx_license =~ /GPL-2\.0.*BSD-2-Clause/) {
3601                                                 my $msg_level = \&WARN;
3602                                                 $msg_level = \&CHK if ($file);
3603                                                 if (&{$msg_level}("SPDX_LICENSE_TAG",
3604
3605                                                                   "DT binding documents should be licensed (GPL-2.0-only OR BSD-2-Clause)\n" . $herecurr) &&
3606                                                     $fix) {
3607                                                         $fixed[$fixlinenr] =~ s/SPDX-License-Identifier: .*/SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)/;
3608                                                 }
3609                                         }
3610                                 }
3611                         }
3612                 }
3613
3614 # check for embedded filenames
3615                 if ($rawline =~ /^\+.*\Q$realfile\E/) {
3616                         WARN("EMBEDDED_FILENAME",
3617                              "It's generally not useful to have the filename in the file\n" . $herecurr);
3618                 }
3619
3620 # check we are in a valid source file if not then ignore this hunk
3621                 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
3622
3623 # check for using SPDX-License-Identifier on the wrong line number
3624                 if ($realline != $checklicenseline &&
3625                     $rawline =~ /\bSPDX-License-Identifier:/ &&
3626                     substr($line, @-, @+ - @-) eq "$;" x (@+ - @-)) {
3627                         WARN("SPDX_LICENSE_TAG",
3628                              "Misplaced SPDX-License-Identifier tag - use line $checklicenseline instead\n" . $herecurr);
3629                 }
3630
3631 # line length limit (with some exclusions)
3632 #
3633 # There are a few types of lines that may extend beyond $max_line_length:
3634 #       logging functions like pr_info that end in a string
3635 #       lines with a single string
3636 #       #defines that are a single string
3637 #       lines with an RFC3986 like URL
3638 #
3639 # There are 3 different line length message types:
3640 # LONG_LINE_COMMENT     a comment starts before but extends beyond $max_line_length
3641 # LONG_LINE_STRING      a string starts before but extends beyond $max_line_length
3642 # LONG_LINE             all other lines longer than $max_line_length
3643 #
3644 # if LONG_LINE is ignored, the other 2 types are also ignored
3645 #
3646
3647                 if ($line =~ /^\+/ && $length > $max_line_length) {
3648                         my $msg_type = "LONG_LINE";
3649
3650                         # Check the allowed long line types first
3651
3652                         # logging functions that end in a string that starts
3653                         # before $max_line_length
3654                         if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
3655                             length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3656                                 $msg_type = "";
3657
3658                         # lines with only strings (w/ possible termination)
3659                         # #defines with only strings
3660                         } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
3661                                  $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
3662                                 $msg_type = "";
3663
3664                         # More special cases
3665                         } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3666                                  $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3667                                 $msg_type = "";
3668
3669                         # URL ($rawline is used in case the URL is in a comment)
3670                         } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
3671                                 $msg_type = "";
3672
3673                         # Otherwise set the alternate message types
3674
3675                         # a comment starts before $max_line_length
3676                         } elsif ($line =~ /($;[\s$;]*)$/ &&
3677                                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3678                                 $msg_type = "LONG_LINE_COMMENT"
3679
3680                         # a quoted string starts before $max_line_length
3681                         } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3682                                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3683                                 $msg_type = "LONG_LINE_STRING"
3684                         }
3685
3686                         if ($msg_type ne "" &&
3687                             (show_type("LONG_LINE") || show_type($msg_type))) {
3688                                 my $msg_level = \&WARN;
3689                                 $msg_level = \&CHK if ($file);
3690                                 &{$msg_level}($msg_type,
3691                                               "line length of $length exceeds $max_line_length columns\n" . $herecurr);
3692                         }
3693                 }
3694
3695 # check for adding lines without a newline.
3696                 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3697                         if (WARN("MISSING_EOF_NEWLINE",
3698                                  "adding a line without newline at end of file\n" . $herecurr) &&
3699                             $fix) {
3700                                 fix_delete_line($fixlinenr+1, "No newline at end of file");
3701                         }
3702                 }
3703
3704 # check for .L prefix local symbols in .S files
3705                 if ($realfile =~ /\.S$/ &&
3706                     $line =~ /^\+\s*(?:[A-Z]+_)?SYM_[A-Z]+_(?:START|END)(?:_[A-Z_]+)?\s*\(\s*\.L/) {
3707                         WARN("AVOID_L_PREFIX",
3708                              "Avoid using '.L' prefixed local symbol names for denoting a range of code via 'SYM_*_START/END' annotations; see Documentation/asm-annotations.rst\n" . $herecurr);
3709                 }
3710
3711 # check we are in a valid source file C or perl if not then ignore this hunk
3712                 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3713
3714 # at the beginning of a line any tabs must come first and anything
3715 # more than $tabsize must use tabs.
3716                 if ($rawline =~ /^\+\s* \t\s*\S/ ||
3717                     $rawline =~ /^\+\s*        \s*/) {
3718                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3719                         $rpt_cleaners = 1;
3720                         if (ERROR("CODE_INDENT",
3721                                   "code indent should use tabs where possible\n" . $herevet) &&
3722                             $fix) {
3723                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3724                         }
3725                 }
3726
3727 # check for space before tabs.
3728                 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3729                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3730                         if (WARN("SPACE_BEFORE_TAB",
3731                                 "please, no space before tabs\n" . $herevet) &&
3732                             $fix) {
3733                                 while ($fixed[$fixlinenr] =~
3734                                            s/(^\+.*) {$tabsize,$tabsize}\t/$1\t\t/) {}
3735                                 while ($fixed[$fixlinenr] =~
3736                                            s/(^\+.*) +\t/$1\t/) {}
3737                         }
3738                 }
3739
3740 # check for assignments on the start of a line
3741                 if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3742                         my $operator = $1;
3743                         if (CHK("ASSIGNMENT_CONTINUATIONS",
3744                                 "Assignment operator '$1' should be on the previous line\n" . $hereprev) &&
3745                             $fix && $prevrawline =~ /^\+/) {
3746                                 # add assignment operator to the previous line, remove from current line
3747                                 $fixed[$fixlinenr - 1] .= " $operator";
3748                                 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3749                         }
3750                 }
3751
3752 # check for && or || at the start of a line
3753                 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3754                         my $operator = $1;
3755                         if (CHK("LOGICAL_CONTINUATIONS",
3756                                 "Logical continuations should be on the previous line\n" . $hereprev) &&
3757                             $fix && $prevrawline =~ /^\+/) {
3758                                 # insert logical operator at last non-comment, non-whitepsace char on previous line
3759                                 $prevline =~ /[\s$;]*$/;
3760                                 my $line_end = substr($prevrawline, $-[0]);
3761                                 $fixed[$fixlinenr - 1] =~ s/\Q$line_end\E$/ $operator$line_end/;
3762                                 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3763                         }
3764                 }
3765
3766 # check indentation starts on a tab stop
3767                 if ($perl_version_ok &&
3768                     $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3769                         my $indent = length($1);
3770                         if ($indent % $tabsize) {
3771                                 if (WARN("TABSTOP",
3772                                          "Statements should start on a tabstop\n" . $herecurr) &&
3773                                     $fix) {
3774                                         $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/$tabsize)@e;
3775                                 }
3776                         }
3777                 }
3778
3779 # check multi-line statement indentation matches previous line
3780                 if ($perl_version_ok &&
3781                     $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3782                         $prevline =~ /^\+(\t*)(.*)$/;
3783                         my $oldindent = $1;
3784                         my $rest = $2;
3785
3786                         my $pos = pos_last_openparen($rest);
3787                         if ($pos >= 0) {
3788                                 $line =~ /^(\+| )([ \t]*)/;
3789                                 my $newindent = $2;
3790
3791                                 my $goodtabindent = $oldindent .
3792                                         "\t" x ($pos / $tabsize) .
3793                                         " "  x ($pos % $tabsize);
3794                                 my $goodspaceindent = $oldindent . " "  x $pos;
3795
3796                                 if ($newindent ne $goodtabindent &&
3797                                     $newindent ne $goodspaceindent) {
3798
3799                                         if (CHK("PARENTHESIS_ALIGNMENT",
3800                                                 "Alignment should match open parenthesis\n" . $hereprev) &&
3801                                             $fix && $line =~ /^\+/) {
3802                                                 $fixed[$fixlinenr] =~
3803                                                     s/^\+[ \t]*/\+$goodtabindent/;
3804                                         }
3805                                 }
3806                         }
3807                 }
3808
3809 # check for space after cast like "(int) foo" or "(struct foo) bar"
3810 # avoid checking a few false positives:
3811 #   "sizeof(<type>)" or "__alignof__(<type>)"
3812 #   function pointer declarations like "(*foo)(int) = bar;"
3813 #   structure definitions like "(struct foo) { 0 };"
3814 #   multiline macros that define functions
3815 #   known attributes or the __attribute__ keyword
3816                 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3817                     (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3818                         if (CHK("SPACING",
3819                                 "No space is necessary after a cast\n" . $herecurr) &&
3820                             $fix) {
3821                                 $fixed[$fixlinenr] =~
3822                                     s/(\(\s*$Type\s*\))[ \t]+/$1/;
3823                         }
3824                 }
3825
3826 # Block comment styles
3827 # Networking with an initial /*
3828                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3829                     $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3830                     $rawline =~ /^\+[ \t]*\*/ &&
3831                     $realline > 3) { # Do not warn about the initial copyright comment block after SPDX-License-Identifier
3832                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3833                              "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3834                 }
3835
3836 # Block comments use * on subsequent lines
3837                 if ($prevline =~ /$;[ \t]*$/ &&                 #ends in comment
3838                     $prevrawline =~ /^\+.*?\/\*/ &&             #starting /*
3839                     $prevrawline !~ /\*\/[ \t]*$/ &&            #no trailing */
3840                     $rawline =~ /^\+/ &&                        #line is new
3841                     $rawline !~ /^\+[ \t]*\*/) {                #no leading *
3842                         WARN("BLOCK_COMMENT_STYLE",
3843                              "Block comments use * on subsequent lines\n" . $hereprev);
3844                 }
3845
3846 # Block comments use */ on trailing lines
3847                 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&       #trailing */
3848                     $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&      #inline /*...*/
3849                     $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&       #trailing **/
3850                     $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {    #non blank */
3851                         WARN("BLOCK_COMMENT_STYLE",
3852                              "Block comments use a trailing */ on a separate line\n" . $herecurr);
3853                 }
3854
3855 # Block comment * alignment
3856                 if ($prevline =~ /$;[ \t]*$/ &&                 #ends in comment
3857                     $line =~ /^\+[ \t]*$;/ &&                   #leading comment
3858                     $rawline =~ /^\+[ \t]*\*/ &&                #leading *
3859                     (($prevrawline =~ /^\+.*?\/\*/ &&           #leading /*
3860                       $prevrawline !~ /\*\/[ \t]*$/) ||         #no trailing */
3861                      $prevrawline =~ /^\+[ \t]*\*/)) {          #leading *
3862                         my $oldindent;
3863                         $prevrawline =~ m@^\+([ \t]*/?)\*@;
3864                         if (defined($1)) {
3865                                 $oldindent = expand_tabs($1);
3866                         } else {
3867                                 $prevrawline =~ m@^\+(.*/?)\*@;
3868                                 $oldindent = expand_tabs($1);
3869                         }
3870                         $rawline =~ m@^\+([ \t]*)\*@;
3871                         my $newindent = $1;
3872                         $newindent = expand_tabs($newindent);
3873                         if (length($oldindent) ne length($newindent)) {
3874                                 WARN("BLOCK_COMMENT_STYLE",
3875                                      "Block comments should align the * on each line\n" . $hereprev);
3876                         }
3877                 }
3878
3879 # check for missing blank lines after struct/union declarations
3880 # with exceptions for various attributes and macros
3881                 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3882                     $line =~ /^\+/ &&
3883                     !($line =~ /^\+\s*$/ ||
3884                       $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3885                       $line =~ /^\+\s*MODULE_/i ||
3886                       $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3887                       $line =~ /^\+[a-z_]*init/ ||
3888                       $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3889                       $line =~ /^\+\s*DECLARE/ ||
3890                       $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3891                       $line =~ /^\+\s*__setup/)) {
3892                         if (CHK("LINE_SPACING",
3893                                 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3894                             $fix) {
3895                                 fix_insert_line($fixlinenr, "\+");
3896                         }
3897                 }
3898
3899 # check for multiple consecutive blank lines
3900                 if ($prevline =~ /^[\+ ]\s*$/ &&
3901                     $line =~ /^\+\s*$/ &&
3902                     $last_blank_line != ($linenr - 1)) {
3903                         if (CHK("LINE_SPACING",
3904                                 "Please don't use multiple blank lines\n" . $hereprev) &&
3905                             $fix) {
3906                                 fix_delete_line($fixlinenr, $rawline);
3907                         }
3908
3909                         $last_blank_line = $linenr;
3910                 }
3911
3912 # check for missing blank lines after declarations
3913 # (declarations must have the same indentation and not be at the start of line)
3914                 if (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/) {
3915                         # use temporaries
3916                         my $sl = $sline;
3917                         my $pl = $prevline;
3918                         # remove $Attribute/$Sparse uses to simplify comparisons
3919                         $sl =~ s/\b(?:$Attribute|$Sparse)\b//g;
3920                         $pl =~ s/\b(?:$Attribute|$Sparse)\b//g;
3921                         if (($pl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3922                         # function pointer declarations
3923                              $pl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3924                         # foo bar; where foo is some local typedef or #define
3925                              $pl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3926                         # known declaration macros
3927                              $pl =~ /^\+\s+$declaration_macros/) &&
3928                         # for "else if" which can look like "$Ident $Ident"
3929                             !($pl =~ /^\+\s+$c90_Keywords\b/ ||
3930                         # other possible extensions of declaration lines
3931                               $pl =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3932                         # not starting a section or a macro "\" extended line
3933                               $pl =~ /(?:\{\s*|\\)$/) &&
3934                         # looks like a declaration
3935                             !($sl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3936                         # function pointer declarations
3937                               $sl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3938                         # foo bar; where foo is some local typedef or #define
3939                               $sl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3940                         # known declaration macros
3941                               $sl =~ /^\+\s+$declaration_macros/ ||
3942                         # start of struct or union or enum
3943                               $sl =~ /^\+\s+(?:static\s+)?(?:const\s+)?(?:union|struct|enum|typedef)\b/ ||
3944                         # start or end of block or continuation of declaration
3945                               $sl =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3946                         # bitfield continuation
3947                               $sl =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3948                         # other possible extensions of declaration lines
3949                               $sl =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/)) {
3950                                 if (WARN("LINE_SPACING",
3951                                          "Missing a blank line after declarations\n" . $hereprev) &&
3952                                     $fix) {
3953                                         fix_insert_line($fixlinenr, "\+");
3954                                 }
3955                         }
3956                 }
3957
3958 # check for spaces at the beginning of a line.
3959 # Exceptions:
3960 #  1) within comments
3961 #  2) indented preprocessor commands
3962 #  3) hanging labels
3963                 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
3964                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3965                         if (WARN("LEADING_SPACE",
3966                                  "please, no spaces at the start of a line\n" . $herevet) &&
3967                             $fix) {
3968                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3969                         }
3970                 }
3971
3972 # check we are in a valid C source file if not then ignore this hunk
3973                 next if ($realfile !~ /\.(h|c)$/);
3974
3975 # check for unusual line ending [ or (
3976                 if ($line =~ /^\+.*([\[\(])\s*$/) {
3977                         CHK("OPEN_ENDED_LINE",
3978                             "Lines should not end with a '$1'\n" . $herecurr);
3979                 }
3980
3981 # check if this appears to be the start function declaration, save the name
3982                 if ($sline =~ /^\+\{\s*$/ &&
3983                     $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3984                         $context_function = $1;
3985                 }
3986
3987 # check if this appears to be the end of function declaration
3988                 if ($sline =~ /^\+\}\s*$/) {
3989                         undef $context_function;
3990                 }
3991
3992 # check indentation of any line with a bare else
3993 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3994 # if the previous line is a break or return and is indented 1 tab more...
3995                 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3996                         my $tabs = length($1) + 1;
3997                         if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3998                             ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3999                              defined $lines[$linenr] &&
4000                              $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
4001                                 WARN("UNNECESSARY_ELSE",
4002                                      "else is not generally useful after a break or return\n" . $hereprev);
4003                         }
4004                 }
4005
4006 # check indentation of a line with a break;
4007 # if the previous line is a goto, return or break
4008 # and is indented the same # of tabs
4009                 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
4010                         my $tabs = $1;
4011                         if ($prevline =~ /^\+$tabs(goto|return|break)\b/) {
4012                                 if (WARN("UNNECESSARY_BREAK",
4013                                          "break is not useful after a $1\n" . $hereprev) &&
4014                                     $fix) {
4015                                         fix_delete_line($fixlinenr, $rawline);
4016                                 }
4017                         }
4018                 }
4019
4020 # check for RCS/CVS revision markers
4021                 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
4022                         WARN("CVS_KEYWORD",
4023                              "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
4024                 }
4025
4026 # check for old HOTPLUG __dev<foo> section markings
4027                 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
4028                         WARN("HOTPLUG_SECTION",
4029                              "Using $1 is unnecessary\n" . $herecurr);
4030                 }
4031
4032 # Check for potential 'bare' types
4033                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
4034                     $realline_next);
4035 #print "LINE<$line>\n";
4036                 if ($linenr > $suppress_statement &&
4037                     $realcnt && $sline =~ /.\s*\S/) {
4038                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4039                                 ctx_statement_block($linenr, $realcnt, 0);
4040                         $stat =~ s/\n./\n /g;
4041                         $cond =~ s/\n./\n /g;
4042
4043 #print "linenr<$linenr> <$stat>\n";
4044                         # If this statement has no statement boundaries within
4045                         # it there is no point in retrying a statement scan
4046                         # until we hit end of it.
4047                         my $frag = $stat; $frag =~ s/;+\s*$//;
4048                         if ($frag !~ /(?:{|;)/) {
4049 #print "skip<$line_nr_next>\n";
4050                                 $suppress_statement = $line_nr_next;
4051                         }
4052
4053                         # Find the real next line.
4054                         $realline_next = $line_nr_next;
4055                         if (defined $realline_next &&
4056                             (!defined $lines[$realline_next - 1] ||
4057                              substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
4058                                 $realline_next++;
4059                         }
4060
4061                         my $s = $stat;
4062                         $s =~ s/{.*$//s;
4063
4064                         # Ignore goto labels.
4065                         if ($s =~ /$Ident:\*$/s) {
4066
4067                         # Ignore functions being called
4068                         } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
4069
4070                         } elsif ($s =~ /^.\s*else\b/s) {
4071
4072                         # declarations always start with types
4073                         } elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?((?:\s*$Ident)+?)\b(?:\s+$Sparse)?\s*\**\s*(?:$Ident|\(\*[^\)]*\))(?:\s*$Modifier)?\s*(?:;|=|,|\()/s) {
4074                                 my $type = $1;
4075                                 $type =~ s/\s+/ /g;
4076                                 possible($type, "A:" . $s);
4077
4078                         # definitions in global scope can only start with types
4079                         } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
4080                                 possible($1, "B:" . $s);
4081                         }
4082
4083                         # any (foo ... *) is a pointer cast, and foo is a type
4084                         while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
4085                                 possible($1, "C:" . $s);
4086                         }
4087
4088                         # Check for any sort of function declaration.
4089                         # int foo(something bar, other baz);
4090                         # void (*store_gdt)(x86_descr_ptr *);
4091                         if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
4092                                 my ($name_len) = length($1);
4093
4094                                 my $ctx = $s;
4095                                 substr($ctx, 0, $name_len + 1, '');
4096                                 $ctx =~ s/\)[^\)]*$//;
4097
4098                                 for my $arg (split(/\s*,\s*/, $ctx)) {
4099                                         if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
4100
4101                                                 possible($1, "D:" . $s);
4102                                         }
4103                                 }
4104                         }
4105
4106                 }
4107
4108 #
4109 # Checks which may be anchored in the context.
4110 #
4111
4112 # Check for switch () and associated case and default
4113 # statements should be at the same indent.
4114                 if ($line=~/\bswitch\s*\(.*\)/) {
4115                         my $err = '';
4116                         my $sep = '';
4117                         my @ctx = ctx_block_outer($linenr, $realcnt);
4118                         shift(@ctx);
4119                         for my $ctx (@ctx) {
4120                                 my ($clen, $cindent) = line_stats($ctx);
4121                                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
4122                                                         $indent != $cindent) {
4123                                         $err .= "$sep$ctx\n";
4124                                         $sep = '';
4125                                 } else {
4126                                         $sep = "[...]\n";
4127                                 }
4128                         }
4129                         if ($err ne '') {
4130                                 ERROR("SWITCH_CASE_INDENT_LEVEL",
4131                                       "switch and case should be at the same indent\n$hereline$err");
4132                         }
4133                 }
4134
4135 # if/while/etc brace do not go on next line, unless defining a do while loop,
4136 # or if that brace on the next line is for something else
4137                 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
4138                         my $pre_ctx = "$1$2";
4139
4140                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
4141
4142                         if ($line =~ /^\+\t{6,}/) {
4143                                 WARN("DEEP_INDENTATION",
4144                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
4145                         }
4146
4147                         my $ctx_cnt = $realcnt - $#ctx - 1;
4148                         my $ctx = join("\n", @ctx);
4149
4150                         my $ctx_ln = $linenr;
4151                         my $ctx_skip = $realcnt;
4152
4153                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
4154                                         defined $lines[$ctx_ln - 1] &&
4155                                         $lines[$ctx_ln - 1] =~ /^-/)) {
4156                                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
4157                                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
4158                                 $ctx_ln++;
4159                         }
4160
4161                         #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
4162                         #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
4163
4164                         if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
4165                                 ERROR("OPEN_BRACE",
4166                                       "that open brace { should be on the previous line\n" .
4167                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4168                         }
4169                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
4170                             $ctx =~ /\)\s*\;\s*$/ &&
4171                             defined $lines[$ctx_ln - 1])
4172                         {
4173                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
4174                                 if ($nindent > $indent) {
4175                                         WARN("TRAILING_SEMICOLON",
4176                                              "trailing semicolon indicates no statements, indent implies otherwise\n" .
4177                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4178                                 }
4179                         }
4180                 }
4181
4182 # Check relative indent for conditionals and blocks.
4183                 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
4184                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4185                                 ctx_statement_block($linenr, $realcnt, 0)
4186                                         if (!defined $stat);
4187                         my ($s, $c) = ($stat, $cond);
4188
4189                         substr($s, 0, length($c), '');
4190
4191                         # remove inline comments
4192                         $s =~ s/$;/ /g;
4193                         $c =~ s/$;/ /g;
4194
4195                         # Find out how long the conditional actually is.
4196                         my @newlines = ($c =~ /\n/gs);
4197                         my $cond_lines = 1 + $#newlines;
4198
4199                         # Make sure we remove the line prefixes as we have
4200                         # none on the first line, and are going to readd them
4201                         # where necessary.
4202                         $s =~ s/\n./\n/gs;
4203                         while ($s =~ /\n\s+\\\n/) {
4204                                 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
4205                         }
4206
4207                         # We want to check the first line inside the block
4208                         # starting at the end of the conditional, so remove:
4209                         #  1) any blank line termination
4210                         #  2) any opening brace { on end of the line
4211                         #  3) any do (...) {
4212                         my $continuation = 0;
4213                         my $check = 0;
4214                         $s =~ s/^.*\bdo\b//;
4215                         $s =~ s/^\s*{//;
4216                         if ($s =~ s/^\s*\\//) {
4217                                 $continuation = 1;
4218                         }
4219                         if ($s =~ s/^\s*?\n//) {
4220                                 $check = 1;
4221                                 $cond_lines++;
4222                         }
4223
4224                         # Also ignore a loop construct at the end of a
4225                         # preprocessor statement.
4226                         if (($prevline =~ /^.\s*#\s*define\s/ ||
4227                             $prevline =~ /\\\s*$/) && $continuation == 0) {
4228                                 $check = 0;
4229                         }
4230
4231                         my $cond_ptr = -1;
4232                         $continuation = 0;
4233                         while ($cond_ptr != $cond_lines) {
4234                                 $cond_ptr = $cond_lines;
4235
4236                                 # If we see an #else/#elif then the code
4237                                 # is not linear.
4238                                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
4239                                         $check = 0;
4240                                 }
4241
4242                                 # Ignore:
4243                                 #  1) blank lines, they should be at 0,
4244                                 #  2) preprocessor lines, and
4245                                 #  3) labels.
4246                                 if ($continuation ||
4247                                     $s =~ /^\s*?\n/ ||
4248                                     $s =~ /^\s*#\s*?/ ||
4249                                     $s =~ /^\s*$Ident\s*:/) {
4250                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
4251                                         if ($s =~ s/^.*?\n//) {
4252                                                 $cond_lines++;
4253                                         }
4254                                 }
4255                         }
4256
4257                         my (undef, $sindent) = line_stats("+" . $s);
4258                         my $stat_real = raw_line($linenr, $cond_lines);
4259
4260                         # Check if either of these lines are modified, else
4261                         # this is not this patch's fault.
4262                         if (!defined($stat_real) ||
4263                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {
4264                                 $check = 0;
4265                         }
4266                         if (defined($stat_real) && $cond_lines > 1) {
4267                                 $stat_real = "[...]\n$stat_real";
4268                         }
4269
4270                         #print "line<$line> prevline<$prevline> indent<$indent> sindent<$sindent> check<$check> continuation<$continuation> s<$s> cond_lines<$cond_lines> stat_real<$stat_real> stat<$stat>\n";
4271
4272                         if ($check && $s ne '' &&
4273                             (($sindent % $tabsize) != 0 ||
4274                              ($sindent < $indent) ||
4275                              ($sindent == $indent &&
4276                               ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
4277                              ($sindent > $indent + $tabsize))) {
4278                                 WARN("SUSPECT_CODE_INDENT",
4279                                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
4280                         }
4281                 }
4282
4283                 # Track the 'values' across context and added lines.
4284                 my $opline = $line; $opline =~ s/^./ /;
4285                 my ($curr_values, $curr_vars) =
4286                                 annotate_values($opline . "\n", $prev_values);
4287                 $curr_values = $prev_values . $curr_values;
4288                 if ($dbg_values) {
4289                         my $outline = $opline; $outline =~ s/\t/ /g;
4290                         print "$linenr > .$outline\n";
4291                         print "$linenr > $curr_values\n";
4292                         print "$linenr >  $curr_vars\n";
4293                 }
4294                 $prev_values = substr($curr_values, -1);
4295
4296 #ignore lines not being added
4297                 next if ($line =~ /^[^\+]/);
4298
4299 # check for self assignments used to avoid compiler warnings
4300 # e.g.: int foo = foo, *bar = NULL;
4301 #       struct foo bar = *(&(bar));
4302                 if ($line =~ /^\+\s*(?:$Declare)?([A-Za-z_][A-Za-z\d_]*)\s*=/) {
4303                         my $var = $1;
4304                         if ($line =~ /^\+\s*(?:$Declare)?$var\s*=\s*(?:$var|\*\s*\(?\s*&\s*\(?\s*$var\s*\)?\s*\)?)\s*[;,]/) {
4305                                 WARN("SELF_ASSIGNMENT",
4306                                      "Do not use self-assignments to avoid compiler warnings\n" . $herecurr);
4307                         }
4308                 }
4309
4310 # check for dereferences that span multiple lines
4311                 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
4312                     $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
4313                         $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
4314                         my $ref = $1;
4315                         $line =~ /^.\s*($Lval)/;
4316                         $ref .= $1;
4317                         $ref =~ s/\s//g;
4318                         WARN("MULTILINE_DEREFERENCE",
4319                              "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
4320                 }
4321
4322 # check for declarations of signed or unsigned without int
4323                 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
4324                         my $type = $1;
4325                         my $var = $2;
4326                         $var = "" if (!defined $var);
4327                         if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
4328                                 my $sign = $1;
4329                                 my $pointer = $2;
4330
4331                                 $pointer = "" if (!defined $pointer);
4332
4333                                 if (WARN("UNSPECIFIED_INT",
4334                                          "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
4335                                     $fix) {
4336                                         my $decl = trim($sign) . " int ";
4337                                         my $comp_pointer = $pointer;
4338                                         $comp_pointer =~ s/\s//g;
4339                                         $decl .= $comp_pointer;
4340                                         $decl = rtrim($decl) if ($var eq "");
4341                                         $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
4342                                 }
4343                         }
4344                 }
4345
4346 # TEST: allow direct testing of the type matcher.
4347                 if ($dbg_type) {
4348                         if ($line =~ /^.\s*$Declare\s*$/) {
4349                                 ERROR("TEST_TYPE",
4350                                       "TEST: is type\n" . $herecurr);
4351                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
4352                                 ERROR("TEST_NOT_TYPE",
4353                                       "TEST: is not type ($1 is)\n". $herecurr);
4354                         }
4355                         next;
4356                 }
4357 # TEST: allow direct testing of the attribute matcher.
4358                 if ($dbg_attr) {
4359                         if ($line =~ /^.\s*$Modifier\s*$/) {
4360                                 ERROR("TEST_ATTR",
4361                                       "TEST: is attr\n" . $herecurr);
4362                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
4363                                 ERROR("TEST_NOT_ATTR",
4364                                       "TEST: is not attr ($1 is)\n". $herecurr);
4365                         }
4366                         next;
4367                 }
4368
4369 # check for initialisation to aggregates open brace on the next line
4370                 if ($line =~ /^.\s*{/ &&
4371                     $prevline =~ /(?:^|[^=])=\s*$/) {
4372                         if (ERROR("OPEN_BRACE",
4373                                   "that open brace { should be on the previous line\n" . $hereprev) &&
4374                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4375                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4376                                 fix_delete_line($fixlinenr, $rawline);
4377                                 my $fixedline = $prevrawline;
4378                                 $fixedline =~ s/\s*=\s*$/ = {/;
4379                                 fix_insert_line($fixlinenr, $fixedline);
4380                                 $fixedline = $line;
4381                                 $fixedline =~ s/^(.\s*)\{\s*/$1/;
4382                                 fix_insert_line($fixlinenr, $fixedline);
4383                         }
4384                 }
4385
4386 #
4387 # Checks which are anchored on the added line.
4388 #
4389
4390 # check for malformed paths in #include statements (uses RAW line)
4391                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
4392                         my $path = $1;
4393                         if ($path =~ m{//}) {
4394                                 ERROR("MALFORMED_INCLUDE",
4395                                       "malformed #include filename\n" . $herecurr);
4396                         }
4397                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
4398                                 ERROR("UAPI_INCLUDE",
4399                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
4400                         }
4401                 }
4402
4403 # no C99 // comments
4404                 if ($line =~ m{//}) {
4405                         if (ERROR("C99_COMMENTS",
4406                                   "do not use C99 // comments\n" . $herecurr) &&
4407                             $fix) {
4408                                 my $line = $fixed[$fixlinenr];
4409                                 if ($line =~ /\/\/(.*)$/) {
4410                                         my $comment = trim($1);
4411                                         $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
4412                                 }
4413                         }
4414                 }
4415                 # Remove C99 comments.
4416                 $line =~ s@//.*@@;
4417                 $opline =~ s@//.*@@;
4418
4419 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
4420 # the whole statement.
4421 #print "APW <$lines[$realline_next - 1]>\n";
4422                 if (defined $realline_next &&
4423                     exists $lines[$realline_next - 1] &&
4424                     !defined $suppress_export{$realline_next} &&
4425                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4426                         # Handle definitions which produce identifiers with
4427                         # a prefix:
4428                         #   XXX(foo);
4429                         #   EXPORT_SYMBOL(something_foo);
4430                         my $name = $1;
4431                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
4432                             $name =~ /^${Ident}_$2/) {
4433 #print "FOO C name<$name>\n";
4434                                 $suppress_export{$realline_next} = 1;
4435
4436                         } elsif ($stat !~ /(?:
4437                                 \n.}\s*$|
4438                                 ^.DEFINE_$Ident\(\Q$name\E\)|
4439                                 ^.DECLARE_$Ident\(\Q$name\E\)|
4440                                 ^.LIST_HEAD\(\Q$name\E\)|
4441                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
4442                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
4443                             )/x) {
4444 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
4445                                 $suppress_export{$realline_next} = 2;
4446                         } else {
4447                                 $suppress_export{$realline_next} = 1;
4448                         }
4449                 }
4450                 if (!defined $suppress_export{$linenr} &&
4451                     $prevline =~ /^.\s*$/ &&
4452                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4453 #print "FOO B <$lines[$linenr - 1]>\n";
4454                         $suppress_export{$linenr} = 2;
4455                 }
4456                 if (defined $suppress_export{$linenr} &&
4457                     $suppress_export{$linenr} == 2) {
4458                         WARN("EXPORT_SYMBOL",
4459                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
4460                 }
4461
4462 # check for global initialisers.
4463                 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/ &&
4464                     !exclude_global_initialisers($realfile)) {
4465                         if (ERROR("GLOBAL_INITIALISERS",
4466                                   "do not initialise globals to $1\n" . $herecurr) &&
4467                             $fix) {
4468                                 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
4469                         }
4470                 }
4471 # check for static initialisers.
4472                 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
4473                         if (ERROR("INITIALISED_STATIC",
4474                                   "do not initialise statics to $1\n" .
4475                                       $herecurr) &&
4476                             $fix) {
4477                                 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
4478                         }
4479                 }
4480
4481 # check for misordered declarations of char/short/int/long with signed/unsigned
4482                 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
4483                         my $tmp = trim($1);
4484                         WARN("MISORDERED_TYPE",
4485                              "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
4486                 }
4487
4488 # check for unnecessary <signed> int declarations of short/long/long long
4489                 while ($sline =~ m{\b($TypeMisordered(\s*\*)*|$C90_int_types)\b}g) {
4490                         my $type = trim($1);
4491                         next if ($type !~ /\bint\b/);
4492                         next if ($type !~ /\b(?:short|long\s+long|long)\b/);
4493                         my $new_type = $type;
4494                         $new_type =~ s/\b\s*int\s*\b/ /;
4495                         $new_type =~ s/\b\s*(?:un)?signed\b\s*/ /;
4496                         $new_type =~ s/^const\s+//;
4497                         $new_type = "unsigned $new_type" if ($type =~ /\bunsigned\b/);
4498                         $new_type = "const $new_type" if ($type =~ /^const\b/);
4499                         $new_type =~ s/\s+/ /g;
4500                         $new_type = trim($new_type);
4501                         if (WARN("UNNECESSARY_INT",
4502                                  "Prefer '$new_type' over '$type' as the int is unnecessary\n" . $herecurr) &&
4503                             $fix) {
4504                                 $fixed[$fixlinenr] =~ s/\b\Q$type\E\b/$new_type/;
4505                         }
4506                 }
4507
4508 # check for static const char * arrays.
4509                 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
4510                         WARN("STATIC_CONST_CHAR_ARRAY",
4511                              "static const char * array should probably be static const char * const\n" .
4512                                 $herecurr);
4513                 }
4514
4515 # check for initialized const char arrays that should be static const
4516                 if ($line =~ /^\+\s*const\s+(char|unsigned\s+char|_*u8|(?:[us]_)?int8_t)\s+\w+\s*\[\s*(?:\w+\s*)?\]\s*=\s*"/) {
4517                         if (WARN("STATIC_CONST_CHAR_ARRAY",
4518                                  "const array should probably be static const\n" . $herecurr) &&
4519                             $fix) {
4520                                 $fixed[$fixlinenr] =~ s/(^.\s*)const\b/${1}static const/;
4521                         }
4522                 }
4523
4524 # check for static char foo[] = "bar" declarations.
4525                 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
4526                         WARN("STATIC_CONST_CHAR_ARRAY",
4527                              "static char array declaration should probably be static const char\n" .
4528                                 $herecurr);
4529                 }
4530
4531 # check for const <foo> const where <foo> is not a pointer or array type
4532                 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
4533                         my $found = $1;
4534                         if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
4535                                 WARN("CONST_CONST",
4536                                      "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
4537                         } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
4538                                 WARN("CONST_CONST",
4539                                      "'const $found const' should probably be 'const $found'\n" . $herecurr);
4540                         }
4541                 }
4542
4543 # check for const static or static <non ptr type> const declarations
4544 # prefer 'static const <foo>' over 'const static <foo>' and 'static <foo> const'
4545                 if ($sline =~ /^\+\s*const\s+static\s+($Type)\b/ ||
4546                     $sline =~ /^\+\s*static\s+($BasicType)\s+const\b/) {
4547                         if (WARN("STATIC_CONST",
4548                                  "Move const after static - use 'static const $1'\n" . $herecurr) &&
4549                             $fix) {
4550                                 $fixed[$fixlinenr] =~ s/\bconst\s+static\b/static const/;
4551                                 $fixed[$fixlinenr] =~ s/\bstatic\s+($BasicType)\s+const\b/static const $1/;
4552                         }
4553                 }
4554
4555 # check for non-global char *foo[] = {"bar", ...} declarations.
4556                 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
4557                         WARN("STATIC_CONST_CHAR_ARRAY",
4558                              "char * array declaration might be better as static const\n" .
4559                                 $herecurr);
4560                 }
4561
4562 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
4563                 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
4564                         my $array = $1;
4565                         if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
4566                                 my $array_div = $1;
4567                                 if (WARN("ARRAY_SIZE",
4568                                          "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
4569                                     $fix) {
4570                                         $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
4571                                 }
4572                         }
4573                 }
4574
4575 # check for function declarations without arguments like "int foo()"
4576                 if ($line =~ /(\b$Type\s*$Ident)\s*\(\s*\)/) {
4577                         if (ERROR("FUNCTION_WITHOUT_ARGS",
4578                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
4579                             $fix) {
4580                                 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
4581                         }
4582                 }
4583
4584 # check for new typedefs, only function parameters and sparse annotations
4585 # make sense.
4586                 if ($line =~ /\btypedef\s/ &&
4587                     $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
4588                     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
4589                     $line !~ /\b$typeTypedefs\b/ &&
4590                     $line !~ /\b__bitwise\b/) {
4591                         WARN("NEW_TYPEDEFS",
4592                              "do not add new typedefs\n" . $herecurr);
4593                 }
4594
4595 # * goes on variable not on type
4596                 # (char*[ const])
4597                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
4598                         #print "AA<$1>\n";
4599                         my ($ident, $from, $to) = ($1, $2, $2);
4600
4601                         # Should start with a space.
4602                         $to =~ s/^(\S)/ $1/;
4603                         # Should not end with a space.
4604                         $to =~ s/\s+$//;
4605                         # '*'s should not have spaces between.
4606                         while ($to =~ s/\*\s+\*/\*\*/) {
4607                         }
4608
4609 ##                      print "1: from<$from> to<$to> ident<$ident>\n";
4610                         if ($from ne $to) {
4611                                 if (ERROR("POINTER_LOCATION",
4612                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
4613                                     $fix) {
4614                                         my $sub_from = $ident;
4615                                         my $sub_to = $ident;
4616                                         $sub_to =~ s/\Q$from\E/$to/;
4617                                         $fixed[$fixlinenr] =~
4618                                             s@\Q$sub_from\E@$sub_to@;
4619                                 }
4620                         }
4621                 }
4622                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
4623                         #print "BB<$1>\n";
4624                         my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
4625
4626                         # Should start with a space.
4627                         $to =~ s/^(\S)/ $1/;
4628                         # Should not end with a space.
4629                         $to =~ s/\s+$//;
4630                         # '*'s should not have spaces between.
4631                         while ($to =~ s/\*\s+\*/\*\*/) {
4632                         }
4633                         # Modifiers should have spaces.
4634                         $to =~ s/(\b$Modifier$)/$1 /;
4635
4636 ##                      print "2: from<$from> to<$to> ident<$ident>\n";
4637                         if ($from ne $to && $ident !~ /^$Modifier$/) {
4638                                 if (ERROR("POINTER_LOCATION",
4639                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
4640                                     $fix) {
4641
4642                                         my $sub_from = $match;
4643                                         my $sub_to = $match;
4644                                         $sub_to =~ s/\Q$from\E/$to/;
4645                                         $fixed[$fixlinenr] =~
4646                                             s@\Q$sub_from\E@$sub_to@;
4647                                 }
4648                         }
4649                 }
4650
4651 # avoid BUG() or BUG_ON()
4652                 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
4653                         my $msg_level = \&WARN;
4654                         $msg_level = \&CHK if ($file);
4655                         &{$msg_level}("AVOID_BUG",
4656                                       "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
4657                 }
4658
4659 # avoid LINUX_VERSION_CODE
4660                 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
4661                         WARN("LINUX_VERSION_CODE",
4662                              "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
4663                 }
4664
4665 # check for uses of printk_ratelimit
4666                 if ($line =~ /\bprintk_ratelimit\s*\(/) {
4667                         WARN("PRINTK_RATELIMITED",
4668                              "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
4669                 }
4670
4671 # printk should use KERN_* levels
4672                 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
4673                         WARN("PRINTK_WITHOUT_KERN_LEVEL",
4674                              "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
4675                 }
4676
4677 # prefer variants of (subsystem|netdev|dev|pr)_<level> to printk(KERN_<LEVEL>
4678                 if ($line =~ /\b(printk(_once|_ratelimited)?)\s*\(\s*KERN_([A-Z]+)/) {
4679                         my $printk = $1;
4680                         my $modifier = $2;
4681                         my $orig = $3;
4682                         $modifier = "" if (!defined($modifier));
4683                         my $level = lc($orig);
4684                         $level = "warn" if ($level eq "warning");
4685                         my $level2 = $level;
4686                         $level2 = "dbg" if ($level eq "debug");
4687                         $level .= $modifier;
4688                         $level2 .= $modifier;
4689                         WARN("PREFER_PR_LEVEL",
4690                              "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to $printk(KERN_$orig ...\n" . $herecurr);
4691                 }
4692
4693 # prefer dev_<level> to dev_printk(KERN_<LEVEL>
4694                 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
4695                         my $orig = $1;
4696                         my $level = lc($orig);
4697                         $level = "warn" if ($level eq "warning");
4698                         $level = "dbg" if ($level eq "debug");
4699                         WARN("PREFER_DEV_LEVEL",
4700                              "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
4701                 }
4702
4703 # trace_printk should not be used in production code.
4704                 if ($line =~ /\b(trace_printk|trace_puts|ftrace_vprintk)\s*\(/) {
4705                         WARN("TRACE_PRINTK",
4706                              "Do not use $1() in production code (this can be ignored if built only with a debug config option)\n" . $herecurr);
4707                 }
4708
4709 # ENOSYS means "bad syscall nr" and nothing else.  This will have a small
4710 # number of false positives, but assembly files are not checked, so at
4711 # least the arch entry code will not trigger this warning.
4712                 if ($line =~ /\bENOSYS\b/) {
4713                         WARN("ENOSYS",
4714                              "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
4715                 }
4716
4717 # ENOTSUPP is not a standard error code and should be avoided in new patches.
4718 # Folks usually mean EOPNOTSUPP (also called ENOTSUP), when they type ENOTSUPP.
4719 # Similarly to ENOSYS warning a small number of false positives is expected.
4720                 if (!$file && $line =~ /\bENOTSUPP\b/) {
4721                         if (WARN("ENOTSUPP",
4722                                  "ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP\n" . $herecurr) &&
4723                             $fix) {
4724                                 $fixed[$fixlinenr] =~ s/\bENOTSUPP\b/EOPNOTSUPP/;
4725                         }
4726                 }
4727
4728 # function brace can't be on same line, except for #defines of do while,
4729 # or if closed on same line
4730                 if ($perl_version_ok &&
4731                     $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
4732                     $sline !~ /\#\s*define\b.*do\s*\{/ &&
4733                     $sline !~ /}/) {
4734                         if (ERROR("OPEN_BRACE",
4735                                   "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
4736                             $fix) {
4737                                 fix_delete_line($fixlinenr, $rawline);
4738                                 my $fixed_line = $rawline;
4739                                 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*)\{(.*)$/;
4740                                 my $line1 = $1;
4741                                 my $line2 = $2;
4742                                 fix_insert_line($fixlinenr, ltrim($line1));
4743                                 fix_insert_line($fixlinenr, "\+{");
4744                                 if ($line2 !~ /^\s*$/) {
4745                                         fix_insert_line($fixlinenr, "\+\t" . trim($line2));
4746                                 }
4747                         }
4748                 }
4749
4750 # open braces for enum, union and struct go on the same line.
4751                 if ($line =~ /^.\s*{/ &&
4752                     $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
4753                         if (ERROR("OPEN_BRACE",
4754                                   "open brace '{' following $1 go on the same line\n" . $hereprev) &&
4755                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4756                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4757                                 fix_delete_line($fixlinenr, $rawline);
4758                                 my $fixedline = rtrim($prevrawline) . " {";
4759                                 fix_insert_line($fixlinenr, $fixedline);
4760                                 $fixedline = $rawline;
4761                                 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
4762                                 if ($fixedline !~ /^\+\s*$/) {
4763                                         fix_insert_line($fixlinenr, $fixedline);
4764                                 }
4765                         }
4766                 }
4767
4768 # missing space after union, struct or enum definition
4769                 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4770                         if (WARN("SPACING",
4771                                  "missing space after $1 definition\n" . $herecurr) &&
4772                             $fix) {
4773                                 $fixed[$fixlinenr] =~
4774                                     s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4775                         }
4776                 }
4777
4778 # Function pointer declarations
4779 # check spacing between type, funcptr, and args
4780 # canonical declaration is "type (*funcptr)(args...)"
4781                 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4782                         my $declare = $1;
4783                         my $pre_pointer_space = $2;
4784                         my $post_pointer_space = $3;
4785                         my $funcname = $4;
4786                         my $post_funcname_space = $5;
4787                         my $pre_args_space = $6;
4788
4789 # the $Declare variable will capture all spaces after the type
4790 # so check it for a missing trailing missing space but pointer return types
4791 # don't need a space so don't warn for those.
4792                         my $post_declare_space = "";
4793                         if ($declare =~ /(\s+)$/) {
4794                                 $post_declare_space = $1;
4795                                 $declare = rtrim($declare);
4796                         }
4797                         if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4798                                 WARN("SPACING",
4799                                      "missing space after return type\n" . $herecurr);
4800                                 $post_declare_space = " ";
4801                         }
4802
4803 # unnecessary space "type  (*funcptr)(args...)"
4804 # This test is not currently implemented because these declarations are
4805 # equivalent to
4806 #       int  foo(int bar, ...)
4807 # and this is form shouldn't/doesn't generate a checkpatch warning.
4808 #
4809 #                       elsif ($declare =~ /\s{2,}$/) {
4810 #                               WARN("SPACING",
4811 #                                    "Multiple spaces after return type\n" . $herecurr);
4812 #                       }
4813
4814 # unnecessary space "type ( *funcptr)(args...)"
4815                         if (defined $pre_pointer_space &&
4816                             $pre_pointer_space =~ /^\s/) {
4817                                 WARN("SPACING",
4818                                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4819                         }
4820
4821 # unnecessary space "type (* funcptr)(args...)"
4822                         if (defined $post_pointer_space &&
4823                             $post_pointer_space =~ /^\s/) {
4824                                 WARN("SPACING",
4825                                      "Unnecessary space before function pointer name\n" . $herecurr);
4826                         }
4827
4828 # unnecessary space "type (*funcptr )(args...)"
4829                         if (defined $post_funcname_space &&
4830                             $post_funcname_space =~ /^\s/) {
4831                                 WARN("SPACING",
4832                                      "Unnecessary space after function pointer name\n" . $herecurr);
4833                         }
4834
4835 # unnecessary space "type (*funcptr) (args...)"
4836                         if (defined $pre_args_space &&
4837                             $pre_args_space =~ /^\s/) {
4838                                 WARN("SPACING",
4839                                      "Unnecessary space before function pointer arguments\n" . $herecurr);
4840                         }
4841
4842                         if (show_type("SPACING") && $fix) {
4843                                 $fixed[$fixlinenr] =~
4844                                     s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4845                         }
4846                 }
4847
4848 # check for spacing round square brackets; allowed:
4849 #  1. with a type on the left -- int [] a;
4850 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4851 #  3. inside a curly brace -- = { [0...10] = 5 }
4852                 while ($line =~ /(.*?\s)\[/g) {
4853                         my ($where, $prefix) = ($-[1], $1);
4854                         if ($prefix !~ /$Type\s+$/ &&
4855                             ($where != 0 || $prefix !~ /^.\s+$/) &&
4856                             $prefix !~ /[{,:]\s+$/) {
4857                                 if (ERROR("BRACKET_SPACE",
4858                                           "space prohibited before open square bracket '['\n" . $herecurr) &&
4859                                     $fix) {
4860                                     $fixed[$fixlinenr] =~
4861                                         s/^(\+.*?)\s+\[/$1\[/;
4862                                 }
4863                         }
4864                 }
4865
4866 # check for spaces between functions and their parentheses.
4867                 while ($line =~ /($Ident)\s+\(/g) {
4868                         my $name = $1;
4869                         my $ctx_before = substr($line, 0, $-[1]);
4870                         my $ctx = "$ctx_before$name";
4871
4872                         # Ignore those directives where spaces _are_ permitted.
4873                         if ($name =~ /^(?:
4874                                 if|for|while|switch|return|case|
4875                                 volatile|__volatile__|
4876                                 __attribute__|format|__extension__|
4877                                 asm|__asm__)$/x)
4878                         {
4879                         # cpp #define statements have non-optional spaces, ie
4880                         # if there is a space between the name and the open
4881                         # parenthesis it is simply not a parameter group.
4882                         } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4883
4884                         # cpp #elif statement condition may start with a (
4885                         } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4886
4887                         # If this whole things ends with a type its most
4888                         # likely a typedef for a function.
4889                         } elsif ($ctx =~ /$Type$/) {
4890
4891                         } else {
4892                                 if (WARN("SPACING",
4893                                          "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4894                                              $fix) {
4895                                         $fixed[$fixlinenr] =~
4896                                             s/\b$name\s+\(/$name\(/;
4897                                 }
4898                         }
4899                 }
4900
4901 # Check operator spacing.
4902                 if (!($line=~/\#\s*include/)) {
4903                         my $fixed_line = "";
4904                         my $line_fixed = 0;
4905
4906                         my $ops = qr{
4907                                 <<=|>>=|<=|>=|==|!=|
4908                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4909                                 =>|->|<<|>>|<|>|=|!|~|
4910                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4911                                 \?:|\?|:
4912                         }x;
4913                         my @elements = split(/($ops|;)/, $opline);
4914
4915 ##                      print("element count: <" . $#elements . ">\n");
4916 ##                      foreach my $el (@elements) {
4917 ##                              print("el: <$el>\n");
4918 ##                      }
4919
4920                         my @fix_elements = ();
4921                         my $off = 0;
4922
4923                         foreach my $el (@elements) {
4924                                 push(@fix_elements, substr($rawline, $off, length($el)));
4925                                 $off += length($el);
4926                         }
4927
4928                         $off = 0;
4929
4930                         my $blank = copy_spacing($opline);
4931                         my $last_after = -1;
4932
4933                         for (my $n = 0; $n < $#elements; $n += 2) {
4934
4935                                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4936
4937 ##                              print("n: <$n> good: <$good>\n");
4938
4939                                 $off += length($elements[$n]);
4940
4941                                 # Pick up the preceding and succeeding characters.
4942                                 my $ca = substr($opline, 0, $off);
4943                                 my $cc = '';
4944                                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4945                                         $cc = substr($opline, $off + length($elements[$n + 1]));
4946                                 }
4947                                 my $cb = "$ca$;$cc";
4948
4949                                 my $a = '';
4950                                 $a = 'V' if ($elements[$n] ne '');
4951                                 $a = 'W' if ($elements[$n] =~ /\s$/);
4952                                 $a = 'C' if ($elements[$n] =~ /$;$/);
4953                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4954                                 $a = 'O' if ($elements[$n] eq '');
4955                                 $a = 'E' if ($ca =~ /^\s*$/);
4956
4957                                 my $op = $elements[$n + 1];
4958
4959                                 my $c = '';
4960                                 if (defined $elements[$n + 2]) {
4961                                         $c = 'V' if ($elements[$n + 2] ne '');
4962                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4963                                         $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4964                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4965                                         $c = 'O' if ($elements[$n + 2] eq '');
4966                                         $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4967                                 } else {
4968                                         $c = 'E';
4969                                 }
4970
4971                                 my $ctx = "${a}x${c}";
4972
4973                                 my $at = "(ctx:$ctx)";
4974
4975                                 my $ptr = substr($blank, 0, $off) . "^";
4976                                 my $hereptr = "$hereline$ptr\n";
4977
4978                                 # Pull out the value of this operator.
4979                                 my $op_type = substr($curr_values, $off + 1, 1);
4980
4981                                 # Get the full operator variant.
4982                                 my $opv = $op . substr($curr_vars, $off, 1);
4983
4984                                 # Ignore operators passed as parameters.
4985                                 if ($op_type ne 'V' &&
4986                                     $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4987
4988 #                               # Ignore comments
4989 #                               } elsif ($op =~ /^$;+$/) {
4990
4991                                 # ; should have either the end of line or a space or \ after it
4992                                 } elsif ($op eq ';') {
4993                                         if ($ctx !~ /.x[WEBC]/ &&
4994                                             $cc !~ /^\\/ && $cc !~ /^;/) {
4995                                                 if (ERROR("SPACING",
4996                                                           "space required after that '$op' $at\n" . $hereptr)) {
4997                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4998                                                         $line_fixed = 1;
4999                                                 }
5000                                         }
5001
5002                                 # // is a comment
5003                                 } elsif ($op eq '//') {
5004
5005                                 #   :   when part of a bitfield
5006                                 } elsif ($opv eq ':B') {
5007                                         # skip the bitfield test for now
5008
5009                                 # No spaces for:
5010                                 #   ->
5011                                 } elsif ($op eq '->') {
5012                                         if ($ctx =~ /Wx.|.xW/) {
5013                                                 if (ERROR("SPACING",
5014                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {
5015                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5016                                                         if (defined $fix_elements[$n + 2]) {
5017                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
5018                                                         }
5019                                                         $line_fixed = 1;
5020                                                 }
5021                                         }
5022
5023                                 # , must not have a space before and must have a space on the right.
5024                                 } elsif ($op eq ',') {
5025                                         my $rtrim_before = 0;
5026                                         my $space_after = 0;
5027                                         if ($ctx =~ /Wx./) {
5028                                                 if (ERROR("SPACING",
5029                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
5030                                                         $line_fixed = 1;
5031                                                         $rtrim_before = 1;
5032                                                 }
5033                                         }
5034                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
5035                                                 if (ERROR("SPACING",
5036                                                           "space required after that '$op' $at\n" . $hereptr)) {
5037                                                         $line_fixed = 1;
5038                                                         $last_after = $n;
5039                                                         $space_after = 1;
5040                                                 }
5041                                         }
5042                                         if ($rtrim_before || $space_after) {
5043                                                 if ($rtrim_before) {
5044                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5045                                                 } else {
5046                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5047                                                 }
5048                                                 if ($space_after) {
5049                                                         $good .= " ";
5050                                                 }
5051                                         }
5052
5053                                 # '*' as part of a type definition -- reported already.
5054                                 } elsif ($opv eq '*_') {
5055                                         #warn "'*' is part of type\n";
5056
5057                                 # unary operators should have a space before and
5058                                 # none after.  May be left adjacent to another
5059                                 # unary operator, or a cast
5060                                 } elsif ($op eq '!' || $op eq '~' ||
5061                                          $opv eq '*U' || $opv eq '-U' ||
5062                                          $opv eq '&U' || $opv eq '&&U') {
5063                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
5064                                                 if (ERROR("SPACING",
5065                                                           "space required before that '$op' $at\n" . $hereptr)) {
5066                                                         if ($n != $last_after + 2) {
5067                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
5068                                                                 $line_fixed = 1;
5069                                                         }
5070                                                 }
5071                                         }
5072                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
5073                                                 # A unary '*' may be const
5074
5075                                         } elsif ($ctx =~ /.xW/) {
5076                                                 if (ERROR("SPACING",
5077                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
5078                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
5079                                                         if (defined $fix_elements[$n + 2]) {
5080                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
5081                                                         }
5082                                                         $line_fixed = 1;
5083                                                 }
5084                                         }
5085
5086                                 # unary ++ and unary -- are allowed no space on one side.
5087                                 } elsif ($op eq '++' or $op eq '--') {
5088                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
5089                                                 if (ERROR("SPACING",
5090                                                           "space required one side of that '$op' $at\n" . $hereptr)) {
5091                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5092                                                         $line_fixed = 1;
5093                                                 }
5094                                         }
5095                                         if ($ctx =~ /Wx[BE]/ ||
5096                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {
5097                                                 if (ERROR("SPACING",
5098                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
5099                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5100                                                         $line_fixed = 1;
5101                                                 }
5102                                         }
5103                                         if ($ctx =~ /ExW/) {
5104                                                 if (ERROR("SPACING",
5105                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
5106                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5107                                                         if (defined $fix_elements[$n + 2]) {
5108                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
5109                                                         }
5110                                                         $line_fixed = 1;
5111                                                 }
5112                                         }
5113
5114                                 # << and >> may either have or not have spaces both sides
5115                                 } elsif ($op eq '<<' or $op eq '>>' or
5116                                          $op eq '&' or $op eq '^' or $op eq '|' or
5117                                          $op eq '+' or $op eq '-' or
5118                                          $op eq '*' or $op eq '/' or
5119                                          $op eq '%')
5120                                 {
5121                                         if ($check) {
5122                                                 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
5123                                                         if (CHK("SPACING",
5124                                                                 "spaces preferred around that '$op' $at\n" . $hereptr)) {
5125                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5126                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
5127                                                                 $line_fixed = 1;
5128                                                         }
5129                                                 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
5130                                                         if (CHK("SPACING",
5131                                                                 "space preferred before that '$op' $at\n" . $hereptr)) {
5132                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
5133                                                                 $line_fixed = 1;
5134                                                         }
5135                                                 }
5136                                         } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
5137                                                 if (ERROR("SPACING",
5138                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {
5139                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5140                                                         if (defined $fix_elements[$n + 2]) {
5141                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
5142                                                         }
5143                                                         $line_fixed = 1;
5144                                                 }
5145                                         }
5146
5147                                 # A colon needs no spaces before when it is
5148                                 # terminating a case value or a label.
5149                                 } elsif ($opv eq ':C' || $opv eq ':L') {
5150                                         if ($ctx =~ /Wx./ and $realfile !~ m@.*\.lds\.h$@) {
5151                                                 if (ERROR("SPACING",
5152                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
5153                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5154                                                         $line_fixed = 1;
5155                                                 }
5156                                         }
5157
5158                                 # All the others need spaces both sides.
5159                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
5160                                         my $ok = 0;
5161
5162                                         # Ignore email addresses <foo@bar>
5163                                         if (($op eq '<' &&
5164                                              $cc =~ /^\S+\@\S+>/) ||
5165                                             ($op eq '>' &&
5166                                              $ca =~ /<\S+\@\S+$/))
5167                                         {
5168                                                 $ok = 1;
5169                                         }
5170
5171                                         # for asm volatile statements
5172                                         # ignore a colon with another
5173                                         # colon immediately before or after
5174                                         if (($op eq ':') &&
5175                                             ($ca =~ /:$/ || $cc =~ /^:/)) {
5176                                                 $ok = 1;
5177                                         }
5178
5179                                         # messages are ERROR, but ?: are CHK
5180                                         if ($ok == 0) {
5181                                                 my $msg_level = \&ERROR;
5182                                                 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
5183
5184                                                 if (&{$msg_level}("SPACING",
5185                                                                   "spaces required around that '$op' $at\n" . $hereptr)) {
5186                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5187                                                         if (defined $fix_elements[$n + 2]) {
5188                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
5189                                                         }
5190                                                         $line_fixed = 1;
5191                                                 }
5192                                         }
5193                                 }
5194                                 $off += length($elements[$n + 1]);
5195
5196 ##                              print("n: <$n> GOOD: <$good>\n");
5197
5198                                 $fixed_line = $fixed_line . $good;
5199                         }
5200
5201                         if (($#elements % 2) == 0) {
5202                                 $fixed_line = $fixed_line . $fix_elements[$#elements];
5203                         }
5204
5205                         if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
5206                                 $fixed[$fixlinenr] = $fixed_line;
5207                         }
5208
5209
5210                 }
5211
5212 # check for whitespace before a non-naked semicolon
5213                 if ($line =~ /^\+.*\S\s+;\s*$/) {
5214                         if (WARN("SPACING",
5215                                  "space prohibited before semicolon\n" . $herecurr) &&
5216                             $fix) {
5217                                 1 while $fixed[$fixlinenr] =~
5218                                     s/^(\+.*\S)\s+;/$1;/;
5219                         }
5220                 }
5221
5222 # check for multiple assignments
5223                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
5224                         CHK("MULTIPLE_ASSIGNMENTS",
5225                             "multiple assignments should be avoided\n" . $herecurr);
5226                 }
5227
5228 ## # check for multiple declarations, allowing for a function declaration
5229 ## # continuation.
5230 ##              if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
5231 ##                  $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
5232 ##
5233 ##                      # Remove any bracketed sections to ensure we do not
5234 ##                      # falsely report the parameters of functions.
5235 ##                      my $ln = $line;
5236 ##                      while ($ln =~ s/\([^\(\)]*\)//g) {
5237 ##                      }
5238 ##                      if ($ln =~ /,/) {
5239 ##                              WARN("MULTIPLE_DECLARATION",
5240 ##                                   "declaring multiple variables together should be avoided\n" . $herecurr);
5241 ##                      }
5242 ##              }
5243
5244 #need space before brace following if, while, etc
5245                 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
5246                     $line =~ /\b(?:else|do)\{/) {
5247                         if (ERROR("SPACING",
5248                                   "space required before the open brace '{'\n" . $herecurr) &&
5249                             $fix) {
5250                                 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|else|\)))\{/$1 {/;
5251                         }
5252                 }
5253
5254 ## # check for blank lines before declarations
5255 ##              if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
5256 ##                  $prevrawline =~ /^.\s*$/) {
5257 ##                      WARN("SPACING",
5258 ##                           "No blank lines before declarations\n" . $hereprev);
5259 ##              }
5260 ##
5261
5262 # closing brace should have a space following it when it has anything
5263 # on the line
5264                 if ($line =~ /}(?!(?:,|;|\)|\}))\S/) {
5265                         if (ERROR("SPACING",
5266                                   "space required after that close brace '}'\n" . $herecurr) &&
5267                             $fix) {
5268                                 $fixed[$fixlinenr] =~
5269                                     s/}((?!(?:,|;|\)))\S)/} $1/;
5270                         }
5271                 }
5272
5273 # check spacing on square brackets
5274                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
5275                         if (ERROR("SPACING",
5276                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
5277                             $fix) {
5278                                 $fixed[$fixlinenr] =~
5279                                     s/\[\s+/\[/;
5280                         }
5281                 }
5282                 if ($line =~ /\s\]/) {
5283                         if (ERROR("SPACING",
5284                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
5285                             $fix) {
5286                                 $fixed[$fixlinenr] =~
5287                                     s/\s+\]/\]/;
5288                         }
5289                 }
5290
5291 # check spacing on parentheses
5292                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
5293                     $line !~ /for\s*\(\s+;/) {
5294                         if (ERROR("SPACING",
5295                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
5296                             $fix) {
5297                                 $fixed[$fixlinenr] =~
5298                                     s/\(\s+/\(/;
5299                         }
5300                 }
5301                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
5302                     $line !~ /for\s*\(.*;\s+\)/ &&
5303                     $line !~ /:\s+\)/) {
5304                         if (ERROR("SPACING",
5305                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
5306                             $fix) {
5307                                 $fixed[$fixlinenr] =~
5308                                     s/\s+\)/\)/;
5309                         }
5310                 }
5311
5312 # check unnecessary parentheses around addressof/dereference single $Lvals
5313 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
5314
5315                 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
5316                         my $var = $1;
5317                         if (CHK("UNNECESSARY_PARENTHESES",
5318                                 "Unnecessary parentheses around $var\n" . $herecurr) &&
5319                             $fix) {
5320                                 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
5321                         }
5322                 }
5323
5324 # check for unnecessary parentheses around function pointer uses
5325 # ie: (foo->bar)(); should be foo->bar();
5326 # but not "if (foo->bar) (" to avoid some false positives
5327                 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
5328                         my $var = $2;
5329                         if (CHK("UNNECESSARY_PARENTHESES",
5330                                 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
5331                             $fix) {
5332                                 my $var2 = deparenthesize($var);
5333                                 $var2 =~ s/\s//g;
5334                                 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
5335                         }
5336                 }
5337
5338 # check for unnecessary parentheses around comparisons in if uses
5339 # when !drivers/staging or command-line uses --strict
5340                 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
5341                     $perl_version_ok && defined($stat) &&
5342                     $stat =~ /(^.\s*if\s*($balanced_parens))/) {
5343                         my $if_stat = $1;
5344                         my $test = substr($2, 1, -1);
5345                         my $herectx;
5346                         while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
5347                                 my $match = $1;
5348                                 # avoid parentheses around potential macro args
5349                                 next if ($match =~ /^\s*\w+\s*$/);
5350                                 if (!defined($herectx)) {
5351                                         $herectx = $here . "\n";
5352                                         my $cnt = statement_rawlines($if_stat);
5353                                         for (my $n = 0; $n < $cnt; $n++) {
5354                                                 my $rl = raw_line($linenr, $n);
5355                                                 $herectx .=  $rl . "\n";
5356                                                 last if $rl =~ /^[ \+].*\{/;
5357                                         }
5358                                 }
5359                                 CHK("UNNECESSARY_PARENTHESES",
5360                                     "Unnecessary parentheses around '$match'\n" . $herectx);
5361                         }
5362                 }
5363
5364 # check that goto labels aren't indented (allow a single space indentation)
5365 # and ignore bitfield definitions like foo:1
5366 # Strictly, labels can have whitespace after the identifier and before the :
5367 # but this is not allowed here as many ?: uses would appear to be labels
5368                 if ($sline =~ /^.\s+[A-Za-z_][A-Za-z\d_]*:(?!\s*\d+)/ &&
5369                     $sline !~ /^. [A-Za-z\d_][A-Za-z\d_]*:/ &&
5370                     $sline !~ /^.\s+default:/) {
5371                         if (WARN("INDENTED_LABEL",
5372                                  "labels should not be indented\n" . $herecurr) &&
5373                             $fix) {
5374                                 $fixed[$fixlinenr] =~
5375                                     s/^(.)\s+/$1/;
5376                         }
5377                 }
5378
5379 # check if a statement with a comma should be two statements like:
5380 #       foo = bar(),    /* comma should be semicolon */
5381 #       bar = baz();
5382                 if (defined($stat) &&
5383                     $stat =~ /^\+\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*,\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*;\s*$/) {
5384                         my $cnt = statement_rawlines($stat);
5385                         my $herectx = get_stat_here($linenr, $cnt, $here);
5386                         WARN("SUSPECT_COMMA_SEMICOLON",
5387                              "Possible comma where semicolon could be used\n" . $herectx);
5388                 }
5389
5390 # return is not a function
5391                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
5392                         my $spacing = $1;
5393                         if ($perl_version_ok &&
5394                             $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
5395                                 my $value = $1;
5396                                 $value = deparenthesize($value);
5397                                 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
5398                                         ERROR("RETURN_PARENTHESES",
5399                                               "return is not a function, parentheses are not required\n" . $herecurr);
5400                                 }
5401                         } elsif ($spacing !~ /\s+/) {
5402                                 ERROR("SPACING",
5403                                       "space required before the open parenthesis '('\n" . $herecurr);
5404                         }
5405                 }
5406
5407 # unnecessary return in a void function
5408 # at end-of-function, with the previous line a single leading tab, then return;
5409 # and the line before that not a goto label target like "out:"
5410                 if ($sline =~ /^[ \+]}\s*$/ &&
5411                     $prevline =~ /^\+\treturn\s*;\s*$/ &&
5412                     $linenr >= 3 &&
5413                     $lines[$linenr - 3] =~ /^[ +]/ &&
5414                     $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
5415                         WARN("RETURN_VOID",
5416                              "void function return statements are not generally useful\n" . $hereprev);
5417                 }
5418
5419 # if statements using unnecessary parentheses - ie: if ((foo == bar))
5420                 if ($perl_version_ok &&
5421                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
5422                         my $openparens = $1;
5423                         my $count = $openparens =~ tr@\(@\(@;
5424                         my $msg = "";
5425                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
5426                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
5427                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
5428                                 WARN("UNNECESSARY_PARENTHESES",
5429                                      "Unnecessary parentheses$msg\n" . $herecurr);
5430                         }
5431                 }
5432
5433 # comparisons with a constant or upper case identifier on the left
5434 #       avoid cases like "foo + BAR < baz"
5435 #       only fix matches surrounded by parentheses to avoid incorrect
5436 #       conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
5437                 if ($perl_version_ok &&
5438                     $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
5439                         my $lead = $1;
5440                         my $const = $2;
5441                         my $comp = $3;
5442                         my $to = $4;
5443                         my $newcomp = $comp;
5444                         if ($lead !~ /(?:$Operators|\.)\s*$/ &&
5445                             $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
5446                             WARN("CONSTANT_COMPARISON",
5447                                  "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
5448                             $fix) {
5449                                 if ($comp eq "<") {
5450                                         $newcomp = ">";
5451                                 } elsif ($comp eq "<=") {
5452                                         $newcomp = ">=";
5453                                 } elsif ($comp eq ">") {
5454                                         $newcomp = "<";
5455                                 } elsif ($comp eq ">=") {
5456                                         $newcomp = "<=";
5457                                 }
5458                                 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
5459                         }
5460                 }
5461
5462 # Return of what appears to be an errno should normally be negative
5463                 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
5464                         my $name = $1;
5465                         if ($name ne 'EOF' && $name ne 'ERROR' && $name !~ /^EPOLL/) {
5466                                 WARN("USE_NEGATIVE_ERRNO",
5467                                      "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
5468                         }
5469                 }
5470
5471 # Need a space before open parenthesis after if, while etc
5472                 if ($line =~ /\b(if|while|for|switch)\(/) {
5473                         if (ERROR("SPACING",
5474                                   "space required before the open parenthesis '('\n" . $herecurr) &&
5475                             $fix) {
5476                                 $fixed[$fixlinenr] =~
5477                                     s/\b(if|while|for|switch)\(/$1 \(/;
5478                         }
5479                 }
5480
5481 # Check for illegal assignment in if conditional -- and check for trailing
5482 # statements after the conditional.
5483                 if ($line =~ /do\s*(?!{)/) {
5484                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
5485                                 ctx_statement_block($linenr, $realcnt, 0)
5486                                         if (!defined $stat);
5487                         my ($stat_next) = ctx_statement_block($line_nr_next,
5488                                                 $remain_next, $off_next);
5489                         $stat_next =~ s/\n./\n /g;
5490                         ##print "stat<$stat> stat_next<$stat_next>\n";
5491
5492                         if ($stat_next =~ /^\s*while\b/) {
5493                                 # If the statement carries leading newlines,
5494                                 # then count those as offsets.
5495                                 my ($whitespace) =
5496                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
5497                                 my $offset =
5498                                         statement_rawlines($whitespace) - 1;
5499
5500                                 $suppress_whiletrailers{$line_nr_next +
5501                                                                 $offset} = 1;
5502                         }
5503                 }
5504                 if (!defined $suppress_whiletrailers{$linenr} &&
5505                     defined($stat) && defined($cond) &&
5506                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
5507                         my ($s, $c) = ($stat, $cond);
5508
5509                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
5510                                 if (ERROR("ASSIGN_IN_IF",
5511                                           "do not use assignment in if condition\n" . $herecurr) &&
5512                                     $fix && $perl_version_ok) {
5513                                         if ($rawline =~ /^\+(\s+)if\s*\(\s*(\!)?\s*\(\s*(($Lval)\s*=\s*$LvalOrFunc)\s*\)\s*(?:($Compare)\s*($FuncArg))?\s*\)\s*(\{)?\s*$/) {
5514                                                 my $space = $1;
5515                                                 my $not = $2;
5516                                                 my $statement = $3;
5517                                                 my $assigned = $4;
5518                                                 my $test = $8;
5519                                                 my $against = $9;
5520                                                 my $brace = $15;
5521                                                 fix_delete_line($fixlinenr, $rawline);
5522                                                 fix_insert_line($fixlinenr, "$space$statement;");
5523                                                 my $newline = "${space}if (";
5524                                                 $newline .= '!' if defined($not);
5525                                                 $newline .= '(' if (defined $not && defined($test) && defined($against));
5526                                                 $newline .= "$assigned";
5527                                                 $newline .= " $test $against" if (defined($test) && defined($against));
5528                                                 $newline .= ')' if (defined $not && defined($test) && defined($against));
5529                                                 $newline .= ')';
5530                                                 $newline .= " {" if (defined($brace));
5531                                                 fix_insert_line($fixlinenr + 1, $newline);
5532                                         }
5533                                 }
5534                         }
5535
5536                         # Find out what is on the end of the line after the
5537                         # conditional.
5538                         substr($s, 0, length($c), '');
5539                         $s =~ s/\n.*//g;
5540                         $s =~ s/$;//g;  # Remove any comments
5541                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
5542                             $c !~ /}\s*while\s*/)
5543                         {
5544                                 # Find out how long the conditional actually is.
5545                                 my @newlines = ($c =~ /\n/gs);
5546                                 my $cond_lines = 1 + $#newlines;
5547                                 my $stat_real = '';
5548
5549                                 $stat_real = raw_line($linenr, $cond_lines)
5550                                                         . "\n" if ($cond_lines);
5551                                 if (defined($stat_real) && $cond_lines > 1) {
5552                                         $stat_real = "[...]\n$stat_real";
5553                                 }
5554
5555                                 ERROR("TRAILING_STATEMENTS",
5556                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
5557                         }
5558                 }
5559
5560 # Check for bitwise tests written as boolean
5561                 if ($line =~ /
5562                         (?:
5563                                 (?:\[|\(|\&\&|\|\|)
5564                                 \s*0[xX][0-9]+\s*
5565                                 (?:\&\&|\|\|)
5566                         |
5567                                 (?:\&\&|\|\|)
5568                                 \s*0[xX][0-9]+\s*
5569                                 (?:\&\&|\|\||\)|\])
5570                         )/x)
5571                 {
5572                         WARN("HEXADECIMAL_BOOLEAN_TEST",
5573                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
5574                 }
5575
5576 # if and else should not have general statements after it
5577                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
5578                         my $s = $1;
5579                         $s =~ s/$;//g;  # Remove any comments
5580                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
5581                                 ERROR("TRAILING_STATEMENTS",
5582                                       "trailing statements should be on next line\n" . $herecurr);
5583                         }
5584                 }
5585 # if should not continue a brace
5586                 if ($line =~ /}\s*if\b/) {
5587                         ERROR("TRAILING_STATEMENTS",
5588                               "trailing statements should be on next line (or did you mean 'else if'?)\n" .
5589                                 $herecurr);
5590                 }
5591 # case and default should not have general statements after them
5592                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
5593                     $line !~ /\G(?:
5594                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
5595                         \s*return\s+
5596                     )/xg)
5597                 {
5598                         ERROR("TRAILING_STATEMENTS",
5599                               "trailing statements should be on next line\n" . $herecurr);
5600                 }
5601
5602                 # Check for }<nl>else {, these must be at the same
5603                 # indent level to be relevant to each other.
5604                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
5605                     $previndent == $indent) {
5606                         if (ERROR("ELSE_AFTER_BRACE",
5607                                   "else should follow close brace '}'\n" . $hereprev) &&
5608                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5609                                 fix_delete_line($fixlinenr - 1, $prevrawline);
5610                                 fix_delete_line($fixlinenr, $rawline);
5611                                 my $fixedline = $prevrawline;
5612                                 $fixedline =~ s/}\s*$//;
5613                                 if ($fixedline !~ /^\+\s*$/) {
5614                                         fix_insert_line($fixlinenr, $fixedline);
5615                                 }
5616                                 $fixedline = $rawline;
5617                                 $fixedline =~ s/^(.\s*)else/$1} else/;
5618                                 fix_insert_line($fixlinenr, $fixedline);
5619                         }
5620                 }
5621
5622                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
5623                     $previndent == $indent) {
5624                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
5625
5626                         # Find out what is on the end of the line after the
5627                         # conditional.
5628                         substr($s, 0, length($c), '');
5629                         $s =~ s/\n.*//g;
5630
5631                         if ($s =~ /^\s*;/) {
5632                                 if (ERROR("WHILE_AFTER_BRACE",
5633                                           "while should follow close brace '}'\n" . $hereprev) &&
5634                                     $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5635                                         fix_delete_line($fixlinenr - 1, $prevrawline);
5636                                         fix_delete_line($fixlinenr, $rawline);
5637                                         my $fixedline = $prevrawline;
5638                                         my $trailing = $rawline;
5639                                         $trailing =~ s/^\+//;
5640                                         $trailing = trim($trailing);
5641                                         $fixedline =~ s/}\s*$/} $trailing/;
5642                                         fix_insert_line($fixlinenr, $fixedline);
5643                                 }
5644                         }
5645                 }
5646
5647 #Specific variable tests
5648                 while ($line =~ m{($Constant|$Lval)}g) {
5649                         my $var = $1;
5650
5651 #CamelCase
5652                         if ($var !~ /^$Constant$/ &&
5653                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
5654 #Ignore some autogenerated defines and enum values
5655                             $var !~ /^(?:[A-Z]+_){1,5}[A-Z]{1,3}[a-z]/ &&
5656 #Ignore Page<foo> variants
5657                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
5658 #Ignore SI style variants like nS, mV and dB
5659 #(ie: max_uV, regulator_min_uA_show, RANGE_mA_VALUE)
5660                             $var !~ /^(?:[a-z0-9_]*|[A-Z0-9_]*)?_?[a-z][A-Z](?:_[a-z0-9_]+|_[A-Z0-9_]+)?$/ &&
5661 #Ignore some three character SI units explicitly, like MiB and KHz
5662                             $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
5663                                 while ($var =~ m{($Ident)}g) {
5664                                         my $word = $1;
5665                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
5666                                         if ($check) {
5667                                                 seed_camelcase_includes();
5668                                                 if (!$file && !$camelcase_file_seeded) {
5669                                                         seed_camelcase_file($realfile);
5670                                                         $camelcase_file_seeded = 1;
5671                                                 }
5672                                         }
5673                                         if (!defined $camelcase{$word}) {
5674                                                 $camelcase{$word} = 1;
5675                                                 CHK("CAMELCASE",
5676                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
5677                                         }
5678                                 }
5679                         }
5680                 }
5681
5682 #no spaces allowed after \ in define
5683                 if ($line =~ /\#\s*define.*\\\s+$/) {
5684                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
5685                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
5686                             $fix) {
5687                                 $fixed[$fixlinenr] =~ s/\s+$//;
5688                         }
5689                 }
5690
5691 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
5692 # itself <asm/foo.h> (uses RAW line)
5693                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
5694                         my $file = "$1.h";
5695                         my $checkfile = "include/linux/$file";
5696                         if (-f "$root/$checkfile" &&
5697                             $realfile ne $checkfile &&
5698                             $1 !~ /$allowed_asm_includes/)
5699                         {
5700                                 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
5701                                 if ($asminclude > 0) {
5702                                         if ($realfile =~ m{^arch/}) {
5703                                                 CHK("ARCH_INCLUDE_LINUX",
5704                                                     "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5705                                         } else {
5706                                                 WARN("INCLUDE_LINUX",
5707                                                      "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5708                                         }
5709                                 }
5710                         }
5711                 }
5712
5713 # multi-statement macros should be enclosed in a do while loop, grab the
5714 # first statement and ensure its the whole macro if its not enclosed
5715 # in a known good container
5716                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
5717                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
5718                         my $ln = $linenr;
5719                         my $cnt = $realcnt;
5720                         my ($off, $dstat, $dcond, $rest);
5721                         my $ctx = '';
5722                         my $has_flow_statement = 0;
5723                         my $has_arg_concat = 0;
5724                         ($dstat, $dcond, $ln, $cnt, $off) =
5725                                 ctx_statement_block($linenr, $realcnt, 0);
5726                         $ctx = $dstat;
5727                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
5728                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
5729
5730                         $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
5731                         $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
5732
5733                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
5734                         my $define_args = $1;
5735                         my $define_stmt = $dstat;
5736                         my @def_args = ();
5737
5738                         if (defined $define_args && $define_args ne "") {
5739                                 $define_args = substr($define_args, 1, length($define_args) - 2);
5740                                 $define_args =~ s/\s*//g;
5741                                 $define_args =~ s/\\\+?//g;
5742                                 @def_args = split(",", $define_args);
5743                         }
5744
5745                         $dstat =~ s/$;//g;
5746                         $dstat =~ s/\\\n.//g;
5747                         $dstat =~ s/^\s*//s;
5748                         $dstat =~ s/\s*$//s;
5749
5750                         # Flatten any parentheses and braces
5751                         while ($dstat =~ s/\([^\(\)]*\)/1u/ ||
5752                                $dstat =~ s/\{[^\{\}]*\}/1u/ ||
5753                                $dstat =~ s/.\[[^\[\]]*\]/1u/)
5754                         {
5755                         }
5756
5757                         # Flatten any obvious string concatenation.
5758                         while ($dstat =~ s/($String)\s*$Ident/$1/ ||
5759                                $dstat =~ s/$Ident\s*($String)/$1/)
5760                         {
5761                         }
5762
5763                         # Make asm volatile uses seem like a generic function
5764                         $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
5765
5766                         my $exceptions = qr{
5767                                 $Declare|
5768                                 module_param_named|
5769                                 MODULE_PARM_DESC|
5770                                 DECLARE_PER_CPU|
5771                                 DEFINE_PER_CPU|
5772                                 __typeof__\(|
5773                                 union|
5774                                 struct|
5775                                 \.$Ident\s*=\s*|
5776                                 ^\"|\"$|
5777                                 ^\[
5778                         }x;
5779                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
5780
5781                         $ctx =~ s/\n*$//;
5782                         my $stmt_cnt = statement_rawlines($ctx);
5783                         my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
5784
5785                         if ($dstat ne '' &&
5786                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
5787                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
5788                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
5789                             $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&                  # character constants
5790                             $dstat !~ /$exceptions/ &&
5791                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
5792                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
5793                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
5794                             $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ &&           # while (...) {...}
5795                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
5796                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
5797                             $dstat !~ /^do\s*{/ &&                                      # do {...
5798                             $dstat !~ /^\(\{/ &&                                                # ({...
5799                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
5800                         {
5801                                 if ($dstat =~ /^\s*if\b/) {
5802                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5803                                               "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5804                                 } elsif ($dstat =~ /;/) {
5805                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5806                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5807                                 } else {
5808                                         ERROR("COMPLEX_MACRO",
5809                                               "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5810                                 }
5811
5812                         }
5813
5814                         # Make $define_stmt single line, comment-free, etc
5815                         my @stmt_array = split('\n', $define_stmt);
5816                         my $first = 1;
5817                         $define_stmt = "";
5818                         foreach my $l (@stmt_array) {
5819                                 $l =~ s/\\$//;
5820                                 if ($first) {
5821                                         $define_stmt = $l;
5822                                         $first = 0;
5823                                 } elsif ($l =~ /^[\+ ]/) {
5824                                         $define_stmt .= substr($l, 1);
5825                                 }
5826                         }
5827                         $define_stmt =~ s/$;//g;
5828                         $define_stmt =~ s/\s+/ /g;
5829                         $define_stmt = trim($define_stmt);
5830
5831 # check if any macro arguments are reused (ignore '...' and 'type')
5832                         foreach my $arg (@def_args) {
5833                                 next if ($arg =~ /\.\.\./);
5834                                 next if ($arg =~ /^type$/i);
5835                                 my $tmp_stmt = $define_stmt;
5836                                 $tmp_stmt =~ s/\b(__must_be_array|offsetof|sizeof|sizeof_field|__stringify|typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
5837                                 $tmp_stmt =~ s/\#+\s*$arg\b//g;
5838                                 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
5839                                 my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
5840                                 if ($use_cnt > 1) {
5841                                         CHK("MACRO_ARG_REUSE",
5842                                             "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
5843                                     }
5844 # check if any macro arguments may have other precedence issues
5845                                 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
5846                                     ((defined($1) && $1 ne ',') ||
5847                                      (defined($2) && $2 ne ','))) {
5848                                         CHK("MACRO_ARG_PRECEDENCE",
5849                                             "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
5850                                 }
5851                         }
5852
5853 # check for macros with flow control, but without ## concatenation
5854 # ## concatenation is commonly a macro that defines a function so ignore those
5855                         if ($has_flow_statement && !$has_arg_concat) {
5856                                 my $cnt = statement_rawlines($ctx);
5857                                 my $herectx = get_stat_here($linenr, $cnt, $here);
5858
5859                                 WARN("MACRO_WITH_FLOW_CONTROL",
5860                                      "Macros with flow control statements should be avoided\n" . "$herectx");
5861                         }
5862
5863 # check for line continuations outside of #defines, preprocessor #, and asm
5864
5865                 } else {
5866                         if ($prevline !~ /^..*\\$/ &&
5867                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
5868                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
5869                             $line =~ /^\+.*\\$/) {
5870                                 WARN("LINE_CONTINUATIONS",
5871                                      "Avoid unnecessary line continuations\n" . $herecurr);
5872                         }
5873                 }
5874
5875 # do {} while (0) macro tests:
5876 # single-statement macros do not need to be enclosed in do while (0) loop,
5877 # macro should not end with a semicolon
5878                 if ($perl_version_ok &&
5879                     $realfile !~ m@/vmlinux.lds.h$@ &&
5880                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5881                         my $ln = $linenr;
5882                         my $cnt = $realcnt;
5883                         my ($off, $dstat, $dcond, $rest);
5884                         my $ctx = '';
5885                         ($dstat, $dcond, $ln, $cnt, $off) =
5886                                 ctx_statement_block($linenr, $realcnt, 0);
5887                         $ctx = $dstat;
5888
5889                         $dstat =~ s/\\\n.//g;
5890                         $dstat =~ s/$;/ /g;
5891
5892                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5893                                 my $stmts = $2;
5894                                 my $semis = $3;
5895
5896                                 $ctx =~ s/\n*$//;
5897                                 my $cnt = statement_rawlines($ctx);
5898                                 my $herectx = get_stat_here($linenr, $cnt, $here);
5899
5900                                 if (($stmts =~ tr/;/;/) == 1 &&
5901                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
5902                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5903                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5904                                 }
5905                                 if (defined $semis && $semis ne "") {
5906                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5907                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5908                                 }
5909                         } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5910                                 $ctx =~ s/\n*$//;
5911                                 my $cnt = statement_rawlines($ctx);
5912                                 my $herectx = get_stat_here($linenr, $cnt, $here);
5913
5914                                 WARN("TRAILING_SEMICOLON",
5915                                      "macros should not use a trailing semicolon\n" . "$herectx");
5916                         }
5917                 }
5918
5919 # check for redundant bracing round if etc
5920                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5921                         my ($level, $endln, @chunks) =
5922                                 ctx_statement_full($linenr, $realcnt, 1);
5923                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5924                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5925                         if ($#chunks > 0 && $level == 0) {
5926                                 my @allowed = ();
5927                                 my $allow = 0;
5928                                 my $seen = 0;
5929                                 my $herectx = $here . "\n";
5930                                 my $ln = $linenr - 1;
5931                                 for my $chunk (@chunks) {
5932                                         my ($cond, $block) = @{$chunk};
5933
5934                                         # If the condition carries leading newlines, then count those as offsets.
5935                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5936                                         my $offset = statement_rawlines($whitespace) - 1;
5937
5938                                         $allowed[$allow] = 0;
5939                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5940
5941                                         # We have looked at and allowed this specific line.
5942                                         $suppress_ifbraces{$ln + $offset} = 1;
5943
5944                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5945                                         $ln += statement_rawlines($block) - 1;
5946
5947                                         substr($block, 0, length($cond), '');
5948
5949                                         $seen++ if ($block =~ /^\s*{/);
5950
5951                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5952                                         if (statement_lines($cond) > 1) {
5953                                                 #print "APW: ALLOWED: cond<$cond>\n";
5954                                                 $allowed[$allow] = 1;
5955                                         }
5956                                         if ($block =~/\b(?:if|for|while)\b/) {
5957                                                 #print "APW: ALLOWED: block<$block>\n";
5958                                                 $allowed[$allow] = 1;
5959                                         }
5960                                         if (statement_block_size($block) > 1) {
5961                                                 #print "APW: ALLOWED: lines block<$block>\n";
5962                                                 $allowed[$allow] = 1;
5963                                         }
5964                                         $allow++;
5965                                 }
5966                                 if ($seen) {
5967                                         my $sum_allowed = 0;
5968                                         foreach (@allowed) {
5969                                                 $sum_allowed += $_;
5970                                         }
5971                                         if ($sum_allowed == 0) {
5972                                                 WARN("BRACES",
5973                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
5974                                         } elsif ($sum_allowed != $allow &&
5975                                                  $seen != $allow) {
5976                                                 CHK("BRACES",
5977                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
5978                                         }
5979                                 }
5980                         }
5981                 }
5982                 if (!defined $suppress_ifbraces{$linenr - 1} &&
5983                                         $line =~ /\b(if|while|for|else)\b/) {
5984                         my $allowed = 0;
5985
5986                         # Check the pre-context.
5987                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5988                                 #print "APW: ALLOWED: pre<$1>\n";
5989                                 $allowed = 1;
5990                         }
5991
5992                         my ($level, $endln, @chunks) =
5993                                 ctx_statement_full($linenr, $realcnt, $-[0]);
5994
5995                         # Check the condition.
5996                         my ($cond, $block) = @{$chunks[0]};
5997                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5998                         if (defined $cond) {
5999                                 substr($block, 0, length($cond), '');
6000                         }
6001                         if (statement_lines($cond) > 1) {
6002                                 #print "APW: ALLOWED: cond<$cond>\n";
6003                                 $allowed = 1;
6004                         }
6005                         if ($block =~/\b(?:if|for|while)\b/) {
6006                                 #print "APW: ALLOWED: block<$block>\n";
6007                                 $allowed = 1;
6008                         }
6009                         if (statement_block_size($block) > 1) {
6010                                 #print "APW: ALLOWED: lines block<$block>\n";
6011                                 $allowed = 1;
6012                         }
6013                         # Check the post-context.
6014                         if (defined $chunks[1]) {
6015                                 my ($cond, $block) = @{$chunks[1]};
6016                                 if (defined $cond) {
6017                                         substr($block, 0, length($cond), '');
6018                                 }
6019                                 if ($block =~ /^\s*\{/) {
6020                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
6021                                         $allowed = 1;
6022                                 }
6023                         }
6024                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
6025                                 my $cnt = statement_rawlines($block);
6026                                 my $herectx = get_stat_here($linenr, $cnt, $here);
6027
6028                                 WARN("BRACES",
6029                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
6030                         }
6031                 }
6032
6033 # check for single line unbalanced braces
6034                 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
6035                     $sline =~ /^.\s*else\s*\{\s*$/) {
6036                         CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
6037                 }
6038
6039 # check for unnecessary blank lines around braces
6040                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
6041                         if (CHK("BRACES",
6042                                 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
6043                             $fix && $prevrawline =~ /^\+/) {
6044                                 fix_delete_line($fixlinenr - 1, $prevrawline);
6045                         }
6046                 }
6047                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
6048                         if (CHK("BRACES",
6049                                 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
6050                             $fix) {
6051                                 fix_delete_line($fixlinenr, $rawline);
6052                         }
6053                 }
6054
6055 # no volatiles please
6056                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
6057                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
6058                         WARN("VOLATILE",
6059                              "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
6060                 }
6061
6062 # Check for user-visible strings broken across lines, which breaks the ability
6063 # to grep for the string.  Make exceptions when the previous string ends in a
6064 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
6065 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
6066                 if ($line =~ /^\+\s*$String/ &&
6067                     $prevline =~ /"\s*$/ &&
6068                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
6069                         if (WARN("SPLIT_STRING",
6070                                  "quoted string split across lines\n" . $hereprev) &&
6071                                      $fix &&
6072                                      $prevrawline =~ /^\+.*"\s*$/ &&
6073                                      $last_coalesced_string_linenr != $linenr - 1) {
6074                                 my $extracted_string = get_quoted_string($line, $rawline);
6075                                 my $comma_close = "";
6076                                 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
6077                                         $comma_close = $1;
6078                                 }
6079
6080                                 fix_delete_line($fixlinenr - 1, $prevrawline);
6081                                 fix_delete_line($fixlinenr, $rawline);
6082                                 my $fixedline = $prevrawline;
6083                                 $fixedline =~ s/"\s*$//;
6084                                 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
6085                                 fix_insert_line($fixlinenr - 1, $fixedline);
6086                                 $fixedline = $rawline;
6087                                 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
6088                                 if ($fixedline !~ /\+\s*$/) {
6089                                         fix_insert_line($fixlinenr, $fixedline);
6090                                 }
6091                                 $last_coalesced_string_linenr = $linenr;
6092                         }
6093                 }
6094
6095 # check for missing a space in a string concatenation
6096                 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
6097                         WARN('MISSING_SPACE',
6098                              "break quoted strings at a space character\n" . $hereprev);
6099                 }
6100
6101 # check for an embedded function name in a string when the function is known
6102 # This does not work very well for -f --file checking as it depends on patch
6103 # context providing the function name or a single line form for in-file
6104 # function declarations
6105                 if ($line =~ /^\+.*$String/ &&
6106                     defined($context_function) &&
6107                     get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
6108                     length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
6109                         WARN("EMBEDDED_FUNCTION_NAME",
6110                              "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
6111                 }
6112
6113 # check for unnecessary function tracing like uses
6114 # This does not use $logFunctions because there are many instances like
6115 # 'dprintk(FOO, "%s()\n", __func__);' which do not match $logFunctions
6116                 if ($rawline =~ /^\+.*\([^"]*"$tracing_logging_tags{0,3}%s(?:\s*\(\s*\)\s*)?$tracing_logging_tags{0,3}(?:\\n)?"\s*,\s*__func__\s*\)\s*;/) {
6117                         if (WARN("TRACING_LOGGING",
6118                                  "Unnecessary ftrace-like logging - prefer using ftrace\n" . $herecurr) &&
6119                             $fix) {
6120                                 fix_delete_line($fixlinenr, $rawline);
6121                         }
6122                 }
6123
6124 # check for spaces before a quoted newline
6125                 if ($rawline =~ /^.*\".*\s\\n/) {
6126                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
6127                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
6128                             $fix) {
6129                                 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
6130                         }
6131
6132                 }
6133
6134 # concatenated string without spaces between elements
6135                 if ($line =~ /$String[A-Za-z0-9_]/ || $line =~ /[A-Za-z0-9_]$String/) {
6136                         if (CHK("CONCATENATED_STRING",
6137                                 "Concatenated strings should use spaces between elements\n" . $herecurr) &&
6138                             $fix) {
6139                                 while ($line =~ /($String)/g) {
6140                                         my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6141                                         $fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
6142                                         $fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
6143                                 }
6144                         }
6145                 }
6146
6147 # uncoalesced string fragments
6148                 if ($line =~ /$String\s*"/) {
6149                         if (WARN("STRING_FRAGMENTS",
6150                                  "Consecutive strings are generally better as a single string\n" . $herecurr) &&
6151                             $fix) {
6152                                 while ($line =~ /($String)(?=\s*")/g) {
6153                                         my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6154                                         $fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
6155                                 }
6156                         }
6157                 }
6158
6159 # check for non-standard and hex prefixed decimal printf formats
6160                 my $show_L = 1; #don't show the same defect twice
6161                 my $show_Z = 1;
6162                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
6163                         my $string = substr($rawline, $-[1], $+[1] - $-[1]);
6164                         $string =~ s/%%/__/g;
6165                         # check for %L
6166                         if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
6167                                 WARN("PRINTF_L",
6168                                      "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
6169                                 $show_L = 0;
6170                         }
6171                         # check for %Z
6172                         if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
6173                                 WARN("PRINTF_Z",
6174                                      "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
6175                                 $show_Z = 0;
6176                         }
6177                         # check for 0x<decimal>
6178                         if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
6179                                 ERROR("PRINTF_0XDECIMAL",
6180                                       "Prefixing 0x with decimal output is defective\n" . $herecurr);
6181                         }
6182                 }
6183
6184 # check for line continuations in quoted strings with odd counts of "
6185                 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
6186                         WARN("LINE_CONTINUATIONS",
6187                              "Avoid line continuations in quoted strings\n" . $herecurr);
6188                 }
6189
6190 # warn about #if 0
6191                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
6192                         WARN("IF_0",
6193                              "Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
6194                 }
6195
6196 # warn about #if 1
6197                 if ($line =~ /^.\s*\#\s*if\s+1\b/) {
6198                         WARN("IF_1",
6199                              "Consider removing the #if 1 and its #endif\n" . $herecurr);
6200                 }
6201
6202 # check for needless "if (<foo>) fn(<foo>)" uses
6203                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
6204                         my $tested = quotemeta($1);
6205                         my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
6206                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
6207                                 my $func = $1;
6208                                 if (WARN('NEEDLESS_IF',
6209                                          "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
6210                                     $fix) {
6211                                         my $do_fix = 1;
6212                                         my $leading_tabs = "";
6213                                         my $new_leading_tabs = "";
6214                                         if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
6215                                                 $leading_tabs = $1;
6216                                         } else {
6217                                                 $do_fix = 0;
6218                                         }
6219                                         if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
6220                                                 $new_leading_tabs = $1;
6221                                                 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
6222                                                         $do_fix = 0;
6223                                                 }
6224                                         } else {
6225                                                 $do_fix = 0;
6226                                         }
6227                                         if ($do_fix) {
6228                                                 fix_delete_line($fixlinenr - 1, $prevrawline);
6229                                                 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
6230                                         }
6231                                 }
6232                         }
6233                 }
6234
6235 # check for unnecessary "Out of Memory" messages
6236                 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
6237                     $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
6238                     (defined $1 || defined $3) &&
6239                     $linenr > 3) {
6240                         my $testval = $2;
6241                         my $testline = $lines[$linenr - 3];
6242
6243                         my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
6244 #                       print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
6245
6246                         if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
6247                             $s !~ /\b__GFP_NOWARN\b/ ) {
6248                                 WARN("OOM_MESSAGE",
6249                                      "Possible unnecessary 'out of memory' message\n" . $hereprev);
6250                         }
6251                 }
6252
6253 # check for logging functions with KERN_<LEVEL>
6254                 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
6255                     $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
6256                         my $level = $1;
6257                         if (WARN("UNNECESSARY_KERN_LEVEL",
6258                                  "Possible unnecessary $level\n" . $herecurr) &&
6259                             $fix) {
6260                                 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
6261                         }
6262                 }
6263
6264 # check for logging continuations
6265                 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
6266                         WARN("LOGGING_CONTINUATION",
6267                              "Avoid logging continuation uses where feasible\n" . $herecurr);
6268                 }
6269
6270 # check for unnecessary use of %h[xudi] and %hh[xudi] in logging functions
6271                 if (defined $stat &&
6272                     $line =~ /\b$logFunctions\s*\(/ &&
6273                     index($stat, '"') >= 0) {
6274                         my $lc = $stat =~ tr@\n@@;
6275                         $lc = $lc + $linenr;
6276                         my $stat_real = get_stat_real($linenr, $lc);
6277                         pos($stat_real) = index($stat_real, '"');
6278                         while ($stat_real =~ /[^\"%]*(%[\#\d\.\*\-]*(h+)[idux])/g) {
6279                                 my $pspec = $1;
6280                                 my $h = $2;
6281                                 my $lineoff = substr($stat_real, 0, $-[1]) =~ tr@\n@@;
6282                                 if (WARN("UNNECESSARY_MODIFIER",
6283                                          "Integer promotion: Using '$h' in '$pspec' is unnecessary\n" . "$here\n$stat_real\n") &&
6284                                     $fix && $fixed[$fixlinenr + $lineoff] =~ /^\+/) {
6285                                         my $nspec = $pspec;
6286                                         $nspec =~ s/h//g;
6287                                         $fixed[$fixlinenr + $lineoff] =~ s/\Q$pspec\E/$nspec/;
6288                                 }
6289                         }
6290                 }
6291
6292 # check for mask then right shift without a parentheses
6293                 if ($perl_version_ok &&
6294                     $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
6295                     $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
6296                         WARN("MASK_THEN_SHIFT",
6297                              "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
6298                 }
6299
6300 # check for pointer comparisons to NULL
6301                 if ($perl_version_ok) {
6302                         while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
6303                                 my $val = $1;
6304                                 my $equal = "!";
6305                                 $equal = "" if ($4 eq "!=");
6306                                 if (CHK("COMPARISON_TO_NULL",
6307                                         "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
6308                                             $fix) {
6309                                         $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
6310                                 }
6311                         }
6312                 }
6313
6314 # check for bad placement of section $InitAttribute (e.g.: __initdata)
6315                 if ($line =~ /(\b$InitAttribute\b)/) {
6316                         my $attr = $1;
6317                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
6318                                 my $ptr = $1;
6319                                 my $var = $2;
6320                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
6321                                       ERROR("MISPLACED_INIT",
6322                                             "$attr should be placed after $var\n" . $herecurr)) ||
6323                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
6324                                       WARN("MISPLACED_INIT",
6325                                            "$attr should be placed after $var\n" . $herecurr))) &&
6326                                     $fix) {
6327                                         $fixed[$fixlinenr] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
6328                                 }
6329                         }
6330                 }
6331
6332 # check for $InitAttributeData (ie: __initdata) with const
6333                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
6334                         my $attr = $1;
6335                         $attr =~ /($InitAttributePrefix)(.*)/;
6336                         my $attr_prefix = $1;
6337                         my $attr_type = $2;
6338                         if (ERROR("INIT_ATTRIBUTE",
6339                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
6340                             $fix) {
6341                                 $fixed[$fixlinenr] =~
6342                                     s/$InitAttributeData/${attr_prefix}initconst/;
6343                         }
6344                 }
6345
6346 # check for $InitAttributeConst (ie: __initconst) without const
6347                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
6348                         my $attr = $1;
6349                         if (ERROR("INIT_ATTRIBUTE",
6350                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
6351                             $fix) {
6352                                 my $lead = $fixed[$fixlinenr] =~
6353                                     /(^\+\s*(?:static\s+))/;
6354                                 $lead = rtrim($1);
6355                                 $lead = "$lead " if ($lead !~ /^\+$/);
6356                                 $lead = "${lead}const ";
6357                                 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
6358                         }
6359                 }
6360
6361 # check for __read_mostly with const non-pointer (should just be const)
6362                 if ($line =~ /\b__read_mostly\b/ &&
6363                     $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
6364                         if (ERROR("CONST_READ_MOSTLY",
6365                                   "Invalid use of __read_mostly with const type\n" . $herecurr) &&
6366                             $fix) {
6367                                 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
6368                         }
6369                 }
6370
6371 # don't use __constant_<foo> functions outside of include/uapi/
6372                 if ($realfile !~ m@^include/uapi/@ &&
6373                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
6374                         my $constant_func = $1;
6375                         my $func = $constant_func;
6376                         $func =~ s/^__constant_//;
6377                         if (WARN("CONSTANT_CONVERSION",
6378                                  "$constant_func should be $func\n" . $herecurr) &&
6379                             $fix) {
6380                                 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
6381                         }
6382                 }
6383
6384 # prefer usleep_range over udelay
6385                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
6386                         my $delay = $1;
6387                         # ignore udelay's < 10, however
6388                         if (! ($delay < 10) ) {
6389                                 CHK("USLEEP_RANGE",
6390                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6391                         }
6392                         if ($delay > 2000) {
6393                                 WARN("LONG_UDELAY",
6394                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
6395                         }
6396                 }
6397
6398 # warn about unexpectedly long msleep's
6399                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
6400                         if ($1 < 20) {
6401                                 WARN("MSLEEP",
6402                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6403                         }
6404                 }
6405
6406 # check for comparisons of jiffies
6407                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
6408                         WARN("JIFFIES_COMPARISON",
6409                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
6410                 }
6411
6412 # check for comparisons of get_jiffies_64()
6413                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
6414                         WARN("JIFFIES_COMPARISON",
6415                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
6416                 }
6417
6418 # warn about #ifdefs in C files
6419 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
6420 #                       print "#ifdef in C files should be avoided\n";
6421 #                       print "$herecurr";
6422 #                       $clean = 0;
6423 #               }
6424
6425 # warn about spacing in #ifdefs
6426                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
6427                         if (ERROR("SPACING",
6428                                   "exactly one space required after that #$1\n" . $herecurr) &&
6429                             $fix) {
6430                                 $fixed[$fixlinenr] =~
6431                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
6432                         }
6433
6434                 }
6435
6436 # check for spinlock_t definitions without a comment.
6437                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
6438                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
6439                         my $which = $1;
6440                         if (!ctx_has_comment($first_line, $linenr)) {
6441                                 CHK("UNCOMMENTED_DEFINITION",
6442                                     "$1 definition without comment\n" . $herecurr);
6443                         }
6444                 }
6445 # check for memory barriers without a comment.
6446
6447                 my $barriers = qr{
6448                         mb|
6449                         rmb|
6450                         wmb
6451                 }x;
6452                 my $barrier_stems = qr{
6453                         mb__before_atomic|
6454                         mb__after_atomic|
6455                         store_release|
6456                         load_acquire|
6457                         store_mb|
6458                         (?:$barriers)
6459                 }x;
6460                 my $all_barriers = qr{
6461                         (?:$barriers)|
6462                         smp_(?:$barrier_stems)|
6463                         virt_(?:$barrier_stems)
6464                 }x;
6465
6466                 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
6467                         if (!ctx_has_comment($first_line, $linenr)) {
6468                                 WARN("MEMORY_BARRIER",
6469                                      "memory barrier without comment\n" . $herecurr);
6470                         }
6471                 }
6472
6473                 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
6474
6475                 if ($realfile !~ m@^include/asm-generic/@ &&
6476                     $realfile !~ m@/barrier\.h$@ &&
6477                     $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
6478                     $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
6479                         WARN("MEMORY_BARRIER",
6480                              "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6481                 }
6482
6483 # check for waitqueue_active without a comment.
6484                 if ($line =~ /\bwaitqueue_active\s*\(/) {
6485                         if (!ctx_has_comment($first_line, $linenr)) {
6486                                 WARN("WAITQUEUE_ACTIVE",
6487                                      "waitqueue_active without comment\n" . $herecurr);
6488                         }
6489                 }
6490
6491 # check for data_race without a comment.
6492                 if ($line =~ /\bdata_race\s*\(/) {
6493                         if (!ctx_has_comment($first_line, $linenr)) {
6494                                 WARN("DATA_RACE",
6495                                      "data_race without comment\n" . $herecurr);
6496                         }
6497                 }
6498
6499 # check of hardware specific defines
6500                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
6501                         CHK("ARCH_DEFINES",
6502                             "architecture specific defines should be avoided\n" .  $herecurr);
6503                 }
6504
6505 # check that the storage class is not after a type
6506                 if ($line =~ /\b($Type)\s+($Storage)\b/) {
6507                         WARN("STORAGE_CLASS",
6508                              "storage class '$2' should be located before type '$1'\n" . $herecurr);
6509                 }
6510 # Check that the storage class is at the beginning of a declaration
6511                 if ($line =~ /\b$Storage\b/ &&
6512                     $line !~ /^.\s*$Storage/ &&
6513                     $line =~ /^.\s*(.+?)\$Storage\s/ &&
6514                     $1 !~ /[\,\)]\s*$/) {
6515                         WARN("STORAGE_CLASS",
6516                              "storage class should be at the beginning of the declaration\n" . $herecurr);
6517                 }
6518
6519 # check the location of the inline attribute, that it is between
6520 # storage class and type.
6521                 if ($line =~ /\b$Type\s+$Inline\b/ ||
6522                     $line =~ /\b$Inline\s+$Storage\b/) {
6523                         ERROR("INLINE_LOCATION",
6524                               "inline keyword should sit between storage class and type\n" . $herecurr);
6525                 }
6526
6527 # Check for __inline__ and __inline, prefer inline
6528                 if ($realfile !~ m@\binclude/uapi/@ &&
6529                     $line =~ /\b(__inline__|__inline)\b/) {
6530                         if (WARN("INLINE",
6531                                  "plain inline is preferred over $1\n" . $herecurr) &&
6532                             $fix) {
6533                                 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
6534
6535                         }
6536                 }
6537
6538 # Check for compiler attributes
6539                 if ($realfile !~ m@\binclude/uapi/@ &&
6540                     $rawline =~ /\b__attribute__\s*\(\s*($balanced_parens)\s*\)/) {
6541                         my $attr = $1;
6542                         $attr =~ s/\s*\(\s*(.*)\)\s*/$1/;
6543
6544                         my %attr_list = (
6545                                 "alias"                         => "__alias",
6546                                 "aligned"                       => "__aligned",
6547                                 "always_inline"                 => "__always_inline",
6548                                 "assume_aligned"                => "__assume_aligned",
6549                                 "cold"                          => "__cold",
6550                                 "const"                         => "__attribute_const__",
6551                                 "copy"                          => "__copy",
6552                                 "designated_init"               => "__designated_init",
6553                                 "externally_visible"            => "__visible",
6554                                 "format"                        => "printf|scanf",
6555                                 "gnu_inline"                    => "__gnu_inline",
6556                                 "malloc"                        => "__malloc",
6557                                 "mode"                          => "__mode",
6558                                 "no_caller_saved_registers"     => "__no_caller_saved_registers",
6559                                 "noclone"                       => "__noclone",
6560                                 "noinline"                      => "noinline",
6561                                 "nonstring"                     => "__nonstring",
6562                                 "noreturn"                      => "__noreturn",
6563                                 "packed"                        => "__packed",
6564                                 "pure"                          => "__pure",
6565                                 "section"                       => "__section",
6566                                 "used"                          => "__used",
6567                                 "weak"                          => "__weak"
6568                         );
6569
6570                         while ($attr =~ /\s*(\w+)\s*(${balanced_parens})?/g) {
6571                                 my $orig_attr = $1;
6572                                 my $params = '';
6573                                 $params = $2 if defined($2);
6574                                 my $curr_attr = $orig_attr;
6575                                 $curr_attr =~ s/^[\s_]+|[\s_]+$//g;
6576                                 if (exists($attr_list{$curr_attr})) {
6577                                         my $new = $attr_list{$curr_attr};
6578                                         if ($curr_attr eq "format" && $params) {
6579                                                 $params =~ /^\s*\(\s*(\w+)\s*,\s*(.*)/;
6580                                                 $new = "__$1\($2";
6581                                         } else {
6582                                                 $new = "$new$params";
6583                                         }
6584                                         if (WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6585                                                  "Prefer $new over __attribute__(($orig_attr$params))\n" . $herecurr) &&
6586                                             $fix) {
6587                                                 my $remove = "\Q$orig_attr\E" . '\s*' . "\Q$params\E" . '(?:\s*,\s*)?';
6588                                                 $fixed[$fixlinenr] =~ s/$remove//;
6589                                                 $fixed[$fixlinenr] =~ s/\b__attribute__/$new __attribute__/;
6590                                                 $fixed[$fixlinenr] =~ s/\}\Q$new\E/} $new/;
6591                                                 $fixed[$fixlinenr] =~ s/ __attribute__\s*\(\s*\(\s*\)\s*\)//;
6592                                         }
6593                                 }
6594                         }
6595
6596                         # Check for __attribute__ unused, prefer __always_unused or __maybe_unused
6597                         if ($attr =~ /^_*unused/) {
6598                                 WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6599                                      "__always_unused or __maybe_unused is preferred over __attribute__((__unused__))\n" . $herecurr);
6600                         }
6601                 }
6602
6603 # Check for __attribute__ weak, or __weak declarations (may have link issues)
6604                 if ($perl_version_ok &&
6605                     $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
6606                     ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
6607                      $line =~ /\b__weak\b/)) {
6608                         ERROR("WEAK_DECLARATION",
6609                               "Using weak declarations can have unintended link defects\n" . $herecurr);
6610                 }
6611
6612 # check for c99 types like uint8_t used outside of uapi/ and tools/
6613                 if ($realfile !~ m@\binclude/uapi/@ &&
6614                     $realfile !~ m@\btools/@ &&
6615                     $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
6616                         my $type = $1;
6617                         if ($type =~ /\b($typeC99Typedefs)\b/) {
6618                                 $type = $1;
6619                                 my $kernel_type = 'u';
6620                                 $kernel_type = 's' if ($type =~ /^_*[si]/);
6621                                 $type =~ /(\d+)/;
6622                                 $kernel_type .= $1;
6623                                 if (CHK("PREFER_KERNEL_TYPES",
6624                                         "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6625                                     $fix) {
6626                                         $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6627                                 }
6628                         }
6629                 }
6630
6631 # check for cast of C90 native int or longer types constants
6632                 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
6633                         my $cast = $1;
6634                         my $const = $2;
6635                         my $suffix = "";
6636                         my $newconst = $const;
6637                         $newconst =~ s/${Int_type}$//;
6638                         $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6639                         if ($cast =~ /\blong\s+long\b/) {
6640                             $suffix .= 'LL';
6641                         } elsif ($cast =~ /\blong\b/) {
6642                             $suffix .= 'L';
6643                         }
6644                         if (WARN("TYPECAST_INT_CONSTANT",
6645                                  "Unnecessary typecast of c90 int constant - '$cast$const' could be '$const$suffix'\n" . $herecurr) &&
6646                             $fix) {
6647                                 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6648                         }
6649                 }
6650
6651 # check for sizeof(&)
6652                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
6653                         WARN("SIZEOF_ADDRESS",
6654                              "sizeof(& should be avoided\n" . $herecurr);
6655                 }
6656
6657 # check for sizeof without parenthesis
6658                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
6659                         if (WARN("SIZEOF_PARENTHESIS",
6660                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6661                             $fix) {
6662                                 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
6663                         }
6664                 }
6665
6666 # check for struct spinlock declarations
6667                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
6668                         WARN("USE_SPINLOCK_T",
6669                              "struct spinlock should be spinlock_t\n" . $herecurr);
6670                 }
6671
6672 # check for seq_printf uses that could be seq_puts
6673                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
6674                         my $fmt = get_quoted_string($line, $rawline);
6675                         $fmt =~ s/%%//g;
6676                         if ($fmt !~ /%/) {
6677                                 if (WARN("PREFER_SEQ_PUTS",
6678                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
6679                                     $fix) {
6680                                         $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6681                                 }
6682                         }
6683                 }
6684
6685 # check for vsprintf extension %p<foo> misuses
6686                 if ($perl_version_ok &&
6687                     defined $stat &&
6688                     $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
6689                     $1 !~ /^_*volatile_*$/) {
6690                         my $stat_real;
6691
6692                         my $lc = $stat =~ tr@\n@@;
6693                         $lc = $lc + $linenr;
6694                         for (my $count = $linenr; $count <= $lc; $count++) {
6695                                 my $specifier;
6696                                 my $extension;
6697                                 my $qualifier;
6698                                 my $bad_specifier = "";
6699                                 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
6700                                 $fmt =~ s/%%//g;
6701
6702                                 while ($fmt =~ /(\%[\*\d\.]*p(\w)(\w*))/g) {
6703                                         $specifier = $1;
6704                                         $extension = $2;
6705                                         $qualifier = $3;
6706                                         if ($extension !~ /[4SsBKRraEehMmIiUDdgVCbGNOxtf]/ ||
6707                                             ($extension eq "f" &&
6708                                              defined $qualifier && $qualifier !~ /^w/) ||
6709                                             ($extension eq "4" &&
6710                                              defined $qualifier && $qualifier !~ /^cc/)) {
6711                                                 $bad_specifier = $specifier;
6712                                                 last;
6713                                         }
6714                                         if ($extension eq "x" && !defined($stat_real)) {
6715                                                 if (!defined($stat_real)) {
6716                                                         $stat_real = get_stat_real($linenr, $lc);
6717                                                 }
6718                                                 WARN("VSPRINTF_SPECIFIER_PX",
6719                                                      "Using vsprintf specifier '\%px' potentially exposes the kernel memory layout, if you don't really need the address please consider using '\%p'.\n" . "$here\n$stat_real\n");
6720                                         }
6721                                 }
6722                                 if ($bad_specifier ne "") {
6723                                         my $stat_real = get_stat_real($linenr, $lc);
6724                                         my $ext_type = "Invalid";
6725                                         my $use = "";
6726                                         if ($bad_specifier =~ /p[Ff]/) {
6727                                                 $use = " - use %pS instead";
6728                                                 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6729                                         }
6730
6731                                         WARN("VSPRINTF_POINTER_EXTENSION",
6732                                              "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6733                                 }
6734                         }
6735                 }
6736
6737 # Check for misused memsets
6738                 if ($perl_version_ok &&
6739                     defined $stat &&
6740                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
6741
6742                         my $ms_addr = $2;
6743                         my $ms_val = $7;
6744                         my $ms_size = $12;
6745
6746                         if ($ms_size =~ /^(0x|)0$/i) {
6747                                 ERROR("MEMSET",
6748                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6749                         } elsif ($ms_size =~ /^(0x|)1$/i) {
6750                                 WARN("MEMSET",
6751                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6752                         }
6753                 }
6754
6755 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6756 #               if ($perl_version_ok &&
6757 #                   defined $stat &&
6758 #                   $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6759 #                       if (WARN("PREFER_ETHER_ADDR_COPY",
6760 #                                "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6761 #                           $fix) {
6762 #                               $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
6763 #                       }
6764 #               }
6765
6766 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6767 #               if ($perl_version_ok &&
6768 #                   defined $stat &&
6769 #                   $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6770 #                       WARN("PREFER_ETHER_ADDR_EQUAL",
6771 #                            "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6772 #               }
6773
6774 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6775 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
6776 #               if ($perl_version_ok &&
6777 #                   defined $stat &&
6778 #                   $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6779 #
6780 #                       my $ms_val = $7;
6781 #
6782 #                       if ($ms_val =~ /^(?:0x|)0+$/i) {
6783 #                               if (WARN("PREFER_ETH_ZERO_ADDR",
6784 #                                        "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
6785 #                                   $fix) {
6786 #                                       $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
6787 #                               }
6788 #                       } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
6789 #                               if (WARN("PREFER_ETH_BROADCAST_ADDR",
6790 #                                        "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
6791 #                                   $fix) {
6792 #                                       $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
6793 #                               }
6794 #                       }
6795 #               }
6796
6797 # strlcpy uses that should likely be strscpy
6798                 if ($line =~ /\bstrlcpy\s*\(/) {
6799                         WARN("STRLCPY",
6800                              "Prefer strscpy over strlcpy - see: https://lore.kernel.org/r/CAHk-=wgfRnXz0W3D37d01q3JFkr_i_uTL=V6A6G1oUZcprmknw\@mail.gmail.com/\n" . $herecurr);
6801                 }
6802
6803 # typecasts on min/max could be min_t/max_t
6804                 if ($perl_version_ok &&
6805                     defined $stat &&
6806                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
6807                         if (defined $2 || defined $7) {
6808                                 my $call = $1;
6809                                 my $cast1 = deparenthesize($2);
6810                                 my $arg1 = $3;
6811                                 my $cast2 = deparenthesize($7);
6812                                 my $arg2 = $8;
6813                                 my $cast;
6814
6815                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
6816                                         $cast = "$cast1 or $cast2";
6817                                 } elsif ($cast1 ne "") {
6818                                         $cast = $cast1;
6819                                 } else {
6820                                         $cast = $cast2;
6821                                 }
6822                                 WARN("MINMAX",
6823                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
6824                         }
6825                 }
6826
6827 # check usleep_range arguments
6828                 if ($perl_version_ok &&
6829                     defined $stat &&
6830                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
6831                         my $min = $1;
6832                         my $max = $7;
6833                         if ($min eq $max) {
6834                                 WARN("USLEEP_RANGE",
6835                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6836                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
6837                                  $min > $max) {
6838                                 WARN("USLEEP_RANGE",
6839                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6840                         }
6841                 }
6842
6843 # check for naked sscanf
6844                 if ($perl_version_ok &&
6845                     defined $stat &&
6846                     $line =~ /\bsscanf\b/ &&
6847                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
6848                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
6849                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
6850                         my $lc = $stat =~ tr@\n@@;
6851                         $lc = $lc + $linenr;
6852                         my $stat_real = get_stat_real($linenr, $lc);
6853                         WARN("NAKED_SSCANF",
6854                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
6855                 }
6856
6857 # check for simple sscanf that should be kstrto<foo>
6858                 if ($perl_version_ok &&
6859                     defined $stat &&
6860                     $line =~ /\bsscanf\b/) {
6861                         my $lc = $stat =~ tr@\n@@;
6862                         $lc = $lc + $linenr;
6863                         my $stat_real = get_stat_real($linenr, $lc);
6864                         if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
6865                                 my $format = $6;
6866                                 my $count = $format =~ tr@%@%@;
6867                                 if ($count == 1 &&
6868                                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
6869                                         WARN("SSCANF_TO_KSTRTO",
6870                                              "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
6871                                 }
6872                         }
6873                 }
6874
6875 # check for new externs in .h files.
6876                 if ($realfile =~ /\.h$/ &&
6877                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
6878                         if (CHK("AVOID_EXTERNS",
6879                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
6880                             $fix) {
6881                                 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
6882                         }
6883                 }
6884
6885 # check for new externs in .c files.
6886                 if ($realfile =~ /\.c$/ && defined $stat &&
6887                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
6888                 {
6889                         my $function_name = $1;
6890                         my $paren_space = $2;
6891
6892                         my $s = $stat;
6893                         if (defined $cond) {
6894                                 substr($s, 0, length($cond), '');
6895                         }
6896                         if ($s =~ /^\s*;/)
6897                         {
6898                                 WARN("AVOID_EXTERNS",
6899                                      "externs should be avoided in .c files\n" .  $herecurr);
6900                         }
6901
6902                         if ($paren_space =~ /\n/) {
6903                                 WARN("FUNCTION_ARGUMENTS",
6904                                      "arguments for function declarations should follow identifier\n" . $herecurr);
6905                         }
6906
6907                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
6908                     $stat =~ /^.\s*extern\s+/)
6909                 {
6910                         WARN("AVOID_EXTERNS",
6911                              "externs should be avoided in .c files\n" .  $herecurr);
6912                 }
6913
6914 # check for function declarations that have arguments without identifier names
6915                 if (defined $stat &&
6916                     $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
6917                     $1 ne "void") {
6918                         my $args = trim($1);
6919                         while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
6920                                 my $arg = trim($1);
6921                                 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
6922                                         WARN("FUNCTION_ARGUMENTS",
6923                                              "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
6924                                 }
6925                         }
6926                 }
6927
6928 # check for function definitions
6929                 if ($perl_version_ok &&
6930                     defined $stat &&
6931                     $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
6932                         $context_function = $1;
6933
6934 # check for multiline function definition with misplaced open brace
6935                         my $ok = 0;
6936                         my $cnt = statement_rawlines($stat);
6937                         my $herectx = $here . "\n";
6938                         for (my $n = 0; $n < $cnt; $n++) {
6939                                 my $rl = raw_line($linenr, $n);
6940                                 $herectx .=  $rl . "\n";
6941                                 $ok = 1 if ($rl =~ /^[ \+]\{/);
6942                                 $ok = 1 if ($rl =~ /\{/ && $n == 0);
6943                                 last if $rl =~ /^[ \+].*\{/;
6944                         }
6945                         if (!$ok) {
6946                                 ERROR("OPEN_BRACE",
6947                                       "open brace '{' following function definitions go on the next line\n" . $herectx);
6948                         }
6949                 }
6950
6951 # checks for new __setup's
6952                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6953                         my $name = $1;
6954
6955                         if (!grep(/$name/, @setup_docs)) {
6956                                 CHK("UNDOCUMENTED_SETUP",
6957                                     "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
6958                         }
6959                 }
6960
6961 # check for pointless casting of alloc functions
6962                 if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
6963                         WARN("UNNECESSARY_CASTS",
6964                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6965                 }
6966
6967 # alloc style
6968 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6969                 if ($perl_version_ok &&
6970                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6971                         CHK("ALLOC_SIZEOF_STRUCT",
6972                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6973                 }
6974
6975 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6976                 if ($perl_version_ok &&
6977                     defined $stat &&
6978                     $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6979                         my $oldfunc = $3;
6980                         my $a1 = $4;
6981                         my $a2 = $10;
6982                         my $newfunc = "kmalloc_array";
6983                         $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6984                         my $r1 = $a1;
6985                         my $r2 = $a2;
6986                         if ($a1 =~ /^sizeof\s*\S/) {
6987                                 $r1 = $a2;
6988                                 $r2 = $a1;
6989                         }
6990                         if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6991                             !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6992                                 my $cnt = statement_rawlines($stat);
6993                                 my $herectx = get_stat_here($linenr, $cnt, $here);
6994
6995                                 if (WARN("ALLOC_WITH_MULTIPLY",
6996                                          "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6997                                     $cnt == 1 &&
6998                                     $fix) {
6999                                         $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
7000                                 }
7001                         }
7002                 }
7003
7004 # check for krealloc arg reuse
7005                 if ($perl_version_ok &&
7006                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*($Lval)\s*,/ &&
7007                     $1 eq $3) {
7008                         WARN("KREALLOC_ARG_REUSE",
7009                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
7010                 }
7011
7012 # check for alloc argument mismatch
7013                 if ($line =~ /\b((?:devm_)?(?:kcalloc|kmalloc_array))\s*\(\s*sizeof\b/) {
7014                         WARN("ALLOC_ARRAY_ARGS",
7015                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
7016                 }
7017
7018 # check for multiple semicolons
7019                 if ($line =~ /;\s*;\s*$/) {
7020                         if (WARN("ONE_SEMICOLON",
7021                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
7022                             $fix) {
7023                                 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
7024                         }
7025                 }
7026
7027 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
7028                 if ($realfile !~ m@^include/uapi/@ &&
7029                     $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
7030                         my $ull = "";
7031                         $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
7032                         if (CHK("BIT_MACRO",
7033                                 "Prefer using the BIT$ull macro\n" . $herecurr) &&
7034                             $fix) {
7035                                 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
7036                         }
7037                 }
7038
7039 # check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
7040                 if ($rawline =~ /\bIS_ENABLED\s*\(\s*(\w+)\s*\)/ && $1 !~ /^${CONFIG_}/) {
7041                         WARN("IS_ENABLED_CONFIG",
7042                              "IS_ENABLED($1) is normally used as IS_ENABLED(${CONFIG_}$1)\n" . $herecurr);
7043                 }
7044
7045 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
7046                 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(${CONFIG_}[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
7047                         my $config = $1;
7048                         if (WARN("PREFER_IS_ENABLED",
7049                                  "Prefer IS_ENABLED(<FOO>) to ${CONFIG_}<FOO> || ${CONFIG_}<FOO>_MODULE\n" . $herecurr) &&
7050                             $fix) {
7051                                 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
7052                         }
7053                 }
7054
7055 # check for /* fallthrough */ like comment, prefer fallthrough;
7056                 my @fallthroughs = (
7057                         'fallthrough',
7058                         '@fallthrough@',
7059                         'lint -fallthrough[ \t]*',
7060                         'intentional(?:ly)?[ \t]*fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)',
7061                         '(?:else,?\s*)?FALL(?:S | |-)?THR(?:OUGH|U|EW)[ \t.!]*(?:-[^\n\r]*)?',
7062                         'Fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7063                         'fall(?:s | |-)?thr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7064                     );
7065                 if ($raw_comment ne '') {
7066                         foreach my $ft (@fallthroughs) {
7067                                 if ($raw_comment =~ /$ft/) {
7068                                         my $msg_level = \&WARN;
7069                                         $msg_level = \&CHK if ($file);
7070                                         &{$msg_level}("PREFER_FALLTHROUGH",
7071                                                       "Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
7072                                         last;
7073                                 }
7074                         }
7075                 }
7076
7077 # check for switch/default statements without a break;
7078                 if ($perl_version_ok &&
7079                     defined $stat &&
7080                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
7081                         my $cnt = statement_rawlines($stat);
7082                         my $herectx = get_stat_here($linenr, $cnt, $here);
7083
7084                         WARN("DEFAULT_NO_BREAK",
7085                              "switch default: should use break\n" . $herectx);
7086                 }
7087
7088 # check for gcc specific __FUNCTION__
7089                 if ($line =~ /\b__FUNCTION__\b/) {
7090                         if (WARN("USE_FUNC",
7091                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
7092                             $fix) {
7093                                 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
7094                         }
7095                 }
7096
7097 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
7098                 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
7099                         ERROR("DATE_TIME",
7100                               "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
7101                 }
7102
7103 # check for use of yield()
7104                 if ($line =~ /\byield\s*\(\s*\)/) {
7105                         WARN("YIELD",
7106                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
7107                 }
7108
7109 # check for comparisons against true and false
7110                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
7111                         my $lead = $1;
7112                         my $arg = $2;
7113                         my $test = $3;
7114                         my $otype = $4;
7115                         my $trail = $5;
7116                         my $op = "!";
7117
7118                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
7119
7120                         my $type = lc($otype);
7121                         if ($type =~ /^(?:true|false)$/) {
7122                                 if (("$test" eq "==" && "$type" eq "true") ||
7123                                     ("$test" eq "!=" && "$type" eq "false")) {
7124                                         $op = "";
7125                                 }
7126
7127                                 CHK("BOOL_COMPARISON",
7128                                     "Using comparison to $otype is error prone\n" . $herecurr);
7129
7130 ## maybe suggesting a correct construct would better
7131 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
7132
7133                         }
7134                 }
7135
7136 # check for semaphores initialized locked
7137                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
7138                         WARN("CONSIDER_COMPLETION",
7139                              "consider using a completion\n" . $herecurr);
7140                 }
7141
7142 # recommend kstrto* over simple_strto* and strict_strto*
7143                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
7144                         WARN("CONSIDER_KSTRTO",
7145                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
7146                 }
7147
7148 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
7149                 if ($line =~ /^.\s*__initcall\s*\(/) {
7150                         WARN("USE_DEVICE_INITCALL",
7151                              "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
7152                 }
7153
7154 # check for spin_is_locked(), suggest lockdep instead
7155                 if ($line =~ /\bspin_is_locked\(/) {
7156                         WARN("USE_LOCKDEP",
7157                              "Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
7158                 }
7159
7160 # check for deprecated apis
7161                 if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
7162                         my $deprecated_api = $1;
7163                         my $new_api = $deprecated_apis{$deprecated_api};
7164                         WARN("DEPRECATED_API",
7165                              "Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
7166                 }
7167
7168 # check for various structs that are normally const (ops, kgdb, device_tree)
7169 # and avoid what seem like struct definitions 'struct foo {'
7170                 if (defined($const_structs) &&
7171                     $line !~ /\bconst\b/ &&
7172                     $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
7173                         WARN("CONST_STRUCT",
7174                              "struct $1 should normally be const\n" . $herecurr);
7175                 }
7176
7177 # use of NR_CPUS is usually wrong
7178 # ignore definitions of NR_CPUS and usage to define arrays as likely right
7179 # ignore designated initializers using NR_CPUS
7180                 if ($line =~ /\bNR_CPUS\b/ &&
7181                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
7182                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
7183                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
7184                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
7185                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/ &&
7186                     $line !~ /^.\s*\.\w+\s*=\s*.*\bNR_CPUS\b/)
7187                 {
7188                         WARN("NR_CPUS",
7189                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
7190                 }
7191
7192 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
7193                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
7194                         ERROR("DEFINE_ARCH_HAS",
7195                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
7196                 }
7197
7198 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
7199                 if ($perl_version_ok &&
7200                     $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
7201                         WARN("LIKELY_MISUSE",
7202                              "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
7203                 }
7204
7205 # return sysfs_emit(foo, fmt, ...) fmt without newline
7206                 if ($line =~ /\breturn\s+sysfs_emit\s*\(\s*$FuncArg\s*,\s*($String)/ &&
7207                     substr($rawline, $-[6], $+[6] - $-[6]) !~ /\\n"$/) {
7208                         my $offset = $+[6] - 1;
7209                         if (WARN("SYSFS_EMIT",
7210                                  "return sysfs_emit(...) formats should include a terminating newline\n" . $herecurr) &&
7211                             $fix) {
7212                                 substr($fixed[$fixlinenr], $offset, 0) = '\\n';
7213                         }
7214                 }
7215
7216 # nested likely/unlikely calls
7217                 if ($line =~ /\b(?:(?:un)?likely)\s*\(\s*!?\s*(IS_ERR(?:_OR_NULL|_VALUE)?|WARN)/) {
7218                         WARN("LIKELY_MISUSE",
7219                              "nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
7220                 }
7221
7222 # whine mightly about in_atomic
7223                 if ($line =~ /\bin_atomic\s*\(/) {
7224                         if ($realfile =~ m@^drivers/@) {
7225                                 ERROR("IN_ATOMIC",
7226                                       "do not use in_atomic in drivers\n" . $herecurr);
7227                         } elsif ($realfile !~ m@^kernel/@) {
7228                                 WARN("IN_ATOMIC",
7229                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
7230                         }
7231                 }
7232
7233 # check for lockdep_set_novalidate_class
7234                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
7235                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
7236                         if ($realfile !~ m@^kernel/lockdep@ &&
7237                             $realfile !~ m@^include/linux/lockdep@ &&
7238                             $realfile !~ m@^drivers/base/core@) {
7239                                 ERROR("LOCKDEP",
7240                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
7241                         }
7242                 }
7243
7244                 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
7245                     $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
7246                         WARN("EXPORTED_WORLD_WRITABLE",
7247                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
7248                 }
7249
7250 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
7251 # and whether or not function naming is typical and if
7252 # DEVICE_ATTR permissions uses are unusual too
7253                 if ($perl_version_ok &&
7254                     defined $stat &&
7255                     $stat =~ /\bDEVICE_ATTR\s*\(\s*(\w+)\s*,\s*\(?\s*(\s*(?:${multi_mode_perms_string_search}|0[0-7]{3,3})\s*)\s*\)?\s*,\s*(\w+)\s*,\s*(\w+)\s*\)/) {
7256                         my $var = $1;
7257                         my $perms = $2;
7258                         my $show = $3;
7259                         my $store = $4;
7260                         my $octal_perms = perms_to_octal($perms);
7261                         if ($show =~ /^${var}_show$/ &&
7262                             $store =~ /^${var}_store$/ &&
7263                             $octal_perms eq "0644") {
7264                                 if (WARN("DEVICE_ATTR_RW",
7265                                          "Use DEVICE_ATTR_RW\n" . $herecurr) &&
7266                                     $fix) {
7267                                         $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
7268                                 }
7269                         } elsif ($show =~ /^${var}_show$/ &&
7270                                  $store =~ /^NULL$/ &&
7271                                  $octal_perms eq "0444") {
7272                                 if (WARN("DEVICE_ATTR_RO",
7273                                          "Use DEVICE_ATTR_RO\n" . $herecurr) &&
7274                                     $fix) {
7275                                         $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
7276                                 }
7277                         } elsif ($show =~ /^NULL$/ &&
7278                                  $store =~ /^${var}_store$/ &&
7279                                  $octal_perms eq "0200") {
7280                                 if (WARN("DEVICE_ATTR_WO",
7281                                          "Use DEVICE_ATTR_WO\n" . $herecurr) &&
7282                                     $fix) {
7283                                         $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
7284                                 }
7285                         } elsif ($octal_perms eq "0644" ||
7286                                  $octal_perms eq "0444" ||
7287                                  $octal_perms eq "0200") {
7288                                 my $newshow = "$show";
7289                                 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
7290                                 my $newstore = $store;
7291                                 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
7292                                 my $rename = "";
7293                                 if ($show ne $newshow) {
7294                                         $rename .= " '$show' to '$newshow'";
7295                                 }
7296                                 if ($store ne $newstore) {
7297                                         $rename .= " '$store' to '$newstore'";
7298                                 }
7299                                 WARN("DEVICE_ATTR_FUNCTIONS",
7300                                      "Consider renaming function(s)$rename\n" . $herecurr);
7301                         } else {
7302                                 WARN("DEVICE_ATTR_PERMS",
7303                                      "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
7304                         }
7305                 }
7306
7307 # Mode permission misuses where it seems decimal should be octal
7308 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
7309 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
7310 #   specific definition of not visible in sysfs.
7311 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
7312 #   use the default permissions
7313                 if ($perl_version_ok &&
7314                     defined $stat &&
7315                     $line =~ /$mode_perms_search/) {
7316                         foreach my $entry (@mode_permission_funcs) {
7317                                 my $func = $entry->[0];
7318                                 my $arg_pos = $entry->[1];
7319
7320                                 my $lc = $stat =~ tr@\n@@;
7321                                 $lc = $lc + $linenr;
7322                                 my $stat_real = get_stat_real($linenr, $lc);
7323
7324                                 my $skip_args = "";
7325                                 if ($arg_pos > 1) {
7326                                         $arg_pos--;
7327                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
7328                                 }
7329                                 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
7330                                 if ($stat =~ /$test/) {
7331                                         my $val = $1;
7332                                         $val = $6 if ($skip_args ne "");
7333                                         if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
7334                                             (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
7335                                              ($val =~ /^$Octal$/ && length($val) ne 4))) {
7336                                                 ERROR("NON_OCTAL_PERMISSIONS",
7337                                                       "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
7338                                         }
7339                                         if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
7340                                                 ERROR("EXPORTED_WORLD_WRITABLE",
7341                                                       "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
7342                                         }
7343                                 }
7344                         }
7345                 }
7346
7347 # check for uses of S_<PERMS> that could be octal for readability
7348                 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
7349                         my $oval = $1;
7350                         my $octal = perms_to_octal($oval);
7351                         if (WARN("SYMBOLIC_PERMS",
7352                                  "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
7353                             $fix) {
7354                                 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
7355                         }
7356                 }
7357
7358 # validate content of MODULE_LICENSE against list from include/linux/module.h
7359                 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
7360                         my $extracted_string = get_quoted_string($line, $rawline);
7361                         my $valid_licenses = qr{
7362                                                 GPL|
7363                                                 GPL\ v2|
7364                                                 GPL\ and\ additional\ rights|
7365                                                 Dual\ BSD/GPL|
7366                                                 Dual\ MIT/GPL|
7367                                                 Dual\ MPL/GPL|
7368                                                 Proprietary
7369                                         }x;
7370                         if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
7371                                 WARN("MODULE_LICENSE",
7372                                      "unknown module license " . $extracted_string . "\n" . $herecurr);
7373                         }
7374                 }
7375
7376 # check for sysctl duplicate constants
7377                 if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
7378                         WARN("DUPLICATED_SYSCTL_CONST",
7379                                 "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
7380                 }
7381         }
7382
7383         # If we have no input at all, then there is nothing to report on
7384         # so just keep quiet.
7385         if ($#rawlines == -1) {
7386                 exit(0);
7387         }
7388
7389         # In mailback mode only produce a report in the negative, for
7390         # things that appear to be patches.
7391         if ($mailback && ($clean == 1 || !$is_patch)) {
7392                 exit(0);
7393         }
7394
7395         # This is not a patch, and we are in 'no-patch' mode so
7396         # just keep quiet.
7397         if (!$chk_patch && !$is_patch) {
7398                 exit(0);
7399         }
7400
7401         if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
7402                 ERROR("NOT_UNIFIED_DIFF",
7403                       "Does not appear to be a unified-diff format patch\n");
7404         }
7405         if ($is_patch && $has_commit_log && $chk_signoff) {
7406                 if ($signoff == 0) {
7407                         ERROR("MISSING_SIGN_OFF",
7408                               "Missing Signed-off-by: line(s)\n");
7409                 } elsif ($authorsignoff != 1) {
7410                         # authorsignoff values:
7411                         # 0 -> missing sign off
7412                         # 1 -> sign off identical
7413                         # 2 -> names and addresses match, comments mismatch
7414                         # 3 -> addresses match, names different
7415                         # 4 -> names match, addresses different
7416                         # 5 -> names match, addresses excluding subaddress details (refer RFC 5233) match
7417
7418                         my $sob_msg = "'From: $author' != 'Signed-off-by: $author_sob'";
7419
7420                         if ($authorsignoff == 0) {
7421                                 ERROR("NO_AUTHOR_SIGN_OFF",
7422                                       "Missing Signed-off-by: line by nominal patch author '$author'\n");
7423                         } elsif ($authorsignoff == 2) {
7424                                 CHK("FROM_SIGN_OFF_MISMATCH",
7425                                     "From:/Signed-off-by: email comments mismatch: $sob_msg\n");
7426                         } elsif ($authorsignoff == 3) {
7427                                 WARN("FROM_SIGN_OFF_MISMATCH",
7428                                      "From:/Signed-off-by: email name mismatch: $sob_msg\n");
7429                         } elsif ($authorsignoff == 4) {
7430                                 WARN("FROM_SIGN_OFF_MISMATCH",
7431                                      "From:/Signed-off-by: email address mismatch: $sob_msg\n");
7432                         } elsif ($authorsignoff == 5) {
7433                                 WARN("FROM_SIGN_OFF_MISMATCH",
7434                                      "From:/Signed-off-by: email subaddress mismatch: $sob_msg\n");
7435                         }
7436                 }
7437         }
7438
7439         print report_dump();
7440         if ($summary && !($clean == 1 && $quiet == 1)) {
7441                 print "$filename " if ($summary_file);
7442                 print "total: $cnt_error errors, $cnt_warn warnings, " .
7443                         (($check)? "$cnt_chk checks, " : "") .
7444                         "$cnt_lines lines checked\n";
7445         }
7446
7447         if ($quiet == 0) {
7448                 # If there were any defects found and not already fixing them
7449                 if (!$clean and !$fix) {
7450                         print << "EOM"
7451
7452 NOTE: For some of the reported defects, checkpatch may be able to
7453       mechanically convert to the typical style using --fix or --fix-inplace.
7454 EOM
7455                 }
7456                 # If there were whitespace errors which cleanpatch can fix
7457                 # then suggest that.
7458                 if ($rpt_cleaners) {
7459                         $rpt_cleaners = 0;
7460                         print << "EOM"
7461
7462 NOTE: Whitespace errors detected.
7463       You may wish to use scripts/cleanpatch or scripts/cleanfile
7464 EOM
7465                 }
7466         }
7467
7468         if ($clean == 0 && $fix &&
7469             ("@rawlines" ne "@fixed" ||
7470              $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
7471                 my $newfile = $filename;
7472                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
7473                 my $linecount = 0;
7474                 my $f;
7475
7476                 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
7477
7478                 open($f, '>', $newfile)
7479                     or die "$P: Can't open $newfile for write\n";
7480                 foreach my $fixed_line (@fixed) {
7481                         $linecount++;
7482                         if ($file) {
7483                                 if ($linecount > 3) {
7484                                         $fixed_line =~ s/^\+//;
7485                                         print $f $fixed_line . "\n";
7486                                 }
7487                         } else {
7488                                 print $f $fixed_line . "\n";
7489                         }
7490                 }
7491                 close($f);
7492
7493                 if (!$quiet) {
7494                         print << "EOM";
7495
7496 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
7497
7498 Do _NOT_ trust the results written to this file.
7499 Do _NOT_ submit these changes without inspecting them for correctness.
7500
7501 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
7502 No warranties, expressed or implied...
7503 EOM
7504                 }
7505         }
7506
7507         if ($quiet == 0) {
7508                 print "\n";
7509                 if ($clean == 1) {
7510                         print "$vname has no obvious style problems and is ready for submission.\n";
7511                 } else {
7512                         print "$vname has style problems, please review.\n";
7513                 }
7514         }
7515         return $clean;
7516 }