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