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 for line lengths > 75 in commit log, warn once
2317                 if ($in_commit_log && !$commit_log_long_line &&
2318                    length($line) > 75 &&
2319                    !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2320                                        # file delta changes
2321                      $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2322                                        # filename then :
2323                      $line =~ /^\s*(?:Fixes:|Link:)/i ||
2324                                        # A Fixes: or Link: line
2325                      $commit_log_possible_stack_dump)) {
2326                         WARN("COMMIT_LOG_LONG_LINE",
2327                              "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2328                         $commit_log_long_line = 1;
2329                 }
2330
2331 # Check if the commit log is in a possible stack dump
2332                if ($in_commit_log && !$commit_log_possible_stack_dump &&
2333                    ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2334                     $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2335                                # timestamp
2336                     $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2337                                # stack dump address
2338                        $commit_log_possible_stack_dump = 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 &&
2349                     ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2350                     ($line =~ /\b[0-9a-f]{12,40}\b/i &&
2351                      $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2352                         my $init_char = "c";
2353                         my $orig_commit = "";
2354                         my $short = 1;
2355                         my $long = 0;
2356                         my $case = 1;
2357                         my $space = 1;
2358                         my $hasdesc = 0;
2359                         my $hasparens = 0;
2360                         my $id = '0123456789ab';
2361                         my $orig_desc = "commit description";
2362                         my $description = "";
2363
2364                         if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2365                                 $init_char = $1;
2366                                 $orig_commit = lc($2);
2367                         } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2368                                 $orig_commit = lc($1);
2369                         }
2370
2371                         $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2372                         $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2373                         $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2374                         $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2375                         if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2376                                 $orig_desc = $1;
2377                                 $hasparens = 1;
2378                         } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2379                                  defined $rawlines[$linenr] &&
2380                                  $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2381                                 $orig_desc = $1;
2382                                 $hasparens = 1;
2383                         } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2384                                  defined $rawlines[$linenr] &&
2385                                  $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2386                                 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2387                                 $orig_desc = $1;
2388                                 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2389                                 $orig_desc .= " " . $1;
2390                                 $hasparens = 1;
2391                         }
2392
2393                         ($id, $description) = git_commit_info($orig_commit,
2394                                                               $id, $orig_desc);
2395
2396                         if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
2397                                 ERROR("GIT_COMMIT_ID",
2398                                       "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2399                         }
2400                 }
2401
2402 # Check for added, moved or deleted files
2403                 if (!$reported_maintainer_file && !$in_commit_log &&
2404                     ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2405                      $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2406                      ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2407                       (defined($1) || defined($2))))) {
2408                         $reported_maintainer_file = 1;
2409                         WARN("FILE_PATH_CHANGES",
2410                              "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2411                 }
2412
2413 # Check for wrappage within a valid hunk of the file
2414                 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2415                         ERROR("CORRUPTED_PATCH",
2416                               "patch seems to be corrupt (line wrapped?)\n" .
2417                                 $herecurr) if (!$emitted_corrupt++);
2418                 }
2419
2420 # Check for absolute kernel paths.
2421                 if ($tree) {
2422                         while ($line =~ m{(?:^|\s)(/\S*)}g) {
2423                                 my $file = $1;
2424
2425                                 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2426                                     check_absolute_file($1, $herecurr)) {
2427                                         #
2428                                 } else {
2429                                         check_absolute_file($file, $herecurr);
2430                                 }
2431                         }
2432                 }
2433
2434 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2435                 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2436                     $rawline !~ m/^$UTF8*$/) {
2437                         my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2438
2439                         my $blank = copy_spacing($rawline);
2440                         my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2441                         my $hereptr = "$hereline$ptr\n";
2442
2443                         CHK("INVALID_UTF8",
2444                             "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2445                 }
2446
2447 # Check if it's the start of a commit log
2448 # (not a header line and we haven't seen the patch filename)
2449                 if ($in_header_lines && $realfile =~ /^$/ &&
2450                     !($rawline =~ /^\s+\S/ ||
2451                       $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2452                         $in_header_lines = 0;
2453                         $in_commit_log = 1;
2454                 }
2455
2456 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2457 # declined it, i.e defined some charset where it is missing.
2458                 if ($in_header_lines &&
2459                     $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2460                     $1 !~ /utf-8/i) {
2461                         $non_utf8_charset = 1;
2462                 }
2463
2464                 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2465                     $rawline =~ /$NON_ASCII_UTF8/) {
2466                         WARN("UTF8_BEFORE_PATCH",
2467                             "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2468                 }
2469
2470 # Check for various typo / spelling mistakes
2471                 if (defined($misspellings) &&
2472                     ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2473                         while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2474                                 my $typo = $1;
2475                                 my $typo_fix = $spelling_fix{lc($typo)};
2476                                 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2477                                 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2478                                 my $msg_type = \&WARN;
2479                                 $msg_type = \&CHK if ($file);
2480                                 if (&{$msg_type}("TYPO_SPELLING",
2481                                                  "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2482                                     $fix) {
2483                                         $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2484                                 }
2485                         }
2486                 }
2487
2488 # ignore non-hunk lines and lines being removed
2489                 next if (!$hunk_line || $line =~ /^-/);
2490
2491 #trailing whitespace
2492                 if ($line =~ /^\+.*\015/) {
2493                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2494                         if (ERROR("DOS_LINE_ENDINGS",
2495                                   "DOS line endings\n" . $herevet) &&
2496                             $fix) {
2497                                 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2498                         }
2499                 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2500                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2501                         if (ERROR("TRAILING_WHITESPACE",
2502                                   "trailing whitespace\n" . $herevet) &&
2503                             $fix) {
2504                                 $fixed[$fixlinenr] =~ s/\s+$//;
2505                         }
2506
2507                         $rpt_cleaners = 1;
2508                 }
2509
2510 # Check for FSF mailing addresses.
2511                 if ($rawline =~ /\bwrite to the Free/i ||
2512                     $rawline =~ /\b59\s+Temple\s+Pl/i ||
2513                     $rawline =~ /\b51\s+Franklin\s+St/i) {
2514                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2515                         my $msg_type = \&ERROR;
2516                         $msg_type = \&CHK if ($file);
2517                         &{$msg_type}("FSF_MAILING_ADDRESS",
2518                                      "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)
2519                 }
2520
2521 # check for Kconfig help text having a real description
2522 # Only applies when adding the entry originally, after that we do not have
2523 # sufficient context to determine whether it is indeed long enough.
2524                 if ($realfile =~ /Kconfig/ &&
2525                     $line =~ /^\+\s*config\s+/) {
2526                         my $length = 0;
2527                         my $cnt = $realcnt;
2528                         my $ln = $linenr + 1;
2529                         my $f;
2530                         my $is_start = 0;
2531                         my $is_end = 0;
2532                         for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2533                                 $f = $lines[$ln - 1];
2534                                 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2535                                 $is_end = $lines[$ln - 1] =~ /^\+/;
2536
2537                                 next if ($f =~ /^-/);
2538                                 last if (!$file && $f =~ /^\@\@/);
2539
2540                                 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2541                                         $is_start = 1;
2542                                 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2543                                         $length = -1;
2544                                 }
2545
2546                                 $f =~ s/^.//;
2547                                 $f =~ s/#.*//;
2548                                 $f =~ s/^\s+//;
2549                                 next if ($f =~ /^$/);
2550                                 if ($f =~ /^\s*config\s/) {
2551                                         $is_end = 1;
2552                                         last;
2553                                 }
2554                                 $length++;
2555                         }
2556                         if ($is_start && $is_end && $length < $min_conf_desc_length) {
2557                                 WARN("CONFIG_DESCRIPTION",
2558                                      "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2559                         }
2560                         #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2561                 }
2562
2563 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2564                 if ($realfile =~ /Kconfig/ &&
2565                     $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2566                         WARN("CONFIG_EXPERIMENTAL",
2567                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2568                 }
2569
2570 # discourage the use of boolean for type definition attributes of Kconfig options
2571                 if ($realfile =~ /Kconfig/ &&
2572                     $line =~ /^\+\s*\bboolean\b/) {
2573                         WARN("CONFIG_TYPE_BOOLEAN",
2574                              "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2575                 }
2576
2577                 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2578                     ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2579                         my $flag = $1;
2580                         my $replacement = {
2581                                 'EXTRA_AFLAGS' =>   'asflags-y',
2582                                 'EXTRA_CFLAGS' =>   'ccflags-y',
2583                                 'EXTRA_CPPFLAGS' => 'cppflags-y',
2584                                 'EXTRA_LDFLAGS' =>  'ldflags-y',
2585                         };
2586
2587                         WARN("DEPRECATED_VARIABLE",
2588                              "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2589                 }
2590
2591 # check for DT compatible documentation
2592                 if (defined $root &&
2593                         (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2594                          ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2595
2596                         my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2597
2598                         my $dt_path = $root . "/Documentation/devicetree/bindings/";
2599                         my $vp_file = $dt_path . "vendor-prefixes.txt";
2600
2601                         foreach my $compat (@compats) {
2602                                 my $compat2 = $compat;
2603                                 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2604                                 my $compat3 = $compat;
2605                                 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2606                                 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2607                                 if ( $? >> 8 ) {
2608                                         WARN("UNDOCUMENTED_DT_STRING",
2609                                              "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2610                                 }
2611
2612                                 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2613                                 my $vendor = $1;
2614                                 `grep -Eq "^$vendor\\b" $vp_file`;
2615                                 if ( $? >> 8 ) {
2616                                         WARN("UNDOCUMENTED_DT_STRING",
2617                                              "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2618                                 }
2619                         }
2620                 }
2621
2622 # check we are in a valid source file if not then ignore this hunk
2623                 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
2624
2625 # line length limit (with some exclusions)
2626 #
2627 # There are a few types of lines that may extend beyond $max_line_length:
2628 #       logging functions like pr_info that end in a string
2629 #       lines with a single string
2630 #       #defines that are a single string
2631 #
2632 # There are 3 different line length message types:
2633 # LONG_LINE_COMMENT     a comment starts before but extends beyond $max_linelength
2634 # LONG_LINE_STRING      a string starts before but extends beyond $max_line_length
2635 # LONG_LINE             all other lines longer than $max_line_length
2636 #
2637 # if LONG_LINE is ignored, the other 2 types are also ignored
2638 #
2639
2640                 if ($line =~ /^\+/ && $length > $max_line_length) {
2641                         my $msg_type = "LONG_LINE";
2642
2643                         # Check the allowed long line types first
2644
2645                         # logging functions that end in a string that starts
2646                         # before $max_line_length
2647                         if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2648                             length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2649                                 $msg_type = "";
2650
2651                         # lines with only strings (w/ possible termination)
2652                         # #defines with only strings
2653                         } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2654                                  $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2655                                 $msg_type = "";
2656
2657                         # Otherwise set the alternate message types
2658
2659                         # a comment starts before $max_line_length
2660                         } elsif ($line =~ /($;[\s$;]*)$/ &&
2661                                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2662                                 $msg_type = "LONG_LINE_COMMENT"
2663
2664                         # a quoted string starts before $max_line_length
2665                         } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2666                                  length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2667                                 $msg_type = "LONG_LINE_STRING"
2668                         }
2669
2670                         if ($msg_type ne "" &&
2671                             (show_type("LONG_LINE") || show_type($msg_type))) {
2672                                 WARN($msg_type,
2673                                      "line over $max_line_length characters\n" . $herecurr);
2674                         }
2675                 }
2676
2677 # check for adding lines without a newline.
2678                 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2679                         WARN("MISSING_EOF_NEWLINE",
2680                              "adding a line without newline at end of file\n" . $herecurr);
2681                 }
2682
2683 # Blackfin: use hi/lo macros
2684                 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2685                         if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2686                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2687                                 ERROR("LO_MACRO",
2688                                       "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2689                         }
2690                         if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2691                                 my $herevet = "$here\n" . cat_vet($line) . "\n";
2692                                 ERROR("HI_MACRO",
2693                                       "use the HI() macro, not (... >> 16)\n" . $herevet);
2694                         }
2695                 }
2696
2697 # check we are in a valid source file C or perl if not then ignore this hunk
2698                 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2699
2700 # at the beginning of a line any tabs must come first and anything
2701 # more than 8 must use tabs.
2702                 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2703                     $rawline =~ /^\+\s*        \s*/) {
2704                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2705                         $rpt_cleaners = 1;
2706                         if (ERROR("CODE_INDENT",
2707                                   "code indent should use tabs where possible\n" . $herevet) &&
2708                             $fix) {
2709                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2710                         }
2711                 }
2712
2713 # check for space before tabs.
2714                 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2715                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2716                         if (WARN("SPACE_BEFORE_TAB",
2717                                 "please, no space before tabs\n" . $herevet) &&
2718                             $fix) {
2719                                 while ($fixed[$fixlinenr] =~
2720                                            s/(^\+.*) {8,8}\t/$1\t\t/) {}
2721                                 while ($fixed[$fixlinenr] =~
2722                                            s/(^\+.*) +\t/$1\t/) {}
2723                         }
2724                 }
2725
2726 # check for && or || at the start of a line
2727                 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2728                         CHK("LOGICAL_CONTINUATIONS",
2729                             "Logical continuations should be on the previous line\n" . $hereprev);
2730                 }
2731
2732 # check multi-line statement indentation matches previous line
2733                 if ($^V && $^V ge 5.10.0 &&
2734                     $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2735                         $prevline =~ /^\+(\t*)(.*)$/;
2736                         my $oldindent = $1;
2737                         my $rest = $2;
2738
2739                         my $pos = pos_last_openparen($rest);
2740                         if ($pos >= 0) {
2741                                 $line =~ /^(\+| )([ \t]*)/;
2742                                 my $newindent = $2;
2743
2744                                 my $goodtabindent = $oldindent .
2745                                         "\t" x ($pos / 8) .
2746                                         " "  x ($pos % 8);
2747                                 my $goodspaceindent = $oldindent . " "  x $pos;
2748
2749                                 if ($newindent ne $goodtabindent &&
2750                                     $newindent ne $goodspaceindent) {
2751
2752                                         if (CHK("PARENTHESIS_ALIGNMENT",
2753                                                 "Alignment should match open parenthesis\n" . $hereprev) &&
2754                                             $fix && $line =~ /^\+/) {
2755                                                 $fixed[$fixlinenr] =~
2756                                                     s/^\+[ \t]*/\+$goodtabindent/;
2757                                         }
2758                                 }
2759                         }
2760                 }
2761
2762 # check for space after cast like "(int) foo" or "(struct foo) bar"
2763 # avoid checking a few false positives:
2764 #   "sizeof(<type>)" or "__alignof__(<type>)"
2765 #   function pointer declarations like "(*foo)(int) = bar;"
2766 #   structure definitions like "(struct foo) { 0 };"
2767 #   multiline macros that define functions
2768 #   known attributes or the __attribute__ keyword
2769                 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2770                     (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2771                         if (CHK("SPACING",
2772                                 "No space is necessary after a cast\n" . $herecurr) &&
2773                             $fix) {
2774                                 $fixed[$fixlinenr] =~
2775                                     s/(\(\s*$Type\s*\))[ \t]+/$1/;
2776                         }
2777                 }
2778
2779 # Block comment styles
2780 # Networking with an initial /*
2781                 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2782                     $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2783                     $rawline =~ /^\+[ \t]*\*/ &&
2784                     $realline > 2) {
2785                         WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2786                              "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2787                 }
2788
2789 # Block comments use * on subsequent lines
2790                 if ($prevline =~ /$;[ \t]*$/ &&                 #ends in comment
2791                     $prevrawline =~ /^\+.*?\/\*/ &&             #starting /*
2792                     $prevrawline !~ /\*\/[ \t]*$/ &&            #no trailing */
2793                     $rawline =~ /^\+/ &&                        #line is new
2794                     $rawline !~ /^\+[ \t]*\*/) {                #no leading *
2795                         WARN("BLOCK_COMMENT_STYLE",
2796                              "Block comments use * on subsequent lines\n" . $hereprev);
2797                 }
2798
2799 # Block comments use */ on trailing lines
2800                 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ &&       #trailing */
2801                     $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ &&      #inline /*...*/
2802                     $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ &&       #trailing **/
2803                     $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) {    #non blank */
2804                         WARN("BLOCK_COMMENT_STYLE",
2805                              "Block comments use a trailing */ on a separate line\n" . $herecurr);
2806                 }
2807
2808 # check for missing blank lines after struct/union declarations
2809 # with exceptions for various attributes and macros
2810                 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2811                     $line =~ /^\+/ &&
2812                     !($line =~ /^\+\s*$/ ||
2813                       $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2814                       $line =~ /^\+\s*MODULE_/i ||
2815                       $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2816                       $line =~ /^\+[a-z_]*init/ ||
2817                       $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2818                       $line =~ /^\+\s*DECLARE/ ||
2819                       $line =~ /^\+\s*__setup/)) {
2820                         if (CHK("LINE_SPACING",
2821                                 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2822                             $fix) {
2823                                 fix_insert_line($fixlinenr, "\+");
2824                         }
2825                 }
2826
2827 # check for multiple consecutive blank lines
2828                 if ($prevline =~ /^[\+ ]\s*$/ &&
2829                     $line =~ /^\+\s*$/ &&
2830                     $last_blank_line != ($linenr - 1)) {
2831                         if (CHK("LINE_SPACING",
2832                                 "Please don't use multiple blank lines\n" . $hereprev) &&
2833                             $fix) {
2834                                 fix_delete_line($fixlinenr, $rawline);
2835                         }
2836
2837                         $last_blank_line = $linenr;
2838                 }
2839
2840 # check for missing blank lines after declarations
2841                 if ($sline =~ /^\+\s+\S/ &&                     #Not at char 1
2842                         # actual declarations
2843                     ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2844                         # function pointer declarations
2845                      $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2846                         # foo bar; where foo is some local typedef or #define
2847                      $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2848                         # known declaration macros
2849                      $prevline =~ /^\+\s+$declaration_macros/) &&
2850                         # for "else if" which can look like "$Ident $Ident"
2851                     !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2852                         # other possible extensions of declaration lines
2853                       $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2854                         # not starting a section or a macro "\" extended line
2855                       $prevline =~ /(?:\{\s*|\\)$/) &&
2856                         # looks like a declaration
2857                     !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2858                         # function pointer declarations
2859                       $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2860                         # foo bar; where foo is some local typedef or #define
2861                       $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2862                         # known declaration macros
2863                       $sline =~ /^\+\s+$declaration_macros/ ||
2864                         # start of struct or union or enum
2865                       $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2866                         # start or end of block or continuation of declaration
2867                       $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2868                         # bitfield continuation
2869                       $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2870                         # other possible extensions of declaration lines
2871                       $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2872                         # indentation of previous and current line are the same
2873                     (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2874                         if (WARN("LINE_SPACING",
2875                                  "Missing a blank line after declarations\n" . $hereprev) &&
2876                             $fix) {
2877                                 fix_insert_line($fixlinenr, "\+");
2878                         }
2879                 }
2880
2881 # check for spaces at the beginning of a line.
2882 # Exceptions:
2883 #  1) within comments
2884 #  2) indented preprocessor commands
2885 #  3) hanging labels
2886                 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/)  {
2887                         my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2888                         if (WARN("LEADING_SPACE",
2889                                  "please, no spaces at the start of a line\n" . $herevet) &&
2890                             $fix) {
2891                                 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2892                         }
2893                 }
2894
2895 # check we are in a valid C source file if not then ignore this hunk
2896                 next if ($realfile !~ /\.(h|c)$/);
2897
2898 # check indentation of any line with a bare else
2899 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
2900 # if the previous line is a break or return and is indented 1 tab more...
2901                 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2902                         my $tabs = length($1) + 1;
2903                         if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2904                             ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2905                              defined $lines[$linenr] &&
2906                              $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
2907                                 WARN("UNNECESSARY_ELSE",
2908                                      "else is not generally useful after a break or return\n" . $hereprev);
2909                         }
2910                 }
2911
2912 # check indentation of a line with a break;
2913 # if the previous line is a goto or return and is indented the same # of tabs
2914                 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2915                         my $tabs = $1;
2916                         if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2917                                 WARN("UNNECESSARY_BREAK",
2918                                      "break is not useful after a goto or return\n" . $hereprev);
2919                         }
2920                 }
2921
2922 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2923                 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2924                         WARN("CONFIG_EXPERIMENTAL",
2925                              "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2926                 }
2927
2928 # check for RCS/CVS revision markers
2929                 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2930                         WARN("CVS_KEYWORD",
2931                              "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2932                 }
2933
2934 # Blackfin: don't use __builtin_bfin_[cs]sync
2935                 if ($line =~ /__builtin_bfin_csync/) {
2936                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2937                         ERROR("CSYNC",
2938                               "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2939                 }
2940                 if ($line =~ /__builtin_bfin_ssync/) {
2941                         my $herevet = "$here\n" . cat_vet($line) . "\n";
2942                         ERROR("SSYNC",
2943                               "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2944                 }
2945
2946 # check for old HOTPLUG __dev<foo> section markings
2947                 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2948                         WARN("HOTPLUG_SECTION",
2949                              "Using $1 is unnecessary\n" . $herecurr);
2950                 }
2951
2952 # Check for potential 'bare' types
2953                 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2954                     $realline_next);
2955 #print "LINE<$line>\n";
2956                 if ($linenr >= $suppress_statement &&
2957                     $realcnt && $sline =~ /.\s*\S/) {
2958                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2959                                 ctx_statement_block($linenr, $realcnt, 0);
2960                         $stat =~ s/\n./\n /g;
2961                         $cond =~ s/\n./\n /g;
2962
2963 #print "linenr<$linenr> <$stat>\n";
2964                         # If this statement has no statement boundaries within
2965                         # it there is no point in retrying a statement scan
2966                         # until we hit end of it.
2967                         my $frag = $stat; $frag =~ s/;+\s*$//;
2968                         if ($frag !~ /(?:{|;)/) {
2969 #print "skip<$line_nr_next>\n";
2970                                 $suppress_statement = $line_nr_next;
2971                         }
2972
2973                         # Find the real next line.
2974                         $realline_next = $line_nr_next;
2975                         if (defined $realline_next &&
2976                             (!defined $lines[$realline_next - 1] ||
2977                              substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2978                                 $realline_next++;
2979                         }
2980
2981                         my $s = $stat;
2982                         $s =~ s/{.*$//s;
2983
2984                         # Ignore goto labels.
2985                         if ($s =~ /$Ident:\*$/s) {
2986
2987                         # Ignore functions being called
2988                         } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2989
2990                         } elsif ($s =~ /^.\s*else\b/s) {
2991
2992                         # declarations always start with types
2993                         } 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) {
2994                                 my $type = $1;
2995                                 $type =~ s/\s+/ /g;
2996                                 possible($type, "A:" . $s);
2997
2998                         # definitions in global scope can only start with types
2999                         } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3000                                 possible($1, "B:" . $s);
3001                         }
3002
3003                         # any (foo ... *) is a pointer cast, and foo is a type
3004                         while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3005                                 possible($1, "C:" . $s);
3006                         }
3007
3008                         # Check for any sort of function declaration.
3009                         # int foo(something bar, other baz);
3010                         # void (*store_gdt)(x86_descr_ptr *);
3011                         if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3012                                 my ($name_len) = length($1);
3013
3014                                 my $ctx = $s;
3015                                 substr($ctx, 0, $name_len + 1, '');
3016                                 $ctx =~ s/\)[^\)]*$//;
3017
3018                                 for my $arg (split(/\s*,\s*/, $ctx)) {
3019                                         if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3020
3021                                                 possible($1, "D:" . $s);
3022                                         }
3023                                 }
3024                         }
3025
3026                 }
3027
3028 #
3029 # Checks which may be anchored in the context.
3030 #
3031
3032 # Check for switch () and associated case and default
3033 # statements should be at the same indent.
3034                 if ($line=~/\bswitch\s*\(.*\)/) {
3035                         my $err = '';
3036                         my $sep = '';
3037                         my @ctx = ctx_block_outer($linenr, $realcnt);
3038                         shift(@ctx);
3039                         for my $ctx (@ctx) {
3040                                 my ($clen, $cindent) = line_stats($ctx);
3041                                 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3042                                                         $indent != $cindent) {
3043                                         $err .= "$sep$ctx\n";
3044                                         $sep = '';
3045                                 } else {
3046                                         $sep = "[...]\n";
3047                                 }
3048                         }
3049                         if ($err ne '') {
3050                                 ERROR("SWITCH_CASE_INDENT_LEVEL",
3051                                       "switch and case should be at the same indent\n$hereline$err");
3052                         }
3053                 }
3054
3055 # if/while/etc brace do not go on next line, unless defining a do while loop,
3056 # or if that brace on the next line is for something else
3057                 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3058                         my $pre_ctx = "$1$2";
3059
3060                         my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3061
3062                         if ($line =~ /^\+\t{6,}/) {
3063                                 WARN("DEEP_INDENTATION",
3064                                      "Too many leading tabs - consider code refactoring\n" . $herecurr);
3065                         }
3066
3067                         my $ctx_cnt = $realcnt - $#ctx - 1;
3068                         my $ctx = join("\n", @ctx);
3069
3070                         my $ctx_ln = $linenr;
3071                         my $ctx_skip = $realcnt;
3072
3073                         while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3074                                         defined $lines[$ctx_ln - 1] &&
3075                                         $lines[$ctx_ln - 1] =~ /^-/)) {
3076                                 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3077                                 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3078                                 $ctx_ln++;
3079                         }
3080
3081                         #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3082                         #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3083
3084                         if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3085                                 ERROR("OPEN_BRACE",
3086                                       "that open brace { should be on the previous line\n" .
3087                                         "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3088                         }
3089                         if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3090                             $ctx =~ /\)\s*\;\s*$/ &&
3091                             defined $lines[$ctx_ln - 1])
3092                         {
3093                                 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3094                                 if ($nindent > $indent) {
3095                                         WARN("TRAILING_SEMICOLON",
3096                                              "trailing semicolon indicates no statements, indent implies otherwise\n" .
3097                                                 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3098                                 }
3099                         }
3100                 }
3101
3102 # Check relative indent for conditionals and blocks.
3103                 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3104                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3105                                 ctx_statement_block($linenr, $realcnt, 0)
3106                                         if (!defined $stat);
3107                         my ($s, $c) = ($stat, $cond);
3108
3109                         substr($s, 0, length($c), '');
3110
3111                         # remove inline comments
3112                         $s =~ s/$;/ /g;
3113                         $c =~ s/$;/ /g;
3114
3115                         # Find out how long the conditional actually is.
3116                         my @newlines = ($c =~ /\n/gs);
3117                         my $cond_lines = 1 + $#newlines;
3118
3119                         # Make sure we remove the line prefixes as we have
3120                         # none on the first line, and are going to readd them
3121                         # where necessary.
3122                         $s =~ s/\n./\n/gs;
3123                         while ($s =~ /\n\s+\\\n/) {
3124                                 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3125                         }
3126
3127                         # We want to check the first line inside the block
3128                         # starting at the end of the conditional, so remove:
3129                         #  1) any blank line termination
3130                         #  2) any opening brace { on end of the line
3131                         #  3) any do (...) {
3132                         my $continuation = 0;
3133                         my $check = 0;
3134                         $s =~ s/^.*\bdo\b//;
3135                         $s =~ s/^\s*{//;
3136                         if ($s =~ s/^\s*\\//) {
3137                                 $continuation = 1;
3138                         }
3139                         if ($s =~ s/^\s*?\n//) {
3140                                 $check = 1;
3141                                 $cond_lines++;
3142                         }
3143
3144                         # Also ignore a loop construct at the end of a
3145                         # preprocessor statement.
3146                         if (($prevline =~ /^.\s*#\s*define\s/ ||
3147                             $prevline =~ /\\\s*$/) && $continuation == 0) {
3148                                 $check = 0;
3149                         }
3150
3151                         my $cond_ptr = -1;
3152                         $continuation = 0;
3153                         while ($cond_ptr != $cond_lines) {
3154                                 $cond_ptr = $cond_lines;
3155
3156                                 # If we see an #else/#elif then the code
3157                                 # is not linear.
3158                                 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3159                                         $check = 0;
3160                                 }
3161
3162                                 # Ignore:
3163                                 #  1) blank lines, they should be at 0,
3164                                 #  2) preprocessor lines, and
3165                                 #  3) labels.
3166                                 if ($continuation ||
3167                                     $s =~ /^\s*?\n/ ||
3168                                     $s =~ /^\s*#\s*?/ ||
3169                                     $s =~ /^\s*$Ident\s*:/) {
3170                                         $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3171                                         if ($s =~ s/^.*?\n//) {
3172                                                 $cond_lines++;
3173                                         }
3174                                 }
3175                         }
3176
3177                         my (undef, $sindent) = line_stats("+" . $s);
3178                         my $stat_real = raw_line($linenr, $cond_lines);
3179
3180                         # Check if either of these lines are modified, else
3181                         # this is not this patch's fault.
3182                         if (!defined($stat_real) ||
3183                             $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3184                                 $check = 0;
3185                         }
3186                         if (defined($stat_real) && $cond_lines > 1) {
3187                                 $stat_real = "[...]\n$stat_real";
3188                         }
3189
3190                         #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";
3191
3192                         if ($check && $s ne '' &&
3193                             (($sindent % 8) != 0 ||
3194                              ($sindent < $indent) ||
3195                              ($sindent > $indent + 8))) {
3196                                 WARN("SUSPECT_CODE_INDENT",
3197                                      "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3198                         }
3199                 }
3200
3201                 # Track the 'values' across context and added lines.
3202                 my $opline = $line; $opline =~ s/^./ /;
3203                 my ($curr_values, $curr_vars) =
3204                                 annotate_values($opline . "\n", $prev_values);
3205                 $curr_values = $prev_values . $curr_values;
3206                 if ($dbg_values) {
3207                         my $outline = $opline; $outline =~ s/\t/ /g;
3208                         print "$linenr > .$outline\n";
3209                         print "$linenr > $curr_values\n";
3210                         print "$linenr >  $curr_vars\n";
3211                 }
3212                 $prev_values = substr($curr_values, -1);
3213
3214 #ignore lines not being added
3215                 next if ($line =~ /^[^\+]/);
3216
3217 # TEST: allow direct testing of the type matcher.
3218                 if ($dbg_type) {
3219                         if ($line =~ /^.\s*$Declare\s*$/) {
3220                                 ERROR("TEST_TYPE",
3221                                       "TEST: is type\n" . $herecurr);
3222                         } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3223                                 ERROR("TEST_NOT_TYPE",
3224                                       "TEST: is not type ($1 is)\n". $herecurr);
3225                         }
3226                         next;
3227                 }
3228 # TEST: allow direct testing of the attribute matcher.
3229                 if ($dbg_attr) {
3230                         if ($line =~ /^.\s*$Modifier\s*$/) {
3231                                 ERROR("TEST_ATTR",
3232                                       "TEST: is attr\n" . $herecurr);
3233                         } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3234                                 ERROR("TEST_NOT_ATTR",
3235                                       "TEST: is not attr ($1 is)\n". $herecurr);
3236                         }
3237                         next;
3238                 }
3239
3240 # check for initialisation to aggregates open brace on the next line
3241                 if ($line =~ /^.\s*{/ &&
3242                     $prevline =~ /(?:^|[^=])=\s*$/) {
3243                         if (ERROR("OPEN_BRACE",
3244                                   "that open brace { should be on the previous line\n" . $hereprev) &&
3245                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3246                                 fix_delete_line($fixlinenr - 1, $prevrawline);
3247                                 fix_delete_line($fixlinenr, $rawline);
3248                                 my $fixedline = $prevrawline;
3249                                 $fixedline =~ s/\s*=\s*$/ = {/;
3250                                 fix_insert_line($fixlinenr, $fixedline);
3251                                 $fixedline = $line;
3252                                 $fixedline =~ s/^(.\s*){\s*/$1/;
3253                                 fix_insert_line($fixlinenr, $fixedline);
3254                         }
3255                 }
3256
3257 #
3258 # Checks which are anchored on the added line.
3259 #
3260
3261 # check for malformed paths in #include statements (uses RAW line)
3262                 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3263                         my $path = $1;
3264                         if ($path =~ m{//}) {
3265                                 ERROR("MALFORMED_INCLUDE",
3266                                       "malformed #include filename\n" . $herecurr);
3267                         }
3268                         if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3269                                 ERROR("UAPI_INCLUDE",
3270                                       "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3271                         }
3272                 }
3273
3274 # no C99 // comments
3275                 if ($line =~ m{//}) {
3276                         if (ERROR("C99_COMMENTS",
3277                                   "do not use C99 // comments\n" . $herecurr) &&
3278                             $fix) {
3279                                 my $line = $fixed[$fixlinenr];
3280                                 if ($line =~ /\/\/(.*)$/) {
3281                                         my $comment = trim($1);
3282                                         $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3283                                 }
3284                         }
3285                 }
3286                 # Remove C99 comments.
3287                 $line =~ s@//.*@@;
3288                 $opline =~ s@//.*@@;
3289
3290 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3291 # the whole statement.
3292 #print "APW <$lines[$realline_next - 1]>\n";
3293                 if (defined $realline_next &&
3294                     exists $lines[$realline_next - 1] &&
3295                     !defined $suppress_export{$realline_next} &&
3296                     ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3297                      $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3298                         # Handle definitions which produce identifiers with
3299                         # a prefix:
3300                         #   XXX(foo);
3301                         #   EXPORT_SYMBOL(something_foo);
3302                         my $name = $1;
3303                         if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3304                             $name =~ /^${Ident}_$2/) {
3305 #print "FOO C name<$name>\n";
3306                                 $suppress_export{$realline_next} = 1;
3307
3308                         } elsif ($stat !~ /(?:
3309                                 \n.}\s*$|
3310                                 ^.DEFINE_$Ident\(\Q$name\E\)|
3311                                 ^.DECLARE_$Ident\(\Q$name\E\)|
3312                                 ^.LIST_HEAD\(\Q$name\E\)|
3313                                 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3314                                 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3315                             )/x) {
3316 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3317                                 $suppress_export{$realline_next} = 2;
3318                         } else {
3319                                 $suppress_export{$realline_next} = 1;
3320                         }
3321                 }
3322                 if (!defined $suppress_export{$linenr} &&
3323                     $prevline =~ /^.\s*$/ &&
3324                     ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3325                      $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3326 #print "FOO B <$lines[$linenr - 1]>\n";
3327                         $suppress_export{$linenr} = 2;
3328                 }
3329                 if (defined $suppress_export{$linenr} &&
3330                     $suppress_export{$linenr} == 2) {
3331                         WARN("EXPORT_SYMBOL",
3332                              "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3333                 }
3334
3335 # check for global initialisers.
3336                 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*(?:0|NULL|false)\s*;/) {
3337                         if (ERROR("GLOBAL_INITIALISERS",
3338                                   "do not initialise globals to 0 or NULL\n" .
3339                                       $herecurr) &&
3340                             $fix) {
3341                                 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*(0|NULL|false)\s*;/$1;/;
3342                         }
3343                 }
3344 # check for static initialisers.
3345                 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
3346                         if (ERROR("INITIALISED_STATIC",
3347                                   "do not initialise statics to 0 or NULL\n" .
3348                                       $herecurr) &&
3349                             $fix) {
3350                                 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
3351                         }
3352                 }
3353
3354 # check for misordered declarations of char/short/int/long with signed/unsigned
3355                 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3356                         my $tmp = trim($1);
3357                         WARN("MISORDERED_TYPE",
3358                              "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3359                 }
3360
3361 # check for static const char * arrays.
3362                 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3363                         WARN("STATIC_CONST_CHAR_ARRAY",
3364                              "static const char * array should probably be static const char * const\n" .
3365                                 $herecurr);
3366                }
3367
3368 # check for static char foo[] = "bar" declarations.
3369                 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3370                         WARN("STATIC_CONST_CHAR_ARRAY",
3371                              "static char array declaration should probably be static const char\n" .
3372                                 $herecurr);
3373                }
3374
3375 # check for const <foo> const where <foo> is not a pointer or array type
3376                 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3377                         my $found = $1;
3378                         if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3379                                 WARN("CONST_CONST",
3380                                      "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3381                         } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3382                                 WARN("CONST_CONST",
3383                                      "'const $found const' should probably be 'const $found'\n" . $herecurr);
3384                         }
3385                 }
3386
3387 # check for non-global char *foo[] = {"bar", ...} declarations.
3388                 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3389                         WARN("STATIC_CONST_CHAR_ARRAY",
3390                              "char * array declaration might be better as static const\n" .
3391                                 $herecurr);
3392                }
3393
3394 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3395                 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3396                         my $array = $1;
3397                         if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3398                                 my $array_div = $1;
3399                                 if (WARN("ARRAY_SIZE",
3400                                          "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3401                                     $fix) {
3402                                         $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3403                                 }
3404                         }
3405                 }
3406
3407 # check for function declarations without arguments like "int foo()"
3408                 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3409                         if (ERROR("FUNCTION_WITHOUT_ARGS",
3410                                   "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3411                             $fix) {
3412                                 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3413                         }
3414                 }
3415
3416 # check for uses of DEFINE_PCI_DEVICE_TABLE
3417                 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3418                         if (WARN("DEFINE_PCI_DEVICE_TABLE",
3419                                  "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3420                             $fix) {
3421                                 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3422                         }
3423                 }
3424
3425 # check for new typedefs, only function parameters and sparse annotations
3426 # make sense.
3427                 if ($line =~ /\btypedef\s/ &&
3428                     $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3429                     $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3430                     $line !~ /\b$typeTypedefs\b/ &&
3431                     $line !~ /\b__bitwise(?:__|)\b/) {
3432                         WARN("NEW_TYPEDEFS",
3433                              "do not add new typedefs\n" . $herecurr);
3434                 }
3435
3436 # * goes on variable not on type
3437                 # (char*[ const])
3438                 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3439                         #print "AA<$1>\n";
3440                         my ($ident, $from, $to) = ($1, $2, $2);
3441
3442                         # Should start with a space.
3443                         $to =~ s/^(\S)/ $1/;
3444                         # Should not end with a space.
3445                         $to =~ s/\s+$//;
3446                         # '*'s should not have spaces between.
3447                         while ($to =~ s/\*\s+\*/\*\*/) {
3448                         }
3449
3450 ##                      print "1: from<$from> to<$to> ident<$ident>\n";
3451                         if ($from ne $to) {
3452                                 if (ERROR("POINTER_LOCATION",
3453                                           "\"(foo$from)\" should be \"(foo$to)\"\n" .  $herecurr) &&
3454                                     $fix) {
3455                                         my $sub_from = $ident;
3456                                         my $sub_to = $ident;
3457                                         $sub_to =~ s/\Q$from\E/$to/;
3458                                         $fixed[$fixlinenr] =~
3459                                             s@\Q$sub_from\E@$sub_to@;
3460                                 }
3461                         }
3462                 }
3463                 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3464                         #print "BB<$1>\n";
3465                         my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3466
3467                         # Should start with a space.
3468                         $to =~ s/^(\S)/ $1/;
3469                         # Should not end with a space.
3470                         $to =~ s/\s+$//;
3471                         # '*'s should not have spaces between.
3472                         while ($to =~ s/\*\s+\*/\*\*/) {
3473                         }
3474                         # Modifiers should have spaces.
3475                         $to =~ s/(\b$Modifier$)/$1 /;
3476
3477 ##                      print "2: from<$from> to<$to> ident<$ident>\n";
3478                         if ($from ne $to && $ident !~ /^$Modifier$/) {
3479                                 if (ERROR("POINTER_LOCATION",
3480                                           "\"foo${from}bar\" should be \"foo${to}bar\"\n" .  $herecurr) &&
3481                                     $fix) {
3482
3483                                         my $sub_from = $match;
3484                                         my $sub_to = $match;
3485                                         $sub_to =~ s/\Q$from\E/$to/;
3486                                         $fixed[$fixlinenr] =~
3487                                             s@\Q$sub_from\E@$sub_to@;
3488                                 }
3489                         }
3490                 }
3491
3492 # avoid BUG() or BUG_ON()
3493                 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3494                         my $msg_type = \&WARN;
3495                         $msg_type = \&CHK if ($file);
3496                         &{$msg_type}("AVOID_BUG",
3497                                      "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3498                 }
3499
3500 # avoid LINUX_VERSION_CODE
3501                 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3502                         WARN("LINUX_VERSION_CODE",
3503                              "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3504                 }
3505
3506 # check for uses of printk_ratelimit
3507                 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3508                         WARN("PRINTK_RATELIMITED",
3509                              "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3510                 }
3511
3512 # printk should use KERN_* levels.  Note that follow on printk's on the
3513 # same line do not need a level, so we use the current block context
3514 # to try and find and validate the current printk.  In summary the current
3515 # printk includes all preceding printk's which have no newline on the end.
3516 # we assume the first bad printk is the one to report.
3517                 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3518                         my $ok = 0;
3519                         for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3520                                 #print "CHECK<$lines[$ln - 1]\n";
3521                                 # we have a preceding printk if it ends
3522                                 # with "\n" ignore it, else it is to blame
3523                                 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3524                                         if ($rawlines[$ln - 1] !~ m{\\n"}) {
3525                                                 $ok = 1;
3526                                         }
3527                                         last;
3528                                 }
3529                         }
3530                         if ($ok == 0) {
3531                                 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3532                                      "printk() should include KERN_ facility level\n" . $herecurr);
3533                         }
3534                 }
3535
3536                 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3537                         my $orig = $1;
3538                         my $level = lc($orig);
3539                         $level = "warn" if ($level eq "warning");
3540                         my $level2 = $level;
3541                         $level2 = "dbg" if ($level eq "debug");
3542                         WARN("PREFER_PR_LEVEL",
3543                              "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(...  to printk(KERN_$orig ...\n" . $herecurr);
3544                 }
3545
3546                 if ($line =~ /\bpr_warning\s*\(/) {
3547                         if (WARN("PREFER_PR_LEVEL",
3548                                  "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3549                             $fix) {
3550                                 $fixed[$fixlinenr] =~
3551                                     s/\bpr_warning\b/pr_warn/;
3552                         }
3553                 }
3554
3555                 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3556                         my $orig = $1;
3557                         my $level = lc($orig);
3558                         $level = "warn" if ($level eq "warning");
3559                         $level = "dbg" if ($level eq "debug");
3560                         WARN("PREFER_DEV_LEVEL",
3561                              "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3562                 }
3563
3564 # ENOSYS means "bad syscall nr" and nothing else.  This will have a small
3565 # number of false positives, but assembly files are not checked, so at
3566 # least the arch entry code will not trigger this warning.
3567                 if ($line =~ /\bENOSYS\b/) {
3568                         WARN("ENOSYS",
3569                              "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3570                 }
3571
3572 # function brace can't be on same line, except for #defines of do while,
3573 # or if closed on same line
3574                 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3575                     !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3576                         if (ERROR("OPEN_BRACE",
3577                                   "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3578                             $fix) {
3579                                 fix_delete_line($fixlinenr, $rawline);
3580                                 my $fixed_line = $rawline;
3581                                 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3582                                 my $line1 = $1;
3583                                 my $line2 = $2;
3584                                 fix_insert_line($fixlinenr, ltrim($line1));
3585                                 fix_insert_line($fixlinenr, "\+{");
3586                                 if ($line2 !~ /^\s*$/) {
3587                                         fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3588                                 }
3589                         }
3590                 }
3591
3592 # open braces for enum, union and struct go on the same line.
3593                 if ($line =~ /^.\s*{/ &&
3594                     $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3595                         if (ERROR("OPEN_BRACE",
3596                                   "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3597                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3598                                 fix_delete_line($fixlinenr - 1, $prevrawline);
3599                                 fix_delete_line($fixlinenr, $rawline);
3600                                 my $fixedline = rtrim($prevrawline) . " {";
3601                                 fix_insert_line($fixlinenr, $fixedline);
3602                                 $fixedline = $rawline;
3603                                 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3604                                 if ($fixedline !~ /^\+\s*$/) {
3605                                         fix_insert_line($fixlinenr, $fixedline);
3606                                 }
3607                         }
3608                 }
3609
3610 # missing space after union, struct or enum definition
3611                 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3612                         if (WARN("SPACING",
3613                                  "missing space after $1 definition\n" . $herecurr) &&
3614                             $fix) {
3615                                 $fixed[$fixlinenr] =~
3616                                     s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3617                         }
3618                 }
3619
3620 # Function pointer declarations
3621 # check spacing between type, funcptr, and args
3622 # canonical declaration is "type (*funcptr)(args...)"
3623                 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3624                         my $declare = $1;
3625                         my $pre_pointer_space = $2;
3626                         my $post_pointer_space = $3;
3627                         my $funcname = $4;
3628                         my $post_funcname_space = $5;
3629                         my $pre_args_space = $6;
3630
3631 # the $Declare variable will capture all spaces after the type
3632 # so check it for a missing trailing missing space but pointer return types
3633 # don't need a space so don't warn for those.
3634                         my $post_declare_space = "";
3635                         if ($declare =~ /(\s+)$/) {
3636                                 $post_declare_space = $1;
3637                                 $declare = rtrim($declare);
3638                         }
3639                         if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3640                                 WARN("SPACING",
3641                                      "missing space after return type\n" . $herecurr);
3642                                 $post_declare_space = " ";
3643                         }
3644
3645 # unnecessary space "type  (*funcptr)(args...)"
3646 # This test is not currently implemented because these declarations are
3647 # equivalent to
3648 #       int  foo(int bar, ...)
3649 # and this is form shouldn't/doesn't generate a checkpatch warning.
3650 #
3651 #                       elsif ($declare =~ /\s{2,}$/) {
3652 #                               WARN("SPACING",
3653 #                                    "Multiple spaces after return type\n" . $herecurr);
3654 #                       }
3655
3656 # unnecessary space "type ( *funcptr)(args...)"
3657                         if (defined $pre_pointer_space &&
3658                             $pre_pointer_space =~ /^\s/) {
3659                                 WARN("SPACING",
3660                                      "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3661                         }
3662
3663 # unnecessary space "type (* funcptr)(args...)"
3664                         if (defined $post_pointer_space &&
3665                             $post_pointer_space =~ /^\s/) {
3666                                 WARN("SPACING",
3667                                      "Unnecessary space before function pointer name\n" . $herecurr);
3668                         }
3669
3670 # unnecessary space "type (*funcptr )(args...)"
3671                         if (defined $post_funcname_space &&
3672                             $post_funcname_space =~ /^\s/) {
3673                                 WARN("SPACING",
3674                                      "Unnecessary space after function pointer name\n" . $herecurr);
3675                         }
3676
3677 # unnecessary space "type (*funcptr) (args...)"
3678                         if (defined $pre_args_space &&
3679                             $pre_args_space =~ /^\s/) {
3680                                 WARN("SPACING",
3681                                      "Unnecessary space before function pointer arguments\n" . $herecurr);
3682                         }
3683
3684                         if (show_type("SPACING") && $fix) {
3685                                 $fixed[$fixlinenr] =~
3686                                     s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3687                         }
3688                 }
3689
3690 # check for spacing round square brackets; allowed:
3691 #  1. with a type on the left -- int [] a;
3692 #  2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3693 #  3. inside a curly brace -- = { [0...10] = 5 }
3694                 while ($line =~ /(.*?\s)\[/g) {
3695                         my ($where, $prefix) = ($-[1], $1);
3696                         if ($prefix !~ /$Type\s+$/ &&
3697                             ($where != 0 || $prefix !~ /^.\s+$/) &&
3698                             $prefix !~ /[{,]\s+$/) {
3699                                 if (ERROR("BRACKET_SPACE",
3700                                           "space prohibited before open square bracket '['\n" . $herecurr) &&
3701                                     $fix) {
3702                                     $fixed[$fixlinenr] =~
3703                                         s/^(\+.*?)\s+\[/$1\[/;
3704                                 }
3705                         }
3706                 }
3707
3708 # check for spaces between functions and their parentheses.
3709                 while ($line =~ /($Ident)\s+\(/g) {
3710                         my $name = $1;
3711                         my $ctx_before = substr($line, 0, $-[1]);
3712                         my $ctx = "$ctx_before$name";
3713
3714                         # Ignore those directives where spaces _are_ permitted.
3715                         if ($name =~ /^(?:
3716                                 if|for|while|switch|return|case|
3717                                 volatile|__volatile__|
3718                                 __attribute__|format|__extension__|
3719                                 asm|__asm__)$/x)
3720                         {
3721                         # cpp #define statements have non-optional spaces, ie
3722                         # if there is a space between the name and the open
3723                         # parenthesis it is simply not a parameter group.
3724                         } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3725
3726                         # cpp #elif statement condition may start with a (
3727                         } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3728
3729                         # If this whole things ends with a type its most
3730                         # likely a typedef for a function.
3731                         } elsif ($ctx =~ /$Type$/) {
3732
3733                         } else {
3734                                 if (WARN("SPACING",
3735                                          "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3736                                              $fix) {
3737                                         $fixed[$fixlinenr] =~
3738                                             s/\b$name\s+\(/$name\(/;
3739                                 }
3740                         }
3741                 }
3742
3743 # Check operator spacing.
3744                 if (!($line=~/\#\s*include/)) {
3745                         my $fixed_line = "";
3746                         my $line_fixed = 0;
3747
3748                         my $ops = qr{
3749                                 <<=|>>=|<=|>=|==|!=|
3750                                 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3751                                 =>|->|<<|>>|<|>|=|!|~|
3752                                 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3753                                 \?:|\?|:
3754                         }x;
3755                         my @elements = split(/($ops|;)/, $opline);
3756
3757 ##                      print("element count: <" . $#elements . ">\n");
3758 ##                      foreach my $el (@elements) {
3759 ##                              print("el: <$el>\n");
3760 ##                      }
3761
3762                         my @fix_elements = ();
3763                         my $off = 0;
3764
3765                         foreach my $el (@elements) {
3766                                 push(@fix_elements, substr($rawline, $off, length($el)));
3767                                 $off += length($el);
3768                         }
3769
3770                         $off = 0;
3771
3772                         my $blank = copy_spacing($opline);
3773                         my $last_after = -1;
3774
3775                         for (my $n = 0; $n < $#elements; $n += 2) {
3776
3777                                 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3778
3779 ##                              print("n: <$n> good: <$good>\n");
3780
3781                                 $off += length($elements[$n]);
3782
3783                                 # Pick up the preceding and succeeding characters.
3784                                 my $ca = substr($opline, 0, $off);
3785                                 my $cc = '';
3786                                 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3787                                         $cc = substr($opline, $off + length($elements[$n + 1]));
3788                                 }
3789                                 my $cb = "$ca$;$cc";
3790
3791                                 my $a = '';
3792                                 $a = 'V' if ($elements[$n] ne '');
3793                                 $a = 'W' if ($elements[$n] =~ /\s$/);
3794                                 $a = 'C' if ($elements[$n] =~ /$;$/);
3795                                 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3796                                 $a = 'O' if ($elements[$n] eq '');
3797                                 $a = 'E' if ($ca =~ /^\s*$/);
3798
3799                                 my $op = $elements[$n + 1];
3800
3801                                 my $c = '';
3802                                 if (defined $elements[$n + 2]) {
3803                                         $c = 'V' if ($elements[$n + 2] ne '');
3804                                         $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3805                                         $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3806                                         $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3807                                         $c = 'O' if ($elements[$n + 2] eq '');
3808                                         $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3809                                 } else {
3810                                         $c = 'E';
3811                                 }
3812
3813                                 my $ctx = "${a}x${c}";
3814
3815                                 my $at = "(ctx:$ctx)";
3816
3817                                 my $ptr = substr($blank, 0, $off) . "^";
3818                                 my $hereptr = "$hereline$ptr\n";
3819
3820                                 # Pull out the value of this operator.
3821                                 my $op_type = substr($curr_values, $off + 1, 1);
3822
3823                                 # Get the full operator variant.
3824                                 my $opv = $op . substr($curr_vars, $off, 1);
3825
3826                                 # Ignore operators passed as parameters.
3827                                 if ($op_type ne 'V' &&
3828                                     $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
3829
3830 #                               # Ignore comments
3831 #                               } elsif ($op =~ /^$;+$/) {
3832
3833                                 # ; should have either the end of line or a space or \ after it
3834                                 } elsif ($op eq ';') {
3835                                         if ($ctx !~ /.x[WEBC]/ &&
3836                                             $cc !~ /^\\/ && $cc !~ /^;/) {
3837                                                 if (ERROR("SPACING",
3838                                                           "space required after that '$op' $at\n" . $hereptr)) {
3839                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3840                                                         $line_fixed = 1;
3841                                                 }
3842                                         }
3843
3844                                 # // is a comment
3845                                 } elsif ($op eq '//') {
3846
3847                                 #   :   when part of a bitfield
3848                                 } elsif ($opv eq ':B') {
3849                                         # skip the bitfield test for now
3850
3851                                 # No spaces for:
3852                                 #   ->
3853                                 } elsif ($op eq '->') {
3854                                         if ($ctx =~ /Wx.|.xW/) {
3855                                                 if (ERROR("SPACING",
3856                                                           "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3857                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3858                                                         if (defined $fix_elements[$n + 2]) {
3859                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3860                                                         }
3861                                                         $line_fixed = 1;
3862                                                 }
3863                                         }
3864
3865                                 # , must not have a space before and must have a space on the right.
3866                                 } elsif ($op eq ',') {
3867                                         my $rtrim_before = 0;
3868                                         my $space_after = 0;
3869                                         if ($ctx =~ /Wx./) {
3870                                                 if (ERROR("SPACING",
3871                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3872                                                         $line_fixed = 1;
3873                                                         $rtrim_before = 1;
3874                                                 }
3875                                         }
3876                                         if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3877                                                 if (ERROR("SPACING",
3878                                                           "space required after that '$op' $at\n" . $hereptr)) {
3879                                                         $line_fixed = 1;
3880                                                         $last_after = $n;
3881                                                         $space_after = 1;
3882                                                 }
3883                                         }
3884                                         if ($rtrim_before || $space_after) {
3885                                                 if ($rtrim_before) {
3886                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3887                                                 } else {
3888                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3889                                                 }
3890                                                 if ($space_after) {
3891                                                         $good .= " ";
3892                                                 }
3893                                         }
3894
3895                                 # '*' as part of a type definition -- reported already.
3896                                 } elsif ($opv eq '*_') {
3897                                         #warn "'*' is part of type\n";
3898
3899                                 # unary operators should have a space before and
3900                                 # none after.  May be left adjacent to another
3901                                 # unary operator, or a cast
3902                                 } elsif ($op eq '!' || $op eq '~' ||
3903                                          $opv eq '*U' || $opv eq '-U' ||
3904                                          $opv eq '&U' || $opv eq '&&U') {
3905                                         if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3906                                                 if (ERROR("SPACING",
3907                                                           "space required before that '$op' $at\n" . $hereptr)) {
3908                                                         if ($n != $last_after + 2) {
3909                                                                 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3910                                                                 $line_fixed = 1;
3911                                                         }
3912                                                 }
3913                                         }
3914                                         if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3915                                                 # A unary '*' may be const
3916
3917                                         } elsif ($ctx =~ /.xW/) {
3918                                                 if (ERROR("SPACING",
3919                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3920                                                         $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3921                                                         if (defined $fix_elements[$n + 2]) {
3922                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3923                                                         }
3924                                                         $line_fixed = 1;
3925                                                 }
3926                                         }
3927
3928                                 # unary ++ and unary -- are allowed no space on one side.
3929                                 } elsif ($op eq '++' or $op eq '--') {
3930                                         if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3931                                                 if (ERROR("SPACING",
3932                                                           "space required one side of that '$op' $at\n" . $hereptr)) {
3933                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3934                                                         $line_fixed = 1;
3935                                                 }
3936                                         }
3937                                         if ($ctx =~ /Wx[BE]/ ||
3938                                             ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3939                                                 if (ERROR("SPACING",
3940                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3941                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3942                                                         $line_fixed = 1;
3943                                                 }
3944                                         }
3945                                         if ($ctx =~ /ExW/) {
3946                                                 if (ERROR("SPACING",
3947                                                           "space prohibited after that '$op' $at\n" . $hereptr)) {
3948                                                         $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3949                                                         if (defined $fix_elements[$n + 2]) {
3950                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3951                                                         }
3952                                                         $line_fixed = 1;
3953                                                 }
3954                                         }
3955
3956                                 # << and >> may either have or not have spaces both sides
3957                                 } elsif ($op eq '<<' or $op eq '>>' or
3958                                          $op eq '&' or $op eq '^' or $op eq '|' or
3959                                          $op eq '+' or $op eq '-' or
3960                                          $op eq '*' or $op eq '/' or
3961                                          $op eq '%')
3962                                 {
3963                                         if ($check) {
3964                                                 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
3965                                                         if (CHK("SPACING",
3966                                                                 "spaces preferred around that '$op' $at\n" . $hereptr)) {
3967                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3968                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3969                                                                 $line_fixed = 1;
3970                                                         }
3971                                                 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
3972                                                         if (CHK("SPACING",
3973                                                                 "space preferred before that '$op' $at\n" . $hereptr)) {
3974                                                                 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
3975                                                                 $line_fixed = 1;
3976                                                         }
3977                                                 }
3978                                         } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3979                                                 if (ERROR("SPACING",
3980                                                           "need consistent spacing around '$op' $at\n" . $hereptr)) {
3981                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3982                                                         if (defined $fix_elements[$n + 2]) {
3983                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
3984                                                         }
3985                                                         $line_fixed = 1;
3986                                                 }
3987                                         }
3988
3989                                 # A colon needs no spaces before when it is
3990                                 # terminating a case value or a label.
3991                                 } elsif ($opv eq ':C' || $opv eq ':L') {
3992                                         if ($ctx =~ /Wx./) {
3993                                                 if (ERROR("SPACING",
3994                                                           "space prohibited before that '$op' $at\n" . $hereptr)) {
3995                                                         $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3996                                                         $line_fixed = 1;
3997                                                 }
3998                                         }
3999
4000                                 # All the others need spaces both sides.
4001                                 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4002                                         my $ok = 0;
4003
4004                                         # Ignore email addresses <foo@bar>
4005                                         if (($op eq '<' &&
4006                                              $cc =~ /^\S+\@\S+>/) ||
4007                                             ($op eq '>' &&
4008                                              $ca =~ /<\S+\@\S+$/))
4009                                         {
4010                                                 $ok = 1;
4011                                         }
4012
4013                                         # for asm volatile statements
4014                                         # ignore a colon with another
4015                                         # colon immediately before or after
4016                                         if (($op eq ':') &&
4017                                             ($ca =~ /:$/ || $cc =~ /^:/)) {
4018                                                 $ok = 1;
4019                                         }
4020
4021                                         # messages are ERROR, but ?: are CHK
4022                                         if ($ok == 0) {
4023                                                 my $msg_type = \&ERROR;
4024                                                 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4025
4026                                                 if (&{$msg_type}("SPACING",
4027                                                                  "spaces required around that '$op' $at\n" . $hereptr)) {
4028                                                         $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4029                                                         if (defined $fix_elements[$n + 2]) {
4030                                                                 $fix_elements[$n + 2] =~ s/^\s+//;
4031                                                         }
4032                                                         $line_fixed = 1;
4033                                                 }
4034                                         }
4035                                 }
4036                                 $off += length($elements[$n + 1]);
4037
4038 ##                              print("n: <$n> GOOD: <$good>\n");
4039
4040                                 $fixed_line = $fixed_line . $good;
4041                         }
4042
4043                         if (($#elements % 2) == 0) {
4044                                 $fixed_line = $fixed_line . $fix_elements[$#elements];
4045                         }
4046
4047                         if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4048                                 $fixed[$fixlinenr] = $fixed_line;
4049                         }
4050
4051
4052                 }
4053
4054 # check for whitespace before a non-naked semicolon
4055                 if ($line =~ /^\+.*\S\s+;\s*$/) {
4056                         if (WARN("SPACING",
4057                                  "space prohibited before semicolon\n" . $herecurr) &&
4058                             $fix) {
4059                                 1 while $fixed[$fixlinenr] =~
4060                                     s/^(\+.*\S)\s+;/$1;/;
4061                         }
4062                 }
4063
4064 # check for multiple assignments
4065                 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4066                         CHK("MULTIPLE_ASSIGNMENTS",
4067                             "multiple assignments should be avoided\n" . $herecurr);
4068                 }
4069
4070 ## # check for multiple declarations, allowing for a function declaration
4071 ## # continuation.
4072 ##              if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4073 ##                  $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4074 ##
4075 ##                      # Remove any bracketed sections to ensure we do not
4076 ##                      # falsly report the parameters of functions.
4077 ##                      my $ln = $line;
4078 ##                      while ($ln =~ s/\([^\(\)]*\)//g) {
4079 ##                      }
4080 ##                      if ($ln =~ /,/) {
4081 ##                              WARN("MULTIPLE_DECLARATION",
4082 ##                                   "declaring multiple variables together should be avoided\n" . $herecurr);
4083 ##                      }
4084 ##              }
4085
4086 #need space before brace following if, while, etc
4087                 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\){/) ||
4088                     $line =~ /do\{/) {
4089                         if (ERROR("SPACING",
4090                                   "space required before the open brace '{'\n" . $herecurr) &&
4091                             $fix) {
4092                                 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
4093                         }
4094                 }
4095
4096 ## # check for blank lines before declarations
4097 ##              if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4098 ##                  $prevrawline =~ /^.\s*$/) {
4099 ##                      WARN("SPACING",
4100 ##                           "No blank lines before declarations\n" . $hereprev);
4101 ##              }
4102 ##
4103
4104 # closing brace should have a space following it when it has anything
4105 # on the line
4106                 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4107                         if (ERROR("SPACING",
4108                                   "space required after that close brace '}'\n" . $herecurr) &&
4109                             $fix) {
4110                                 $fixed[$fixlinenr] =~
4111                                     s/}((?!(?:,|;|\)))\S)/} $1/;
4112                         }
4113                 }
4114
4115 # check spacing on square brackets
4116                 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4117                         if (ERROR("SPACING",
4118                                   "space prohibited after that open square bracket '['\n" . $herecurr) &&
4119                             $fix) {
4120                                 $fixed[$fixlinenr] =~
4121                                     s/\[\s+/\[/;
4122                         }
4123                 }
4124                 if ($line =~ /\s\]/) {
4125                         if (ERROR("SPACING",
4126                                   "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4127                             $fix) {
4128                                 $fixed[$fixlinenr] =~
4129                                     s/\s+\]/\]/;
4130                         }
4131                 }
4132
4133 # check spacing on parentheses
4134                 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4135                     $line !~ /for\s*\(\s+;/) {
4136                         if (ERROR("SPACING",
4137                                   "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4138                             $fix) {
4139                                 $fixed[$fixlinenr] =~
4140                                     s/\(\s+/\(/;
4141                         }
4142                 }
4143                 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4144                     $line !~ /for\s*\(.*;\s+\)/ &&
4145                     $line !~ /:\s+\)/) {
4146                         if (ERROR("SPACING",
4147                                   "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4148                             $fix) {
4149                                 $fixed[$fixlinenr] =~
4150                                     s/\s+\)/\)/;
4151                         }
4152                 }
4153
4154 # check unnecessary parentheses around addressof/dereference single $Lvals
4155 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4156
4157                 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4158                         my $var = $1;
4159                         if (CHK("UNNECESSARY_PARENTHESES",
4160                                 "Unnecessary parentheses around $var\n" . $herecurr) &&
4161                             $fix) {
4162                                 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4163                         }
4164                 }
4165
4166 # check for unnecessary parentheses around function pointer uses
4167 # ie: (foo->bar)(); should be foo->bar();
4168 # but not "if (foo->bar) (" to avoid some false positives
4169                 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4170                         my $var = $2;
4171                         if (CHK("UNNECESSARY_PARENTHESES",
4172                                 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4173                             $fix) {
4174                                 my $var2 = deparenthesize($var);
4175                                 $var2 =~ s/\s//g;
4176                                 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4177                         }
4178                 }
4179
4180 #goto labels aren't indented, allow a single space however
4181                 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4182                    !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4183                         if (WARN("INDENTED_LABEL",
4184                                  "labels should not be indented\n" . $herecurr) &&
4185                             $fix) {
4186                                 $fixed[$fixlinenr] =~
4187                                     s/^(.)\s+/$1/;
4188                         }
4189                 }
4190
4191 # return is not a function
4192                 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4193                         my $spacing = $1;
4194                         if ($^V && $^V ge 5.10.0 &&
4195                             $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4196                                 my $value = $1;
4197                                 $value = deparenthesize($value);
4198                                 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4199                                         ERROR("RETURN_PARENTHESES",
4200                                               "return is not a function, parentheses are not required\n" . $herecurr);
4201                                 }
4202                         } elsif ($spacing !~ /\s+/) {
4203                                 ERROR("SPACING",
4204                                       "space required before the open parenthesis '('\n" . $herecurr);
4205                         }
4206                 }
4207
4208 # unnecessary return in a void function
4209 # at end-of-function, with the previous line a single leading tab, then return;
4210 # and the line before that not a goto label target like "out:"
4211                 if ($sline =~ /^[ \+]}\s*$/ &&
4212                     $prevline =~ /^\+\treturn\s*;\s*$/ &&
4213                     $linenr >= 3 &&
4214                     $lines[$linenr - 3] =~ /^[ +]/ &&
4215                     $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4216                         WARN("RETURN_VOID",
4217                              "void function return statements are not generally useful\n" . $hereprev);
4218                }
4219
4220 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4221                 if ($^V && $^V ge 5.10.0 &&
4222                     $line =~ /\bif\s*((?:\(\s*){2,})/) {
4223                         my $openparens = $1;
4224                         my $count = $openparens =~ tr@\(@\(@;
4225                         my $msg = "";
4226                         if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4227                                 my $comp = $4;  #Not $1 because of $LvalOrFunc
4228                                 $msg = " - maybe == should be = ?" if ($comp eq "==");
4229                                 WARN("UNNECESSARY_PARENTHESES",
4230                                      "Unnecessary parentheses$msg\n" . $herecurr);
4231                         }
4232                 }
4233
4234 # Return of what appears to be an errno should normally be negative
4235                 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4236                         my $name = $1;
4237                         if ($name ne 'EOF' && $name ne 'ERROR') {
4238                                 WARN("USE_NEGATIVE_ERRNO",
4239                                      "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4240                         }
4241                 }
4242
4243 # Need a space before open parenthesis after if, while etc
4244                 if ($line =~ /\b(if|while|for|switch)\(/) {
4245                         if (ERROR("SPACING",
4246                                   "space required before the open parenthesis '('\n" . $herecurr) &&
4247                             $fix) {
4248                                 $fixed[$fixlinenr] =~
4249                                     s/\b(if|while|for|switch)\(/$1 \(/;
4250                         }
4251                 }
4252
4253 # Check for illegal assignment in if conditional -- and check for trailing
4254 # statements after the conditional.
4255                 if ($line =~ /do\s*(?!{)/) {
4256                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4257                                 ctx_statement_block($linenr, $realcnt, 0)
4258                                         if (!defined $stat);
4259                         my ($stat_next) = ctx_statement_block($line_nr_next,
4260                                                 $remain_next, $off_next);
4261                         $stat_next =~ s/\n./\n /g;
4262                         ##print "stat<$stat> stat_next<$stat_next>\n";
4263
4264                         if ($stat_next =~ /^\s*while\b/) {
4265                                 # If the statement carries leading newlines,
4266                                 # then count those as offsets.
4267                                 my ($whitespace) =
4268                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4269                                 my $offset =
4270                                         statement_rawlines($whitespace) - 1;
4271
4272                                 $suppress_whiletrailers{$line_nr_next +
4273                                                                 $offset} = 1;
4274                         }
4275                 }
4276                 if (!defined $suppress_whiletrailers{$linenr} &&
4277                     defined($stat) && defined($cond) &&
4278                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4279                         my ($s, $c) = ($stat, $cond);
4280
4281                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4282                                 ERROR("ASSIGN_IN_IF",
4283                                       "do not use assignment in if condition\n" . $herecurr);
4284                         }
4285
4286                         # Find out what is on the end of the line after the
4287                         # conditional.
4288                         substr($s, 0, length($c), '');
4289                         $s =~ s/\n.*//g;
4290                         $s =~ s/$;//g;  # Remove any comments
4291                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4292                             $c !~ /}\s*while\s*/)
4293                         {
4294                                 # Find out how long the conditional actually is.
4295                                 my @newlines = ($c =~ /\n/gs);
4296                                 my $cond_lines = 1 + $#newlines;
4297                                 my $stat_real = '';
4298
4299                                 $stat_real = raw_line($linenr, $cond_lines)
4300                                                         . "\n" if ($cond_lines);
4301                                 if (defined($stat_real) && $cond_lines > 1) {
4302                                         $stat_real = "[...]\n$stat_real";
4303                                 }
4304
4305                                 ERROR("TRAILING_STATEMENTS",
4306                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
4307                         }
4308                 }
4309
4310 # Check for bitwise tests written as boolean
4311                 if ($line =~ /
4312                         (?:
4313                                 (?:\[|\(|\&\&|\|\|)
4314                                 \s*0[xX][0-9]+\s*
4315                                 (?:\&\&|\|\|)
4316                         |
4317                                 (?:\&\&|\|\|)
4318                                 \s*0[xX][0-9]+\s*
4319                                 (?:\&\&|\|\||\)|\])
4320                         )/x)
4321                 {
4322                         WARN("HEXADECIMAL_BOOLEAN_TEST",
4323                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4324                 }
4325
4326 # if and else should not have general statements after it
4327                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4328                         my $s = $1;
4329                         $s =~ s/$;//g;  # Remove any comments
4330                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4331                                 ERROR("TRAILING_STATEMENTS",
4332                                       "trailing statements should be on next line\n" . $herecurr);
4333                         }
4334                 }
4335 # if should not continue a brace
4336                 if ($line =~ /}\s*if\b/) {
4337                         ERROR("TRAILING_STATEMENTS",
4338                               "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4339                                 $herecurr);
4340                 }
4341 # case and default should not have general statements after them
4342                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4343                     $line !~ /\G(?:
4344                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4345                         \s*return\s+
4346                     )/xg)
4347                 {
4348                         ERROR("TRAILING_STATEMENTS",
4349                               "trailing statements should be on next line\n" . $herecurr);
4350                 }
4351
4352                 # Check for }<nl>else {, these must be at the same
4353                 # indent level to be relevant to each other.
4354                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4355                     $previndent == $indent) {
4356                         if (ERROR("ELSE_AFTER_BRACE",
4357                                   "else should follow close brace '}'\n" . $hereprev) &&
4358                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4359                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4360                                 fix_delete_line($fixlinenr, $rawline);
4361                                 my $fixedline = $prevrawline;
4362                                 $fixedline =~ s/}\s*$//;
4363                                 if ($fixedline !~ /^\+\s*$/) {
4364                                         fix_insert_line($fixlinenr, $fixedline);
4365                                 }
4366                                 $fixedline = $rawline;
4367                                 $fixedline =~ s/^(.\s*)else/$1} else/;
4368                                 fix_insert_line($fixlinenr, $fixedline);
4369                         }
4370                 }
4371
4372                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4373                     $previndent == $indent) {
4374                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4375
4376                         # Find out what is on the end of the line after the
4377                         # conditional.
4378                         substr($s, 0, length($c), '');
4379                         $s =~ s/\n.*//g;
4380
4381                         if ($s =~ /^\s*;/) {
4382                                 if (ERROR("WHILE_AFTER_BRACE",
4383                                           "while should follow close brace '}'\n" . $hereprev) &&
4384                                     $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4385                                         fix_delete_line($fixlinenr - 1, $prevrawline);
4386                                         fix_delete_line($fixlinenr, $rawline);
4387                                         my $fixedline = $prevrawline;
4388                                         my $trailing = $rawline;
4389                                         $trailing =~ s/^\+//;
4390                                         $trailing = trim($trailing);
4391                                         $fixedline =~ s/}\s*$/} $trailing/;
4392                                         fix_insert_line($fixlinenr, $fixedline);
4393                                 }
4394                         }
4395                 }
4396
4397 #Specific variable tests
4398                 while ($line =~ m{($Constant|$Lval)}g) {
4399                         my $var = $1;
4400
4401 #gcc binary extension
4402                         if ($var =~ /^$Binary$/) {
4403                                 if (WARN("GCC_BINARY_CONSTANT",
4404                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4405                                     $fix) {
4406                                         my $hexval = sprintf("0x%x", oct($var));
4407                                         $fixed[$fixlinenr] =~
4408                                             s/\b$var\b/$hexval/;
4409                                 }
4410                         }
4411
4412 #CamelCase
4413                         if ($var !~ /^$Constant$/ &&
4414                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4415 #Ignore Page<foo> variants
4416                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4417 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4418                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4419 #Ignore some three character SI units explicitly, like MiB and KHz
4420                             $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4421                                 while ($var =~ m{($Ident)}g) {
4422                                         my $word = $1;
4423                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4424                                         if ($check) {
4425                                                 seed_camelcase_includes();
4426                                                 if (!$file && !$camelcase_file_seeded) {
4427                                                         seed_camelcase_file($realfile);
4428                                                         $camelcase_file_seeded = 1;
4429                                                 }
4430                                         }
4431                                         if (!defined $camelcase{$word}) {
4432                                                 $camelcase{$word} = 1;
4433                                                 CHK("CAMELCASE",
4434                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
4435                                         }
4436                                 }
4437                         }
4438                 }
4439
4440 #no spaces allowed after \ in define
4441                 if ($line =~ /\#\s*define.*\\\s+$/) {
4442                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4443                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4444                             $fix) {
4445                                 $fixed[$fixlinenr] =~ s/\s+$//;
4446                         }
4447                 }
4448
4449 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4450 # itself <asm/foo.h> (uses RAW line)
4451                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4452                         my $file = "$1.h";
4453                         my $checkfile = "include/linux/$file";
4454                         if (-f "$root/$checkfile" &&
4455                             $realfile ne $checkfile &&
4456                             $1 !~ /$allowed_asm_includes/)
4457                         {
4458                                 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4459                                 if ($asminclude > 0) {
4460                                         if ($realfile =~ m{^arch/}) {
4461                                                 CHK("ARCH_INCLUDE_LINUX",
4462                                                     "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4463                                         } else {
4464                                                 WARN("INCLUDE_LINUX",
4465                                                      "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4466                                         }
4467                                 }
4468                         }
4469                 }
4470
4471 # multi-statement macros should be enclosed in a do while loop, grab the
4472 # first statement and ensure its the whole macro if its not enclosed
4473 # in a known good container
4474                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4475                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4476                         my $ln = $linenr;
4477                         my $cnt = $realcnt;
4478                         my ($off, $dstat, $dcond, $rest);
4479                         my $ctx = '';
4480                         my $has_flow_statement = 0;
4481                         my $has_arg_concat = 0;
4482                         ($dstat, $dcond, $ln, $cnt, $off) =
4483                                 ctx_statement_block($linenr, $realcnt, 0);
4484                         $ctx = $dstat;
4485                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4486                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4487
4488                         $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4489                         $has_arg_concat = 1 if ($ctx =~ /\#\#/);
4490
4491                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4492                         $dstat =~ s/$;//g;
4493                         $dstat =~ s/\\\n.//g;
4494                         $dstat =~ s/^\s*//s;
4495                         $dstat =~ s/\s*$//s;
4496
4497                         # Flatten any parentheses and braces
4498                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4499                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
4500                                $dstat =~ s/\[[^\[\]]*\]/1/)
4501                         {
4502                         }
4503
4504                         # Flatten any obvious string concatentation.
4505                         while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4506                                $dstat =~ s/$Ident\s*($String)/$1/)
4507                         {
4508                         }
4509
4510                         my $exceptions = qr{
4511                                 $Declare|
4512                                 module_param_named|
4513                                 MODULE_PARM_DESC|
4514                                 DECLARE_PER_CPU|
4515                                 DEFINE_PER_CPU|
4516                                 __typeof__\(|
4517                                 union|
4518                                 struct|
4519                                 \.$Ident\s*=\s*|
4520                                 ^\"|\"$
4521                         }x;
4522                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4523                         if ($dstat ne '' &&
4524                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
4525                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
4526                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4527                             $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&                  # character constants
4528                             $dstat !~ /$exceptions/ &&
4529                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
4530                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
4531                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
4532                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
4533                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
4534                             $dstat !~ /^do\s*{/ &&                                      # do {...
4535                             $dstat !~ /^\(\{/ &&                                                # ({...
4536                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4537                         {
4538                                 $ctx =~ s/\n*$//;
4539                                 my $herectx = $here . "\n";
4540                                 my $cnt = statement_rawlines($ctx);
4541
4542                                 for (my $n = 0; $n < $cnt; $n++) {
4543                                         $herectx .= raw_line($linenr, $n) . "\n";
4544                                 }
4545
4546                                 if ($dstat =~ /;/) {
4547                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4548                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4549                                 } else {
4550                                         ERROR("COMPLEX_MACRO",
4551                                               "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4552                                 }
4553                         }
4554
4555 # check for macros with flow control, but without ## concatenation
4556 # ## concatenation is commonly a macro that defines a function so ignore those
4557                         if ($has_flow_statement && !$has_arg_concat) {
4558                                 my $herectx = $here . "\n";
4559                                 my $cnt = statement_rawlines($ctx);
4560
4561                                 for (my $n = 0; $n < $cnt; $n++) {
4562                                         $herectx .= raw_line($linenr, $n) . "\n";
4563                                 }
4564                                 WARN("MACRO_WITH_FLOW_CONTROL",
4565                                      "Macros with flow control statements should be avoided\n" . "$herectx");
4566                         }
4567
4568 # check for line continuations outside of #defines, preprocessor #, and asm
4569
4570                 } else {
4571                         if ($prevline !~ /^..*\\$/ &&
4572                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
4573                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
4574                             $line =~ /^\+.*\\$/) {
4575                                 WARN("LINE_CONTINUATIONS",
4576                                      "Avoid unnecessary line continuations\n" . $herecurr);
4577                         }
4578                 }
4579
4580 # do {} while (0) macro tests:
4581 # single-statement macros do not need to be enclosed in do while (0) loop,
4582 # macro should not end with a semicolon
4583                 if ($^V && $^V ge 5.10.0 &&
4584                     $realfile !~ m@/vmlinux.lds.h$@ &&
4585                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4586                         my $ln = $linenr;
4587                         my $cnt = $realcnt;
4588                         my ($off, $dstat, $dcond, $rest);
4589                         my $ctx = '';
4590                         ($dstat, $dcond, $ln, $cnt, $off) =
4591                                 ctx_statement_block($linenr, $realcnt, 0);
4592                         $ctx = $dstat;
4593
4594                         $dstat =~ s/\\\n.//g;
4595                         $dstat =~ s/$;/ /g;
4596
4597                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4598                                 my $stmts = $2;
4599                                 my $semis = $3;
4600
4601                                 $ctx =~ s/\n*$//;
4602                                 my $cnt = statement_rawlines($ctx);
4603                                 my $herectx = $here . "\n";
4604
4605                                 for (my $n = 0; $n < $cnt; $n++) {
4606                                         $herectx .= raw_line($linenr, $n) . "\n";
4607                                 }
4608
4609                                 if (($stmts =~ tr/;/;/) == 1 &&
4610                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
4611                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4612                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4613                                 }
4614                                 if (defined $semis && $semis ne "") {
4615                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4616                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4617                                 }
4618                         } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4619                                 $ctx =~ s/\n*$//;
4620                                 my $cnt = statement_rawlines($ctx);
4621                                 my $herectx = $here . "\n";
4622
4623                                 for (my $n = 0; $n < $cnt; $n++) {
4624                                         $herectx .= raw_line($linenr, $n) . "\n";
4625                                 }
4626
4627                                 WARN("TRAILING_SEMICOLON",
4628                                      "macros should not use a trailing semicolon\n" . "$herectx");
4629                         }
4630                 }
4631
4632 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4633 # all assignments may have only one of the following with an assignment:
4634 #       .
4635 #       ALIGN(...)
4636 #       VMLINUX_SYMBOL(...)
4637                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4638                         WARN("MISSING_VMLINUX_SYMBOL",
4639                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4640                 }
4641
4642 # check for redundant bracing round if etc
4643                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4644                         my ($level, $endln, @chunks) =
4645                                 ctx_statement_full($linenr, $realcnt, 1);
4646                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4647                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4648                         if ($#chunks > 0 && $level == 0) {
4649                                 my @allowed = ();
4650                                 my $allow = 0;
4651                                 my $seen = 0;
4652                                 my $herectx = $here . "\n";
4653                                 my $ln = $linenr - 1;
4654                                 for my $chunk (@chunks) {
4655                                         my ($cond, $block) = @{$chunk};
4656
4657                                         # If the condition carries leading newlines, then count those as offsets.
4658                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4659                                         my $offset = statement_rawlines($whitespace) - 1;
4660
4661                                         $allowed[$allow] = 0;
4662                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4663
4664                                         # We have looked at and allowed this specific line.
4665                                         $suppress_ifbraces{$ln + $offset} = 1;
4666
4667                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4668                                         $ln += statement_rawlines($block) - 1;
4669
4670                                         substr($block, 0, length($cond), '');
4671
4672                                         $seen++ if ($block =~ /^\s*{/);
4673
4674                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4675                                         if (statement_lines($cond) > 1) {
4676                                                 #print "APW: ALLOWED: cond<$cond>\n";
4677                                                 $allowed[$allow] = 1;
4678                                         }
4679                                         if ($block =~/\b(?:if|for|while)\b/) {
4680                                                 #print "APW: ALLOWED: block<$block>\n";
4681                                                 $allowed[$allow] = 1;
4682                                         }
4683                                         if (statement_block_size($block) > 1) {
4684                                                 #print "APW: ALLOWED: lines block<$block>\n";
4685                                                 $allowed[$allow] = 1;
4686                                         }
4687                                         $allow++;
4688                                 }
4689                                 if ($seen) {
4690                                         my $sum_allowed = 0;
4691                                         foreach (@allowed) {
4692                                                 $sum_allowed += $_;
4693                                         }
4694                                         if ($sum_allowed == 0) {
4695                                                 WARN("BRACES",
4696                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
4697                                         } elsif ($sum_allowed != $allow &&
4698                                                  $seen != $allow) {
4699                                                 CHK("BRACES",
4700                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
4701                                         }
4702                                 }
4703                         }
4704                 }
4705                 if (!defined $suppress_ifbraces{$linenr - 1} &&
4706                                         $line =~ /\b(if|while|for|else)\b/) {
4707                         my $allowed = 0;
4708
4709                         # Check the pre-context.
4710                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4711                                 #print "APW: ALLOWED: pre<$1>\n";
4712                                 $allowed = 1;
4713                         }
4714
4715                         my ($level, $endln, @chunks) =
4716                                 ctx_statement_full($linenr, $realcnt, $-[0]);
4717
4718                         # Check the condition.
4719                         my ($cond, $block) = @{$chunks[0]};
4720                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4721                         if (defined $cond) {
4722                                 substr($block, 0, length($cond), '');
4723                         }
4724                         if (statement_lines($cond) > 1) {
4725                                 #print "APW: ALLOWED: cond<$cond>\n";
4726                                 $allowed = 1;
4727                         }
4728                         if ($block =~/\b(?:if|for|while)\b/) {
4729                                 #print "APW: ALLOWED: block<$block>\n";
4730                                 $allowed = 1;
4731                         }
4732                         if (statement_block_size($block) > 1) {
4733                                 #print "APW: ALLOWED: lines block<$block>\n";
4734                                 $allowed = 1;
4735                         }
4736                         # Check the post-context.
4737                         if (defined $chunks[1]) {
4738                                 my ($cond, $block) = @{$chunks[1]};
4739                                 if (defined $cond) {
4740                                         substr($block, 0, length($cond), '');
4741                                 }
4742                                 if ($block =~ /^\s*\{/) {
4743                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
4744                                         $allowed = 1;
4745                                 }
4746                         }
4747                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4748                                 my $herectx = $here . "\n";
4749                                 my $cnt = statement_rawlines($block);
4750
4751                                 for (my $n = 0; $n < $cnt; $n++) {
4752                                         $herectx .= raw_line($linenr, $n) . "\n";
4753                                 }
4754
4755                                 WARN("BRACES",
4756                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
4757                         }
4758                 }
4759
4760 # check for unnecessary blank lines around braces
4761                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4762                         if (CHK("BRACES",
4763                                 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4764                             $fix && $prevrawline =~ /^\+/) {
4765                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4766                         }
4767                 }
4768                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4769                         if (CHK("BRACES",
4770                                 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4771                             $fix) {
4772                                 fix_delete_line($fixlinenr, $rawline);
4773                         }
4774                 }
4775
4776 # no volatiles please
4777                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4778                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4779                         WARN("VOLATILE",
4780                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4781                 }
4782
4783 # Check for user-visible strings broken across lines, which breaks the ability
4784 # to grep for the string.  Make exceptions when the previous string ends in a
4785 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4786 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
4787                 if ($line =~ /^\+\s*$String/ &&
4788                     $prevline =~ /"\s*$/ &&
4789                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4790                         if (WARN("SPLIT_STRING",
4791                                  "quoted string split across lines\n" . $hereprev) &&
4792                                      $fix &&
4793                                      $prevrawline =~ /^\+.*"\s*$/ &&
4794                                      $last_coalesced_string_linenr != $linenr - 1) {
4795                                 my $extracted_string = get_quoted_string($line, $rawline);
4796                                 my $comma_close = "";
4797                                 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4798                                         $comma_close = $1;
4799                                 }
4800
4801                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4802                                 fix_delete_line($fixlinenr, $rawline);
4803                                 my $fixedline = $prevrawline;
4804                                 $fixedline =~ s/"\s*$//;
4805                                 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4806                                 fix_insert_line($fixlinenr - 1, $fixedline);
4807                                 $fixedline = $rawline;
4808                                 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4809                                 if ($fixedline !~ /\+\s*$/) {
4810                                         fix_insert_line($fixlinenr, $fixedline);
4811                                 }
4812                                 $last_coalesced_string_linenr = $linenr;
4813                         }
4814                 }
4815
4816 # check for missing a space in a string concatenation
4817                 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4818                         WARN('MISSING_SPACE',
4819                              "break quoted strings at a space character\n" . $hereprev);
4820                 }
4821
4822 # check for spaces before a quoted newline
4823                 if ($rawline =~ /^.*\".*\s\\n/) {
4824                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
4825                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
4826                             $fix) {
4827                                 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
4828                         }
4829
4830                 }
4831
4832 # concatenated string without spaces between elements
4833                 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
4834                         CHK("CONCATENATED_STRING",
4835                             "Concatenated strings should use spaces between elements\n" . $herecurr);
4836                 }
4837
4838 # uncoalesced string fragments
4839                 if ($line =~ /$String\s*"/) {
4840                         WARN("STRING_FRAGMENTS",
4841                              "Consecutive strings are generally better as a single string\n" . $herecurr);
4842                 }
4843
4844 # check for %L{u,d,i} and 0x%[udi] in strings
4845                 my $string;
4846                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4847                         $string = substr($rawline, $-[1], $+[1] - $-[1]);
4848                         $string =~ s/%%/__/g;
4849                         if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
4850                                 WARN("PRINTF_L",
4851                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4852                                 last;
4853                         }
4854                         if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
4855                                 ERROR("PRINTF_0xDECIMAL",
4856                                       "Prefixing 0x with decimal output is defective\n" . $herecurr);
4857                         }
4858                 }
4859
4860 # check for line continuations in quoted strings with odd counts of "
4861                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4862                         WARN("LINE_CONTINUATIONS",
4863                              "Avoid line continuations in quoted strings\n" . $herecurr);
4864                 }
4865
4866 # warn about #if 0
4867                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
4868                         CHK("REDUNDANT_CODE",
4869                             "if this code is redundant consider removing it\n" .
4870                                 $herecurr);
4871                 }
4872
4873 # check for needless "if (<foo>) fn(<foo>)" uses
4874                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4875                         my $tested = quotemeta($1);
4876                         my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
4877                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
4878                                 my $func = $1;
4879                                 if (WARN('NEEDLESS_IF',
4880                                          "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
4881                                     $fix) {
4882                                         my $do_fix = 1;
4883                                         my $leading_tabs = "";
4884                                         my $new_leading_tabs = "";
4885                                         if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
4886                                                 $leading_tabs = $1;
4887                                         } else {
4888                                                 $do_fix = 0;
4889                                         }
4890                                         if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
4891                                                 $new_leading_tabs = $1;
4892                                                 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
4893                                                         $do_fix = 0;
4894                                                 }
4895                                         } else {
4896                                                 $do_fix = 0;
4897                                         }
4898                                         if ($do_fix) {
4899                                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4900                                                 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
4901                                         }
4902                                 }
4903                         }
4904                 }
4905
4906 # check for unnecessary "Out of Memory" messages
4907                 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4908                     $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4909                     (defined $1 || defined $3) &&
4910                     $linenr > 3) {
4911                         my $testval = $2;
4912                         my $testline = $lines[$linenr - 3];
4913
4914                         my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4915 #                       print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4916
4917                         if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4918                                 WARN("OOM_MESSAGE",
4919                                      "Possible unnecessary 'out of memory' message\n" . $hereprev);
4920                         }
4921                 }
4922
4923 # check for logging functions with KERN_<LEVEL>
4924                 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
4925                     $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
4926                         my $level = $1;
4927                         if (WARN("UNNECESSARY_KERN_LEVEL",
4928                                  "Possible unnecessary $level\n" . $herecurr) &&
4929                             $fix) {
4930                                 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
4931                         }
4932                 }
4933
4934 # check for mask then right shift without a parentheses
4935                 if ($^V && $^V ge 5.10.0 &&
4936                     $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
4937                     $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
4938                         WARN("MASK_THEN_SHIFT",
4939                              "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
4940                 }
4941
4942 # check for pointer comparisons to NULL
4943                 if ($^V && $^V ge 5.10.0) {
4944                         while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
4945                                 my $val = $1;
4946                                 my $equal = "!";
4947                                 $equal = "" if ($4 eq "!=");
4948                                 if (CHK("COMPARISON_TO_NULL",
4949                                         "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
4950                                             $fix) {
4951                                         $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
4952                                 }
4953                         }
4954                 }
4955
4956 # check for bad placement of section $InitAttribute (e.g.: __initdata)
4957                 if ($line =~ /(\b$InitAttribute\b)/) {
4958                         my $attr = $1;
4959                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4960                                 my $ptr = $1;
4961                                 my $var = $2;
4962                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4963                                       ERROR("MISPLACED_INIT",
4964                                             "$attr should be placed after $var\n" . $herecurr)) ||
4965                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4966                                       WARN("MISPLACED_INIT",
4967                                            "$attr should be placed after $var\n" . $herecurr))) &&
4968                                     $fix) {
4969                                         $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;
4970                                 }
4971                         }
4972                 }
4973
4974 # check for $InitAttributeData (ie: __initdata) with const
4975                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4976                         my $attr = $1;
4977                         $attr =~ /($InitAttributePrefix)(.*)/;
4978                         my $attr_prefix = $1;
4979                         my $attr_type = $2;
4980                         if (ERROR("INIT_ATTRIBUTE",
4981                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4982                             $fix) {
4983                                 $fixed[$fixlinenr] =~
4984                                     s/$InitAttributeData/${attr_prefix}initconst/;
4985                         }
4986                 }
4987
4988 # check for $InitAttributeConst (ie: __initconst) without const
4989                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4990                         my $attr = $1;
4991                         if (ERROR("INIT_ATTRIBUTE",
4992                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
4993                             $fix) {
4994                                 my $lead = $fixed[$fixlinenr] =~
4995                                     /(^\+\s*(?:static\s+))/;
4996                                 $lead = rtrim($1);
4997                                 $lead = "$lead " if ($lead !~ /^\+$/);
4998                                 $lead = "${lead}const ";
4999                                 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5000                         }
5001                 }
5002
5003 # check for __read_mostly with const non-pointer (should just be const)
5004                 if ($line =~ /\b__read_mostly\b/ &&
5005                     $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5006                         if (ERROR("CONST_READ_MOSTLY",
5007                                   "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5008                             $fix) {
5009                                 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5010                         }
5011                 }
5012
5013 # don't use __constant_<foo> functions outside of include/uapi/
5014                 if ($realfile !~ m@^include/uapi/@ &&
5015                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5016                         my $constant_func = $1;
5017                         my $func = $constant_func;
5018                         $func =~ s/^__constant_//;
5019                         if (WARN("CONSTANT_CONVERSION",
5020                                  "$constant_func should be $func\n" . $herecurr) &&
5021                             $fix) {
5022                                 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5023                         }
5024                 }
5025
5026 # prefer usleep_range over udelay
5027                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5028                         my $delay = $1;
5029                         # ignore udelay's < 10, however
5030                         if (! ($delay < 10) ) {
5031                                 CHK("USLEEP_RANGE",
5032                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5033                         }
5034                         if ($delay > 2000) {
5035                                 WARN("LONG_UDELAY",
5036                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5037                         }
5038                 }
5039
5040 # warn about unexpectedly long msleep's
5041                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5042                         if ($1 < 20) {
5043                                 WARN("MSLEEP",
5044                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5045                         }
5046                 }
5047
5048 # check for comparisons of jiffies
5049                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5050                         WARN("JIFFIES_COMPARISON",
5051                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5052                 }
5053
5054 # check for comparisons of get_jiffies_64()
5055                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5056                         WARN("JIFFIES_COMPARISON",
5057                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5058                 }
5059
5060 # warn about #ifdefs in C files
5061 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5062 #                       print "#ifdef in C files should be avoided\n";
5063 #                       print "$herecurr";
5064 #                       $clean = 0;
5065 #               }
5066
5067 # warn about spacing in #ifdefs
5068                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5069                         if (ERROR("SPACING",
5070                                   "exactly one space required after that #$1\n" . $herecurr) &&
5071                             $fix) {
5072                                 $fixed[$fixlinenr] =~
5073                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5074                         }
5075
5076                 }
5077
5078 # check for spinlock_t definitions without a comment.
5079                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5080                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5081                         my $which = $1;
5082                         if (!ctx_has_comment($first_line, $linenr)) {
5083                                 CHK("UNCOMMENTED_DEFINITION",
5084                                     "$1 definition without comment\n" . $herecurr);
5085                         }
5086                 }
5087 # check for memory barriers without a comment.
5088                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
5089                         if (!ctx_has_comment($first_line, $linenr)) {
5090                                 WARN("MEMORY_BARRIER",
5091                                      "memory barrier without comment\n" . $herecurr);
5092                         }
5093                 }
5094
5095 # check for waitqueue_active without a comment.
5096                 if ($line =~ /\bwaitqueue_active\s*\(/) {
5097                         if (!ctx_has_comment($first_line, $linenr)) {
5098                                 WARN("WAITQUEUE_ACTIVE",
5099                                      "waitqueue_active without comment\n" . $herecurr);
5100                         }
5101                 }
5102
5103 # Check for expedited grace periods that interrupt non-idle non-nohz
5104 # online CPUs.  These expedited can therefore degrade real-time response
5105 # if used carelessly, and should be avoided where not absolutely
5106 # needed.  It is always OK to use synchronize_rcu_expedited() and
5107 # synchronize_sched_expedited() at boot time (before real-time applications
5108 # start) and in error situations where real-time response is compromised in
5109 # any case.  Note that synchronize_srcu_expedited() does -not- interrupt
5110 # other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5111 # Of course, nothing comes for free, and srcu_read_lock() and
5112 # srcu_read_unlock() do contain full memory barriers in payment for
5113 # synchronize_srcu_expedited() non-interruption properties.
5114                 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5115                         WARN("EXPEDITED_RCU_GRACE_PERIOD",
5116                              "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5117
5118                 }
5119
5120 # check of hardware specific defines
5121                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5122                         CHK("ARCH_DEFINES",
5123                             "architecture specific defines should be avoided\n" .  $herecurr);
5124                 }
5125
5126 # Check that the storage class is at the beginning of a declaration
5127                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
5128                         WARN("STORAGE_CLASS",
5129                              "storage class should be at the beginning of the declaration\n" . $herecurr)
5130                 }
5131
5132 # check the location of the inline attribute, that it is between
5133 # storage class and type.
5134                 if ($line =~ /\b$Type\s+$Inline\b/ ||
5135                     $line =~ /\b$Inline\s+$Storage\b/) {
5136                         ERROR("INLINE_LOCATION",
5137                               "inline keyword should sit between storage class and type\n" . $herecurr);
5138                 }
5139
5140 # Check for __inline__ and __inline, prefer inline
5141                 if ($realfile !~ m@\binclude/uapi/@ &&
5142                     $line =~ /\b(__inline__|__inline)\b/) {
5143                         if (WARN("INLINE",
5144                                  "plain inline is preferred over $1\n" . $herecurr) &&
5145                             $fix) {
5146                                 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5147
5148                         }
5149                 }
5150
5151 # Check for __attribute__ packed, prefer __packed
5152                 if ($realfile !~ m@\binclude/uapi/@ &&
5153                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5154                         WARN("PREFER_PACKED",
5155                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5156                 }
5157
5158 # Check for __attribute__ aligned, prefer __aligned
5159                 if ($realfile !~ m@\binclude/uapi/@ &&
5160                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5161                         WARN("PREFER_ALIGNED",
5162                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5163                 }
5164
5165 # Check for __attribute__ format(printf, prefer __printf
5166                 if ($realfile !~ m@\binclude/uapi/@ &&
5167                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5168                         if (WARN("PREFER_PRINTF",
5169                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5170                             $fix) {
5171                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5172
5173                         }
5174                 }
5175
5176 # Check for __attribute__ format(scanf, prefer __scanf
5177                 if ($realfile !~ m@\binclude/uapi/@ &&
5178                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5179                         if (WARN("PREFER_SCANF",
5180                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5181                             $fix) {
5182                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5183                         }
5184                 }
5185
5186 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5187                 if ($^V && $^V ge 5.10.0 &&
5188                     $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5189                     ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5190                      $line =~ /\b__weak\b/)) {
5191                         ERROR("WEAK_DECLARATION",
5192                               "Using weak declarations can have unintended link defects\n" . $herecurr);
5193                 }
5194
5195 # check for c99 types like uint8_t used outside of uapi/
5196                 if ($realfile !~ m@\binclude/uapi/@ &&
5197                     $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5198                         my $type = $1;
5199                         if ($type =~ /\b($typeC99Typedefs)\b/) {
5200                                 $type = $1;
5201                                 my $kernel_type = 'u';
5202                                 $kernel_type = 's' if ($type =~ /^_*[si]/);
5203                                 $type =~ /(\d+)/;
5204                                 $kernel_type .= $1;
5205                                 if (CHK("PREFER_KERNEL_TYPES",
5206                                         "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5207                                     $fix) {
5208                                         $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5209                                 }
5210                         }
5211                 }
5212
5213 # check for sizeof(&)
5214                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5215                         WARN("SIZEOF_ADDRESS",
5216                              "sizeof(& should be avoided\n" . $herecurr);
5217                 }
5218
5219 # check for sizeof without parenthesis
5220                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5221                         if (WARN("SIZEOF_PARENTHESIS",
5222                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5223                             $fix) {
5224                                 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5225                         }
5226                 }
5227
5228 # check for struct spinlock declarations
5229                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5230                         WARN("USE_SPINLOCK_T",
5231                              "struct spinlock should be spinlock_t\n" . $herecurr);
5232                 }
5233
5234 # check for seq_printf uses that could be seq_puts
5235                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5236                         my $fmt = get_quoted_string($line, $rawline);
5237                         $fmt =~ s/%%//g;
5238                         if ($fmt !~ /%/) {
5239                                 if (WARN("PREFER_SEQ_PUTS",
5240                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5241                                     $fix) {
5242                                         $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5243                                 }
5244                         }
5245                 }
5246
5247 # Check for misused memsets
5248                 if ($^V && $^V ge 5.10.0 &&
5249                     defined $stat &&
5250                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5251
5252                         my $ms_addr = $2;
5253                         my $ms_val = $7;
5254                         my $ms_size = $12;
5255
5256                         if ($ms_size =~ /^(0x|)0$/i) {
5257                                 ERROR("MEMSET",
5258                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5259                         } elsif ($ms_size =~ /^(0x|)1$/i) {
5260                                 WARN("MEMSET",
5261                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5262                         }
5263                 }
5264
5265 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5266                 if ($^V && $^V ge 5.10.0 &&
5267                     defined $stat &&
5268                     $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5269                         if (WARN("PREFER_ETHER_ADDR_COPY",
5270                                  "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5271                             $fix) {
5272                                 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5273                         }
5274                 }
5275
5276 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5277                 if ($^V && $^V ge 5.10.0 &&
5278                     defined $stat &&
5279                     $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5280                         WARN("PREFER_ETHER_ADDR_EQUAL",
5281                              "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5282                 }
5283
5284 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5285 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5286                 if ($^V && $^V ge 5.10.0 &&
5287                     defined $stat &&
5288                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5289
5290                         my $ms_val = $7;
5291
5292                         if ($ms_val =~ /^(?:0x|)0+$/i) {
5293                                 if (WARN("PREFER_ETH_ZERO_ADDR",
5294                                          "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5295                                     $fix) {
5296                                         $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5297                                 }
5298                         } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5299                                 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5300                                          "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5301                                     $fix) {
5302                                         $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5303                                 }
5304                         }
5305                 }
5306
5307 # typecasts on min/max could be min_t/max_t
5308                 if ($^V && $^V ge 5.10.0 &&
5309                     defined $stat &&
5310                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5311                         if (defined $2 || defined $7) {
5312                                 my $call = $1;
5313                                 my $cast1 = deparenthesize($2);
5314                                 my $arg1 = $3;
5315                                 my $cast2 = deparenthesize($7);
5316                                 my $arg2 = $8;
5317                                 my $cast;
5318
5319                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5320                                         $cast = "$cast1 or $cast2";
5321                                 } elsif ($cast1 ne "") {
5322                                         $cast = $cast1;
5323                                 } else {
5324                                         $cast = $cast2;
5325                                 }
5326                                 WARN("MINMAX",
5327                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5328                         }
5329                 }
5330
5331 # check usleep_range arguments
5332                 if ($^V && $^V ge 5.10.0 &&
5333                     defined $stat &&
5334                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5335                         my $min = $1;
5336                         my $max = $7;
5337                         if ($min eq $max) {
5338                                 WARN("USLEEP_RANGE",
5339                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5340                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5341                                  $min > $max) {
5342                                 WARN("USLEEP_RANGE",
5343                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5344                         }
5345                 }
5346
5347 # check for naked sscanf
5348                 if ($^V && $^V ge 5.10.0 &&
5349                     defined $stat &&
5350                     $line =~ /\bsscanf\b/ &&
5351                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5352                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5353                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5354                         my $lc = $stat =~ tr@\n@@;
5355                         $lc = $lc + $linenr;
5356                         my $stat_real = raw_line($linenr, 0);
5357                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5358                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5359                         }
5360                         WARN("NAKED_SSCANF",
5361                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5362                 }
5363
5364 # check for simple sscanf that should be kstrto<foo>
5365                 if ($^V && $^V ge 5.10.0 &&
5366                     defined $stat &&
5367                     $line =~ /\bsscanf\b/) {
5368                         my $lc = $stat =~ tr@\n@@;
5369                         $lc = $lc + $linenr;
5370                         my $stat_real = raw_line($linenr, 0);
5371                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5372                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5373                         }
5374                         if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5375                                 my $format = $6;
5376                                 my $count = $format =~ tr@%@%@;
5377                                 if ($count == 1 &&
5378                                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5379                                         WARN("SSCANF_TO_KSTRTO",
5380                                              "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5381                                 }
5382                         }
5383                 }
5384
5385 # check for new externs in .h files.
5386                 if ($realfile =~ /\.h$/ &&
5387                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5388                         if (CHK("AVOID_EXTERNS",
5389                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5390                             $fix) {
5391                                 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5392                         }
5393                 }
5394
5395 # check for new externs in .c files.
5396                 if ($realfile =~ /\.c$/ && defined $stat &&
5397                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5398                 {
5399                         my $function_name = $1;
5400                         my $paren_space = $2;
5401
5402                         my $s = $stat;
5403                         if (defined $cond) {
5404                                 substr($s, 0, length($cond), '');
5405                         }
5406                         if ($s =~ /^\s*;/ &&
5407                             $function_name ne 'uninitialized_var')
5408                         {
5409                                 WARN("AVOID_EXTERNS",
5410                                      "externs should be avoided in .c files\n" .  $herecurr);
5411                         }
5412
5413                         if ($paren_space =~ /\n/) {
5414                                 WARN("FUNCTION_ARGUMENTS",
5415                                      "arguments for function declarations should follow identifier\n" . $herecurr);
5416                         }
5417
5418                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5419                     $stat =~ /^.\s*extern\s+/)
5420                 {
5421                         WARN("AVOID_EXTERNS",
5422                              "externs should be avoided in .c files\n" .  $herecurr);
5423                 }
5424
5425 # checks for new __setup's
5426                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5427                         my $name = $1;
5428
5429                         if (!grep(/$name/, @setup_docs)) {
5430                                 CHK("UNDOCUMENTED_SETUP",
5431                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
5432                         }
5433                 }
5434
5435 # check for pointless casting of kmalloc return
5436                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5437                         WARN("UNNECESSARY_CASTS",
5438                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5439                 }
5440
5441 # alloc style
5442 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5443                 if ($^V && $^V ge 5.10.0 &&
5444                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5445                         CHK("ALLOC_SIZEOF_STRUCT",
5446                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5447                 }
5448
5449 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5450                 if ($^V && $^V ge 5.10.0 &&
5451                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5452                         my $oldfunc = $3;
5453                         my $a1 = $4;
5454                         my $a2 = $10;
5455                         my $newfunc = "kmalloc_array";
5456                         $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5457                         my $r1 = $a1;
5458                         my $r2 = $a2;
5459                         if ($a1 =~ /^sizeof\s*\S/) {
5460                                 $r1 = $a2;
5461                                 $r2 = $a1;
5462                         }
5463                         if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5464                             !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5465                                 if (WARN("ALLOC_WITH_MULTIPLY",
5466                                          "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5467                                     $fix) {
5468                                         $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;
5469
5470                                 }
5471                         }
5472                 }
5473
5474 # check for krealloc arg reuse
5475                 if ($^V && $^V ge 5.10.0 &&
5476                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5477                         WARN("KREALLOC_ARG_REUSE",
5478                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5479                 }
5480
5481 # check for alloc argument mismatch
5482                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5483                         WARN("ALLOC_ARRAY_ARGS",
5484                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5485                 }
5486
5487 # check for multiple semicolons
5488                 if ($line =~ /;\s*;\s*$/) {
5489                         if (WARN("ONE_SEMICOLON",
5490                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
5491                             $fix) {
5492                                 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5493                         }
5494                 }
5495
5496 # check for #defines like: 1 << <digit> that could be BIT(digit)
5497                 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5498                         my $ull = "";
5499                         $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5500                         if (CHK("BIT_MACRO",
5501                                 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5502                             $fix) {
5503                                 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5504                         }
5505                 }
5506
5507 # check for case / default statements not preceded by break/fallthrough/switch
5508                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5509                         my $has_break = 0;
5510                         my $has_statement = 0;
5511                         my $count = 0;
5512                         my $prevline = $linenr;
5513                         while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5514                                 $prevline--;
5515                                 my $rline = $rawlines[$prevline - 1];
5516                                 my $fline = $lines[$prevline - 1];
5517                                 last if ($fline =~ /^\@\@/);
5518                                 next if ($fline =~ /^\-/);
5519                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5520                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5521                                 next if ($fline =~ /^.[\s$;]*$/);
5522                                 $has_statement = 1;
5523                                 $count++;
5524                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5525                         }
5526                         if (!$has_break && $has_statement) {
5527                                 WARN("MISSING_BREAK",
5528                                      "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5529                         }
5530                 }
5531
5532 # check for switch/default statements without a break;
5533                 if ($^V && $^V ge 5.10.0 &&
5534                     defined $stat &&
5535                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5536                         my $ctx = '';
5537                         my $herectx = $here . "\n";
5538                         my $cnt = statement_rawlines($stat);
5539                         for (my $n = 0; $n < $cnt; $n++) {
5540                                 $herectx .= raw_line($linenr, $n) . "\n";
5541                         }
5542                         WARN("DEFAULT_NO_BREAK",
5543                              "switch default: should use break\n" . $herectx);
5544                 }
5545
5546 # check for gcc specific __FUNCTION__
5547                 if ($line =~ /\b__FUNCTION__\b/) {
5548                         if (WARN("USE_FUNC",
5549                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
5550                             $fix) {
5551                                 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5552                         }
5553                 }
5554
5555 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
5556                 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5557                         ERROR("DATE_TIME",
5558                               "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5559                 }
5560
5561 # check for use of yield()
5562                 if ($line =~ /\byield\s*\(\s*\)/) {
5563                         WARN("YIELD",
5564                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
5565                 }
5566
5567 # check for comparisons against true and false
5568                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5569                         my $lead = $1;
5570                         my $arg = $2;
5571                         my $test = $3;
5572                         my $otype = $4;
5573                         my $trail = $5;
5574                         my $op = "!";
5575
5576                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5577
5578                         my $type = lc($otype);
5579                         if ($type =~ /^(?:true|false)$/) {
5580                                 if (("$test" eq "==" && "$type" eq "true") ||
5581                                     ("$test" eq "!=" && "$type" eq "false")) {
5582                                         $op = "";
5583                                 }
5584
5585                                 CHK("BOOL_COMPARISON",
5586                                     "Using comparison to $otype is error prone\n" . $herecurr);
5587
5588 ## maybe suggesting a correct construct would better
5589 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5590
5591                         }
5592                 }
5593
5594 # check for semaphores initialized locked
5595                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
5596                         WARN("CONSIDER_COMPLETION",
5597                              "consider using a completion\n" . $herecurr);
5598                 }
5599
5600 # recommend kstrto* over simple_strto* and strict_strto*
5601                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5602                         WARN("CONSIDER_KSTRTO",
5603                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
5604                 }
5605
5606 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
5607                 if ($line =~ /^.\s*__initcall\s*\(/) {
5608                         WARN("USE_DEVICE_INITCALL",
5609                              "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5610                 }
5611
5612 # check for various structs that are normally const (ops, kgdb, device_tree)
5613                 my $const_structs = qr{
5614                                 acpi_dock_ops|
5615                                 address_space_operations|
5616                                 backlight_ops|
5617                                 block_device_operations|
5618                                 dentry_operations|
5619                                 dev_pm_ops|
5620                                 dma_map_ops|
5621                                 extent_io_ops|
5622                                 file_lock_operations|
5623                                 file_operations|
5624                                 hv_ops|
5625                                 ide_dma_ops|
5626                                 intel_dvo_dev_ops|
5627                                 item_operations|
5628                                 iwl_ops|
5629                                 kgdb_arch|
5630                                 kgdb_io|
5631                                 kset_uevent_ops|
5632                                 lock_manager_operations|
5633                                 microcode_ops|
5634                                 mtrr_ops|
5635                                 neigh_ops|
5636                                 nlmsvc_binding|
5637                                 of_device_id|
5638                                 pci_raw_ops|
5639                                 pipe_buf_operations|
5640                                 platform_hibernation_ops|
5641                                 platform_suspend_ops|
5642                                 proto_ops|
5643                                 rpc_pipe_ops|
5644                                 seq_operations|
5645                                 snd_ac97_build_ops|
5646                                 soc_pcmcia_socket_ops|
5647                                 stacktrace_ops|
5648                                 sysfs_ops|
5649                                 tty_operations|
5650                                 uart_ops|
5651                                 usb_mon_operations|
5652                                 wd_ops}x;
5653                 if ($line !~ /\bconst\b/ &&
5654                     $line =~ /\bstruct\s+($const_structs)\b/) {
5655                         WARN("CONST_STRUCT",
5656                              "struct $1 should normally be const\n" .
5657                                 $herecurr);
5658                 }
5659
5660 # use of NR_CPUS is usually wrong
5661 # ignore definitions of NR_CPUS and usage to define arrays as likely right
5662                 if ($line =~ /\bNR_CPUS\b/ &&
5663                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5664                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
5665                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5666                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5667                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
5668                 {
5669                         WARN("NR_CPUS",
5670                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
5671                 }
5672
5673 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5674                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5675                         ERROR("DEFINE_ARCH_HAS",
5676                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5677                 }
5678
5679 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
5680                 if ($^V && $^V ge 5.10.0 &&
5681                     $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5682                         WARN("LIKELY_MISUSE",
5683                              "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5684                 }
5685
5686 # whine mightly about in_atomic
5687                 if ($line =~ /\bin_atomic\s*\(/) {
5688                         if ($realfile =~ m@^drivers/@) {
5689                                 ERROR("IN_ATOMIC",
5690                                       "do not use in_atomic in drivers\n" . $herecurr);
5691                         } elsif ($realfile !~ m@^kernel/@) {
5692                                 WARN("IN_ATOMIC",
5693                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5694                         }
5695                 }
5696
5697 # check for lockdep_set_novalidate_class
5698                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5699                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
5700                         if ($realfile !~ m@^kernel/lockdep@ &&
5701                             $realfile !~ m@^include/linux/lockdep@ &&
5702                             $realfile !~ m@^drivers/base/core@) {
5703                                 ERROR("LOCKDEP",
5704                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5705                         }
5706                 }
5707
5708                 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5709                     $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
5710                         WARN("EXPORTED_WORLD_WRITABLE",
5711                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5712                 }
5713
5714 # Mode permission misuses where it seems decimal should be octal
5715 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5716                 if ($^V && $^V ge 5.10.0 &&
5717                     $line =~ /$mode_perms_search/) {
5718                         foreach my $entry (@mode_permission_funcs) {
5719                                 my $func = $entry->[0];
5720                                 my $arg_pos = $entry->[1];
5721
5722                                 my $skip_args = "";
5723                                 if ($arg_pos > 1) {
5724                                         $arg_pos--;
5725                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5726                                 }
5727                                 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5728                                 if ($line =~ /$test/) {
5729                                         my $val = $1;
5730                                         $val = $6 if ($skip_args ne "");
5731
5732                                         if ($val !~ /^0$/ &&
5733                                             (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5734                                              length($val) ne 4)) {
5735                                                 ERROR("NON_OCTAL_PERMISSIONS",
5736                                                       "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
5737                                         } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5738                                                 ERROR("EXPORTED_WORLD_WRITABLE",
5739                                                       "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5740                                         }
5741                                 }
5742                         }
5743                 }
5744
5745 # validate content of MODULE_LICENSE against list from include/linux/module.h
5746                 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
5747                         my $extracted_string = get_quoted_string($line, $rawline);
5748                         my $valid_licenses = qr{
5749                                                 GPL|
5750                                                 GPL\ v2|
5751                                                 GPL\ and\ additional\ rights|
5752                                                 Dual\ BSD/GPL|
5753                                                 Dual\ MIT/GPL|
5754                                                 Dual\ MPL/GPL|
5755                                                 Proprietary
5756                                         }x;
5757                         if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
5758                                 WARN("MODULE_LICENSE",
5759                                      "unknown module license " . $extracted_string . "\n" . $herecurr);
5760                         }
5761                 }
5762         }
5763
5764         # If we have no input at all, then there is nothing to report on
5765         # so just keep quiet.
5766         if ($#rawlines == -1) {
5767                 exit(0);
5768         }
5769
5770         # In mailback mode only produce a report in the negative, for
5771         # things that appear to be patches.
5772         if ($mailback && ($clean == 1 || !$is_patch)) {
5773                 exit(0);
5774         }
5775
5776         # This is not a patch, and we are are in 'no-patch' mode so
5777         # just keep quiet.
5778         if (!$chk_patch && !$is_patch) {
5779                 exit(0);
5780         }
5781
5782         if (!$is_patch && $file !~ /cover-letter\.patch$/) {
5783                 ERROR("NOT_UNIFIED_DIFF",
5784                       "Does not appear to be a unified-diff format patch\n");
5785         }
5786         if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
5787                 ERROR("MISSING_SIGN_OFF",
5788                       "Missing Signed-off-by: line(s)\n");
5789         }
5790
5791         print report_dump();
5792         if ($summary && !($clean == 1 && $quiet == 1)) {
5793                 print "$filename " if ($summary_file);
5794                 print "total: $cnt_error errors, $cnt_warn warnings, " .
5795                         (($check)? "$cnt_chk checks, " : "") .
5796                         "$cnt_lines lines checked\n";
5797         }
5798
5799         if ($quiet == 0) {
5800                 # If there were whitespace errors which cleanpatch can fix
5801                 # then suggest that.
5802                 if ($rpt_cleaners) {
5803                         $rpt_cleaners = 0;
5804                         print << "EOM"
5805
5806 NOTE: Whitespace errors detected.
5807       You may wish to use scripts/cleanpatch or scripts/cleanfile
5808 EOM
5809                 }
5810         }
5811
5812         if ($clean == 0 && $fix &&
5813             ("@rawlines" ne "@fixed" ||
5814              $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
5815                 my $newfile = $filename;
5816                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
5817                 my $linecount = 0;
5818                 my $f;
5819
5820                 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5821
5822                 open($f, '>', $newfile)
5823                     or die "$P: Can't open $newfile for write\n";
5824                 foreach my $fixed_line (@fixed) {
5825                         $linecount++;
5826                         if ($file) {
5827                                 if ($linecount > 3) {
5828                                         $fixed_line =~ s/^\+//;
5829                                         print $f $fixed_line . "\n";
5830                                 }
5831                         } else {
5832                                 print $f $fixed_line . "\n";
5833                         }
5834                 }
5835                 close($f);
5836
5837                 if (!$quiet) {
5838                         print << "EOM";
5839
5840 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5841
5842 Do _NOT_ trust the results written to this file.
5843 Do _NOT_ submit these changes without inspecting them for correctness.
5844
5845 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5846 No warranties, expressed or implied...
5847 EOM
5848                 }
5849         }
5850
5851         if ($quiet == 0) {
5852                 print "\n";
5853                 if ($clean == 1) {
5854                         print "$vname has no obvious style problems and is ready for submission.\n";
5855                 } else {
5856                         print "$vname has style problems, please review.\n";
5857                 }
5858         }
5859         return $clean;
5860 }