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