scripts/checkpatch.pl

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