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