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