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