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