scripts/checkpatch.pl

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