scripts/checkpatch.pl

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