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 <[email protected]> (the ugly bit)
   6 # (c) 2007,2008, Andy Whitcroft <[email protected]> (new conditions, test suite)
   7 # (c) 2008-2010 Andy Whitcroft <[email protected]>
   8 # (c) 2010-2018 Joe Perches <[email protected]>
   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 [email protected]" bad
1418                 #   "joe smith <[email protected]" 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                                 # [email protected] or [email protected] 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 # check if this is an unused argument
6045                                 if ($define_stmt !~ /\b$arg\b/) {
6046                                         WARN("MACRO_ARG_UNUSED",
6047                                              "Argument '$arg' is not used in function-like macro\n" . "$herectx");
6048                                 }
6049                         }
6050
6051 # check for macros with flow control, but without ## concatenation
6052 # ## concatenation is commonly a macro that defines a function so ignore those
6053                         if ($has_flow_statement && !$has_arg_concat) {
6054                                 my $cnt = statement_rawlines($ctx);
6055                                 my $herectx = get_stat_here($linenr, $cnt, $here);
6056
6057                                 WARN("MACRO_WITH_FLOW_CONTROL",
6058                                      "Macros with flow control statements should be avoided\n" . "$herectx");
6059                         }
6060
6061 # check for line continuations outside of #defines, preprocessor #, and asm
6062
6063                 } elsif ($realfile =~ m@/vmlinux.lds.h$@) {
6064                     $line =~ s/(\w+)/$maybe_linker_symbol{$1}++/ge;
6065                     #print "REAL: $realfile\nln: $line\nkeys:", sort keys %maybe_linker_symbol;
6066                 } else {
6067                         if ($prevline !~ /^..*\\$/ &&
6068                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
6069                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
6070                             $line =~ /^\+.*\\$/) {
6071                                 WARN("LINE_CONTINUATIONS",
6072                                      "Avoid unnecessary line continuations\n" . $herecurr);
6073                         }
6074                 }
6075
6076 # do {} while (0) macro tests:
6077 # single-statement macros do not need to be enclosed in do while (0) loop,
6078 # macro should not end with a semicolon
6079                 if ($perl_version_ok &&
6080                     $realfile !~ m@/vmlinux.lds.h$@ &&
6081                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
6082                         my $ln = $linenr;
6083                         my $cnt = $realcnt;
6084                         my ($off, $dstat, $dcond, $rest);
6085                         my $ctx = '';
6086                         ($dstat, $dcond, $ln, $cnt, $off) =
6087                                 ctx_statement_block($linenr, $realcnt, 0);
6088                         $ctx = $dstat;
6089
6090                         $dstat =~ s/\\\n.//g;
6091                         $dstat =~ s/$;/ /g;
6092
6093                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
6094                                 my $stmts = $2;
6095                                 my $semis = $3;
6096
6097                                 $ctx =~ s/\n*$//;
6098                                 my $cnt = statement_rawlines($ctx);
6099                                 my $herectx = get_stat_here($linenr, $cnt, $here);
6100
6101                                 if (($stmts =~ tr/;/;/) == 1 &&
6102                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
6103                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
6104                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
6105                                 }
6106                                 if (defined $semis && $semis ne "") {
6107                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
6108                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
6109                                 }
6110                         } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
6111                                 $ctx =~ s/\n*$//;
6112                                 my $cnt = statement_rawlines($ctx);
6113                                 my $herectx = get_stat_here($linenr, $cnt, $here);
6114
6115                                 WARN("TRAILING_SEMICOLON",
6116                                      "macros should not use a trailing semicolon\n" . "$herectx");
6117                         }
6118                 }
6119
6120 # check for redundant bracing round if etc
6121                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
6122                         my ($level, $endln, @chunks) =
6123                                 ctx_statement_full($linenr, $realcnt, 1);
6124                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
6125                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
6126                         if ($#chunks > 0 && $level == 0) {
6127                                 my @allowed = ();
6128                                 my $allow = 0;
6129                                 my $seen = 0;
6130                                 my $herectx = $here . "\n";
6131                                 my $ln = $linenr - 1;
6132                                 for my $chunk (@chunks) {
6133                                         my ($cond, $block) = @{$chunk};
6134
6135                                         # If the condition carries leading newlines, then count those as offsets.
6136                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
6137                                         my $offset = statement_rawlines($whitespace) - 1;
6138
6139                                         $allowed[$allow] = 0;
6140                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
6141
6142                                         # We have looked at and allowed this specific line.
6143                                         $suppress_ifbraces{$ln + $offset} = 1;
6144
6145                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
6146                                         $ln += statement_rawlines($block) - 1;
6147
6148                                         substr($block, 0, length($cond), '');
6149
6150                                         $seen++ if ($block =~ /^\s*{/);
6151
6152                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
6153                                         if (statement_lines($cond) > 1) {
6154                                                 #print "APW: ALLOWED: cond<$cond>\n";
6155                                                 $allowed[$allow] = 1;
6156                                         }
6157                                         if ($block =~/\b(?:if|for|while)\b/) {
6158                                                 #print "APW: ALLOWED: block<$block>\n";
6159                                                 $allowed[$allow] = 1;
6160                                         }
6161                                         if (statement_block_size($block) > 1) {
6162                                                 #print "APW: ALLOWED: lines block<$block>\n";
6163                                                 $allowed[$allow] = 1;
6164                                         }
6165                                         $allow++;
6166                                 }
6167                                 if ($seen) {
6168                                         my $sum_allowed = 0;
6169                                         foreach (@allowed) {
6170                                                 $sum_allowed += $_;
6171                                         }
6172                                         if ($sum_allowed == 0) {
6173                                                 WARN("BRACES",
6174                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
6175                                         } elsif ($sum_allowed != $allow &&
6176                                                  $seen != $allow) {
6177                                                 CHK("BRACES",
6178                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
6179                                         }
6180                                 }
6181                         }
6182                 }
6183                 if (!defined $suppress_ifbraces{$linenr - 1} &&
6184                                         $line =~ /\b(if|while|for|else)\b/) {
6185                         my $allowed = 0;
6186
6187                         # Check the pre-context.
6188                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
6189                                 #print "APW: ALLOWED: pre<$1>\n";
6190                                 $allowed = 1;
6191                         }
6192
6193                         my ($level, $endln, @chunks) =
6194                                 ctx_statement_full($linenr, $realcnt, $-[0]);
6195
6196                         # Check the condition.
6197                         my ($cond, $block) = @{$chunks[0]};
6198                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
6199                         if (defined $cond) {
6200                                 substr($block, 0, length($cond), '');
6201                         }
6202                         if (statement_lines($cond) > 1) {
6203                                 #print "APW: ALLOWED: cond<$cond>\n";
6204                                 $allowed = 1;
6205                         }
6206                         if ($block =~/\b(?:if|for|while)\b/) {
6207                                 #print "APW: ALLOWED: block<$block>\n";
6208                                 $allowed = 1;
6209                         }
6210                         if (statement_block_size($block) > 1) {
6211                                 #print "APW: ALLOWED: lines block<$block>\n";
6212                                 $allowed = 1;
6213                         }
6214                         # Check the post-context.
6215                         if (defined $chunks[1]) {
6216                                 my ($cond, $block) = @{$chunks[1]};
6217                                 if (defined $cond) {
6218                                         substr($block, 0, length($cond), '');
6219                                 }
6220                                 if ($block =~ /^\s*\{/) {
6221                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
6222                                         $allowed = 1;
6223                                 }
6224                         }
6225                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
6226                                 my $cnt = statement_rawlines($block);
6227                                 my $herectx = get_stat_here($linenr, $cnt, $here);
6228
6229                                 WARN("BRACES",
6230                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
6231                         }
6232                 }
6233
6234 # check for single line unbalanced braces
6235                 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
6236                     $sline =~ /^.\s*else\s*\{\s*$/) {
6237                         CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
6238                 }
6239
6240 # check for unnecessary blank lines around braces
6241                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
6242                         if (CHK("BRACES",
6243                                 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
6244                             $fix && $prevrawline =~ /^\+/) {
6245                                 fix_delete_line($fixlinenr - 1, $prevrawline);
6246                         }
6247                 }
6248                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
6249                         if (CHK("BRACES",
6250                                 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
6251                             $fix) {
6252                                 fix_delete_line($fixlinenr, $rawline);
6253                         }
6254                 }
6255
6256 # no volatiles please
6257                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
6258                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
6259                         WARN("VOLATILE",
6260                              "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
6261                 }
6262
6263 # Check for user-visible strings broken across lines, which breaks the ability
6264 # to grep for the string.  Make exceptions when the previous string ends in a
6265 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
6266 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
6267                 if ($line =~ /^\+\s*$String/ &&
6268                     $prevline =~ /"\s*$/ &&
6269                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
6270                         if (WARN("SPLIT_STRING",
6271                                  "quoted string split across lines\n" . $hereprev) &&
6272                                      $fix &&
6273                                      $prevrawline =~ /^\+.*"\s*$/ &&
6274                                      $last_coalesced_string_linenr != $linenr - 1) {
6275                                 my $extracted_string = get_quoted_string($line, $rawline);
6276                                 my $comma_close = "";
6277                                 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
6278                                         $comma_close = $1;
6279                                 }
6280
6281                                 fix_delete_line($fixlinenr - 1, $prevrawline);
6282                                 fix_delete_line($fixlinenr, $rawline);
6283                                 my $fixedline = $prevrawline;
6284                                 $fixedline =~ s/"\s*$//;
6285                                 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
6286                                 fix_insert_line($fixlinenr - 1, $fixedline);
6287                                 $fixedline = $rawline;
6288                                 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
6289                                 if ($fixedline !~ /\+\s*$/) {
6290                                         fix_insert_line($fixlinenr, $fixedline);
6291                                 }
6292                                 $last_coalesced_string_linenr = $linenr;
6293                         }
6294                 }
6295
6296 # check for missing a space in a string concatenation
6297                 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
6298                         WARN('MISSING_SPACE',
6299                              "break quoted strings at a space character\n" . $hereprev);
6300                 }
6301
6302 # check for an embedded function name in a string when the function is known
6303 # This does not work very well for -f --file checking as it depends on patch
6304 # context providing the function name or a single line form for in-file
6305 # function declarations
6306                 if ($line =~ /^\+.*$String/ &&
6307                     defined($context_function) &&
6308                     get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
6309                     length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
6310                         WARN("EMBEDDED_FUNCTION_NAME",
6311                              "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
6312                 }
6313
6314 # check for unnecessary function tracing like uses
6315 # This does not use $logFunctions because there are many instances like
6316 # 'dprintk(FOO, "%s()\n", __func__);' which do not match $logFunctions
6317                 if ($rawline =~ /^\+.*\([^"]*"$tracing_logging_tags{0,3}%s(?:\s*\(\s*\)\s*)?$tracing_logging_tags{0,3}(?:\\n)?"\s*,\s*__func__\s*\)\s*;/) {
6318                         if (WARN("TRACING_LOGGING",
6319                                  "Unnecessary ftrace-like logging - prefer using ftrace\n" . $herecurr) &&
6320                             $fix) {
6321                                 fix_delete_line($fixlinenr, $rawline);
6322                         }
6323                 }
6324
6325 # check for spaces before a quoted newline
6326                 if ($rawline =~ /^.*\".*\s\\n/) {
6327                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
6328                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
6329                             $fix) {
6330                                 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
6331                         }
6332
6333                 }
6334
6335 # concatenated string without spaces between elements
6336                 if ($line =~ /$String[A-Z_]/ ||
6337                     ($line =~ /([A-Za-z0-9_]+)$String/ && $1 !~ /^[Lu]$/)) {
6338                         if (CHK("CONCATENATED_STRING",
6339                                 "Concatenated strings should use spaces between elements\n" . $herecurr) &&
6340                             $fix) {
6341                                 while ($line =~ /($String)/g) {
6342                                         my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6343                                         $fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
6344                                         $fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
6345                                 }
6346                         }
6347                 }
6348
6349 # uncoalesced string fragments
6350                 if ($line =~ /$String\s*[Lu]?"/) {
6351                         if (WARN("STRING_FRAGMENTS",
6352                                  "Consecutive strings are generally better as a single string\n" . $herecurr) &&
6353                             $fix) {
6354                                 while ($line =~ /($String)(?=\s*")/g) {
6355                                         my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6356                                         $fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
6357                                 }
6358                         }
6359                 }
6360
6361 # check for non-standard and hex prefixed decimal printf formats
6362                 my $show_L = 1; #don't show the same defect twice
6363                 my $show_Z = 1;
6364                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
6365                         my $string = substr($rawline, $-[1], $+[1] - $-[1]);
6366                         $string =~ s/%%/__/g;
6367                         # check for %L
6368                         if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
6369                                 WARN("PRINTF_L",
6370                                      "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
6371                                 $show_L = 0;
6372                         }
6373                         # check for %Z
6374                         if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
6375                                 WARN("PRINTF_Z",
6376                                      "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
6377                                 $show_Z = 0;
6378                         }
6379                         # check for 0x<decimal>
6380                         if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
6381                                 ERROR("PRINTF_0XDECIMAL",
6382                                       "Prefixing 0x with decimal output is defective\n" . $herecurr);
6383                         }
6384                 }
6385
6386 # check for line continuations in quoted strings with odd counts of "
6387                 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
6388                         WARN("LINE_CONTINUATIONS",
6389                              "Avoid line continuations in quoted strings\n" . $herecurr);
6390                 }
6391
6392 # warn about #if 0
6393                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
6394                         WARN("IF_0",
6395                              "Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
6396                 }
6397
6398 # warn about #if 1
6399                 if ($line =~ /^.\s*\#\s*if\s+1\b/) {
6400                         WARN("IF_1",
6401                              "Consider removing the #if 1 and its #endif\n" . $herecurr);
6402                 }
6403
6404 # check for needless "if (<foo>) fn(<foo>)" uses
6405                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
6406                         my $tested = quotemeta($1);
6407                         my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
6408                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
6409                                 my $func = $1;
6410                                 if (WARN('NEEDLESS_IF',
6411                                          "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
6412                                     $fix) {
6413                                         my $do_fix = 1;
6414                                         my $leading_tabs = "";
6415                                         my $new_leading_tabs = "";
6416                                         if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
6417                                                 $leading_tabs = $1;
6418                                         } else {
6419                                                 $do_fix = 0;
6420                                         }
6421                                         if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
6422                                                 $new_leading_tabs = $1;
6423                                                 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
6424                                                         $do_fix = 0;
6425                                                 }
6426                                         } else {
6427                                                 $do_fix = 0;
6428                                         }
6429                                         if ($do_fix) {
6430                                                 fix_delete_line($fixlinenr - 1, $prevrawline);
6431                                                 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
6432                                         }
6433                                 }
6434                         }
6435                 }
6436
6437 # check for unnecessary "Out of Memory" messages
6438                 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
6439                     $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
6440                     (defined $1 || defined $3) &&
6441                     $linenr > 3) {
6442                         my $testval = $2;
6443                         my $testline = $lines[$linenr - 3];
6444
6445                         my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
6446 #                       print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
6447
6448                         if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
6449                             $s !~ /\b__GFP_NOWARN\b/ ) {
6450                                 WARN("OOM_MESSAGE",
6451                                      "Possible unnecessary 'out of memory' message\n" . $hereprev);
6452                         }
6453                 }
6454
6455 # check for logging functions with KERN_<LEVEL>
6456                 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
6457                     $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
6458                         my $level = $1;
6459                         if (WARN("UNNECESSARY_KERN_LEVEL",
6460                                  "Possible unnecessary $level\n" . $herecurr) &&
6461                             $fix) {
6462                                 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
6463                         }
6464                 }
6465
6466 # check for logging continuations
6467                 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
6468                         WARN("LOGGING_CONTINUATION",
6469                              "Avoid logging continuation uses where feasible\n" . $herecurr);
6470                 }
6471
6472 # check for unnecessary use of %h[xudi] and %hh[xudi] in logging functions
6473                 if (defined $stat &&
6474                     $line =~ /\b$logFunctions\s*\(/ &&
6475                     index($stat, '"') >= 0) {
6476                         my $lc = $stat =~ tr@\n@@;
6477                         $lc = $lc + $linenr;
6478                         my $stat_real = get_stat_real($linenr, $lc);
6479                         pos($stat_real) = index($stat_real, '"');
6480                         while ($stat_real =~ /[^\"%]*(%[\#\d\.\*\-]*(h+)[idux])/g) {
6481                                 my $pspec = $1;
6482                                 my $h = $2;
6483                                 my $lineoff = substr($stat_real, 0, $-[1]) =~ tr@\n@@;
6484                                 if (WARN("UNNECESSARY_MODIFIER",
6485                                          "Integer promotion: Using '$h' in '$pspec' is unnecessary\n" . "$here\n$stat_real\n") &&
6486                                     $fix && $fixed[$fixlinenr + $lineoff] =~ /^\+/) {
6487                                         my $nspec = $pspec;
6488                                         $nspec =~ s/h//g;
6489                                         $fixed[$fixlinenr + $lineoff] =~ s/\Q$pspec\E/$nspec/;
6490                                 }
6491                         }
6492                 }
6493
6494 # check for mask then right shift without a parentheses
6495                 if ($perl_version_ok &&
6496                     $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
6497                     $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
6498                         WARN("MASK_THEN_SHIFT",
6499                              "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
6500                 }
6501
6502 # check for pointer comparisons to NULL
6503                 if ($perl_version_ok) {
6504                         while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
6505                                 my $val = $1;
6506                                 my $equal = "!";
6507                                 $equal = "" if ($4 eq "!=");
6508                                 if (CHK("COMPARISON_TO_NULL",
6509                                         "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
6510                                             $fix) {
6511                                         $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
6512                                 }
6513                         }
6514                 }
6515
6516 # check for bad placement of section $InitAttribute (e.g.: __initdata)
6517                 if ($line =~ /(\b$InitAttribute\b)/) {
6518                         my $attr = $1;
6519                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
6520                                 my $ptr = $1;
6521                                 my $var = $2;
6522                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
6523                                       ERROR("MISPLACED_INIT",
6524                                             "$attr should be placed after $var\n" . $herecurr)) ||
6525                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
6526                                       WARN("MISPLACED_INIT",
6527                                            "$attr should be placed after $var\n" . $herecurr))) &&
6528                                     $fix) {
6529                                         $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;
6530                                 }
6531                         }
6532                 }
6533
6534 # check for $InitAttributeData (ie: __initdata) with const
6535                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
6536                         my $attr = $1;
6537                         $attr =~ /($InitAttributePrefix)(.*)/;
6538                         my $attr_prefix = $1;
6539                         my $attr_type = $2;
6540                         if (ERROR("INIT_ATTRIBUTE",
6541                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
6542                             $fix) {
6543                                 $fixed[$fixlinenr] =~
6544                                     s/$InitAttributeData/${attr_prefix}initconst/;
6545                         }
6546                 }
6547
6548 # check for $InitAttributeConst (ie: __initconst) without const
6549                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
6550                         my $attr = $1;
6551                         if (ERROR("INIT_ATTRIBUTE",
6552                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
6553                             $fix) {
6554                                 my $lead = $fixed[$fixlinenr] =~
6555                                     /(^\+\s*(?:static\s+))/;
6556                                 $lead = rtrim($1);
6557                                 $lead = "$lead " if ($lead !~ /^\+$/);
6558                                 $lead = "${lead}const ";
6559                                 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
6560                         }
6561                 }
6562
6563 # check for __read_mostly with const non-pointer (should just be const)
6564                 if ($line =~ /\b__read_mostly\b/ &&
6565                     $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
6566                         if (ERROR("CONST_READ_MOSTLY",
6567                                   "Invalid use of __read_mostly with const type\n" . $herecurr) &&
6568                             $fix) {
6569                                 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
6570                         }
6571                 }
6572
6573 # don't use __constant_<foo> functions outside of include/uapi/
6574                 if ($realfile !~ m@^include/uapi/@ &&
6575                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
6576                         my $constant_func = $1;
6577                         my $func = $constant_func;
6578                         $func =~ s/^__constant_//;
6579                         if (WARN("CONSTANT_CONVERSION",
6580                                  "$constant_func should be $func\n" . $herecurr) &&
6581                             $fix) {
6582                                 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
6583                         }
6584                 }
6585
6586 # prefer usleep_range over udelay
6587                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
6588                         my $delay = $1;
6589                         # ignore udelay's < 10, however
6590                         if (! ($delay < 10) ) {
6591                                 CHK("USLEEP_RANGE",
6592                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6593                         }
6594                         if ($delay > 2000) {
6595                                 WARN("LONG_UDELAY",
6596                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
6597                         }
6598                 }
6599
6600 # warn about unexpectedly long msleep's
6601                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
6602                         if ($1 < 20) {
6603                                 WARN("MSLEEP",
6604                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6605                         }
6606                 }
6607
6608 # check for comparisons of jiffies
6609                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
6610                         WARN("JIFFIES_COMPARISON",
6611                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
6612                 }
6613
6614 # check for comparisons of get_jiffies_64()
6615                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
6616                         WARN("JIFFIES_COMPARISON",
6617                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
6618                 }
6619
6620 # warn about #ifdefs in C files
6621 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
6622 #                       print "#ifdef in C files should be avoided\n";
6623 #                       print "$herecurr";
6624 #                       $clean = 0;
6625 #               }
6626
6627 # warn about spacing in #ifdefs
6628                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
6629                         if (ERROR("SPACING",
6630                                   "exactly one space required after that #$1\n" . $herecurr) &&
6631                             $fix) {
6632                                 $fixed[$fixlinenr] =~
6633                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
6634                         }
6635
6636                 }
6637
6638 # check for spinlock_t definitions without a comment.
6639                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
6640                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
6641                         my $which = $1;
6642                         if (!ctx_has_comment($first_line, $linenr)) {
6643                                 CHK("UNCOMMENTED_DEFINITION",
6644                                     "$1 definition without comment\n" . $herecurr);
6645                         }
6646                 }
6647 # check for memory barriers without a comment.
6648
6649                 my $barriers = qr{
6650                         mb|
6651                         rmb|
6652                         wmb
6653                 }x;
6654                 my $barrier_stems = qr{
6655                         mb__before_atomic|
6656                         mb__after_atomic|
6657                         store_release|
6658                         load_acquire|
6659                         store_mb|
6660                         (?:$barriers)
6661                 }x;
6662                 my $all_barriers = qr{
6663                         (?:$barriers)|
6664                         smp_(?:$barrier_stems)|
6665                         virt_(?:$barrier_stems)
6666                 }x;
6667
6668                 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
6669                         if (!ctx_has_comment($first_line, $linenr)) {
6670                                 WARN("MEMORY_BARRIER",
6671                                      "memory barrier without comment\n" . $herecurr);
6672                         }
6673                 }
6674
6675                 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
6676
6677                 if ($realfile !~ m@^include/asm-generic/@ &&
6678                     $realfile !~ m@/barrier\.h$@ &&
6679                     $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
6680                     $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
6681                         WARN("MEMORY_BARRIER",
6682                              "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6683                 }
6684
6685 # check for waitqueue_active without a comment.
6686                 if ($line =~ /\bwaitqueue_active\s*\(/) {
6687                         if (!ctx_has_comment($first_line, $linenr)) {
6688                                 WARN("WAITQUEUE_ACTIVE",
6689                                      "waitqueue_active without comment\n" . $herecurr);
6690                         }
6691                 }
6692
6693 # check for data_race without a comment.
6694                 if ($line =~ /\bdata_race\s*\(/) {
6695                         if (!ctx_has_comment($first_line, $linenr)) {
6696                                 WARN("DATA_RACE",
6697                                      "data_race without comment\n" . $herecurr);
6698                         }
6699                 }
6700
6701 # check of hardware specific defines
6702                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
6703                         CHK("ARCH_DEFINES",
6704                             "architecture specific defines should be avoided\n" .  $herecurr);
6705                 }
6706
6707 # check that the storage class is not after a type
6708                 if ($line =~ /\b($Type)\s+($Storage)\b/) {
6709                         WARN("STORAGE_CLASS",
6710                              "storage class '$2' should be located before type '$1'\n" . $herecurr);
6711                 }
6712 # Check that the storage class is at the beginning of a declaration
6713                 if ($line =~ /\b$Storage\b/ &&
6714                     $line !~ /^.\s*$Storage/ &&
6715                     $line =~ /^.\s*(.+?)\$Storage\s/ &&
6716                     $1 !~ /[\,\)]\s*$/) {
6717                         WARN("STORAGE_CLASS",
6718                              "storage class should be at the beginning of the declaration\n" . $herecurr);
6719                 }
6720
6721 # check the location of the inline attribute, that it is between
6722 # storage class and type.
6723                 if ($line =~ /\b$Type\s+$Inline\b/ ||
6724                     $line =~ /\b$Inline\s+$Storage\b/) {
6725                         ERROR("INLINE_LOCATION",
6726                               "inline keyword should sit between storage class and type\n" . $herecurr);
6727                 }
6728
6729 # Check for __inline__ and __inline, prefer inline
6730                 if ($realfile !~ m@\binclude/uapi/@ &&
6731                     $line =~ /\b(__inline__|__inline)\b/) {
6732                         if (WARN("INLINE",
6733                                  "plain inline is preferred over $1\n" . $herecurr) &&
6734                             $fix) {
6735                                 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
6736
6737                         }
6738                 }
6739
6740 # Check for compiler attributes
6741                 if ($realfile !~ m@\binclude/uapi/@ &&
6742                     $rawline =~ /\b__attribute__\s*\(\s*($balanced_parens)\s*\)/) {
6743                         my $attr = $1;
6744                         $attr =~ s/\s*\(\s*(.*)\)\s*/$1/;
6745
6746                         my %attr_list = (
6747                                 "alias"                         => "__alias",
6748                                 "aligned"                       => "__aligned",
6749                                 "always_inline"                 => "__always_inline",
6750                                 "assume_aligned"                => "__assume_aligned",
6751                                 "cold"                          => "__cold",
6752                                 "const"                         => "__attribute_const__",
6753                                 "copy"                          => "__copy",
6754                                 "designated_init"               => "__designated_init",
6755                                 "externally_visible"            => "__visible",
6756                                 "format"                        => "printf|scanf",
6757                                 "gnu_inline"                    => "__gnu_inline",
6758                                 "malloc"                        => "__malloc",
6759                                 "mode"                          => "__mode",
6760                                 "no_caller_saved_registers"     => "__no_caller_saved_registers",
6761                                 "noclone"                       => "__noclone",
6762                                 "noinline"                      => "noinline",
6763                                 "nonstring"                     => "__nonstring",
6764                                 "noreturn"                      => "__noreturn",
6765                                 "packed"                        => "__packed",
6766                                 "pure"                          => "__pure",
6767                                 "section"                       => "__section",
6768                                 "used"                          => "__used",
6769                                 "weak"                          => "__weak"
6770                         );
6771
6772                         while ($attr =~ /\s*(\w+)\s*(${balanced_parens})?/g) {
6773                                 my $orig_attr = $1;
6774                                 my $params = '';
6775                                 $params = $2 if defined($2);
6776                                 my $curr_attr = $orig_attr;
6777                                 $curr_attr =~ s/^[\s_]+|[\s_]+$//g;
6778                                 if (exists($attr_list{$curr_attr})) {
6779                                         my $new = $attr_list{$curr_attr};
6780                                         if ($curr_attr eq "format" && $params) {
6781                                                 $params =~ /^\s*\(\s*(\w+)\s*,\s*(.*)/;
6782                                                 $new = "__$1\($2";
6783                                         } else {
6784                                                 $new = "$new$params";
6785                                         }
6786                                         if (WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6787                                                  "Prefer $new over __attribute__(($orig_attr$params))\n" . $herecurr) &&
6788                                             $fix) {
6789                                                 my $remove = "\Q$orig_attr\E" . '\s*' . "\Q$params\E" . '(?:\s*,\s*)?';
6790                                                 $fixed[$fixlinenr] =~ s/$remove//;
6791                                                 $fixed[$fixlinenr] =~ s/\b__attribute__/$new __attribute__/;
6792                                                 $fixed[$fixlinenr] =~ s/\}\Q$new\E/} $new/;
6793                                                 $fixed[$fixlinenr] =~ s/ __attribute__\s*\(\s*\(\s*\)\s*\)//;
6794                                         }
6795                                 }
6796                         }
6797
6798                         # Check for __attribute__ unused, prefer __always_unused or __maybe_unused
6799                         if ($attr =~ /^_*unused/) {
6800                                 WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6801                                      "__always_unused or __maybe_unused is preferred over __attribute__((__unused__))\n" . $herecurr);
6802                         }
6803                 }
6804
6805 # Check for __attribute__ weak, or __weak declarations (may have link issues)
6806                 if ($perl_version_ok &&
6807                     $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
6808                     ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
6809                      $line =~ /\b__weak\b/)) {
6810                         ERROR("WEAK_DECLARATION",
6811                               "Using weak declarations can have unintended link defects\n" . $herecurr);
6812                 }
6813
6814 # check for c99 types like uint8_t used outside of uapi/ and tools/
6815                 if ($realfile !~ m@\binclude/uapi/@ &&
6816                     $realfile !~ m@\btools/@ &&
6817                     $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
6818                         my $type = $1;
6819                         if ($type =~ /\b($typeC99Typedefs)\b/) {
6820                                 $type = $1;
6821                                 my $kernel_type = 'u';
6822                                 $kernel_type = 's' if ($type =~ /^_*[si]/);
6823                                 $type =~ /(\d+)/;
6824                                 $kernel_type .= $1;
6825                                 if (CHK("PREFER_KERNEL_TYPES",
6826                                         "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6827                                     $fix) {
6828                                         $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6829                                 }
6830                         }
6831                 }
6832
6833 # check for cast of C90 native int or longer types constants
6834                 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
6835                         my $cast = $1;
6836                         my $const = $2;
6837                         my $suffix = "";
6838                         my $newconst = $const;
6839                         $newconst =~ s/${Int_type}$//;
6840                         $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6841                         if ($cast =~ /\blong\s+long\b/) {
6842                             $suffix .= 'LL';
6843                         } elsif ($cast =~ /\blong\b/) {
6844                             $suffix .= 'L';
6845                         }
6846                         if (WARN("TYPECAST_INT_CONSTANT",
6847                                  "Unnecessary typecast of c90 int constant - '$cast$const' could be '$const$suffix'\n" . $herecurr) &&
6848                             $fix) {
6849                                 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6850                         }
6851                 }
6852
6853 # check for sizeof(&)
6854                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
6855                         WARN("SIZEOF_ADDRESS",
6856                              "sizeof(& should be avoided\n" . $herecurr);
6857                 }
6858
6859 # check for sizeof without parenthesis
6860                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
6861                         if (WARN("SIZEOF_PARENTHESIS",
6862                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6863                             $fix) {
6864                                 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
6865                         }
6866                 }
6867
6868 # check for struct spinlock declarations
6869                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
6870                         WARN("USE_SPINLOCK_T",
6871                              "struct spinlock should be spinlock_t\n" . $herecurr);
6872                 }
6873
6874 # check for seq_printf uses that could be seq_puts
6875                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
6876                         my $fmt = get_quoted_string($line, $rawline);
6877                         $fmt =~ s/%%//g;
6878                         if ($fmt !~ /%/) {
6879                                 if (WARN("PREFER_SEQ_PUTS",
6880                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
6881                                     $fix) {
6882                                         $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6883                                 }
6884                         }
6885                 }
6886
6887 # check for vsprintf extension %p<foo> misuses
6888                 if ($perl_version_ok &&
6889                     defined $stat &&
6890                     $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
6891                     $1 !~ /^_*volatile_*$/) {
6892                         my $stat_real;
6893
6894                         my $lc = $stat =~ tr@\n@@;
6895                         $lc = $lc + $linenr;
6896                         for (my $count = $linenr; $count <= $lc; $count++) {
6897                                 my $specifier;
6898                                 my $extension;
6899                                 my $qualifier;
6900                                 my $bad_specifier = "";
6901                                 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
6902                                 $fmt =~ s/%%//g;
6903
6904                                 while ($fmt =~ /(\%[\*\d\.]*p(\w)(\w*))/g) {
6905                                         $specifier = $1;
6906                                         $extension = $2;
6907                                         $qualifier = $3;
6908                                         if ($extension !~ /[4SsBKRraEehMmIiUDdgVCbGNOxtf]/ ||
6909                                             ($extension eq "f" &&
6910                                              defined $qualifier && $qualifier !~ /^w/) ||
6911                                             ($extension eq "4" &&
6912                                              defined $qualifier && $qualifier !~ /^cc/)) {
6913                                                 $bad_specifier = $specifier;
6914                                                 last;
6915                                         }
6916                                         if ($extension eq "x" && !defined($stat_real)) {
6917                                                 if (!defined($stat_real)) {
6918                                                         $stat_real = get_stat_real($linenr, $lc);
6919                                                 }
6920                                                 WARN("VSPRINTF_SPECIFIER_PX",
6921                                                      "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");
6922                                         }
6923                                 }
6924                                 if ($bad_specifier ne "") {
6925                                         my $stat_real = get_stat_real($linenr, $lc);
6926                                         my $msg_level = \&WARN;
6927                                         my $ext_type = "Invalid";
6928                                         my $use = "";
6929                                         if ($bad_specifier =~ /p[Ff]/) {
6930                                                 $use = " - use %pS instead";
6931                                                 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6932                                         } elsif ($bad_specifier =~ /pA/) {
6933                                                 $use =  " - '%pA' is only intended to be used from Rust code";
6934                                                 $msg_level = \&ERROR;
6935                                         }
6936
6937                                         &{$msg_level}("VSPRINTF_POINTER_EXTENSION",
6938                                                       "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6939                                 }
6940                         }
6941                 }
6942
6943 # Check for misused memsets
6944                 if ($perl_version_ok &&
6945                     defined $stat &&
6946                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
6947
6948                         my $ms_addr = $2;
6949                         my $ms_val = $7;
6950                         my $ms_size = $12;
6951
6952                         if ($ms_size =~ /^(0x|)0$/i) {
6953                                 ERROR("MEMSET",
6954                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6955                         } elsif ($ms_size =~ /^(0x|)1$/i) {
6956                                 WARN("MEMSET",
6957                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6958                         }
6959                 }
6960
6961 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6962 #               if ($perl_version_ok &&
6963 #                   defined $stat &&
6964 #                   $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6965 #                       if (WARN("PREFER_ETHER_ADDR_COPY",
6966 #                                "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6967 #                           $fix) {
6968 #                               $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
6969 #                       }
6970 #               }
6971
6972 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6973 #               if ($perl_version_ok &&
6974 #                   defined $stat &&
6975 #                   $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6976 #                       WARN("PREFER_ETHER_ADDR_EQUAL",
6977 #                            "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6978 #               }
6979
6980 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6981 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
6982 #               if ($perl_version_ok &&
6983 #                   defined $stat &&
6984 #                   $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6985 #
6986 #                       my $ms_val = $7;
6987 #
6988 #                       if ($ms_val =~ /^(?:0x|)0+$/i) {
6989 #                               if (WARN("PREFER_ETH_ZERO_ADDR",
6990 #                                        "Prefer eth_zero_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_zero_addr($2)/;
6993 #                               }
6994 #                       } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
6995 #                               if (WARN("PREFER_ETH_BROADCAST_ADDR",
6996 #                                        "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
6997 #                                   $fix) {
6998 #                                       $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
6999 #                               }
7000 #                       }
7001 #               }
7002
7003 # strcpy uses that should likely be strscpy
7004                 if ($line =~ /\bstrcpy\s*\(/) {
7005                         WARN("STRCPY",
7006                              "Prefer strscpy over strcpy - see: https://github.com/KSPP/linux/issues/88\n" . $herecurr);
7007                 }
7008
7009 # strlcpy uses that should likely be strscpy
7010                 if ($line =~ /\bstrlcpy\s*\(/) {
7011                         WARN("STRLCPY",
7012                              "Prefer strscpy over strlcpy - see: https://github.com/KSPP/linux/issues/89\n" . $herecurr);
7013                 }
7014
7015 # strncpy uses that should likely be strscpy or strscpy_pad
7016                 if ($line =~ /\bstrncpy\s*\(/) {
7017                         WARN("STRNCPY",
7018                              "Prefer strscpy, strscpy_pad, or __nonstring over strncpy - see: https://github.com/KSPP/linux/issues/90\n" . $herecurr);
7019                 }
7020
7021 # ethtool_sprintf uses that should likely be ethtool_puts
7022                 if ($line =~ /\bethtool_sprintf\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
7023                         if (WARN("PREFER_ETHTOOL_PUTS",
7024                                  "Prefer ethtool_puts over ethtool_sprintf with only two arguments\n" . $herecurr) &&
7025                             $fix) {
7026                                 $fixed[$fixlinenr] =~ s/\bethtool_sprintf\s*\(\s*($FuncArg)\s*,\s*($FuncArg)/ethtool_puts($1, $7)/;
7027                         }
7028                 }
7029
7030                 # use $rawline because $line loses %s via sanitization and thus we can't match against it.
7031                 if ($rawline =~ /\bethtool_sprintf\s*\(\s*$FuncArg\s*,\s*\"\%s\"\s*,\s*$FuncArg\s*\)/) {
7032                         if (WARN("PREFER_ETHTOOL_PUTS",
7033                                  "Prefer ethtool_puts over ethtool_sprintf with standalone \"%s\" specifier\n" . $herecurr) &&
7034                             $fix) {
7035                                 $fixed[$fixlinenr] =~ s/\bethtool_sprintf\s*\(\s*($FuncArg)\s*,\s*"\%s"\s*,\s*($FuncArg)/ethtool_puts($1, $7)/;
7036                         }
7037                 }
7038
7039
7040 # typecasts on min/max could be min_t/max_t
7041                 if ($perl_version_ok &&
7042                     defined $stat &&
7043                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
7044                         if (defined $2 || defined $7) {
7045                                 my $call = $1;
7046                                 my $cast1 = deparenthesize($2);
7047                                 my $arg1 = $3;
7048                                 my $cast2 = deparenthesize($7);
7049                                 my $arg2 = $8;
7050                                 my $cast;
7051
7052                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
7053                                         $cast = "$cast1 or $cast2";
7054                                 } elsif ($cast1 ne "") {
7055                                         $cast = $cast1;
7056                                 } else {
7057                                         $cast = $cast2;
7058                                 }
7059                                 WARN("MINMAX",
7060                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
7061                         }
7062                 }
7063
7064 # check usleep_range arguments
7065                 if ($perl_version_ok &&
7066                     defined $stat &&
7067                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
7068                         my $min = $1;
7069                         my $max = $7;
7070                         if ($min eq $max) {
7071                                 WARN("USLEEP_RANGE",
7072                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
7073                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
7074                                  $min > $max) {
7075                                 WARN("USLEEP_RANGE",
7076                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
7077                         }
7078                 }
7079
7080 # check for naked sscanf
7081                 if ($perl_version_ok &&
7082                     defined $stat &&
7083                     $line =~ /\bsscanf\b/ &&
7084                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
7085                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
7086                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
7087                         my $lc = $stat =~ tr@\n@@;
7088                         $lc = $lc + $linenr;
7089                         my $stat_real = get_stat_real($linenr, $lc);
7090                         WARN("NAKED_SSCANF",
7091                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
7092                 }
7093
7094 # check for simple sscanf that should be kstrto<foo>
7095                 if ($perl_version_ok &&
7096                     defined $stat &&
7097                     $line =~ /\bsscanf\b/) {
7098                         my $lc = $stat =~ tr@\n@@;
7099                         $lc = $lc + $linenr;
7100                         my $stat_real = get_stat_real($linenr, $lc);
7101                         if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
7102                                 my $format = $6;
7103                                 my $count = $format =~ tr@%@%@;
7104                                 if ($count == 1 &&
7105                                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
7106                                         WARN("SSCANF_TO_KSTRTO",
7107                                              "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
7108                                 }
7109                         }
7110                 }
7111
7112 # check for new externs in .h files.
7113                 if ($realfile =~ /\.h$/ &&
7114                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
7115                         if (CHK("AVOID_EXTERNS",
7116                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
7117                             $fix) {
7118                                 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
7119                         }
7120                 }
7121
7122 # check for new externs in .c files.
7123                 if ($realfile =~ /\.c$/ && defined $stat &&
7124                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
7125                 {
7126                         my $function_name = $1;
7127                         my $paren_space = $2;
7128
7129                         my $s = $stat;
7130                         if (defined $cond) {
7131                                 substr($s, 0, length($cond), '');
7132                         }
7133                         if ($s =~ /^\s*;/)
7134                         {
7135                                 WARN("AVOID_EXTERNS",
7136                                      "externs should be avoided in .c files\n" .  $herecurr);
7137                         }
7138
7139                         if ($paren_space =~ /\n/) {
7140                                 WARN("FUNCTION_ARGUMENTS",
7141                                      "arguments for function declarations should follow identifier\n" . $herecurr);
7142                         }
7143
7144                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
7145                     $stat =~ /^\+extern struct\s+(\w+)\s+(\w+)\[\];/)
7146                 {
7147                         my ($st_type, $st_name) = ($1, $2);
7148
7149                         for my $s (keys %maybe_linker_symbol) {
7150                             #print "Linker symbol? $st_name : $s\n";
7151                             goto LIKELY_LINKER_SYMBOL
7152                                 if $st_name =~ /$s/;
7153                         }
7154                         WARN("AVOID_EXTERNS",
7155                              "found a file-scoped extern type:$st_type name:$st_name in .c file\n"
7156                              . "is this a linker symbol ?\n" . $herecurr);
7157                   LIKELY_LINKER_SYMBOL:
7158
7159                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
7160                     $stat =~ /^.\s*extern\s+/)
7161                 {
7162                         WARN("AVOID_EXTERNS",
7163                              "externs should be avoided in .c files\n" .  $herecurr);
7164                 }
7165
7166 # check for function declarations that have arguments without identifier names
7167                 if (defined $stat &&
7168                     $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
7169                     $1 ne "void") {
7170                         my $args = trim($1);
7171                         while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
7172                                 my $arg = trim($1);
7173                                 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
7174                                         WARN("FUNCTION_ARGUMENTS",
7175                                              "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
7176                                 }
7177                         }
7178                 }
7179
7180 # check for function definitions
7181                 if ($perl_version_ok &&
7182                     defined $stat &&
7183                     $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
7184                         $context_function = $1;
7185
7186 # check for multiline function definition with misplaced open brace
7187                         my $ok = 0;
7188                         my $cnt = statement_rawlines($stat);
7189                         my $herectx = $here . "\n";
7190                         for (my $n = 0; $n < $cnt; $n++) {
7191                                 my $rl = raw_line($linenr, $n);
7192                                 $herectx .=  $rl . "\n";
7193                                 $ok = 1 if ($rl =~ /^[ \+]\{/);
7194                                 $ok = 1 if ($rl =~ /\{/ && $n == 0);
7195                                 last if $rl =~ /^[ \+].*\{/;
7196                         }
7197                         if (!$ok) {
7198                                 ERROR("OPEN_BRACE",
7199                                       "open brace '{' following function definitions go on the next line\n" . $herectx);
7200                         }
7201                 }
7202
7203 # checks for new __setup's
7204                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
7205                         my $name = $1;
7206
7207                         if (!grep(/$name/, @setup_docs)) {
7208                                 CHK("UNDOCUMENTED_SETUP",
7209                                     "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
7210                         }
7211                 }
7212
7213 # check for pointless casting of alloc functions
7214                 if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
7215                         WARN("UNNECESSARY_CASTS",
7216                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
7217                 }
7218
7219 # alloc style
7220 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
7221                 if ($perl_version_ok &&
7222                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
7223                         CHK("ALLOC_SIZEOF_STRUCT",
7224                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
7225                 }
7226
7227 # check for (kv|k)[mz]alloc with multiplies that could be kmalloc_array/kvmalloc_array/kvcalloc/kcalloc
7228                 if ($perl_version_ok &&
7229                     defined $stat &&
7230                     $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k)[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
7231                         my $oldfunc = $3;
7232                         my $a1 = $4;
7233                         my $a2 = $10;
7234                         my $newfunc = "kmalloc_array";
7235                         $newfunc = "kvmalloc_array" if ($oldfunc eq "kvmalloc");
7236                         $newfunc = "kvcalloc" if ($oldfunc eq "kvzalloc");
7237                         $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
7238                         my $r1 = $a1;
7239                         my $r2 = $a2;
7240                         if ($a1 =~ /^sizeof\s*\S/) {
7241                                 $r1 = $a2;
7242                                 $r2 = $a1;
7243                         }
7244                         if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
7245                             !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
7246                                 my $cnt = statement_rawlines($stat);
7247                                 my $herectx = get_stat_here($linenr, $cnt, $here);
7248
7249                                 if (WARN("ALLOC_WITH_MULTIPLY",
7250                                          "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
7251                                     $cnt == 1 &&
7252                                     $fix) {
7253                                         $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;
7254                                 }
7255                         }
7256                 }
7257
7258 # check for krealloc arg reuse
7259                 if ($perl_version_ok &&
7260                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*($Lval)\s*,/ &&
7261                     $1 eq $3) {
7262                         WARN("KREALLOC_ARG_REUSE",
7263                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
7264                 }
7265
7266 # check for alloc argument mismatch
7267                 if ($line =~ /\b((?:devm_)?((?:k|kv)?(calloc|malloc_array)(?:_node)?))\s*\(\s*sizeof\b/) {
7268                         WARN("ALLOC_ARRAY_ARGS",
7269                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
7270                 }
7271
7272 # check for multiple semicolons
7273                 if ($line =~ /;\s*;\s*$/) {
7274                         if (WARN("ONE_SEMICOLON",
7275                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
7276                             $fix) {
7277                                 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
7278                         }
7279                 }
7280
7281 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
7282                 if ($realfile !~ m@^include/uapi/@ &&
7283                     $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
7284                         my $ull = "";
7285                         $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
7286                         if (CHK("BIT_MACRO",
7287                                 "Prefer using the BIT$ull macro\n" . $herecurr) &&
7288                             $fix) {
7289                                 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
7290                         }
7291                 }
7292
7293 # check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
7294                 if ($rawline =~ /\bIS_ENABLED\s*\(\s*(\w+)\s*\)/ && $1 !~ /^${CONFIG_}/) {
7295                         WARN("IS_ENABLED_CONFIG",
7296                              "IS_ENABLED($1) is normally used as IS_ENABLED(${CONFIG_}$1)\n" . $herecurr);
7297                 }
7298
7299 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
7300                 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(${CONFIG_}[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
7301                         my $config = $1;
7302                         if (WARN("PREFER_IS_ENABLED",
7303                                  "Prefer IS_ENABLED(<FOO>) to ${CONFIG_}<FOO> || ${CONFIG_}<FOO>_MODULE\n" . $herecurr) &&
7304                             $fix) {
7305                                 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
7306                         }
7307                 }
7308
7309 # check for /* fallthrough */ like comment, prefer fallthrough;
7310                 my @fallthroughs = (
7311                         'fallthrough',
7312                         '@fallthrough@',
7313                         'lint -fallthrough[ \t]*',
7314                         'intentional(?:ly)?[ \t]*fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)',
7315                         '(?:else,?\s*)?FALL(?:S | |-)?THR(?:OUGH|U|EW)[ \t.!]*(?:-[^\n\r]*)?',
7316                         'Fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7317                         'fall(?:s | |-)?thr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7318                     );
7319                 if ($raw_comment ne '') {
7320                         foreach my $ft (@fallthroughs) {
7321                                 if ($raw_comment =~ /$ft/) {
7322                                         my $msg_level = \&WARN;
7323                                         $msg_level = \&CHK if ($file);
7324                                         &{$msg_level}("PREFER_FALLTHROUGH",
7325                                                       "Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
7326                                         last;
7327                                 }
7328                         }
7329                 }
7330
7331 # check for switch/default statements without a break;
7332                 if ($perl_version_ok &&
7333                     defined $stat &&
7334                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
7335                         my $cnt = statement_rawlines($stat);
7336                         my $herectx = get_stat_here($linenr, $cnt, $here);
7337
7338                         WARN("DEFAULT_NO_BREAK",
7339                              "switch default: should use break\n" . $herectx);
7340                 }
7341
7342 # check for gcc specific __FUNCTION__
7343                 if ($line =~ /\b__FUNCTION__\b/) {
7344                         if (WARN("USE_FUNC",
7345                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
7346                             $fix) {
7347                                 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
7348                         }
7349                 }
7350
7351 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
7352                 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
7353                         ERROR("DATE_TIME",
7354                               "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
7355                 }
7356
7357 # check for use of yield()
7358                 if ($line =~ /\byield\s*\(\s*\)/) {
7359                         WARN("YIELD",
7360                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
7361                 }
7362
7363 # check for comparisons against true and false
7364                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
7365                         my $lead = $1;
7366                         my $arg = $2;
7367                         my $test = $3;
7368                         my $otype = $4;
7369                         my $trail = $5;
7370                         my $op = "!";
7371
7372                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
7373
7374                         my $type = lc($otype);
7375                         if ($type =~ /^(?:true|false)$/) {
7376                                 if (("$test" eq "==" && "$type" eq "true") ||
7377                                     ("$test" eq "!=" && "$type" eq "false")) {
7378                                         $op = "";
7379                                 }
7380
7381                                 CHK("BOOL_COMPARISON",
7382                                     "Using comparison to $otype is error prone\n" . $herecurr);
7383
7384 ## maybe suggesting a correct construct would better
7385 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
7386
7387                         }
7388                 }
7389
7390 # check for semaphores initialized locked
7391                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
7392                         WARN("CONSIDER_COMPLETION",
7393                              "consider using a completion\n" . $herecurr);
7394                 }
7395
7396 # recommend kstrto* over simple_strto* and strict_strto*
7397                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
7398                         WARN("CONSIDER_KSTRTO",
7399                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
7400                 }
7401
7402 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
7403                 if ($line =~ /^.\s*__initcall\s*\(/) {
7404                         WARN("USE_DEVICE_INITCALL",
7405                              "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
7406                 }
7407
7408 # check for spin_is_locked(), suggest lockdep instead
7409                 if ($line =~ /\bspin_is_locked\(/) {
7410                         WARN("USE_LOCKDEP",
7411                              "Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
7412                 }
7413
7414 # check for deprecated apis
7415                 if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
7416                         my $deprecated_api = $1;
7417                         my $new_api = $deprecated_apis{$deprecated_api};
7418                         WARN("DEPRECATED_API",
7419                              "Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
7420                 }
7421
7422 # check for various structs that are normally const (ops, kgdb, device_tree)
7423 # and avoid what seem like struct definitions 'struct foo {'
7424                 if (defined($const_structs) &&
7425                     $line !~ /\bconst\b/ &&
7426                     $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
7427                         WARN("CONST_STRUCT",
7428                              "struct $1 should normally be const\n" . $herecurr);
7429                 }
7430
7431 # use of NR_CPUS is usually wrong
7432 # ignore definitions of NR_CPUS and usage to define arrays as likely right
7433 # ignore designated initializers using NR_CPUS
7434                 if ($line =~ /\bNR_CPUS\b/ &&
7435                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
7436                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
7437                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
7438                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
7439                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/ &&
7440                     $line !~ /^.\s*\.\w+\s*=\s*.*\bNR_CPUS\b/)
7441                 {
7442                         WARN("NR_CPUS",
7443                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
7444                 }
7445
7446 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
7447                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
7448                         ERROR("DEFINE_ARCH_HAS",
7449                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
7450                 }
7451
7452 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
7453                 if ($perl_version_ok &&
7454                     $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
7455                         WARN("LIKELY_MISUSE",
7456                              "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
7457                 }
7458
7459 # return sysfs_emit(foo, fmt, ...) fmt without newline
7460                 if ($line =~ /\breturn\s+sysfs_emit\s*\(\s*$FuncArg\s*,\s*($String)/ &&
7461                     substr($rawline, $-[6], $+[6] - $-[6]) !~ /\\n"$/) {
7462                         my $offset = $+[6] - 1;
7463                         if (WARN("SYSFS_EMIT",
7464                                  "return sysfs_emit(...) formats should include a terminating newline\n" . $herecurr) &&
7465                             $fix) {
7466                                 substr($fixed[$fixlinenr], $offset, 0) = '\\n';
7467                         }
7468                 }
7469
7470 # check for array definition/declarations that should use flexible arrays instead
7471                 if ($sline =~ /^[\+ ]\s*\}(?:\s*__packed)?\s*;\s*$/ &&
7472                     $prevline =~ /^\+\s*(?:\}(?:\s*__packed\s*)?|$Type)\s*$Ident\s*\[\s*(0|1)\s*\]\s*;\s*$/) {
7473                         if (ERROR("FLEXIBLE_ARRAY",
7474                                   "Use C99 flexible arrays - see https://docs.kernel.org/process/deprecated.html#zero-length-and-one-element-arrays\n" . $hereprev) &&
7475                             $1 == '0' && $fix) {
7476                                 $fixed[$fixlinenr - 1] =~ s/\[\s*0\s*\]/[]/;
7477                         }
7478                 }
7479
7480 # nested likely/unlikely calls
7481                 if ($line =~ /\b(?:(?:un)?likely)\s*\(\s*!?\s*(IS_ERR(?:_OR_NULL|_VALUE)?|WARN)/) {
7482                         WARN("LIKELY_MISUSE",
7483                              "nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
7484                 }
7485
7486 # whine mightly about in_atomic
7487                 if ($line =~ /\bin_atomic\s*\(/) {
7488                         if ($realfile =~ m@^drivers/@) {
7489                                 ERROR("IN_ATOMIC",
7490                                       "do not use in_atomic in drivers\n" . $herecurr);
7491                         } elsif ($realfile !~ m@^kernel/@) {
7492                                 WARN("IN_ATOMIC",
7493                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
7494                         }
7495                 }
7496
7497 # Complain about RCU Tasks Trace used outside of BPF (and of course, RCU).
7498                 our $rcu_trace_funcs = qr{(?x:
7499                         rcu_read_lock_trace |
7500                         rcu_read_lock_trace_held |
7501                         rcu_read_unlock_trace |
7502                         call_rcu_tasks_trace |
7503                         synchronize_rcu_tasks_trace |
7504                         rcu_barrier_tasks_trace |
7505                         rcu_request_urgent_qs_task
7506                 )};
7507                 our $rcu_trace_paths = qr{(?x:
7508                         kernel/bpf/ |
7509                         include/linux/bpf |
7510                         net/bpf/ |
7511                         kernel/rcu/ |
7512                         include/linux/rcu
7513                 )};
7514                 if ($line =~ /\b($rcu_trace_funcs)\s*\(/) {
7515                         if ($realfile !~ m{^$rcu_trace_paths}) {
7516                                 WARN("RCU_TASKS_TRACE",
7517                                      "use of RCU tasks trace is incorrect outside BPF or core RCU code\n" . $herecurr);
7518                         }
7519                 }
7520
7521 # check for lockdep_set_novalidate_class
7522                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
7523                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
7524                         if ($realfile !~ m@^kernel/lockdep@ &&
7525                             $realfile !~ m@^include/linux/lockdep@ &&
7526                             $realfile !~ m@^drivers/base/core@) {
7527                                 ERROR("LOCKDEP",
7528                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
7529                         }
7530                 }
7531
7532                 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
7533                     $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
7534                         WARN("EXPORTED_WORLD_WRITABLE",
7535                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
7536                 }
7537
7538 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
7539 # and whether or not function naming is typical and if
7540 # DEVICE_ATTR permissions uses are unusual too
7541                 if ($perl_version_ok &&
7542                     defined $stat &&
7543                     $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*\)/) {
7544                         my $var = $1;
7545                         my $perms = $2;
7546                         my $show = $3;
7547                         my $store = $4;
7548                         my $octal_perms = perms_to_octal($perms);
7549                         if ($show =~ /^${var}_show$/ &&
7550                             $store =~ /^${var}_store$/ &&
7551                             $octal_perms eq "0644") {
7552                                 if (WARN("DEVICE_ATTR_RW",
7553                                          "Use DEVICE_ATTR_RW\n" . $herecurr) &&
7554                                     $fix) {
7555                                         $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
7556                                 }
7557                         } elsif ($show =~ /^${var}_show$/ &&
7558                                  $store =~ /^NULL$/ &&
7559                                  $octal_perms eq "0444") {
7560                                 if (WARN("DEVICE_ATTR_RO",
7561                                          "Use DEVICE_ATTR_RO\n" . $herecurr) &&
7562                                     $fix) {
7563                                         $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
7564                                 }
7565                         } elsif ($show =~ /^NULL$/ &&
7566                                  $store =~ /^${var}_store$/ &&
7567                                  $octal_perms eq "0200") {
7568                                 if (WARN("DEVICE_ATTR_WO",
7569                                          "Use DEVICE_ATTR_WO\n" . $herecurr) &&
7570                                     $fix) {
7571                                         $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
7572                                 }
7573                         } elsif ($octal_perms eq "0644" ||
7574                                  $octal_perms eq "0444" ||
7575                                  $octal_perms eq "0200") {
7576                                 my $newshow = "$show";
7577                                 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
7578                                 my $newstore = $store;
7579                                 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
7580                                 my $rename = "";
7581                                 if ($show ne $newshow) {
7582                                         $rename .= " '$show' to '$newshow'";
7583                                 }
7584                                 if ($store ne $newstore) {
7585                                         $rename .= " '$store' to '$newstore'";
7586                                 }
7587                                 WARN("DEVICE_ATTR_FUNCTIONS",
7588                                      "Consider renaming function(s)$rename\n" . $herecurr);
7589                         } else {
7590                                 WARN("DEVICE_ATTR_PERMS",
7591                                      "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
7592                         }
7593                 }
7594
7595 # Mode permission misuses where it seems decimal should be octal
7596 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
7597 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
7598 #   specific definition of not visible in sysfs.
7599 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
7600 #   use the default permissions
7601                 if ($perl_version_ok &&
7602                     defined $stat &&
7603                     $line =~ /$mode_perms_search/) {
7604                         foreach my $entry (@mode_permission_funcs) {
7605                                 my $func = $entry->[0];
7606                                 my $arg_pos = $entry->[1];
7607
7608                                 my $lc = $stat =~ tr@\n@@;
7609                                 $lc = $lc + $linenr;
7610                                 my $stat_real = get_stat_real($linenr, $lc);
7611
7612                                 my $skip_args = "";
7613                                 if ($arg_pos > 1) {
7614                                         $arg_pos--;
7615                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
7616                                 }
7617                                 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
7618                                 if ($stat =~ /$test/) {
7619                                         my $val = $1;
7620                                         $val = $6 if ($skip_args ne "");
7621                                         if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
7622                                             (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
7623                                              ($val =~ /^$Octal$/ && length($val) ne 4))) {
7624                                                 ERROR("NON_OCTAL_PERMISSIONS",
7625                                                       "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
7626                                         }
7627                                         if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
7628                                                 ERROR("EXPORTED_WORLD_WRITABLE",
7629                                                       "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
7630                                         }
7631                                 }
7632                         }
7633                 }
7634
7635 # check for uses of S_<PERMS> that could be octal for readability
7636                 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
7637                         my $oval = $1;
7638                         my $octal = perms_to_octal($oval);
7639                         if (WARN("SYMBOLIC_PERMS",
7640                                  "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
7641                             $fix) {
7642                                 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
7643                         }
7644                 }
7645
7646 # validate content of MODULE_LICENSE against list from include/linux/module.h
7647                 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
7648                         my $extracted_string = get_quoted_string($line, $rawline);
7649                         my $valid_licenses = qr{
7650                                                 GPL|
7651                                                 GPL\ v2|
7652                                                 GPL\ and\ additional\ rights|
7653                                                 Dual\ BSD/GPL|
7654                                                 Dual\ MIT/GPL|
7655                                                 Dual\ MPL/GPL|
7656                                                 Proprietary
7657                                         }x;
7658                         if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
7659                                 WARN("MODULE_LICENSE",
7660                                      "unknown module license " . $extracted_string . "\n" . $herecurr);
7661                         }
7662                         if (!$file && $extracted_string eq '"GPL v2"') {
7663                                 if (WARN("MODULE_LICENSE",
7664                                      "Prefer \"GPL\" over \"GPL v2\" - see commit bf7fbeeae6db (\"module: Cure the MODULE_LICENSE \"GPL\" vs. \"GPL v2\" bogosity\")\n" . $herecurr) &&
7665                                     $fix) {
7666                                         $fixed[$fixlinenr] =~ s/\bMODULE_LICENSE\s*\(\s*"GPL v2"\s*\)/MODULE_LICENSE("GPL")/;
7667                                 }
7668                         }
7669                 }
7670
7671 # check for sysctl duplicate constants
7672                 if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
7673                         WARN("DUPLICATED_SYSCTL_CONST",
7674                                 "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
7675                 }
7676         }
7677
7678         # If we have no input at all, then there is nothing to report on
7679         # so just keep quiet.
7680         if ($#rawlines == -1) {
7681                 exit(0);
7682         }
7683
7684         # In mailback mode only produce a report in the negative, for
7685         # things that appear to be patches.
7686         if ($mailback && ($clean == 1 || !$is_patch)) {
7687                 exit(0);
7688         }
7689
7690         # This is not a patch, and we are in 'no-patch' mode so
7691         # just keep quiet.
7692         if (!$chk_patch && !$is_patch) {
7693                 exit(0);
7694         }
7695
7696         if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
7697                 ERROR("NOT_UNIFIED_DIFF",
7698                       "Does not appear to be a unified-diff format patch\n");
7699         }
7700         if ($is_patch && $has_commit_log && $chk_signoff) {
7701                 if ($signoff == 0) {
7702                         ERROR("MISSING_SIGN_OFF",
7703                               "Missing Signed-off-by: line(s)\n");
7704                 } elsif ($authorsignoff != 1) {
7705                         # authorsignoff values:
7706                         # 0 -> missing sign off
7707                         # 1 -> sign off identical
7708                         # 2 -> names and addresses match, comments mismatch
7709                         # 3 -> addresses match, names different
7710                         # 4 -> names match, addresses different
7711                         # 5 -> names match, addresses excluding subaddress details (refer RFC 5233) match
7712
7713                         my $sob_msg = "'From: $author' != 'Signed-off-by: $author_sob'";
7714
7715                         if ($authorsignoff == 0) {
7716                                 ERROR("NO_AUTHOR_SIGN_OFF",
7717                                       "Missing Signed-off-by: line by nominal patch author '$author'\n");
7718                         } elsif ($authorsignoff == 2) {
7719                                 CHK("FROM_SIGN_OFF_MISMATCH",
7720                                     "From:/Signed-off-by: email comments mismatch: $sob_msg\n");
7721                         } elsif ($authorsignoff == 3) {
7722                                 WARN("FROM_SIGN_OFF_MISMATCH",
7723                                      "From:/Signed-off-by: email name mismatch: $sob_msg\n");
7724                         } elsif ($authorsignoff == 4) {
7725                                 WARN("FROM_SIGN_OFF_MISMATCH",
7726                                      "From:/Signed-off-by: email address mismatch: $sob_msg\n");
7727                         } elsif ($authorsignoff == 5) {
7728                                 WARN("FROM_SIGN_OFF_MISMATCH",
7729                                      "From:/Signed-off-by: email subaddress mismatch: $sob_msg\n");
7730                         }
7731                 }
7732         }
7733
7734         print report_dump();
7735         if ($summary && !($clean == 1 && $quiet == 1)) {
7736                 print "$filename " if ($summary_file);
7737                 print "total: $cnt_error errors, $cnt_warn warnings, " .
7738                         (($check)? "$cnt_chk checks, " : "") .
7739                         "$cnt_lines lines checked\n";
7740         }
7741
7742         if ($quiet == 0) {
7743                 # If there were any defects found and not already fixing them
7744                 if (!$clean and !$fix) {
7745                         print << "EOM"
7746
7747 NOTE: For some of the reported defects, checkpatch may be able to
7748       mechanically convert to the typical style using --fix or --fix-inplace.
7749 EOM
7750                 }
7751                 # If there were whitespace errors which cleanpatch can fix
7752                 # then suggest that.
7753                 if ($rpt_cleaners) {
7754                         $rpt_cleaners = 0;
7755                         print << "EOM"
7756
7757 NOTE: Whitespace errors detected.
7758       You may wish to use scripts/cleanpatch or scripts/cleanfile
7759 EOM
7760                 }
7761         }
7762
7763         if ($clean == 0 && $fix &&
7764             ("@rawlines" ne "@fixed" ||
7765              $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
7766                 my $newfile = $filename;
7767                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
7768                 my $linecount = 0;
7769                 my $f;
7770
7771                 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
7772
7773                 open($f, '>', $newfile)
7774                     or die "$P: Can't open $newfile for write\n";
7775                 foreach my $fixed_line (@fixed) {
7776                         $linecount++;
7777                         if ($file) {
7778                                 if ($linecount > 3) {
7779                                         $fixed_line =~ s/^\+//;
7780                                         print $f $fixed_line . "\n";
7781                                 }
7782                         } else {
7783                                 print $f $fixed_line . "\n";
7784                         }
7785                 }
7786                 close($f);
7787
7788                 if (!$quiet) {
7789                         print << "EOM";
7790
7791 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
7792
7793 Do _NOT_ trust the results written to this file.
7794 Do _NOT_ submit these changes without inspecting them for correctness.
7795
7796 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
7797 No warranties, expressed or implied...
7798 EOM
7799                 }
7800         }
7801
7802         if ($quiet == 0) {
7803                 print "\n";
7804                 if ($clean == 1) {
7805                         print "$vname has no obvious style problems and is ready for submission.\n";
7806                 } else {
7807                         print "$vname has style problems, please review.\n";
7808                 }
7809         }
7810         return $clean;
7811 }