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