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 # comparisons with a constant or upper case identifier on the left
4235 #       avoid cases like "foo + BAR < baz"
4236 #       only fix matches surrounded by parentheses to avoid incorrect
4237 #       conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4238                 if ($^V && $^V ge 5.10.0 &&
4239                     $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4240                         my $lead = $1;
4241                         my $const = $2;
4242                         my $comp = $3;
4243                         my $to = $4;
4244                         my $newcomp = $comp;
4245                         if ($lead !~ /$Operators\s*$/ &&
4246                             $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4247                             WARN("CONSTANT_COMPARISON",
4248                                  "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4249                             $fix) {
4250                                 if ($comp eq "<") {
4251                                         $newcomp = ">";
4252                                 } elsif ($comp eq "<=") {
4253                                         $newcomp = ">=";
4254                                 } elsif ($comp eq ">") {
4255                                         $newcomp = "<";
4256                                 } elsif ($comp eq ">=") {
4257                                         $newcomp = "<=";
4258                                 }
4259                                 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4260                         }
4261                 }
4262
4263 # Return of what appears to be an errno should normally be negative
4264                 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4265                         my $name = $1;
4266                         if ($name ne 'EOF' && $name ne 'ERROR') {
4267                                 WARN("USE_NEGATIVE_ERRNO",
4268                                      "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4269                         }
4270                 }
4271
4272 # Need a space before open parenthesis after if, while etc
4273                 if ($line =~ /\b(if|while|for|switch)\(/) {
4274                         if (ERROR("SPACING",
4275                                   "space required before the open parenthesis '('\n" . $herecurr) &&
4276                             $fix) {
4277                                 $fixed[$fixlinenr] =~
4278                                     s/\b(if|while|for|switch)\(/$1 \(/;
4279                         }
4280                 }
4281
4282 # Check for illegal assignment in if conditional -- and check for trailing
4283 # statements after the conditional.
4284                 if ($line =~ /do\s*(?!{)/) {
4285                         ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4286                                 ctx_statement_block($linenr, $realcnt, 0)
4287                                         if (!defined $stat);
4288                         my ($stat_next) = ctx_statement_block($line_nr_next,
4289                                                 $remain_next, $off_next);
4290                         $stat_next =~ s/\n./\n /g;
4291                         ##print "stat<$stat> stat_next<$stat_next>\n";
4292
4293                         if ($stat_next =~ /^\s*while\b/) {
4294                                 # If the statement carries leading newlines,
4295                                 # then count those as offsets.
4296                                 my ($whitespace) =
4297                                         ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4298                                 my $offset =
4299                                         statement_rawlines($whitespace) - 1;
4300
4301                                 $suppress_whiletrailers{$line_nr_next +
4302                                                                 $offset} = 1;
4303                         }
4304                 }
4305                 if (!defined $suppress_whiletrailers{$linenr} &&
4306                     defined($stat) && defined($cond) &&
4307                     $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4308                         my ($s, $c) = ($stat, $cond);
4309
4310                         if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4311                                 ERROR("ASSIGN_IN_IF",
4312                                       "do not use assignment in if condition\n" . $herecurr);
4313                         }
4314
4315                         # Find out what is on the end of the line after the
4316                         # conditional.
4317                         substr($s, 0, length($c), '');
4318                         $s =~ s/\n.*//g;
4319                         $s =~ s/$;//g;  # Remove any comments
4320                         if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4321                             $c !~ /}\s*while\s*/)
4322                         {
4323                                 # Find out how long the conditional actually is.
4324                                 my @newlines = ($c =~ /\n/gs);
4325                                 my $cond_lines = 1 + $#newlines;
4326                                 my $stat_real = '';
4327
4328                                 $stat_real = raw_line($linenr, $cond_lines)
4329                                                         . "\n" if ($cond_lines);
4330                                 if (defined($stat_real) && $cond_lines > 1) {
4331                                         $stat_real = "[...]\n$stat_real";
4332                                 }
4333
4334                                 ERROR("TRAILING_STATEMENTS",
4335                                       "trailing statements should be on next line\n" . $herecurr . $stat_real);
4336                         }
4337                 }
4338
4339 # Check for bitwise tests written as boolean
4340                 if ($line =~ /
4341                         (?:
4342                                 (?:\[|\(|\&\&|\|\|)
4343                                 \s*0[xX][0-9]+\s*
4344                                 (?:\&\&|\|\|)
4345                         |
4346                                 (?:\&\&|\|\|)
4347                                 \s*0[xX][0-9]+\s*
4348                                 (?:\&\&|\|\||\)|\])
4349                         )/x)
4350                 {
4351                         WARN("HEXADECIMAL_BOOLEAN_TEST",
4352                              "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4353                 }
4354
4355 # if and else should not have general statements after it
4356                 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4357                         my $s = $1;
4358                         $s =~ s/$;//g;  # Remove any comments
4359                         if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4360                                 ERROR("TRAILING_STATEMENTS",
4361                                       "trailing statements should be on next line\n" . $herecurr);
4362                         }
4363                 }
4364 # if should not continue a brace
4365                 if ($line =~ /}\s*if\b/) {
4366                         ERROR("TRAILING_STATEMENTS",
4367                               "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4368                                 $herecurr);
4369                 }
4370 # case and default should not have general statements after them
4371                 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4372                     $line !~ /\G(?:
4373                         (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4374                         \s*return\s+
4375                     )/xg)
4376                 {
4377                         ERROR("TRAILING_STATEMENTS",
4378                               "trailing statements should be on next line\n" . $herecurr);
4379                 }
4380
4381                 # Check for }<nl>else {, these must be at the same
4382                 # indent level to be relevant to each other.
4383                 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4384                     $previndent == $indent) {
4385                         if (ERROR("ELSE_AFTER_BRACE",
4386                                   "else should follow close brace '}'\n" . $hereprev) &&
4387                             $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4388                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4389                                 fix_delete_line($fixlinenr, $rawline);
4390                                 my $fixedline = $prevrawline;
4391                                 $fixedline =~ s/}\s*$//;
4392                                 if ($fixedline !~ /^\+\s*$/) {
4393                                         fix_insert_line($fixlinenr, $fixedline);
4394                                 }
4395                                 $fixedline = $rawline;
4396                                 $fixedline =~ s/^(.\s*)else/$1} else/;
4397                                 fix_insert_line($fixlinenr, $fixedline);
4398                         }
4399                 }
4400
4401                 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4402                     $previndent == $indent) {
4403                         my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4404
4405                         # Find out what is on the end of the line after the
4406                         # conditional.
4407                         substr($s, 0, length($c), '');
4408                         $s =~ s/\n.*//g;
4409
4410                         if ($s =~ /^\s*;/) {
4411                                 if (ERROR("WHILE_AFTER_BRACE",
4412                                           "while should follow close brace '}'\n" . $hereprev) &&
4413                                     $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4414                                         fix_delete_line($fixlinenr - 1, $prevrawline);
4415                                         fix_delete_line($fixlinenr, $rawline);
4416                                         my $fixedline = $prevrawline;
4417                                         my $trailing = $rawline;
4418                                         $trailing =~ s/^\+//;
4419                                         $trailing = trim($trailing);
4420                                         $fixedline =~ s/}\s*$/} $trailing/;
4421                                         fix_insert_line($fixlinenr, $fixedline);
4422                                 }
4423                         }
4424                 }
4425
4426 #Specific variable tests
4427                 while ($line =~ m{($Constant|$Lval)}g) {
4428                         my $var = $1;
4429
4430 #gcc binary extension
4431                         if ($var =~ /^$Binary$/) {
4432                                 if (WARN("GCC_BINARY_CONSTANT",
4433                                          "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4434                                     $fix) {
4435                                         my $hexval = sprintf("0x%x", oct($var));
4436                                         $fixed[$fixlinenr] =~
4437                                             s/\b$var\b/$hexval/;
4438                                 }
4439                         }
4440
4441 #CamelCase
4442                         if ($var !~ /^$Constant$/ &&
4443                             $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4444 #Ignore Page<foo> variants
4445                             $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4446 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4447                             $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4448 #Ignore some three character SI units explicitly, like MiB and KHz
4449                             $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4450                                 while ($var =~ m{($Ident)}g) {
4451                                         my $word = $1;
4452                                         next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4453                                         if ($check) {
4454                                                 seed_camelcase_includes();
4455                                                 if (!$file && !$camelcase_file_seeded) {
4456                                                         seed_camelcase_file($realfile);
4457                                                         $camelcase_file_seeded = 1;
4458                                                 }
4459                                         }
4460                                         if (!defined $camelcase{$word}) {
4461                                                 $camelcase{$word} = 1;
4462                                                 CHK("CAMELCASE",
4463                                                     "Avoid CamelCase: <$word>\n" . $herecurr);
4464                                         }
4465                                 }
4466                         }
4467                 }
4468
4469 #no spaces allowed after \ in define
4470                 if ($line =~ /\#\s*define.*\\\s+$/) {
4471                         if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4472                                  "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4473                             $fix) {
4474                                 $fixed[$fixlinenr] =~ s/\s+$//;
4475                         }
4476                 }
4477
4478 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4479 # itself <asm/foo.h> (uses RAW line)
4480                 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4481                         my $file = "$1.h";
4482                         my $checkfile = "include/linux/$file";
4483                         if (-f "$root/$checkfile" &&
4484                             $realfile ne $checkfile &&
4485                             $1 !~ /$allowed_asm_includes/)
4486                         {
4487                                 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4488                                 if ($asminclude > 0) {
4489                                         if ($realfile =~ m{^arch/}) {
4490                                                 CHK("ARCH_INCLUDE_LINUX",
4491                                                     "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4492                                         } else {
4493                                                 WARN("INCLUDE_LINUX",
4494                                                      "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4495                                         }
4496                                 }
4497                         }
4498                 }
4499
4500 # multi-statement macros should be enclosed in a do while loop, grab the
4501 # first statement and ensure its the whole macro if its not enclosed
4502 # in a known good container
4503                 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4504                     $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4505                         my $ln = $linenr;
4506                         my $cnt = $realcnt;
4507                         my ($off, $dstat, $dcond, $rest);
4508                         my $ctx = '';
4509                         my $has_flow_statement = 0;
4510                         my $has_arg_concat = 0;
4511                         ($dstat, $dcond, $ln, $cnt, $off) =
4512                                 ctx_statement_block($linenr, $realcnt, 0);
4513                         $ctx = $dstat;
4514                         #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4515                         #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4516
4517                         $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4518                         $has_arg_concat = 1 if ($ctx =~ /\#\#/);
4519
4520                         $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4521                         $dstat =~ s/$;//g;
4522                         $dstat =~ s/\\\n.//g;
4523                         $dstat =~ s/^\s*//s;
4524                         $dstat =~ s/\s*$//s;
4525
4526                         # Flatten any parentheses and braces
4527                         while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4528                                $dstat =~ s/\{[^\{\}]*\}/1/ ||
4529                                $dstat =~ s/\[[^\[\]]*\]/1/)
4530                         {
4531                         }
4532
4533                         # Flatten any obvious string concatentation.
4534                         while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4535                                $dstat =~ s/$Ident\s*($String)/$1/)
4536                         {
4537                         }
4538
4539                         my $exceptions = qr{
4540                                 $Declare|
4541                                 module_param_named|
4542                                 MODULE_PARM_DESC|
4543                                 DECLARE_PER_CPU|
4544                                 DEFINE_PER_CPU|
4545                                 __typeof__\(|
4546                                 union|
4547                                 struct|
4548                                 \.$Ident\s*=\s*|
4549                                 ^\"|\"$
4550                         }x;
4551                         #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4552                         if ($dstat ne '' &&
4553                             $dstat !~ /^(?:$Ident|-?$Constant),$/ &&                    # 10, // foo(),
4554                             $dstat !~ /^(?:$Ident|-?$Constant);$/ &&                    # foo();
4555                             $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ &&          # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4556                             $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ &&                  # character constants
4557                             $dstat !~ /$exceptions/ &&
4558                             $dstat !~ /^\.$Ident\s*=/ &&                                # .foo =
4559                             $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ &&          # stringification #foo
4560                             $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ &&       # do {...} while (...); // do {...} while (...)
4561                             $dstat !~ /^for\s*$Constant$/ &&                            # for (...)
4562                             $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ &&   # for (...) bar()
4563                             $dstat !~ /^do\s*{/ &&                                      # do {...
4564                             $dstat !~ /^\(\{/ &&                                                # ({...
4565                             $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4566                         {
4567                                 $ctx =~ s/\n*$//;
4568                                 my $herectx = $here . "\n";
4569                                 my $cnt = statement_rawlines($ctx);
4570
4571                                 for (my $n = 0; $n < $cnt; $n++) {
4572                                         $herectx .= raw_line($linenr, $n) . "\n";
4573                                 }
4574
4575                                 if ($dstat =~ /;/) {
4576                                         ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4577                                               "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4578                                 } else {
4579                                         ERROR("COMPLEX_MACRO",
4580                                               "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4581                                 }
4582                         }
4583
4584 # check for macros with flow control, but without ## concatenation
4585 # ## concatenation is commonly a macro that defines a function so ignore those
4586                         if ($has_flow_statement && !$has_arg_concat) {
4587                                 my $herectx = $here . "\n";
4588                                 my $cnt = statement_rawlines($ctx);
4589
4590                                 for (my $n = 0; $n < $cnt; $n++) {
4591                                         $herectx .= raw_line($linenr, $n) . "\n";
4592                                 }
4593                                 WARN("MACRO_WITH_FLOW_CONTROL",
4594                                      "Macros with flow control statements should be avoided\n" . "$herectx");
4595                         }
4596
4597 # check for line continuations outside of #defines, preprocessor #, and asm
4598
4599                 } else {
4600                         if ($prevline !~ /^..*\\$/ &&
4601                             $line !~ /^\+\s*\#.*\\$/ &&         # preprocessor
4602                             $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ &&   # asm
4603                             $line =~ /^\+.*\\$/) {
4604                                 WARN("LINE_CONTINUATIONS",
4605                                      "Avoid unnecessary line continuations\n" . $herecurr);
4606                         }
4607                 }
4608
4609 # do {} while (0) macro tests:
4610 # single-statement macros do not need to be enclosed in do while (0) loop,
4611 # macro should not end with a semicolon
4612                 if ($^V && $^V ge 5.10.0 &&
4613                     $realfile !~ m@/vmlinux.lds.h$@ &&
4614                     $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4615                         my $ln = $linenr;
4616                         my $cnt = $realcnt;
4617                         my ($off, $dstat, $dcond, $rest);
4618                         my $ctx = '';
4619                         ($dstat, $dcond, $ln, $cnt, $off) =
4620                                 ctx_statement_block($linenr, $realcnt, 0);
4621                         $ctx = $dstat;
4622
4623                         $dstat =~ s/\\\n.//g;
4624                         $dstat =~ s/$;/ /g;
4625
4626                         if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4627                                 my $stmts = $2;
4628                                 my $semis = $3;
4629
4630                                 $ctx =~ s/\n*$//;
4631                                 my $cnt = statement_rawlines($ctx);
4632                                 my $herectx = $here . "\n";
4633
4634                                 for (my $n = 0; $n < $cnt; $n++) {
4635                                         $herectx .= raw_line($linenr, $n) . "\n";
4636                                 }
4637
4638                                 if (($stmts =~ tr/;/;/) == 1 &&
4639                                     $stmts !~ /^\s*(if|while|for|switch)\b/) {
4640                                         WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4641                                              "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4642                                 }
4643                                 if (defined $semis && $semis ne "") {
4644                                         WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4645                                              "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4646                                 }
4647                         } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4648                                 $ctx =~ s/\n*$//;
4649                                 my $cnt = statement_rawlines($ctx);
4650                                 my $herectx = $here . "\n";
4651
4652                                 for (my $n = 0; $n < $cnt; $n++) {
4653                                         $herectx .= raw_line($linenr, $n) . "\n";
4654                                 }
4655
4656                                 WARN("TRAILING_SEMICOLON",
4657                                      "macros should not use a trailing semicolon\n" . "$herectx");
4658                         }
4659                 }
4660
4661 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4662 # all assignments may have only one of the following with an assignment:
4663 #       .
4664 #       ALIGN(...)
4665 #       VMLINUX_SYMBOL(...)
4666                 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4667                         WARN("MISSING_VMLINUX_SYMBOL",
4668                              "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4669                 }
4670
4671 # check for redundant bracing round if etc
4672                 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4673                         my ($level, $endln, @chunks) =
4674                                 ctx_statement_full($linenr, $realcnt, 1);
4675                         #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4676                         #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4677                         if ($#chunks > 0 && $level == 0) {
4678                                 my @allowed = ();
4679                                 my $allow = 0;
4680                                 my $seen = 0;
4681                                 my $herectx = $here . "\n";
4682                                 my $ln = $linenr - 1;
4683                                 for my $chunk (@chunks) {
4684                                         my ($cond, $block) = @{$chunk};
4685
4686                                         # If the condition carries leading newlines, then count those as offsets.
4687                                         my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4688                                         my $offset = statement_rawlines($whitespace) - 1;
4689
4690                                         $allowed[$allow] = 0;
4691                                         #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4692
4693                                         # We have looked at and allowed this specific line.
4694                                         $suppress_ifbraces{$ln + $offset} = 1;
4695
4696                                         $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4697                                         $ln += statement_rawlines($block) - 1;
4698
4699                                         substr($block, 0, length($cond), '');
4700
4701                                         $seen++ if ($block =~ /^\s*{/);
4702
4703                                         #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4704                                         if (statement_lines($cond) > 1) {
4705                                                 #print "APW: ALLOWED: cond<$cond>\n";
4706                                                 $allowed[$allow] = 1;
4707                                         }
4708                                         if ($block =~/\b(?:if|for|while)\b/) {
4709                                                 #print "APW: ALLOWED: block<$block>\n";
4710                                                 $allowed[$allow] = 1;
4711                                         }
4712                                         if (statement_block_size($block) > 1) {
4713                                                 #print "APW: ALLOWED: lines block<$block>\n";
4714                                                 $allowed[$allow] = 1;
4715                                         }
4716                                         $allow++;
4717                                 }
4718                                 if ($seen) {
4719                                         my $sum_allowed = 0;
4720                                         foreach (@allowed) {
4721                                                 $sum_allowed += $_;
4722                                         }
4723                                         if ($sum_allowed == 0) {
4724                                                 WARN("BRACES",
4725                                                      "braces {} are not necessary for any arm of this statement\n" . $herectx);
4726                                         } elsif ($sum_allowed != $allow &&
4727                                                  $seen != $allow) {
4728                                                 CHK("BRACES",
4729                                                     "braces {} should be used on all arms of this statement\n" . $herectx);
4730                                         }
4731                                 }
4732                         }
4733                 }
4734                 if (!defined $suppress_ifbraces{$linenr - 1} &&
4735                                         $line =~ /\b(if|while|for|else)\b/) {
4736                         my $allowed = 0;
4737
4738                         # Check the pre-context.
4739                         if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4740                                 #print "APW: ALLOWED: pre<$1>\n";
4741                                 $allowed = 1;
4742                         }
4743
4744                         my ($level, $endln, @chunks) =
4745                                 ctx_statement_full($linenr, $realcnt, $-[0]);
4746
4747                         # Check the condition.
4748                         my ($cond, $block) = @{$chunks[0]};
4749                         #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4750                         if (defined $cond) {
4751                                 substr($block, 0, length($cond), '');
4752                         }
4753                         if (statement_lines($cond) > 1) {
4754                                 #print "APW: ALLOWED: cond<$cond>\n";
4755                                 $allowed = 1;
4756                         }
4757                         if ($block =~/\b(?:if|for|while)\b/) {
4758                                 #print "APW: ALLOWED: block<$block>\n";
4759                                 $allowed = 1;
4760                         }
4761                         if (statement_block_size($block) > 1) {
4762                                 #print "APW: ALLOWED: lines block<$block>\n";
4763                                 $allowed = 1;
4764                         }
4765                         # Check the post-context.
4766                         if (defined $chunks[1]) {
4767                                 my ($cond, $block) = @{$chunks[1]};
4768                                 if (defined $cond) {
4769                                         substr($block, 0, length($cond), '');
4770                                 }
4771                                 if ($block =~ /^\s*\{/) {
4772                                         #print "APW: ALLOWED: chunk-1 block<$block>\n";
4773                                         $allowed = 1;
4774                                 }
4775                         }
4776                         if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4777                                 my $herectx = $here . "\n";
4778                                 my $cnt = statement_rawlines($block);
4779
4780                                 for (my $n = 0; $n < $cnt; $n++) {
4781                                         $herectx .= raw_line($linenr, $n) . "\n";
4782                                 }
4783
4784                                 WARN("BRACES",
4785                                      "braces {} are not necessary for single statement blocks\n" . $herectx);
4786                         }
4787                 }
4788
4789 # check for unnecessary blank lines around braces
4790                 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4791                         if (CHK("BRACES",
4792                                 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4793                             $fix && $prevrawline =~ /^\+/) {
4794                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4795                         }
4796                 }
4797                 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4798                         if (CHK("BRACES",
4799                                 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4800                             $fix) {
4801                                 fix_delete_line($fixlinenr, $rawline);
4802                         }
4803                 }
4804
4805 # no volatiles please
4806                 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4807                 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4808                         WARN("VOLATILE",
4809                              "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4810                 }
4811
4812 # Check for user-visible strings broken across lines, which breaks the ability
4813 # to grep for the string.  Make exceptions when the previous string ends in a
4814 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4815 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
4816                 if ($line =~ /^\+\s*$String/ &&
4817                     $prevline =~ /"\s*$/ &&
4818                     $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4819                         if (WARN("SPLIT_STRING",
4820                                  "quoted string split across lines\n" . $hereprev) &&
4821                                      $fix &&
4822                                      $prevrawline =~ /^\+.*"\s*$/ &&
4823                                      $last_coalesced_string_linenr != $linenr - 1) {
4824                                 my $extracted_string = get_quoted_string($line, $rawline);
4825                                 my $comma_close = "";
4826                                 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4827                                         $comma_close = $1;
4828                                 }
4829
4830                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4831                                 fix_delete_line($fixlinenr, $rawline);
4832                                 my $fixedline = $prevrawline;
4833                                 $fixedline =~ s/"\s*$//;
4834                                 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4835                                 fix_insert_line($fixlinenr - 1, $fixedline);
4836                                 $fixedline = $rawline;
4837                                 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4838                                 if ($fixedline !~ /\+\s*$/) {
4839                                         fix_insert_line($fixlinenr, $fixedline);
4840                                 }
4841                                 $last_coalesced_string_linenr = $linenr;
4842                         }
4843                 }
4844
4845 # check for missing a space in a string concatenation
4846                 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4847                         WARN('MISSING_SPACE',
4848                              "break quoted strings at a space character\n" . $hereprev);
4849                 }
4850
4851 # check for spaces before a quoted newline
4852                 if ($rawline =~ /^.*\".*\s\\n/) {
4853                         if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
4854                                  "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
4855                             $fix) {
4856                                 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
4857                         }
4858
4859                 }
4860
4861 # concatenated string without spaces between elements
4862                 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
4863                         CHK("CONCATENATED_STRING",
4864                             "Concatenated strings should use spaces between elements\n" . $herecurr);
4865                 }
4866
4867 # uncoalesced string fragments
4868                 if ($line =~ /$String\s*"/) {
4869                         WARN("STRING_FRAGMENTS",
4870                              "Consecutive strings are generally better as a single string\n" . $herecurr);
4871                 }
4872
4873 # check for %L{u,d,i} and 0x%[udi] in strings
4874                 my $string;
4875                 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4876                         $string = substr($rawline, $-[1], $+[1] - $-[1]);
4877                         $string =~ s/%%/__/g;
4878                         if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
4879                                 WARN("PRINTF_L",
4880                                      "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4881                                 last;
4882                         }
4883                         if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
4884                                 ERROR("PRINTF_0xDECIMAL",
4885                                       "Prefixing 0x with decimal output is defective\n" . $herecurr);
4886                         }
4887                 }
4888
4889 # check for line continuations in quoted strings with odd counts of "
4890                 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4891                         WARN("LINE_CONTINUATIONS",
4892                              "Avoid line continuations in quoted strings\n" . $herecurr);
4893                 }
4894
4895 # warn about #if 0
4896                 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
4897                         CHK("REDUNDANT_CODE",
4898                             "if this code is redundant consider removing it\n" .
4899                                 $herecurr);
4900                 }
4901
4902 # check for needless "if (<foo>) fn(<foo>)" uses
4903                 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4904                         my $tested = quotemeta($1);
4905                         my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
4906                         if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
4907                                 my $func = $1;
4908                                 if (WARN('NEEDLESS_IF',
4909                                          "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
4910                                     $fix) {
4911                                         my $do_fix = 1;
4912                                         my $leading_tabs = "";
4913                                         my $new_leading_tabs = "";
4914                                         if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
4915                                                 $leading_tabs = $1;
4916                                         } else {
4917                                                 $do_fix = 0;
4918                                         }
4919                                         if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
4920                                                 $new_leading_tabs = $1;
4921                                                 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
4922                                                         $do_fix = 0;
4923                                                 }
4924                                         } else {
4925                                                 $do_fix = 0;
4926                                         }
4927                                         if ($do_fix) {
4928                                                 fix_delete_line($fixlinenr - 1, $prevrawline);
4929                                                 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
4930                                         }
4931                                 }
4932                         }
4933                 }
4934
4935 # check for unnecessary "Out of Memory" messages
4936                 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4937                     $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4938                     (defined $1 || defined $3) &&
4939                     $linenr > 3) {
4940                         my $testval = $2;
4941                         my $testline = $lines[$linenr - 3];
4942
4943                         my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4944 #                       print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4945
4946                         if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4947                                 WARN("OOM_MESSAGE",
4948                                      "Possible unnecessary 'out of memory' message\n" . $hereprev);
4949                         }
4950                 }
4951
4952 # check for logging functions with KERN_<LEVEL>
4953                 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
4954                     $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
4955                         my $level = $1;
4956                         if (WARN("UNNECESSARY_KERN_LEVEL",
4957                                  "Possible unnecessary $level\n" . $herecurr) &&
4958                             $fix) {
4959                                 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
4960                         }
4961                 }
4962
4963 # check for mask then right shift without a parentheses
4964                 if ($^V && $^V ge 5.10.0 &&
4965                     $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
4966                     $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
4967                         WARN("MASK_THEN_SHIFT",
4968                              "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
4969                 }
4970
4971 # check for pointer comparisons to NULL
4972                 if ($^V && $^V ge 5.10.0) {
4973                         while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
4974                                 my $val = $1;
4975                                 my $equal = "!";
4976                                 $equal = "" if ($4 eq "!=");
4977                                 if (CHK("COMPARISON_TO_NULL",
4978                                         "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
4979                                             $fix) {
4980                                         $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
4981                                 }
4982                         }
4983                 }
4984
4985 # check for bad placement of section $InitAttribute (e.g.: __initdata)
4986                 if ($line =~ /(\b$InitAttribute\b)/) {
4987                         my $attr = $1;
4988                         if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4989                                 my $ptr = $1;
4990                                 my $var = $2;
4991                                 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4992                                       ERROR("MISPLACED_INIT",
4993                                             "$attr should be placed after $var\n" . $herecurr)) ||
4994                                      ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4995                                       WARN("MISPLACED_INIT",
4996                                            "$attr should be placed after $var\n" . $herecurr))) &&
4997                                     $fix) {
4998                                         $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;
4999                                 }
5000                         }
5001                 }
5002
5003 # check for $InitAttributeData (ie: __initdata) with const
5004                 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5005                         my $attr = $1;
5006                         $attr =~ /($InitAttributePrefix)(.*)/;
5007                         my $attr_prefix = $1;
5008                         my $attr_type = $2;
5009                         if (ERROR("INIT_ATTRIBUTE",
5010                                   "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5011                             $fix) {
5012                                 $fixed[$fixlinenr] =~
5013                                     s/$InitAttributeData/${attr_prefix}initconst/;
5014                         }
5015                 }
5016
5017 # check for $InitAttributeConst (ie: __initconst) without const
5018                 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5019                         my $attr = $1;
5020                         if (ERROR("INIT_ATTRIBUTE",
5021                                   "Use of $attr requires a separate use of const\n" . $herecurr) &&
5022                             $fix) {
5023                                 my $lead = $fixed[$fixlinenr] =~
5024                                     /(^\+\s*(?:static\s+))/;
5025                                 $lead = rtrim($1);
5026                                 $lead = "$lead " if ($lead !~ /^\+$/);
5027                                 $lead = "${lead}const ";
5028                                 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5029                         }
5030                 }
5031
5032 # check for __read_mostly with const non-pointer (should just be const)
5033                 if ($line =~ /\b__read_mostly\b/ &&
5034                     $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5035                         if (ERROR("CONST_READ_MOSTLY",
5036                                   "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5037                             $fix) {
5038                                 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5039                         }
5040                 }
5041
5042 # don't use __constant_<foo> functions outside of include/uapi/
5043                 if ($realfile !~ m@^include/uapi/@ &&
5044                     $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5045                         my $constant_func = $1;
5046                         my $func = $constant_func;
5047                         $func =~ s/^__constant_//;
5048                         if (WARN("CONSTANT_CONVERSION",
5049                                  "$constant_func should be $func\n" . $herecurr) &&
5050                             $fix) {
5051                                 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5052                         }
5053                 }
5054
5055 # prefer usleep_range over udelay
5056                 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5057                         my $delay = $1;
5058                         # ignore udelay's < 10, however
5059                         if (! ($delay < 10) ) {
5060                                 CHK("USLEEP_RANGE",
5061                                     "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5062                         }
5063                         if ($delay > 2000) {
5064                                 WARN("LONG_UDELAY",
5065                                      "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5066                         }
5067                 }
5068
5069 # warn about unexpectedly long msleep's
5070                 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5071                         if ($1 < 20) {
5072                                 WARN("MSLEEP",
5073                                      "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5074                         }
5075                 }
5076
5077 # check for comparisons of jiffies
5078                 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5079                         WARN("JIFFIES_COMPARISON",
5080                              "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5081                 }
5082
5083 # check for comparisons of get_jiffies_64()
5084                 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5085                         WARN("JIFFIES_COMPARISON",
5086                              "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5087                 }
5088
5089 # warn about #ifdefs in C files
5090 #               if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5091 #                       print "#ifdef in C files should be avoided\n";
5092 #                       print "$herecurr";
5093 #                       $clean = 0;
5094 #               }
5095
5096 # warn about spacing in #ifdefs
5097                 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5098                         if (ERROR("SPACING",
5099                                   "exactly one space required after that #$1\n" . $herecurr) &&
5100                             $fix) {
5101                                 $fixed[$fixlinenr] =~
5102                                     s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5103                         }
5104
5105                 }
5106
5107 # check for spinlock_t definitions without a comment.
5108                 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5109                     $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5110                         my $which = $1;
5111                         if (!ctx_has_comment($first_line, $linenr)) {
5112                                 CHK("UNCOMMENTED_DEFINITION",
5113                                     "$1 definition without comment\n" . $herecurr);
5114                         }
5115                 }
5116 # check for memory barriers without a comment.
5117                 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
5118                         if (!ctx_has_comment($first_line, $linenr)) {
5119                                 WARN("MEMORY_BARRIER",
5120                                      "memory barrier without comment\n" . $herecurr);
5121                         }
5122                 }
5123
5124 # check for waitqueue_active without a comment.
5125                 if ($line =~ /\bwaitqueue_active\s*\(/) {
5126                         if (!ctx_has_comment($first_line, $linenr)) {
5127                                 WARN("WAITQUEUE_ACTIVE",
5128                                      "waitqueue_active without comment\n" . $herecurr);
5129                         }
5130                 }
5131
5132 # Check for expedited grace periods that interrupt non-idle non-nohz
5133 # online CPUs.  These expedited can therefore degrade real-time response
5134 # if used carelessly, and should be avoided where not absolutely
5135 # needed.  It is always OK to use synchronize_rcu_expedited() and
5136 # synchronize_sched_expedited() at boot time (before real-time applications
5137 # start) and in error situations where real-time response is compromised in
5138 # any case.  Note that synchronize_srcu_expedited() does -not- interrupt
5139 # other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5140 # Of course, nothing comes for free, and srcu_read_lock() and
5141 # srcu_read_unlock() do contain full memory barriers in payment for
5142 # synchronize_srcu_expedited() non-interruption properties.
5143                 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5144                         WARN("EXPEDITED_RCU_GRACE_PERIOD",
5145                              "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5146
5147                 }
5148
5149 # check of hardware specific defines
5150                 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5151                         CHK("ARCH_DEFINES",
5152                             "architecture specific defines should be avoided\n" .  $herecurr);
5153                 }
5154
5155 # Check that the storage class is at the beginning of a declaration
5156                 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
5157                         WARN("STORAGE_CLASS",
5158                              "storage class should be at the beginning of the declaration\n" . $herecurr)
5159                 }
5160
5161 # check the location of the inline attribute, that it is between
5162 # storage class and type.
5163                 if ($line =~ /\b$Type\s+$Inline\b/ ||
5164                     $line =~ /\b$Inline\s+$Storage\b/) {
5165                         ERROR("INLINE_LOCATION",
5166                               "inline keyword should sit between storage class and type\n" . $herecurr);
5167                 }
5168
5169 # Check for __inline__ and __inline, prefer inline
5170                 if ($realfile !~ m@\binclude/uapi/@ &&
5171                     $line =~ /\b(__inline__|__inline)\b/) {
5172                         if (WARN("INLINE",
5173                                  "plain inline is preferred over $1\n" . $herecurr) &&
5174                             $fix) {
5175                                 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5176
5177                         }
5178                 }
5179
5180 # Check for __attribute__ packed, prefer __packed
5181                 if ($realfile !~ m@\binclude/uapi/@ &&
5182                     $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5183                         WARN("PREFER_PACKED",
5184                              "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5185                 }
5186
5187 # Check for __attribute__ aligned, prefer __aligned
5188                 if ($realfile !~ m@\binclude/uapi/@ &&
5189                     $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5190                         WARN("PREFER_ALIGNED",
5191                              "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5192                 }
5193
5194 # Check for __attribute__ format(printf, prefer __printf
5195                 if ($realfile !~ m@\binclude/uapi/@ &&
5196                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5197                         if (WARN("PREFER_PRINTF",
5198                                  "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5199                             $fix) {
5200                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5201
5202                         }
5203                 }
5204
5205 # Check for __attribute__ format(scanf, prefer __scanf
5206                 if ($realfile !~ m@\binclude/uapi/@ &&
5207                     $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5208                         if (WARN("PREFER_SCANF",
5209                                  "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5210                             $fix) {
5211                                 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5212                         }
5213                 }
5214
5215 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5216                 if ($^V && $^V ge 5.10.0 &&
5217                     $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5218                     ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5219                      $line =~ /\b__weak\b/)) {
5220                         ERROR("WEAK_DECLARATION",
5221                               "Using weak declarations can have unintended link defects\n" . $herecurr);
5222                 }
5223
5224 # check for c99 types like uint8_t used outside of uapi/
5225                 if ($realfile !~ m@\binclude/uapi/@ &&
5226                     $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5227                         my $type = $1;
5228                         if ($type =~ /\b($typeC99Typedefs)\b/) {
5229                                 $type = $1;
5230                                 my $kernel_type = 'u';
5231                                 $kernel_type = 's' if ($type =~ /^_*[si]/);
5232                                 $type =~ /(\d+)/;
5233                                 $kernel_type .= $1;
5234                                 if (CHK("PREFER_KERNEL_TYPES",
5235                                         "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5236                                     $fix) {
5237                                         $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5238                                 }
5239                         }
5240                 }
5241
5242 # check for sizeof(&)
5243                 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5244                         WARN("SIZEOF_ADDRESS",
5245                              "sizeof(& should be avoided\n" . $herecurr);
5246                 }
5247
5248 # check for sizeof without parenthesis
5249                 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5250                         if (WARN("SIZEOF_PARENTHESIS",
5251                                  "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5252                             $fix) {
5253                                 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5254                         }
5255                 }
5256
5257 # check for struct spinlock declarations
5258                 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5259                         WARN("USE_SPINLOCK_T",
5260                              "struct spinlock should be spinlock_t\n" . $herecurr);
5261                 }
5262
5263 # check for seq_printf uses that could be seq_puts
5264                 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5265                         my $fmt = get_quoted_string($line, $rawline);
5266                         $fmt =~ s/%%//g;
5267                         if ($fmt !~ /%/) {
5268                                 if (WARN("PREFER_SEQ_PUTS",
5269                                          "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5270                                     $fix) {
5271                                         $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5272                                 }
5273                         }
5274                 }
5275
5276 # Check for misused memsets
5277                 if ($^V && $^V ge 5.10.0 &&
5278                     defined $stat &&
5279                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5280
5281                         my $ms_addr = $2;
5282                         my $ms_val = $7;
5283                         my $ms_size = $12;
5284
5285                         if ($ms_size =~ /^(0x|)0$/i) {
5286                                 ERROR("MEMSET",
5287                                       "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5288                         } elsif ($ms_size =~ /^(0x|)1$/i) {
5289                                 WARN("MEMSET",
5290                                      "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5291                         }
5292                 }
5293
5294 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5295                 if ($^V && $^V ge 5.10.0 &&
5296                     defined $stat &&
5297                     $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5298                         if (WARN("PREFER_ETHER_ADDR_COPY",
5299                                  "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5300                             $fix) {
5301                                 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5302                         }
5303                 }
5304
5305 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5306                 if ($^V && $^V ge 5.10.0 &&
5307                     defined $stat &&
5308                     $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5309                         WARN("PREFER_ETHER_ADDR_EQUAL",
5310                              "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5311                 }
5312
5313 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5314 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5315                 if ($^V && $^V ge 5.10.0 &&
5316                     defined $stat &&
5317                     $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5318
5319                         my $ms_val = $7;
5320
5321                         if ($ms_val =~ /^(?:0x|)0+$/i) {
5322                                 if (WARN("PREFER_ETH_ZERO_ADDR",
5323                                          "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5324                                     $fix) {
5325                                         $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5326                                 }
5327                         } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5328                                 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5329                                          "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5330                                     $fix) {
5331                                         $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5332                                 }
5333                         }
5334                 }
5335
5336 # typecasts on min/max could be min_t/max_t
5337                 if ($^V && $^V ge 5.10.0 &&
5338                     defined $stat &&
5339                     $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5340                         if (defined $2 || defined $7) {
5341                                 my $call = $1;
5342                                 my $cast1 = deparenthesize($2);
5343                                 my $arg1 = $3;
5344                                 my $cast2 = deparenthesize($7);
5345                                 my $arg2 = $8;
5346                                 my $cast;
5347
5348                                 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5349                                         $cast = "$cast1 or $cast2";
5350                                 } elsif ($cast1 ne "") {
5351                                         $cast = $cast1;
5352                                 } else {
5353                                         $cast = $cast2;
5354                                 }
5355                                 WARN("MINMAX",
5356                                      "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5357                         }
5358                 }
5359
5360 # check usleep_range arguments
5361                 if ($^V && $^V ge 5.10.0 &&
5362                     defined $stat &&
5363                     $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5364                         my $min = $1;
5365                         my $max = $7;
5366                         if ($min eq $max) {
5367                                 WARN("USLEEP_RANGE",
5368                                      "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5369                         } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5370                                  $min > $max) {
5371                                 WARN("USLEEP_RANGE",
5372                                      "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5373                         }
5374                 }
5375
5376 # check for naked sscanf
5377                 if ($^V && $^V ge 5.10.0 &&
5378                     defined $stat &&
5379                     $line =~ /\bsscanf\b/ &&
5380                     ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5381                      $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5382                      $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5383                         my $lc = $stat =~ tr@\n@@;
5384                         $lc = $lc + $linenr;
5385                         my $stat_real = raw_line($linenr, 0);
5386                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5387                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5388                         }
5389                         WARN("NAKED_SSCANF",
5390                              "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5391                 }
5392
5393 # check for simple sscanf that should be kstrto<foo>
5394                 if ($^V && $^V ge 5.10.0 &&
5395                     defined $stat &&
5396                     $line =~ /\bsscanf\b/) {
5397                         my $lc = $stat =~ tr@\n@@;
5398                         $lc = $lc + $linenr;
5399                         my $stat_real = raw_line($linenr, 0);
5400                         for (my $count = $linenr + 1; $count <= $lc; $count++) {
5401                                 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5402                         }
5403                         if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5404                                 my $format = $6;
5405                                 my $count = $format =~ tr@%@%@;
5406                                 if ($count == 1 &&
5407                                     $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5408                                         WARN("SSCANF_TO_KSTRTO",
5409                                              "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5410                                 }
5411                         }
5412                 }
5413
5414 # check for new externs in .h files.
5415                 if ($realfile =~ /\.h$/ &&
5416                     $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5417                         if (CHK("AVOID_EXTERNS",
5418                                 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5419                             $fix) {
5420                                 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5421                         }
5422                 }
5423
5424 # check for new externs in .c files.
5425                 if ($realfile =~ /\.c$/ && defined $stat &&
5426                     $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5427                 {
5428                         my $function_name = $1;
5429                         my $paren_space = $2;
5430
5431                         my $s = $stat;
5432                         if (defined $cond) {
5433                                 substr($s, 0, length($cond), '');
5434                         }
5435                         if ($s =~ /^\s*;/ &&
5436                             $function_name ne 'uninitialized_var')
5437                         {
5438                                 WARN("AVOID_EXTERNS",
5439                                      "externs should be avoided in .c files\n" .  $herecurr);
5440                         }
5441
5442                         if ($paren_space =~ /\n/) {
5443                                 WARN("FUNCTION_ARGUMENTS",
5444                                      "arguments for function declarations should follow identifier\n" . $herecurr);
5445                         }
5446
5447                 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5448                     $stat =~ /^.\s*extern\s+/)
5449                 {
5450                         WARN("AVOID_EXTERNS",
5451                              "externs should be avoided in .c files\n" .  $herecurr);
5452                 }
5453
5454 # checks for new __setup's
5455                 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5456                         my $name = $1;
5457
5458                         if (!grep(/$name/, @setup_docs)) {
5459                                 CHK("UNDOCUMENTED_SETUP",
5460                                     "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
5461                         }
5462                 }
5463
5464 # check for pointless casting of kmalloc return
5465                 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5466                         WARN("UNNECESSARY_CASTS",
5467                              "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5468                 }
5469
5470 # alloc style
5471 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5472                 if ($^V && $^V ge 5.10.0 &&
5473                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5474                         CHK("ALLOC_SIZEOF_STRUCT",
5475                             "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5476                 }
5477
5478 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5479                 if ($^V && $^V ge 5.10.0 &&
5480                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5481                         my $oldfunc = $3;
5482                         my $a1 = $4;
5483                         my $a2 = $10;
5484                         my $newfunc = "kmalloc_array";
5485                         $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5486                         my $r1 = $a1;
5487                         my $r2 = $a2;
5488                         if ($a1 =~ /^sizeof\s*\S/) {
5489                                 $r1 = $a2;
5490                                 $r2 = $a1;
5491                         }
5492                         if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5493                             !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5494                                 if (WARN("ALLOC_WITH_MULTIPLY",
5495                                          "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5496                                     $fix) {
5497                                         $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;
5498
5499                                 }
5500                         }
5501                 }
5502
5503 # check for krealloc arg reuse
5504                 if ($^V && $^V ge 5.10.0 &&
5505                     $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5506                         WARN("KREALLOC_ARG_REUSE",
5507                              "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5508                 }
5509
5510 # check for alloc argument mismatch
5511                 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5512                         WARN("ALLOC_ARRAY_ARGS",
5513                              "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5514                 }
5515
5516 # check for multiple semicolons
5517                 if ($line =~ /;\s*;\s*$/) {
5518                         if (WARN("ONE_SEMICOLON",
5519                                  "Statements terminations use 1 semicolon\n" . $herecurr) &&
5520                             $fix) {
5521                                 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5522                         }
5523                 }
5524
5525 # check for #defines like: 1 << <digit> that could be BIT(digit)
5526                 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5527                         my $ull = "";
5528                         $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5529                         if (CHK("BIT_MACRO",
5530                                 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5531                             $fix) {
5532                                 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5533                         }
5534                 }
5535
5536 # check for case / default statements not preceded by break/fallthrough/switch
5537                 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5538                         my $has_break = 0;
5539                         my $has_statement = 0;
5540                         my $count = 0;
5541                         my $prevline = $linenr;
5542                         while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5543                                 $prevline--;
5544                                 my $rline = $rawlines[$prevline - 1];
5545                                 my $fline = $lines[$prevline - 1];
5546                                 last if ($fline =~ /^\@\@/);
5547                                 next if ($fline =~ /^\-/);
5548                                 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5549                                 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5550                                 next if ($fline =~ /^.[\s$;]*$/);
5551                                 $has_statement = 1;
5552                                 $count++;
5553                                 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5554                         }
5555                         if (!$has_break && $has_statement) {
5556                                 WARN("MISSING_BREAK",
5557                                      "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5558                         }
5559                 }
5560
5561 # check for switch/default statements without a break;
5562                 if ($^V && $^V ge 5.10.0 &&
5563                     defined $stat &&
5564                     $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5565                         my $ctx = '';
5566                         my $herectx = $here . "\n";
5567                         my $cnt = statement_rawlines($stat);
5568                         for (my $n = 0; $n < $cnt; $n++) {
5569                                 $herectx .= raw_line($linenr, $n) . "\n";
5570                         }
5571                         WARN("DEFAULT_NO_BREAK",
5572                              "switch default: should use break\n" . $herectx);
5573                 }
5574
5575 # check for gcc specific __FUNCTION__
5576                 if ($line =~ /\b__FUNCTION__\b/) {
5577                         if (WARN("USE_FUNC",
5578                                  "__func__ should be used instead of gcc specific __FUNCTION__\n"  . $herecurr) &&
5579                             $fix) {
5580                                 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5581                         }
5582                 }
5583
5584 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
5585                 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5586                         ERROR("DATE_TIME",
5587                               "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5588                 }
5589
5590 # check for use of yield()
5591                 if ($line =~ /\byield\s*\(\s*\)/) {
5592                         WARN("YIELD",
5593                              "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n"  . $herecurr);
5594                 }
5595
5596 # check for comparisons against true and false
5597                 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5598                         my $lead = $1;
5599                         my $arg = $2;
5600                         my $test = $3;
5601                         my $otype = $4;
5602                         my $trail = $5;
5603                         my $op = "!";
5604
5605                         ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5606
5607                         my $type = lc($otype);
5608                         if ($type =~ /^(?:true|false)$/) {
5609                                 if (("$test" eq "==" && "$type" eq "true") ||
5610                                     ("$test" eq "!=" && "$type" eq "false")) {
5611                                         $op = "";
5612                                 }
5613
5614                                 CHK("BOOL_COMPARISON",
5615                                     "Using comparison to $otype is error prone\n" . $herecurr);
5616
5617 ## maybe suggesting a correct construct would better
5618 ##                                  "Using comparison to $otype is error prone.  Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5619
5620                         }
5621                 }
5622
5623 # check for semaphores initialized locked
5624                 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
5625                         WARN("CONSIDER_COMPLETION",
5626                              "consider using a completion\n" . $herecurr);
5627                 }
5628
5629 # recommend kstrto* over simple_strto* and strict_strto*
5630                 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5631                         WARN("CONSIDER_KSTRTO",
5632                              "$1 is obsolete, use k$3 instead\n" . $herecurr);
5633                 }
5634
5635 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
5636                 if ($line =~ /^.\s*__initcall\s*\(/) {
5637                         WARN("USE_DEVICE_INITCALL",
5638                              "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5639                 }
5640
5641 # check for various structs that are normally const (ops, kgdb, device_tree)
5642                 my $const_structs = qr{
5643                                 acpi_dock_ops|
5644                                 address_space_operations|
5645                                 backlight_ops|
5646                                 block_device_operations|
5647                                 dentry_operations|
5648                                 dev_pm_ops|
5649                                 dma_map_ops|
5650                                 extent_io_ops|
5651                                 file_lock_operations|
5652                                 file_operations|
5653                                 hv_ops|
5654                                 ide_dma_ops|
5655                                 intel_dvo_dev_ops|
5656                                 item_operations|
5657                                 iwl_ops|
5658                                 kgdb_arch|
5659                                 kgdb_io|
5660                                 kset_uevent_ops|
5661                                 lock_manager_operations|
5662                                 microcode_ops|
5663                                 mtrr_ops|
5664                                 neigh_ops|
5665                                 nlmsvc_binding|
5666                                 of_device_id|
5667                                 pci_raw_ops|
5668                                 pipe_buf_operations|
5669                                 platform_hibernation_ops|
5670                                 platform_suspend_ops|
5671                                 proto_ops|
5672                                 rpc_pipe_ops|
5673                                 seq_operations|
5674                                 snd_ac97_build_ops|
5675                                 soc_pcmcia_socket_ops|
5676                                 stacktrace_ops|
5677                                 sysfs_ops|
5678                                 tty_operations|
5679                                 uart_ops|
5680                                 usb_mon_operations|
5681                                 wd_ops}x;
5682                 if ($line !~ /\bconst\b/ &&
5683                     $line =~ /\bstruct\s+($const_structs)\b/) {
5684                         WARN("CONST_STRUCT",
5685                              "struct $1 should normally be const\n" .
5686                                 $herecurr);
5687                 }
5688
5689 # use of NR_CPUS is usually wrong
5690 # ignore definitions of NR_CPUS and usage to define arrays as likely right
5691                 if ($line =~ /\bNR_CPUS\b/ &&
5692                     $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5693                     $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
5694                     $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5695                     $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5696                     $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
5697                 {
5698                         WARN("NR_CPUS",
5699                              "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
5700                 }
5701
5702 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5703                 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5704                         ERROR("DEFINE_ARCH_HAS",
5705                               "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5706                 }
5707
5708 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
5709                 if ($^V && $^V ge 5.10.0 &&
5710                     $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5711                         WARN("LIKELY_MISUSE",
5712                              "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5713                 }
5714
5715 # whine mightly about in_atomic
5716                 if ($line =~ /\bin_atomic\s*\(/) {
5717                         if ($realfile =~ m@^drivers/@) {
5718                                 ERROR("IN_ATOMIC",
5719                                       "do not use in_atomic in drivers\n" . $herecurr);
5720                         } elsif ($realfile !~ m@^kernel/@) {
5721                                 WARN("IN_ATOMIC",
5722                                      "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5723                         }
5724                 }
5725
5726 # check for lockdep_set_novalidate_class
5727                 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5728                     $line =~ /__lockdep_no_validate__\s*\)/ ) {
5729                         if ($realfile !~ m@^kernel/lockdep@ &&
5730                             $realfile !~ m@^include/linux/lockdep@ &&
5731                             $realfile !~ m@^drivers/base/core@) {
5732                                 ERROR("LOCKDEP",
5733                                       "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5734                         }
5735                 }
5736
5737                 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5738                     $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
5739                         WARN("EXPORTED_WORLD_WRITABLE",
5740                              "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5741                 }
5742
5743 # Mode permission misuses where it seems decimal should be octal
5744 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5745                 if ($^V && $^V ge 5.10.0 &&
5746                     $line =~ /$mode_perms_search/) {
5747                         foreach my $entry (@mode_permission_funcs) {
5748                                 my $func = $entry->[0];
5749                                 my $arg_pos = $entry->[1];
5750
5751                                 my $skip_args = "";
5752                                 if ($arg_pos > 1) {
5753                                         $arg_pos--;
5754                                         $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5755                                 }
5756                                 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5757                                 if ($line =~ /$test/) {
5758                                         my $val = $1;
5759                                         $val = $6 if ($skip_args ne "");
5760
5761                                         if ($val !~ /^0$/ &&
5762                                             (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5763                                              length($val) ne 4)) {
5764                                                 ERROR("NON_OCTAL_PERMISSIONS",
5765                                                       "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
5766                                         } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5767                                                 ERROR("EXPORTED_WORLD_WRITABLE",
5768                                                       "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5769                                         }
5770                                 }
5771                         }
5772                 }
5773
5774 # validate content of MODULE_LICENSE against list from include/linux/module.h
5775                 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
5776                         my $extracted_string = get_quoted_string($line, $rawline);
5777                         my $valid_licenses = qr{
5778                                                 GPL|
5779                                                 GPL\ v2|
5780                                                 GPL\ and\ additional\ rights|
5781                                                 Dual\ BSD/GPL|
5782                                                 Dual\ MIT/GPL|
5783                                                 Dual\ MPL/GPL|
5784                                                 Proprietary
5785                                         }x;
5786                         if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
5787                                 WARN("MODULE_LICENSE",
5788                                      "unknown module license " . $extracted_string . "\n" . $herecurr);
5789                         }
5790                 }
5791         }
5792
5793         # If we have no input at all, then there is nothing to report on
5794         # so just keep quiet.
5795         if ($#rawlines == -1) {
5796                 exit(0);
5797         }
5798
5799         # In mailback mode only produce a report in the negative, for
5800         # things that appear to be patches.
5801         if ($mailback && ($clean == 1 || !$is_patch)) {
5802                 exit(0);
5803         }
5804
5805         # This is not a patch, and we are are in 'no-patch' mode so
5806         # just keep quiet.
5807         if (!$chk_patch && !$is_patch) {
5808                 exit(0);
5809         }
5810
5811         if (!$is_patch && $file !~ /cover-letter\.patch$/) {
5812                 ERROR("NOT_UNIFIED_DIFF",
5813                       "Does not appear to be a unified-diff format patch\n");
5814         }
5815         if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
5816                 ERROR("MISSING_SIGN_OFF",
5817                       "Missing Signed-off-by: line(s)\n");
5818         }
5819
5820         print report_dump();
5821         if ($summary && !($clean == 1 && $quiet == 1)) {
5822                 print "$filename " if ($summary_file);
5823                 print "total: $cnt_error errors, $cnt_warn warnings, " .
5824                         (($check)? "$cnt_chk checks, " : "") .
5825                         "$cnt_lines lines checked\n";
5826         }
5827
5828         if ($quiet == 0) {
5829                 # If there were whitespace errors which cleanpatch can fix
5830                 # then suggest that.
5831                 if ($rpt_cleaners) {
5832                         $rpt_cleaners = 0;
5833                         print << "EOM"
5834
5835 NOTE: Whitespace errors detected.
5836       You may wish to use scripts/cleanpatch or scripts/cleanfile
5837 EOM
5838                 }
5839         }
5840
5841         if ($clean == 0 && $fix &&
5842             ("@rawlines" ne "@fixed" ||
5843              $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
5844                 my $newfile = $filename;
5845                 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
5846                 my $linecount = 0;
5847                 my $f;
5848
5849                 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5850
5851                 open($f, '>', $newfile)
5852                     or die "$P: Can't open $newfile for write\n";
5853                 foreach my $fixed_line (@fixed) {
5854                         $linecount++;
5855                         if ($file) {
5856                                 if ($linecount > 3) {
5857                                         $fixed_line =~ s/^\+//;
5858                                         print $f $fixed_line . "\n";
5859                                 }
5860                         } else {
5861                                 print $f $fixed_line . "\n";
5862                         }
5863                 }
5864                 close($f);
5865
5866                 if (!$quiet) {
5867                         print << "EOM";
5868
5869 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5870
5871 Do _NOT_ trust the results written to this file.
5872 Do _NOT_ submit these changes without inspecting them for correctness.
5873
5874 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5875 No warranties, expressed or implied...
5876 EOM
5877                 }
5878         }
5879
5880         if ($quiet == 0) {
5881                 print "\n";
5882                 if ($clean == 1) {
5883                         print "$vname has no obvious style problems and is ready for submission.\n";
5884                 } else {
5885                         print "$vname has style problems, please review.\n";
5886                 }
5887         }
5888         return $clean;
5889 }