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