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