scripts/checkpatch.pl

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