scripts/checkpatch.pl

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