scripts/checkpatch.pl

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