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