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