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 8use strict; 9use POSIX; 10 11my $P = $0; 12$P =~ s@.*/@@g; 13 14my $V = '0.32'; 15 16use Getopt::Long qw(:config no_auto_abbrev); 17 18my $quiet = 0; 19my $tree = 1; 20my $chk_signoff = 1; 21my $chk_patch = 1; 22my $tst_only; 23my $emacs = 0; 24my $terse = 0; 25my $file = 0; 26my $check = 0; 27my $summary = 1; 28my $mailback = 0; 29my $summary_file = 0; 30my $show_types = 0; 31my $fix = 0; 32my $root; 33my %debug; 34my %camelcase = (); 35my %use_type = (); 36my @use = (); 37my %ignore_type = (); 38my @ignore = (); 39my $help = 0; 40my $configuration_file = ".checkpatch.conf"; 41my $max_line_length = 80; 42my $ignore_perl_version = 0; 43my $minimum_perl_version = 5.10.0; 44 45sub help { 46 my ($exitcode) = @_; 47 48 print << "EOM"; 49Usage: $P [OPTION]... [FILE]... 50Version: $V 51 52Options: 53 -q, --quiet quiet 54 --no-tree run without a kernel tree 55 --no-signoff do not check for 'Signed-off-by' line 56 --patch treat FILE as patchfile (default) 57 --emacs emacs compile window format 58 --terse one line per report 59 -f, --file treat FILE as regular source file 60 --subjective, --strict enable more subjective tests 61 --types TYPE(,TYPE2...) show only these comma separated message types 62 --ignore TYPE(,TYPE2...) ignore various comma separated message types 63 --max-line-length=n set the maximum line length, if exceeded, warn 64 --show-types show the message "types" in the output 65 --root=PATH PATH to the kernel tree root 66 --no-summary suppress the per-file summary 67 --mailback only produce a report in case of warnings/errors 68 --summary-file include the filename in summary 69 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of 70 'values', 'possible', 'type', and 'attr' (default 71 is all off) 72 --test-only=WORD report only warnings/errors containing WORD 73 literally 74 --fix EXPERIMENTAL - may create horrible results 75 If correctable single-line errors exist, create 76 "<inputfile>.EXPERIMENTAL-checkpatch-fixes" 77 with potential errors corrected to the preferred 78 checkpatch style 79 --ignore-perl-version override checking of perl version. expect 80 runtime errors. 81 -h, --help, --version display this help and exit 82 83When FILE is - read standard input. 84EOM 85 86 exit($exitcode); 87} 88 89my $conf = which_conf($configuration_file); 90if (-f $conf) { 91 my @conf_args; 92 open(my $conffile, '<', "$conf") 93 or warn "$P: Can't find a readable $configuration_file file $!\n"; 94 95 while (<$conffile>) { 96 my $line = $_; 97 98 $line =~ s/\s*\n?$//g; 99 $line =~ s/^\s*//g; 100 $line =~ s/\s+/ /g; 101 102 next if ($line =~ m/^\s*#/); 103 next if ($line =~ m/^\s*$/); 104 105 my @words = split(" ", $line); 106 foreach my $word (@words) { 107 last if ($word =~ m/^#/); 108 push (@conf_args, $word); 109 } 110 } 111 close($conffile); 112 unshift(@ARGV, @conf_args) if @conf_args; 113} 114 115GetOptions( 116 'q|quiet+' => \$quiet, 117 'tree!' => \$tree, 118 'signoff!' => \$chk_signoff, 119 'patch!' => \$chk_patch, 120 'emacs!' => \$emacs, 121 'terse!' => \$terse, 122 'f|file!' => \$file, 123 'subjective!' => \$check, 124 'strict!' => \$check, 125 'ignore=s' => \@ignore, 126 'types=s' => \@use, 127 'show-types!' => \$show_types, 128 'max-line-length=i' => \$max_line_length, 129 'root=s' => \$root, 130 'summary!' => \$summary, 131 'mailback!' => \$mailback, 132 'summary-file!' => \$summary_file, 133 'fix!' => \$fix, 134 'ignore-perl-version!' => \$ignore_perl_version, 135 'debug=s' => \%debug, 136 'test-only=s' => \$tst_only, 137 'h|help' => \$help, 138 'version' => \$help 139) or help(1); 140 141help(0) if ($help); 142 143my $exit = 0; 144 145if ($^V && $^V lt $minimum_perl_version) { 146 printf "$P: requires at least perl version %vd\n", $minimum_perl_version; 147 if (!$ignore_perl_version) { 148 exit(1); 149 } 150} 151 152if ($#ARGV < 0) { 153 print "$P: no input files\n"; 154 exit(1); 155} 156 157sub hash_save_array_words { 158 my ($hashRef, $arrayRef) = @_; 159 160 my @array = split(/,/, join(',', @$arrayRef)); 161 foreach my $word (@array) { 162 $word =~ s/\s*\n?$//g; 163 $word =~ s/^\s*//g; 164 $word =~ s/\s+/ /g; 165 $word =~ tr/[a-z]/[A-Z]/; 166 167 next if ($word =~ m/^\s*#/); 168 next if ($word =~ m/^\s*$/); 169 170 $hashRef->{$word}++; 171 } 172} 173 174sub hash_show_words { 175 my ($hashRef, $prefix) = @_; 176 177 if ($quiet == 0 && keys %$hashRef) { 178 print "NOTE: $prefix message types:"; 179 foreach my $word (sort keys %$hashRef) { 180 print " $word"; 181 } 182 print "\n\n"; 183 } 184} 185 186hash_save_array_words(\%ignore_type, \@ignore); 187hash_save_array_words(\%use_type, \@use); 188 189my $dbg_values = 0; 190my $dbg_possible = 0; 191my $dbg_type = 0; 192my $dbg_attr = 0; 193for my $key (keys %debug) { 194 ## no critic 195 eval "\${dbg_$key} = '$debug{$key}';"; 196 die "$@" if ($@); 197} 198 199my $rpt_cleaners = 0; 200 201if ($terse) { 202 $emacs = 1; 203 $quiet++; 204} 205 206if ($tree) { 207 if (defined $root) { 208 if (!top_of_kernel_tree($root)) { 209 die "$P: $root: --root does not point at a valid tree\n"; 210 } 211 } else { 212 if (top_of_kernel_tree('.')) { 213 $root = '.'; 214 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ && 215 top_of_kernel_tree($1)) { 216 $root = $1; 217 } 218 } 219 220 if (!defined $root) { 221 print "Must be run from the top-level dir. of a kernel tree\n"; 222 exit(2); 223 } 224} 225 226my $emitted_corrupt = 0; 227 228our $Ident = qr{ 229 [A-Za-z_][A-Za-z\d_]* 230 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)* 231 }x; 232our $Storage = qr{extern|static|asmlinkage}; 233our $Sparse = qr{ 234 __user| 235 __kernel| 236 __force| 237 __iomem| 238 __must_check| 239 __init_refok| 240 __kprobes| 241 __ref| 242 __rcu 243 }x; 244our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)}; 245our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)}; 246our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)}; 247our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)}; 248our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit}; 249 250# Notes to $Attribute: 251# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check 252our $Attribute = qr{ 253 const| 254 __percpu| 255 __nocast| 256 __safe| 257 __bitwise__| 258 __packed__| 259 __packed2__| 260 __naked| 261 __maybe_unused| 262 __always_unused| 263 __noreturn| 264 __used| 265 __cold| 266 __noclone| 267 __deprecated| 268 __read_mostly| 269 __kprobes| 270 $InitAttribute| 271 ____cacheline_aligned| 272 ____cacheline_aligned_in_smp| 273 ____cacheline_internodealigned_in_smp| 274 __weak 275 }x; 276our $Modifier; 277our $Inline = qr{inline|__always_inline|noinline}; 278our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]}; 279our $Lval = qr{$Ident(?:$Member)*}; 280 281our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u}; 282our $Binary = qr{(?i)0b[01]+$Int_type?}; 283our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?}; 284our $Int = qr{[0-9]+$Int_type?}; 285our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?}; 286our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?}; 287our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?}; 288our $Float = qr{$Float_hex|$Float_dec|$Float_int}; 289our $Constant = qr{$Float|$Binary|$Hex|$Int}; 290our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=}; 291our $Compare = qr{<=|>=|==|!=|<|>}; 292our $Arithmetic = qr{\+|-|\*|\/|%}; 293our $Operators = qr{ 294 <=|>=|==|!=| 295 =>|->|<<|>>|<|>|!|~| 296 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic 297 }x; 298 299our $NonptrType; 300our $NonptrTypeWithAttr; 301our $Type; 302our $Declare; 303 304our $NON_ASCII_UTF8 = qr{ 305 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte 306 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs 307 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte 308 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates 309 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3 310 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15 311 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16 312}x; 313 314our $UTF8 = qr{ 315 [\x09\x0A\x0D\x20-\x7E] # ASCII 316 | $NON_ASCII_UTF8 317}x; 318 319our $typeTypedefs = qr{(?x: 320 (?:__)?(?:u|s|be|le)(?:8|16|32|64)| 321 atomic_t 322)}; 323 324our $logFunctions = qr{(?x: 325 printk(?:_ratelimited|_once|)| 326 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)| 327 WARN(?:_RATELIMIT|_ONCE|)| 328 panic| 329 MODULE_[A-Z_]+| 330 seq_vprintf|seq_printf|seq_puts 331)}; 332 333our $signature_tags = qr{(?xi: 334 Signed-off-by:| 335 Acked-by:| 336 Tested-by:| 337 Reviewed-by:| 338 Reported-by:| 339 Suggested-by:| 340 To:| 341 Cc: 342)}; 343 344our @typeList = ( 345 qr{void}, 346 qr{(?:unsigned\s+)?char}, 347 qr{(?:unsigned\s+)?short}, 348 qr{(?:unsigned\s+)?int}, 349 qr{(?:unsigned\s+)?long}, 350 qr{(?:unsigned\s+)?long\s+int}, 351 qr{(?:unsigned\s+)?long\s+long}, 352 qr{(?:unsigned\s+)?long\s+long\s+int}, 353 qr{unsigned}, 354 qr{float}, 355 qr{double}, 356 qr{bool}, 357 qr{struct\s+$Ident}, 358 qr{union\s+$Ident}, 359 qr{enum\s+$Ident}, 360 qr{${Ident}_t}, 361 qr{${Ident}_handler}, 362 qr{${Ident}_handler_fn}, 363); 364our @typeListWithAttr = ( 365 @typeList, 366 qr{struct\s+$InitAttribute\s+$Ident}, 367 qr{union\s+$InitAttribute\s+$Ident}, 368); 369 370our @modifierList = ( 371 qr{fastcall}, 372); 373 374our $allowed_asm_includes = qr{(?x: 375 irq| 376 memory 377)}; 378# memory.h: ARM has a custom one 379 380sub build_types { 381 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)"; 382 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)"; 383 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)"; 384 $Modifier = qr{(?:$Attribute|$Sparse|$mods)}; 385 $NonptrType = qr{ 386 (?:$Modifier\s+|const\s+)* 387 (?: 388 (?:typeof|__typeof__)\s*\([^\)]*\)| 389 (?:$typeTypedefs\b)| 390 (?:${all}\b) 391 ) 392 (?:\s+$Modifier|\s+const)* 393 }x; 394 $NonptrTypeWithAttr = qr{ 395 (?:$Modifier\s+|const\s+)* 396 (?: 397 (?:typeof|__typeof__)\s*\([^\)]*\)| 398 (?:$typeTypedefs\b)| 399 (?:${allWithAttr}\b) 400 ) 401 (?:\s+$Modifier|\s+const)* 402 }x; 403 $Type = qr{ 404 $NonptrType 405 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*|\[\])+|(?:\s*\[\s*\])+)? 406 (?:\s+$Inline|\s+$Modifier)* 407 }x; 408 $Declare = qr{(?:$Storage\s+)?$Type}; 409} 410build_types(); 411 412our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*}; 413 414# Using $balanced_parens, $LvalOrFunc, or $FuncArg 415# requires at least perl version v5.10.0 416# Any use must be runtime checked with $^V 417 418our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/; 419our $LvalOrFunc = qr{($Lval)\s*($balanced_parens{0,1})\s*}; 420our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)}; 421 422sub deparenthesize { 423 my ($string) = @_; 424 return "" if (!defined($string)); 425 $string =~ s@^\s*\(\s*@@g; 426 $string =~ s@\s*\)\s*$@@g; 427 $string =~ s@\s+@ @g; 428 return $string; 429} 430 431sub seed_camelcase_file { 432 my ($file) = @_; 433 434 return if (!(-f $file)); 435 436 local $/; 437 438 open(my $include_file, '<', "$file") 439 or warn "$P: Can't read '$file' $!\n"; 440 my $text = <$include_file>; 441 close($include_file); 442 443 my @lines = split('\n', $text); 444 445 foreach my $line (@lines) { 446 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/); 447 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) { 448 $camelcase{$1} = 1; 449 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) { 450 $camelcase{$1} = 1; 451 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) { 452 $camelcase{$1} = 1; 453 } 454 } 455} 456 457my $camelcase_seeded = 0; 458sub seed_camelcase_includes { 459 return if ($camelcase_seeded); 460 461 my $files; 462 my $camelcase_cache = ""; 463 my @include_files = (); 464 465 $camelcase_seeded = 1; 466 467 if (-d ".git") { 468 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`; 469 chomp $git_last_include_commit; 470 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit"; 471 } else { 472 my $last_mod_date = 0; 473 $files = `find $root/include -name "*.h"`; 474 @include_files = split('\n', $files); 475 foreach my $file (@include_files) { 476 my $date = POSIX::strftime("%Y%m%d%H%M", 477 localtime((stat $file)[9])); 478 $last_mod_date = $date if ($last_mod_date < $date); 479 } 480 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date"; 481 } 482 483 if ($camelcase_cache ne "" && -f $camelcase_cache) { 484 open(my $camelcase_file, '<', "$camelcase_cache") 485 or warn "$P: Can't read '$camelcase_cache' $!\n"; 486 while (<$camelcase_file>) { 487 chomp; 488 $camelcase{$_} = 1; 489 } 490 close($camelcase_file); 491 492 return; 493 } 494 495 if (-d ".git") { 496 $files = `git ls-files "include/*.h"`; 497 @include_files = split('\n', $files); 498 } 499 500 foreach my $file (@include_files) { 501 seed_camelcase_file($file); 502 } 503 504 if ($camelcase_cache ne "") { 505 unlink glob ".checkpatch-camelcase.*"; 506 open(my $camelcase_file, '>', "$camelcase_cache") 507 or warn "$P: Can't write '$camelcase_cache' $!\n"; 508 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) { 509 print $camelcase_file ("$_\n"); 510 } 511 close($camelcase_file); 512 } 513} 514 515$chk_signoff = 0 if ($file); 516 517my @rawlines = (); 518my @lines = (); 519my @fixed = (); 520my $vname; 521for my $filename (@ARGV) { 522 my $FILE; 523 if ($file) { 524 open($FILE, '-|', "diff -u /dev/null $filename") || 525 die "$P: $filename: diff failed - $!\n"; 526 } elsif ($filename eq '-') { 527 open($FILE, '<&STDIN'); 528 } else { 529 open($FILE, '<', "$filename") || 530 die "$P: $filename: open failed - $!\n"; 531 } 532 if ($filename eq '-') { 533 $vname = 'Your patch'; 534 } else { 535 $vname = $filename; 536 } 537 while (<$FILE>) { 538 chomp; 539 push(@rawlines, $_); 540 } 541 close($FILE); 542 if (!process($filename)) { 543 $exit = 1; 544 } 545 @rawlines = (); 546 @lines = (); 547 @fixed = (); 548} 549 550exit($exit); 551 552sub top_of_kernel_tree { 553 my ($root) = @_; 554 555 my @tree_check = ( 556 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile", 557 "README", "Documentation", "arch", "include", "drivers", 558 "fs", "init", "ipc", "kernel", "lib", "scripts", 559 ); 560 561 foreach my $check (@tree_check) { 562 if (! -e $root . '/' . $check) { 563 return 0; 564 } 565 } 566 return 1; 567} 568 569sub parse_email { 570 my ($formatted_email) = @_; 571 572 my $name = ""; 573 my $address = ""; 574 my $comment = ""; 575 576 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) { 577 $name = $1; 578 $address = $2; 579 $comment = $3 if defined $3; 580 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) { 581 $address = $1; 582 $comment = $2 if defined $2; 583 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) { 584 $address = $1; 585 $comment = $2 if defined $2; 586 $formatted_email =~ s/$address.*$//; 587 $name = $formatted_email; 588 $name = trim($name); 589 $name =~ s/^\"|\"$//g; 590 # If there's a name left after stripping spaces and 591 # leading quotes, and the address doesn't have both 592 # leading and trailing angle brackets, the address 593 # is invalid. ie: 594 # "joe smith joe@smith.com" bad 595 # "joe smith <joe@smith.com" bad 596 if ($name ne "" && $address !~ /^<[^>]+>$/) { 597 $name = ""; 598 $address = ""; 599 $comment = ""; 600 } 601 } 602 603 $name = trim($name); 604 $name =~ s/^\"|\"$//g; 605 $address = trim($address); 606 $address =~ s/^\<|\>$//g; 607 608 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars 609 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes 610 $name = "\"$name\""; 611 } 612 613 return ($name, $address, $comment); 614} 615 616sub format_email { 617 my ($name, $address) = @_; 618 619 my $formatted_email; 620 621 $name = trim($name); 622 $name =~ s/^\"|\"$//g; 623 $address = trim($address); 624 625 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars 626 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes 627 $name = "\"$name\""; 628 } 629 630 if ("$name" eq "") { 631 $formatted_email = "$address"; 632 } else { 633 $formatted_email = "$name <$address>"; 634 } 635 636 return $formatted_email; 637} 638 639sub which_conf { 640 my ($conf) = @_; 641 642 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) { 643 if (-e "$path/$conf") { 644 return "$path/$conf"; 645 } 646 } 647 648 return ""; 649} 650 651sub expand_tabs { 652 my ($str) = @_; 653 654 my $res = ''; 655 my $n = 0; 656 for my $c (split(//, $str)) { 657 if ($c eq "\t") { 658 $res .= ' '; 659 $n++; 660 for (; ($n % 8) != 0; $n++) { 661 $res .= ' '; 662 } 663 next; 664 } 665 $res .= $c; 666 $n++; 667 } 668 669 return $res; 670} 671sub copy_spacing { 672 (my $res = shift) =~ tr/\t/ /c; 673 return $res; 674} 675 676sub line_stats { 677 my ($line) = @_; 678 679 # Drop the diff line leader and expand tabs 680 $line =~ s/^.//; 681 $line = expand_tabs($line); 682 683 # Pick the indent from the front of the line. 684 my ($white) = ($line =~ /^(\s*)/); 685 686 return (length($line), length($white)); 687} 688 689my $sanitise_quote = ''; 690 691sub sanitise_line_reset { 692 my ($in_comment) = @_; 693 694 if ($in_comment) { 695 $sanitise_quote = '*/'; 696 } else { 697 $sanitise_quote = ''; 698 } 699} 700sub sanitise_line { 701 my ($line) = @_; 702 703 my $res = ''; 704 my $l = ''; 705 706 my $qlen = 0; 707 my $off = 0; 708 my $c; 709 710 # Always copy over the diff marker. 711 $res = substr($line, 0, 1); 712 713 for ($off = 1; $off < length($line); $off++) { 714 $c = substr($line, $off, 1); 715 716 # Comments we are wacking completly including the begin 717 # and end, all to $;. 718 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') { 719 $sanitise_quote = '*/'; 720 721 substr($res, $off, 2, "$;$;"); 722 $off++; 723 next; 724 } 725 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') { 726 $sanitise_quote = ''; 727 substr($res, $off, 2, "$;$;"); 728 $off++; 729 next; 730 } 731 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') { 732 $sanitise_quote = '//'; 733 734 substr($res, $off, 2, $sanitise_quote); 735 $off++; 736 next; 737 } 738 739 # A \ in a string means ignore the next character. 740 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') && 741 $c eq "\\") { 742 substr($res, $off, 2, 'XX'); 743 $off++; 744 next; 745 } 746 # Regular quotes. 747 if ($c eq "'" || $c eq '"') { 748 if ($sanitise_quote eq '') { 749 $sanitise_quote = $c; 750 751 substr($res, $off, 1, $c); 752 next; 753 } elsif ($sanitise_quote eq $c) { 754 $sanitise_quote = ''; 755 } 756 } 757 758 #print "c<$c> SQ<$sanitise_quote>\n"; 759 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") { 760 substr($res, $off, 1, $;); 761 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") { 762 substr($res, $off, 1, $;); 763 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") { 764 substr($res, $off, 1, 'X'); 765 } else { 766 substr($res, $off, 1, $c); 767 } 768 } 769 770 if ($sanitise_quote eq '//') { 771 $sanitise_quote = ''; 772 } 773 774 # The pathname on a #include may be surrounded by '<' and '>'. 775 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) { 776 my $clean = 'X' x length($1); 777 $res =~ s@\<.*\>@<$clean>@; 778 779 # The whole of a #error is a string. 780 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) { 781 my $clean = 'X' x length($1); 782 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@; 783 } 784 785 return $res; 786} 787 788sub get_quoted_string { 789 my ($line, $rawline) = @_; 790 791 return "" if ($line !~ m/(\"[X]+\")/g); 792 return substr($rawline, $-[0], $+[0] - $-[0]); 793} 794 795sub ctx_statement_block { 796 my ($linenr, $remain, $off) = @_; 797 my $line = $linenr - 1; 798 my $blk = ''; 799 my $soff = $off; 800 my $coff = $off - 1; 801 my $coff_set = 0; 802 803 my $loff = 0; 804 805 my $type = ''; 806 my $level = 0; 807 my @stack = (); 808 my $p; 809 my $c; 810 my $len = 0; 811 812 my $remainder; 813 while (1) { 814 @stack = (['', 0]) if ($#stack == -1); 815 816 #warn "CSB: blk<$blk> remain<$remain>\n"; 817 # If we are about to drop off the end, pull in more 818 # context. 819 if ($off >= $len) { 820 for (; $remain > 0; $line++) { 821 last if (!defined $lines[$line]); 822 next if ($lines[$line] =~ /^-/); 823 $remain--; 824 $loff = $len; 825 $blk .= $lines[$line] . "\n"; 826 $len = length($blk); 827 $line++; 828 last; 829 } 830 # Bail if there is no further context. 831 #warn "CSB: blk<$blk> off<$off> len<$len>\n"; 832 if ($off >= $len) { 833 last; 834 } 835 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) { 836 $level++; 837 $type = '#'; 838 } 839 } 840 $p = $c; 841 $c = substr($blk, $off, 1); 842 $remainder = substr($blk, $off); 843 844 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n"; 845 846 # Handle nested #if/#else. 847 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) { 848 push(@stack, [ $type, $level ]); 849 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) { 850 ($type, $level) = @{$stack[$#stack - 1]}; 851 } elsif ($remainder =~ /^#\s*endif\b/) { 852 ($type, $level) = @{pop(@stack)}; 853 } 854 855 # Statement ends at the ';' or a close '}' at the 856 # outermost level. 857 if ($level == 0 && $c eq ';') { 858 last; 859 } 860 861 # An else is really a conditional as long as its not else if 862 if ($level == 0 && $coff_set == 0 && 863 (!defined($p) || $p =~ /(?:\s|\}|\+)/) && 864 $remainder =~ /^(else)(?:\s|{)/ && 865 $remainder !~ /^else\s+if\b/) { 866 $coff = $off + length($1) - 1; 867 $coff_set = 1; 868 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n"; 869 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n"; 870 } 871 872 if (($type eq '' || $type eq '(') && $c eq '(') { 873 $level++; 874 $type = '('; 875 } 876 if ($type eq '(' && $c eq ')') { 877 $level--; 878 $type = ($level != 0)? '(' : ''; 879 880 if ($level == 0 && $coff < $soff) { 881 $coff = $off; 882 $coff_set = 1; 883 #warn "CSB: mark coff<$coff>\n"; 884 } 885 } 886 if (($type eq '' || $type eq '{') && $c eq '{') { 887 $level++; 888 $type = '{'; 889 } 890 if ($type eq '{' && $c eq '}') { 891 $level--; 892 $type = ($level != 0)? '{' : ''; 893 894 if ($level == 0) { 895 if (substr($blk, $off + 1, 1) eq ';') { 896 $off++; 897 } 898 last; 899 } 900 } 901 # Preprocessor commands end at the newline unless escaped. 902 if ($type eq '#' && $c eq "\n" && $p ne "\\") { 903 $level--; 904 $type = ''; 905 $off++; 906 last; 907 } 908 $off++; 909 } 910 # We are truly at the end, so shuffle to the next line. 911 if ($off == $len) { 912 $loff = $len + 1; 913 $line++; 914 $remain--; 915 } 916 917 my $statement = substr($blk, $soff, $off - $soff + 1); 918 my $condition = substr($blk, $soff, $coff - $soff + 1); 919 920 #warn "STATEMENT<$statement>\n"; 921 #warn "CONDITION<$condition>\n"; 922 923 #print "coff<$coff> soff<$off> loff<$loff>\n"; 924 925 return ($statement, $condition, 926 $line, $remain + 1, $off - $loff + 1, $level); 927} 928 929sub statement_lines { 930 my ($stmt) = @_; 931 932 # Strip the diff line prefixes and rip blank lines at start and end. 933 $stmt =~ s/(^|\n)./$1/g; 934 $stmt =~ s/^\s*//; 935 $stmt =~ s/\s*$//; 936 937 my @stmt_lines = ($stmt =~ /\n/g); 938 939 return $#stmt_lines + 2; 940} 941 942sub statement_rawlines { 943 my ($stmt) = @_; 944 945 my @stmt_lines = ($stmt =~ /\n/g); 946 947 return $#stmt_lines + 2; 948} 949 950sub statement_block_size { 951 my ($stmt) = @_; 952 953 $stmt =~ s/(^|\n)./$1/g; 954 $stmt =~ s/^\s*{//; 955 $stmt =~ s/}\s*$//; 956 $stmt =~ s/^\s*//; 957 $stmt =~ s/\s*$//; 958 959 my @stmt_lines = ($stmt =~ /\n/g); 960 my @stmt_statements = ($stmt =~ /;/g); 961 962 my $stmt_lines = $#stmt_lines + 2; 963 my $stmt_statements = $#stmt_statements + 1; 964 965 if ($stmt_lines > $stmt_statements) { 966 return $stmt_lines; 967 } else { 968 return $stmt_statements; 969 } 970} 971 972sub ctx_statement_full { 973 my ($linenr, $remain, $off) = @_; 974 my ($statement, $condition, $level); 975 976 my (@chunks); 977 978 # Grab the first conditional/block pair. 979 ($statement, $condition, $linenr, $remain, $off, $level) = 980 ctx_statement_block($linenr, $remain, $off); 981 #print "F: c<$condition> s<$statement> remain<$remain>\n"; 982 push(@chunks, [ $condition, $statement ]); 983 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) { 984 return ($level, $linenr, @chunks); 985 } 986 987 # Pull in the following conditional/block pairs and see if they 988 # could continue the statement. 989 for (;;) { 990 ($statement, $condition, $linenr, $remain, $off, $level) = 991 ctx_statement_block($linenr, $remain, $off); 992 #print "C: c<$condition> s<$statement> remain<$remain>\n"; 993 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s)); 994 #print "C: push\n"; 995 push(@chunks, [ $condition, $statement ]); 996 } 997 998 return ($level, $linenr, @chunks); 999} 1000 1001sub ctx_block_get { 1002 my ($linenr, $remain, $outer, $open, $close, $off) = @_; 1003 my $line; 1004 my $start = $linenr - 1; 1005 my $blk = ''; 1006 my @o; 1007 my @c; 1008 my @res = (); 1009 1010 my $level = 0; 1011 my @stack = ($level); 1012 for ($line = $start; $remain > 0; $line++) { 1013 next if ($rawlines[$line] =~ /^-/); 1014 $remain--; 1015 1016 $blk .= $rawlines[$line]; 1017 1018 # Handle nested #if/#else. 1019 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) { 1020 push(@stack, $level); 1021 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) { 1022 $level = $stack[$#stack - 1]; 1023 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) { 1024 $level = pop(@stack); 1025 } 1026 1027 foreach my $c (split(//, $lines[$line])) { 1028 ##print "C<$c>L<$level><$open$close>O<$off>\n"; 1029 if ($off > 0) { 1030 $off--; 1031 next; 1032 } 1033 1034 if ($c eq $close && $level > 0) { 1035 $level--; 1036 last if ($level == 0); 1037 } elsif ($c eq $open) { 1038 $level++; 1039 } 1040 } 1041 1042 if (!$outer || $level <= 1) { 1043 push(@res, $rawlines[$line]); 1044 } 1045 1046 last if ($level == 0); 1047 } 1048 1049 return ($level, @res); 1050} 1051sub ctx_block_outer { 1052 my ($linenr, $remain) = @_; 1053 1054 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0); 1055 return @r; 1056} 1057sub ctx_block { 1058 my ($linenr, $remain) = @_; 1059 1060 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0); 1061 return @r; 1062} 1063sub ctx_statement { 1064 my ($linenr, $remain, $off) = @_; 1065 1066 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off); 1067 return @r; 1068} 1069sub ctx_block_level { 1070 my ($linenr, $remain) = @_; 1071 1072 return ctx_block_get($linenr, $remain, 0, '{', '}', 0); 1073} 1074sub ctx_statement_level { 1075 my ($linenr, $remain, $off) = @_; 1076 1077 return ctx_block_get($linenr, $remain, 0, '(', ')', $off); 1078} 1079 1080sub ctx_locate_comment { 1081 my ($first_line, $end_line) = @_; 1082 1083 # Catch a comment on the end of the line itself. 1084 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@); 1085 return $current_comment if (defined $current_comment); 1086 1087 # Look through the context and try and figure out if there is a 1088 # comment. 1089 my $in_comment = 0; 1090 $current_comment = ''; 1091 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) { 1092 my $line = $rawlines[$linenr - 1]; 1093 #warn " $line\n"; 1094 if ($linenr == $first_line and $line =~ m@^.\s*\*@) { 1095 $in_comment = 1; 1096 } 1097 if ($line =~ m@/\*@) { 1098 $in_comment = 1; 1099 } 1100 if (!$in_comment && $current_comment ne '') { 1101 $current_comment = ''; 1102 } 1103 $current_comment .= $line . "\n" if ($in_comment); 1104 if ($line =~ m@\*/@) { 1105 $in_comment = 0; 1106 } 1107 } 1108 1109 chomp($current_comment); 1110 return($current_comment); 1111} 1112sub ctx_has_comment { 1113 my ($first_line, $end_line) = @_; 1114 my $cmt = ctx_locate_comment($first_line, $end_line); 1115 1116 ##print "LINE: $rawlines[$end_line - 1 ]\n"; 1117 ##print "CMMT: $cmt\n"; 1118 1119 return ($cmt ne ''); 1120} 1121 1122sub raw_line { 1123 my ($linenr, $cnt) = @_; 1124 1125 my $offset = $linenr - 1; 1126 $cnt++; 1127 1128 my $line; 1129 while ($cnt) { 1130 $line = $rawlines[$offset++]; 1131 next if (defined($line) && $line =~ /^-/); 1132 $cnt--; 1133 } 1134 1135 return $line; 1136} 1137 1138sub cat_vet { 1139 my ($vet) = @_; 1140 my ($res, $coded); 1141 1142 $res = ''; 1143 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) { 1144 $res .= $1; 1145 if ($2 ne '') { 1146 $coded = sprintf("^%c", unpack('C', $2) + 64); 1147 $res .= $coded; 1148 } 1149 } 1150 $res =~ s/$/\$/; 1151 1152 return $res; 1153} 1154 1155my $av_preprocessor = 0; 1156my $av_pending; 1157my @av_paren_type; 1158my $av_pend_colon; 1159 1160sub annotate_reset { 1161 $av_preprocessor = 0; 1162 $av_pending = '_'; 1163 @av_paren_type = ('E'); 1164 $av_pend_colon = 'O'; 1165} 1166 1167sub annotate_values { 1168 my ($stream, $type) = @_; 1169 1170 my $res; 1171 my $var = '_' x length($stream); 1172 my $cur = $stream; 1173 1174 print "$stream\n" if ($dbg_values > 1); 1175 1176 while (length($cur)) { 1177 @av_paren_type = ('E') if ($#av_paren_type < 0); 1178 print " <" . join('', @av_paren_type) . 1179 "> <$type> <$av_pending>" if ($dbg_values > 1); 1180 if ($cur =~ /^(\s+)/o) { 1181 print "WS($1)\n" if ($dbg_values > 1); 1182 if ($1 =~ /\n/ && $av_preprocessor) { 1183 $type = pop(@av_paren_type); 1184 $av_preprocessor = 0; 1185 } 1186 1187 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') { 1188 print "CAST($1)\n" if ($dbg_values > 1); 1189 push(@av_paren_type, $type); 1190 $type = 'c'; 1191 1192 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) { 1193 print "DECLARE($1)\n" if ($dbg_values > 1); 1194 $type = 'T'; 1195 1196 } elsif ($cur =~ /^($Modifier)\s*/) { 1197 print "MODIFIER($1)\n" if ($dbg_values > 1); 1198 $type = 'T'; 1199 1200 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) { 1201 print "DEFINE($1,$2)\n" if ($dbg_values > 1); 1202 $av_preprocessor = 1; 1203 push(@av_paren_type, $type); 1204 if ($2 ne '') { 1205 $av_pending = 'N'; 1206 } 1207 $type = 'E'; 1208 1209 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) { 1210 print "UNDEF($1)\n" if ($dbg_values > 1); 1211 $av_preprocessor = 1; 1212 push(@av_paren_type, $type); 1213 1214 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) { 1215 print "PRE_START($1)\n" if ($dbg_values > 1); 1216 $av_preprocessor = 1; 1217 1218 push(@av_paren_type, $type); 1219 push(@av_paren_type, $type); 1220 $type = 'E'; 1221 1222 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) { 1223 print "PRE_RESTART($1)\n" if ($dbg_values > 1); 1224 $av_preprocessor = 1; 1225 1226 push(@av_paren_type, $av_paren_type[$#av_paren_type]); 1227 1228 $type = 'E'; 1229 1230 } elsif ($cur =~ /^(\#\s*(?:endif))/o) { 1231 print "PRE_END($1)\n" if ($dbg_values > 1); 1232 1233 $av_preprocessor = 1; 1234 1235 # Assume all arms of the conditional end as this 1236 # one does, and continue as if the #endif was not here. 1237 pop(@av_paren_type); 1238 push(@av_paren_type, $type); 1239 $type = 'E'; 1240 1241 } elsif ($cur =~ /^(\\\n)/o) { 1242 print "PRECONT($1)\n" if ($dbg_values > 1); 1243 1244 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) { 1245 print "ATTR($1)\n" if ($dbg_values > 1); 1246 $av_pending = $type; 1247 $type = 'N'; 1248 1249 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) { 1250 print "SIZEOF($1)\n" if ($dbg_values > 1); 1251 if (defined $2) { 1252 $av_pending = 'V'; 1253 } 1254 $type = 'N'; 1255 1256 } elsif ($cur =~ /^(if|while|for)\b/o) { 1257 print "COND($1)\n" if ($dbg_values > 1); 1258 $av_pending = 'E'; 1259 $type = 'N'; 1260 1261 } elsif ($cur =~/^(case)/o) { 1262 print "CASE($1)\n" if ($dbg_values > 1); 1263 $av_pend_colon = 'C'; 1264 $type = 'N'; 1265 1266 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) { 1267 print "KEYWORD($1)\n" if ($dbg_values > 1); 1268 $type = 'N'; 1269 1270 } elsif ($cur =~ /^(\()/o) { 1271 print "PAREN('$1')\n" if ($dbg_values > 1); 1272 push(@av_paren_type, $av_pending); 1273 $av_pending = '_'; 1274 $type = 'N'; 1275 1276 } elsif ($cur =~ /^(\))/o) { 1277 my $new_type = pop(@av_paren_type); 1278 if ($new_type ne '_') { 1279 $type = $new_type; 1280 print "PAREN('$1') -> $type\n" 1281 if ($dbg_values > 1); 1282 } else { 1283 print "PAREN('$1')\n" if ($dbg_values > 1); 1284 } 1285 1286 } elsif ($cur =~ /^($Ident)\s*\(/o) { 1287 print "FUNC($1)\n" if ($dbg_values > 1); 1288 $type = 'V'; 1289 $av_pending = 'V'; 1290 1291 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) { 1292 if (defined $2 && $type eq 'C' || $type eq 'T') { 1293 $av_pend_colon = 'B'; 1294 } elsif ($type eq 'E') { 1295 $av_pend_colon = 'L'; 1296 } 1297 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1); 1298 $type = 'V'; 1299 1300 } elsif ($cur =~ /^($Ident|$Constant)/o) { 1301 print "IDENT($1)\n" if ($dbg_values > 1); 1302 $type = 'V'; 1303 1304 } elsif ($cur =~ /^($Assignment)/o) { 1305 print "ASSIGN($1)\n" if ($dbg_values > 1); 1306 $type = 'N'; 1307 1308 } elsif ($cur =~/^(;|{|})/) { 1309 print "END($1)\n" if ($dbg_values > 1); 1310 $type = 'E'; 1311 $av_pend_colon = 'O'; 1312 1313 } elsif ($cur =~/^(,)/) { 1314 print "COMMA($1)\n" if ($dbg_values > 1); 1315 $type = 'C'; 1316 1317 } elsif ($cur =~ /^(\?)/o) { 1318 print "QUESTION($1)\n" if ($dbg_values > 1); 1319 $type = 'N'; 1320 1321 } elsif ($cur =~ /^(:)/o) { 1322 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1); 1323 1324 substr($var, length($res), 1, $av_pend_colon); 1325 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') { 1326 $type = 'E'; 1327 } else { 1328 $type = 'N'; 1329 } 1330 $av_pend_colon = 'O'; 1331 1332 } elsif ($cur =~ /^(\[)/o) { 1333 print "CLOSE($1)\n" if ($dbg_values > 1); 1334 $type = 'N'; 1335 1336 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) { 1337 my $variant; 1338 1339 print "OPV($1)\n" if ($dbg_values > 1); 1340 if ($type eq 'V') { 1341 $variant = 'B'; 1342 } else { 1343 $variant = 'U'; 1344 } 1345 1346 substr($var, length($res), 1, $variant); 1347 $type = 'N'; 1348 1349 } elsif ($cur =~ /^($Operators)/o) { 1350 print "OP($1)\n" if ($dbg_values > 1); 1351 if ($1 ne '++' && $1 ne '--') { 1352 $type = 'N'; 1353 } 1354 1355 } elsif ($cur =~ /(^.)/o) { 1356 print "C($1)\n" if ($dbg_values > 1); 1357 } 1358 if (defined $1) { 1359 $cur = substr($cur, length($1)); 1360 $res .= $type x length($1); 1361 } 1362 } 1363 1364 return ($res, $var); 1365} 1366 1367sub possible { 1368 my ($possible, $line) = @_; 1369 my $notPermitted = qr{(?: 1370 ^(?: 1371 $Modifier| 1372 $Storage| 1373 $Type| 1374 DEFINE_\S+ 1375 )$| 1376 ^(?: 1377 goto| 1378 return| 1379 case| 1380 else| 1381 asm|__asm__| 1382 do| 1383 \#| 1384 \#\#| 1385 )(?:\s|$)| 1386 ^(?:typedef|struct|enum)\b 1387 )}x; 1388 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2); 1389 if ($possible !~ $notPermitted) { 1390 # Check for modifiers. 1391 $possible =~ s/\s*$Storage\s*//g; 1392 $possible =~ s/\s*$Sparse\s*//g; 1393 if ($possible =~ /^\s*$/) { 1394 1395 } elsif ($possible =~ /\s/) { 1396 $possible =~ s/\s*$Type\s*//g; 1397 for my $modifier (split(' ', $possible)) { 1398 if ($modifier !~ $notPermitted) { 1399 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible); 1400 push(@modifierList, $modifier); 1401 } 1402 } 1403 1404 } else { 1405 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible); 1406 push(@typeList, $possible); 1407 } 1408 build_types(); 1409 } else { 1410 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1); 1411 } 1412} 1413 1414my $prefix = ''; 1415 1416sub show_type { 1417 return defined $use_type{$_[0]} if (scalar keys %use_type > 0); 1418 1419 return !defined $ignore_type{$_[0]}; 1420} 1421 1422sub report { 1423 if (!show_type($_[1]) || 1424 (defined $tst_only && $_[2] !~ /\Q$tst_only\E/)) { 1425 return 0; 1426 } 1427 my $line; 1428 if ($show_types) { 1429 $line = "$prefix$_[0]:$_[1]: $_[2]\n"; 1430 } else { 1431 $line = "$prefix$_[0]: $_[2]\n"; 1432 } 1433 $line = (split('\n', $line))[0] . "\n" if ($terse); 1434 1435 push(our @report, $line); 1436 1437 return 1; 1438} 1439sub report_dump { 1440 our @report; 1441} 1442 1443sub ERROR { 1444 if (report("ERROR", $_[0], $_[1])) { 1445 our $clean = 0; 1446 our $cnt_error++; 1447 return 1; 1448 } 1449 return 0; 1450} 1451sub WARN { 1452 if (report("WARNING", $_[0], $_[1])) { 1453 our $clean = 0; 1454 our $cnt_warn++; 1455 return 1; 1456 } 1457 return 0; 1458} 1459sub CHK { 1460 if ($check && report("CHECK", $_[0], $_[1])) { 1461 our $clean = 0; 1462 our $cnt_chk++; 1463 return 1; 1464 } 1465 return 0; 1466} 1467 1468sub check_absolute_file { 1469 my ($absolute, $herecurr) = @_; 1470 my $file = $absolute; 1471 1472 ##print "absolute<$absolute>\n"; 1473 1474 # See if any suffix of this path is a path within the tree. 1475 while ($file =~ s@^[^/]*/@@) { 1476 if (-f "$root/$file") { 1477 ##print "file<$file>\n"; 1478 last; 1479 } 1480 } 1481 if (! -f _) { 1482 return 0; 1483 } 1484 1485 # It is, so see if the prefix is acceptable. 1486 my $prefix = $absolute; 1487 substr($prefix, -length($file)) = ''; 1488 1489 ##print "prefix<$prefix>\n"; 1490 if ($prefix ne ".../") { 1491 WARN("USE_RELATIVE_PATH", 1492 "use relative pathname instead of absolute in changelog text\n" . $herecurr); 1493 } 1494} 1495 1496sub trim { 1497 my ($string) = @_; 1498 1499 $string =~ s/^\s+|\s+$//g; 1500 1501 return $string; 1502} 1503 1504sub ltrim { 1505 my ($string) = @_; 1506 1507 $string =~ s/^\s+//; 1508 1509 return $string; 1510} 1511 1512sub rtrim { 1513 my ($string) = @_; 1514 1515 $string =~ s/\s+$//; 1516 1517 return $string; 1518} 1519 1520sub string_find_replace { 1521 my ($string, $find, $replace) = @_; 1522 1523 $string =~ s/$find/$replace/g; 1524 1525 return $string; 1526} 1527 1528sub tabify { 1529 my ($leading) = @_; 1530 1531 my $source_indent = 8; 1532 my $max_spaces_before_tab = $source_indent - 1; 1533 my $spaces_to_tab = " " x $source_indent; 1534 1535 #convert leading spaces to tabs 1536 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g; 1537 #Remove spaces before a tab 1538 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g; 1539 1540 return "$leading"; 1541} 1542 1543sub pos_last_openparen { 1544 my ($line) = @_; 1545 1546 my $pos = 0; 1547 1548 my $opens = $line =~ tr/\(/\(/; 1549 my $closes = $line =~ tr/\)/\)/; 1550 1551 my $last_openparen = 0; 1552 1553 if (($opens == 0) || ($closes >= $opens)) { 1554 return -1; 1555 } 1556 1557 my $len = length($line); 1558 1559 for ($pos = 0; $pos < $len; $pos++) { 1560 my $string = substr($line, $pos); 1561 if ($string =~ /^($FuncArg|$balanced_parens)/) { 1562 $pos += length($1) - 1; 1563 } elsif (substr($line, $pos, 1) eq '(') { 1564 $last_openparen = $pos; 1565 } elsif (index($string, '(') == -1) { 1566 last; 1567 } 1568 } 1569 1570 return $last_openparen + 1; 1571} 1572 1573sub process { 1574 my $filename = shift; 1575 1576 my $linenr=0; 1577 my $prevline=""; 1578 my $prevrawline=""; 1579 my $stashline=""; 1580 my $stashrawline=""; 1581 1582 my $length; 1583 my $indent; 1584 my $previndent=0; 1585 my $stashindent=0; 1586 1587 our $clean = 1; 1588 my $signoff = 0; 1589 my $is_patch = 0; 1590 1591 my $in_header_lines = 1; 1592 my $in_commit_log = 0; #Scanning lines before patch 1593 1594 my $non_utf8_charset = 0; 1595 1596 our @report = (); 1597 our $cnt_lines = 0; 1598 our $cnt_error = 0; 1599 our $cnt_warn = 0; 1600 our $cnt_chk = 0; 1601 1602 # Trace the real file/line as we go. 1603 my $realfile = ''; 1604 my $realline = 0; 1605 my $realcnt = 0; 1606 my $here = ''; 1607 my $in_comment = 0; 1608 my $comment_edge = 0; 1609 my $first_line = 0; 1610 my $p1_prefix = ''; 1611 1612 my $prev_values = 'E'; 1613 1614 # suppression flags 1615 my %suppress_ifbraces; 1616 my %suppress_whiletrailers; 1617 my %suppress_export; 1618 my $suppress_statement = 0; 1619 1620 my %signatures = (); 1621 1622 # Pre-scan the patch sanitizing the lines. 1623 # Pre-scan the patch looking for any __setup documentation. 1624 # 1625 my @setup_docs = (); 1626 my $setup_docs = 0; 1627 1628 my $camelcase_file_seeded = 0; 1629 1630 sanitise_line_reset(); 1631 my $line; 1632 foreach my $rawline (@rawlines) { 1633 $linenr++; 1634 $line = $rawline; 1635 1636 push(@fixed, $rawline) if ($fix); 1637 1638 if ($rawline=~/^\+\+\+\s+(\S+)/) { 1639 $setup_docs = 0; 1640 if ($1 =~ m@Documentation/kernel-parameters.txt$@) { 1641 $setup_docs = 1; 1642 } 1643 #next; 1644 } 1645 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) { 1646 $realline=$1-1; 1647 if (defined $2) { 1648 $realcnt=$3+1; 1649 } else { 1650 $realcnt=1+1; 1651 } 1652 $in_comment = 0; 1653 1654 # Guestimate if this is a continuing comment. Run 1655 # the context looking for a comment "edge". If this 1656 # edge is a close comment then we must be in a comment 1657 # at context start. 1658 my $edge; 1659 my $cnt = $realcnt; 1660 for (my $ln = $linenr + 1; $cnt > 0; $ln++) { 1661 next if (defined $rawlines[$ln - 1] && 1662 $rawlines[$ln - 1] =~ /^-/); 1663 $cnt--; 1664 #print "RAW<$rawlines[$ln - 1]>\n"; 1665 last if (!defined $rawlines[$ln - 1]); 1666 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ && 1667 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) { 1668 ($edge) = $1; 1669 last; 1670 } 1671 } 1672 if (defined $edge && $edge eq '*/') { 1673 $in_comment = 1; 1674 } 1675 1676 # Guestimate if this is a continuing comment. If this 1677 # is the start of a diff block and this line starts 1678 # ' *' then it is very likely a comment. 1679 if (!defined $edge && 1680 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@) 1681 { 1682 $in_comment = 1; 1683 } 1684 1685 ##print "COMMENT:$in_comment edge<$edge> $rawline\n"; 1686 sanitise_line_reset($in_comment); 1687 1688 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) { 1689 # Standardise the strings and chars within the input to 1690 # simplify matching -- only bother with positive lines. 1691 $line = sanitise_line($rawline); 1692 } 1693 push(@lines, $line); 1694 1695 if ($realcnt > 1) { 1696 $realcnt-- if ($line =~ /^(?:\+| |$)/); 1697 } else { 1698 $realcnt = 0; 1699 } 1700 1701 #print "==>$rawline\n"; 1702 #print "-->$line\n"; 1703 1704 if ($setup_docs && $line =~ /^\+/) { 1705 push(@setup_docs, $line); 1706 } 1707 } 1708 1709 $prefix = ''; 1710 1711 $realcnt = 0; 1712 $linenr = 0; 1713 foreach my $line (@lines) { 1714 $linenr++; 1715 my $sline = $line; #copy of $line 1716 $sline =~ s/$;/ /g; #with comments as spaces 1717 1718 my $rawline = $rawlines[$linenr - 1]; 1719 1720#extract the line range in the file after the patch is applied 1721 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) { 1722 $is_patch = 1; 1723 $first_line = $linenr + 1; 1724 $realline=$1-1; 1725 if (defined $2) { 1726 $realcnt=$3+1; 1727 } else { 1728 $realcnt=1+1; 1729 } 1730 annotate_reset(); 1731 $prev_values = 'E'; 1732 1733 %suppress_ifbraces = (); 1734 %suppress_whiletrailers = (); 1735 %suppress_export = (); 1736 $suppress_statement = 0; 1737 next; 1738 1739# track the line number as we move through the hunk, note that 1740# new versions of GNU diff omit the leading space on completely 1741# blank context lines so we need to count that too. 1742 } elsif ($line =~ /^( |\+|$)/) { 1743 $realline++; 1744 $realcnt-- if ($realcnt != 0); 1745 1746 # Measure the line length and indent. 1747 ($length, $indent) = line_stats($rawline); 1748 1749 # Track the previous line. 1750 ($prevline, $stashline) = ($stashline, $line); 1751 ($previndent, $stashindent) = ($stashindent, $indent); 1752 ($prevrawline, $stashrawline) = ($stashrawline, $rawline); 1753 1754 #warn "line<$line>\n"; 1755 1756 } elsif ($realcnt == 1) { 1757 $realcnt--; 1758 } 1759 1760 my $hunk_line = ($realcnt != 0); 1761 1762#make up the handle for any error we report on this line 1763 $prefix = "$filename:$realline: " if ($emacs && $file); 1764 $prefix = "$filename:$linenr: " if ($emacs && !$file); 1765 1766 $here = "#$linenr: " if (!$file); 1767 $here = "#$realline: " if ($file); 1768 1769 # extract the filename as it passes 1770 if ($line =~ /^diff --git.*?(\S+)$/) { 1771 $realfile = $1; 1772 $realfile =~ s@^([^/]*)/@@ if (!$file); 1773 $in_commit_log = 0; 1774 } elsif ($line =~ /^\+\+\+\s+(\S+)/) { 1775 $realfile = $1; 1776 $realfile =~ s@^([^/]*)/@@ if (!$file); 1777 $in_commit_log = 0; 1778 1779 $p1_prefix = $1; 1780 if (!$file && $tree && $p1_prefix ne '' && 1781 -e "$root/$p1_prefix") { 1782 WARN("PATCH_PREFIX", 1783 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n"); 1784 } 1785 1786 if ($realfile =~ m@^include/asm/@) { 1787 ERROR("MODIFIED_INCLUDE_ASM", 1788 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n"); 1789 } 1790 next; 1791 } 1792 1793 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0); 1794 1795 my $hereline = "$here\n$rawline\n"; 1796 my $herecurr = "$here\n$rawline\n"; 1797 my $hereprev = "$here\n$prevrawline\n$rawline\n"; 1798 1799 $cnt_lines++ if ($realcnt != 0); 1800 1801# Check for incorrect file permissions 1802 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) { 1803 my $permhere = $here . "FILE: $realfile\n"; 1804 if ($realfile !~ m@scripts/@ && 1805 $realfile !~ /\.(py|pl|awk|sh)$/) { 1806 ERROR("EXECUTE_PERMISSIONS", 1807 "do not set execute permissions for source files\n" . $permhere); 1808 } 1809 } 1810 1811# Check the patch for a signoff: 1812 if ($line =~ /^\s*signed-off-by:/i) { 1813 $signoff++; 1814 $in_commit_log = 0; 1815 } 1816 1817# Check signature styles 1818 if (!$in_header_lines && 1819 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) { 1820 my $space_before = $1; 1821 my $sign_off = $2; 1822 my $space_after = $3; 1823 my $email = $4; 1824 my $ucfirst_sign_off = ucfirst(lc($sign_off)); 1825 1826 if ($sign_off !~ /$signature_tags/) { 1827 WARN("BAD_SIGN_OFF", 1828 "Non-standard signature: $sign_off\n" . $herecurr); 1829 } 1830 if (defined $space_before && $space_before ne "") { 1831 if (WARN("BAD_SIGN_OFF", 1832 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) && 1833 $fix) { 1834 $fixed[$linenr - 1] = 1835 "$ucfirst_sign_off $email"; 1836 } 1837 } 1838 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) { 1839 if (WARN("BAD_SIGN_OFF", 1840 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) && 1841 $fix) { 1842 $fixed[$linenr - 1] = 1843 "$ucfirst_sign_off $email"; 1844 } 1845 1846 } 1847 if (!defined $space_after || $space_after ne " ") { 1848 if (WARN("BAD_SIGN_OFF", 1849 "Use a single space after $ucfirst_sign_off\n" . $herecurr) && 1850 $fix) { 1851 $fixed[$linenr - 1] = 1852 "$ucfirst_sign_off $email"; 1853 } 1854 } 1855 1856 my ($email_name, $email_address, $comment) = parse_email($email); 1857 my $suggested_email = format_email(($email_name, $email_address)); 1858 if ($suggested_email eq "") { 1859 ERROR("BAD_SIGN_OFF", 1860 "Unrecognized email address: '$email'\n" . $herecurr); 1861 } else { 1862 my $dequoted = $suggested_email; 1863 $dequoted =~ s/^"//; 1864 $dequoted =~ s/" </ </; 1865 # Don't force email to have quotes 1866 # Allow just an angle bracketed address 1867 if ("$dequoted$comment" ne $email && 1868 "<$email_address>$comment" ne $email && 1869 "$suggested_email$comment" ne $email) { 1870 WARN("BAD_SIGN_OFF", 1871 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr); 1872 } 1873 } 1874 1875# Check for duplicate signatures 1876 my $sig_nospace = $line; 1877 $sig_nospace =~ s/\s//g; 1878 $sig_nospace = lc($sig_nospace); 1879 if (defined $signatures{$sig_nospace}) { 1880 WARN("BAD_SIGN_OFF", 1881 "Duplicate signature\n" . $herecurr); 1882 } else { 1883 $signatures{$sig_nospace} = 1; 1884 } 1885 } 1886 1887# Check for wrappage within a valid hunk of the file 1888 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) { 1889 ERROR("CORRUPTED_PATCH", 1890 "patch seems to be corrupt (line wrapped?)\n" . 1891 $herecurr) if (!$emitted_corrupt++); 1892 } 1893 1894# Check for absolute kernel paths. 1895 if ($tree) { 1896 while ($line =~ m{(?:^|\s)(/\S*)}g) { 1897 my $file = $1; 1898 1899 if ($file =~ m{^(.*?)(?::\d+)+:?$} && 1900 check_absolute_file($1, $herecurr)) { 1901 # 1902 } else { 1903 check_absolute_file($file, $herecurr); 1904 } 1905 } 1906 } 1907 1908# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php 1909 if (($realfile =~ /^$/ || $line =~ /^\+/) && 1910 $rawline !~ m/^$UTF8*$/) { 1911 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/); 1912 1913 my $blank = copy_spacing($rawline); 1914 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^"; 1915 my $hereptr = "$hereline$ptr\n"; 1916 1917 CHK("INVALID_UTF8", 1918 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr); 1919 } 1920 1921# Check if it's the start of a commit log 1922# (not a header line and we haven't seen the patch filename) 1923 if ($in_header_lines && $realfile =~ /^$/ && 1924 $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) { 1925 $in_header_lines = 0; 1926 $in_commit_log = 1; 1927 } 1928 1929# Check if there is UTF-8 in a commit log when a mail header has explicitly 1930# declined it, i.e defined some charset where it is missing. 1931 if ($in_header_lines && 1932 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ && 1933 $1 !~ /utf-8/i) { 1934 $non_utf8_charset = 1; 1935 } 1936 1937 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ && 1938 $rawline =~ /$NON_ASCII_UTF8/) { 1939 WARN("UTF8_BEFORE_PATCH", 1940 "8-bit UTF-8 used in possible commit log\n" . $herecurr); 1941 } 1942 1943# ignore non-hunk lines and lines being removed 1944 next if (!$hunk_line || $line =~ /^-/); 1945 1946#trailing whitespace 1947 if ($line =~ /^\+.*\015/) { 1948 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 1949 if (ERROR("DOS_LINE_ENDINGS", 1950 "DOS line endings\n" . $herevet) && 1951 $fix) { 1952 $fixed[$linenr - 1] =~ s/[\s\015]+$//; 1953 } 1954 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) { 1955 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 1956 if (ERROR("TRAILING_WHITESPACE", 1957 "trailing whitespace\n" . $herevet) && 1958 $fix) { 1959 $fixed[$linenr - 1] =~ s/\s+$//; 1960 } 1961 1962 $rpt_cleaners = 1; 1963 } 1964 1965# Check for FSF mailing addresses. 1966 if ($rawline =~ /You should have received a copy/ || 1967 $rawline =~ /write to the Free Software/ || 1968 $rawline =~ /59 Temple Place/ || 1969 $rawline =~ /51 Franklin Street/) { 1970 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 1971 my $msg_type = \&ERROR; 1972 $msg_type = \&CHK if ($file); 1973 &{$msg_type}("FSF_MAILING_ADDRESS", 1974 "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) 1975 } 1976 1977# check for Kconfig help text having a real description 1978# Only applies when adding the entry originally, after that we do not have 1979# sufficient context to determine whether it is indeed long enough. 1980 if ($realfile =~ /Kconfig/ && 1981 $line =~ /.\s*config\s+/) { 1982 my $length = 0; 1983 my $cnt = $realcnt; 1984 my $ln = $linenr + 1; 1985 my $f; 1986 my $is_start = 0; 1987 my $is_end = 0; 1988 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) { 1989 $f = $lines[$ln - 1]; 1990 $cnt-- if ($lines[$ln - 1] !~ /^-/); 1991 $is_end = $lines[$ln - 1] =~ /^\+/; 1992 1993 next if ($f =~ /^-/); 1994 1995 if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) { 1996 $is_start = 1; 1997 } elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) { 1998 $length = -1; 1999 } 2000 2001 $f =~ s/^.//; 2002 $f =~ s/#.*//; 2003 $f =~ s/^\s+//; 2004 next if ($f =~ /^$/); 2005 if ($f =~ /^\s*config\s/) { 2006 $is_end = 1; 2007 last; 2008 } 2009 $length++; 2010 } 2011 WARN("CONFIG_DESCRIPTION", 2012 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4); 2013 #print "is_start<$is_start> is_end<$is_end> length<$length>\n"; 2014 } 2015 2016# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig. 2017 if ($realfile =~ /Kconfig/ && 2018 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) { 2019 WARN("CONFIG_EXPERIMENTAL", 2020 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n"); 2021 } 2022 2023 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) && 2024 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) { 2025 my $flag = $1; 2026 my $replacement = { 2027 'EXTRA_AFLAGS' => 'asflags-y', 2028 'EXTRA_CFLAGS' => 'ccflags-y', 2029 'EXTRA_CPPFLAGS' => 'cppflags-y', 2030 'EXTRA_LDFLAGS' => 'ldflags-y', 2031 }; 2032 2033 WARN("DEPRECATED_VARIABLE", 2034 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag}); 2035 } 2036 2037# check we are in a valid source file if not then ignore this hunk 2038 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/); 2039 2040#line length limit 2041 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ && 2042 $rawline !~ /^.\s*\*\s*\@$Ident\s/ && 2043 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ || 2044 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) && 2045 $length > $max_line_length) 2046 { 2047 WARN("LONG_LINE", 2048 "line over $max_line_length characters\n" . $herecurr); 2049 } 2050 2051# Check for user-visible strings broken across lines, which breaks the ability 2052# to grep for the string. Limited to strings used as parameters (those 2053# following an open parenthesis), which almost completely eliminates false 2054# positives, as well as warning only once per parameter rather than once per 2055# line of the string. Make an exception when the previous string ends in a 2056# newline (multiple lines in one string constant) or \n\t (common in inline 2057# assembly to indent the instruction on the following line). 2058 if ($line =~ /^\+\s*"/ && 2059 $prevline =~ /"\s*$/ && 2060 $prevline =~ /\(/ && 2061 $prevrawline !~ /\\n(?:\\t)*"\s*$/) { 2062 WARN("SPLIT_STRING", 2063 "quoted string split across lines\n" . $hereprev); 2064 } 2065 2066# check for spaces before a quoted newline 2067 if ($rawline =~ /^.*\".*\s\\n/) { 2068 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE", 2069 "unnecessary whitespace before a quoted newline\n" . $herecurr) && 2070 $fix) { 2071 $fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/; 2072 } 2073 2074 } 2075 2076# check for adding lines without a newline. 2077 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) { 2078 WARN("MISSING_EOF_NEWLINE", 2079 "adding a line without newline at end of file\n" . $herecurr); 2080 } 2081 2082# Blackfin: use hi/lo macros 2083 if ($realfile =~ m@arch/blackfin/.*\.S$@) { 2084 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) { 2085 my $herevet = "$here\n" . cat_vet($line) . "\n"; 2086 ERROR("LO_MACRO", 2087 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet); 2088 } 2089 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) { 2090 my $herevet = "$here\n" . cat_vet($line) . "\n"; 2091 ERROR("HI_MACRO", 2092 "use the HI() macro, not (... >> 16)\n" . $herevet); 2093 } 2094 } 2095 2096# check we are in a valid source file C or perl if not then ignore this hunk 2097 next if ($realfile !~ /\.(h|c|pl)$/); 2098 2099# at the beginning of a line any tabs must come first and anything 2100# more than 8 must use tabs. 2101 if ($rawline =~ /^\+\s* \t\s*\S/ || 2102 $rawline =~ /^\+\s* \s*/) { 2103 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 2104 $rpt_cleaners = 1; 2105 if (ERROR("CODE_INDENT", 2106 "code indent should use tabs where possible\n" . $herevet) && 2107 $fix) { 2108 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e; 2109 } 2110 } 2111 2112# check for space before tabs. 2113 if ($rawline =~ /^\+/ && $rawline =~ / \t/) { 2114 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 2115 if (WARN("SPACE_BEFORE_TAB", 2116 "please, no space before tabs\n" . $herevet) && 2117 $fix) { 2118 $fixed[$linenr - 1] =~ 2119 s/(^\+.*) +\t/$1\t/; 2120 } 2121 } 2122 2123# check for && or || at the start of a line 2124 if ($rawline =~ /^\+\s*(&&|\|\|)/) { 2125 CHK("LOGICAL_CONTINUATIONS", 2126 "Logical continuations should be on the previous line\n" . $hereprev); 2127 } 2128 2129# check multi-line statement indentation matches previous line 2130 if ($^V && $^V ge 5.10.0 && 2131 $prevline =~ /^\+(\t*)(if \(|$Ident\().*(\&\&|\|\||,)\s*$/) { 2132 $prevline =~ /^\+(\t*)(.*)$/; 2133 my $oldindent = $1; 2134 my $rest = $2; 2135 2136 my $pos = pos_last_openparen($rest); 2137 if ($pos >= 0) { 2138 $line =~ /^(\+| )([ \t]*)/; 2139 my $newindent = $2; 2140 2141 my $goodtabindent = $oldindent . 2142 "\t" x ($pos / 8) . 2143 " " x ($pos % 8); 2144 my $goodspaceindent = $oldindent . " " x $pos; 2145 2146 if ($newindent ne $goodtabindent && 2147 $newindent ne $goodspaceindent) { 2148 2149 if (CHK("PARENTHESIS_ALIGNMENT", 2150 "Alignment should match open parenthesis\n" . $hereprev) && 2151 $fix && $line =~ /^\+/) { 2152 $fixed[$linenr - 1] =~ 2153 s/^\+[ \t]*/\+$goodtabindent/; 2154 } 2155 } 2156 } 2157 } 2158 2159 if ($line =~ /^\+.*\*[ \t]*\)[ \t]+(?!$Assignment|$Arithmetic)/) { 2160 if (CHK("SPACING", 2161 "No space is necessary after a cast\n" . $hereprev) && 2162 $fix) { 2163 $fixed[$linenr - 1] =~ 2164 s/^(\+.*\*[ \t]*\))[ \t]+/$1/; 2165 } 2166 } 2167 2168 if ($realfile =~ m@^(drivers/net/|net/)@ && 2169 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ && 2170 $rawline =~ /^\+[ \t]*\*/) { 2171 WARN("NETWORKING_BLOCK_COMMENT_STYLE", 2172 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev); 2173 } 2174 2175 if ($realfile =~ m@^(drivers/net/|net/)@ && 2176 $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /* 2177 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */ 2178 $rawline =~ /^\+/ && #line is new 2179 $rawline !~ /^\+[ \t]*\*/) { #no leading * 2180 WARN("NETWORKING_BLOCK_COMMENT_STYLE", 2181 "networking block comments start with * on subsequent lines\n" . $hereprev); 2182 } 2183 2184 if ($realfile =~ m@^(drivers/net/|net/)@ && 2185 $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */ 2186 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/ 2187 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/ 2188 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */ 2189 WARN("NETWORKING_BLOCK_COMMENT_STYLE", 2190 "networking block comments put the trailing */ on a separate line\n" . $herecurr); 2191 } 2192 2193# check for spaces at the beginning of a line. 2194# Exceptions: 2195# 1) within comments 2196# 2) indented preprocessor commands 2197# 3) hanging labels 2198 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) { 2199 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 2200 if (WARN("LEADING_SPACE", 2201 "please, no spaces at the start of a line\n" . $herevet) && 2202 $fix) { 2203 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e; 2204 } 2205 } 2206 2207# check we are in a valid C source file if not then ignore this hunk 2208 next if ($realfile !~ /\.(h|c)$/); 2209 2210# discourage the addition of CONFIG_EXPERIMENTAL in #if(def). 2211 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) { 2212 WARN("CONFIG_EXPERIMENTAL", 2213 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n"); 2214 } 2215 2216# check for RCS/CVS revision markers 2217 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) { 2218 WARN("CVS_KEYWORD", 2219 "CVS style keyword markers, these will _not_ be updated\n". $herecurr); 2220 } 2221 2222# Blackfin: don't use __builtin_bfin_[cs]sync 2223 if ($line =~ /__builtin_bfin_csync/) { 2224 my $herevet = "$here\n" . cat_vet($line) . "\n"; 2225 ERROR("CSYNC", 2226 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet); 2227 } 2228 if ($line =~ /__builtin_bfin_ssync/) { 2229 my $herevet = "$here\n" . cat_vet($line) . "\n"; 2230 ERROR("SSYNC", 2231 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet); 2232 } 2233 2234# check for old HOTPLUG __dev<foo> section markings 2235 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) { 2236 WARN("HOTPLUG_SECTION", 2237 "Using $1 is unnecessary\n" . $herecurr); 2238 } 2239 2240# Check for potential 'bare' types 2241 my ($stat, $cond, $line_nr_next, $remain_next, $off_next, 2242 $realline_next); 2243#print "LINE<$line>\n"; 2244 if ($linenr >= $suppress_statement && 2245 $realcnt && $sline =~ /.\s*\S/) { 2246 ($stat, $cond, $line_nr_next, $remain_next, $off_next) = 2247 ctx_statement_block($linenr, $realcnt, 0); 2248 $stat =~ s/\n./\n /g; 2249 $cond =~ s/\n./\n /g; 2250 2251#print "linenr<$linenr> <$stat>\n"; 2252 # If this statement has no statement boundaries within 2253 # it there is no point in retrying a statement scan 2254 # until we hit end of it. 2255 my $frag = $stat; $frag =~ s/;+\s*$//; 2256 if ($frag !~ /(?:{|;)/) { 2257#print "skip<$line_nr_next>\n"; 2258 $suppress_statement = $line_nr_next; 2259 } 2260 2261 # Find the real next line. 2262 $realline_next = $line_nr_next; 2263 if (defined $realline_next && 2264 (!defined $lines[$realline_next - 1] || 2265 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) { 2266 $realline_next++; 2267 } 2268 2269 my $s = $stat; 2270 $s =~ s/{.*$//s; 2271 2272 # Ignore goto labels. 2273 if ($s =~ /$Ident:\*$/s) { 2274 2275 # Ignore functions being called 2276 } elsif ($s =~ /^.\s*$Ident\s*\(/s) { 2277 2278 } elsif ($s =~ /^.\s*else\b/s) { 2279 2280 # declarations always start with types 2281 } 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) { 2282 my $type = $1; 2283 $type =~ s/\s+/ /g; 2284 possible($type, "A:" . $s); 2285 2286 # definitions in global scope can only start with types 2287 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) { 2288 possible($1, "B:" . $s); 2289 } 2290 2291 # any (foo ... *) is a pointer cast, and foo is a type 2292 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) { 2293 possible($1, "C:" . $s); 2294 } 2295 2296 # Check for any sort of function declaration. 2297 # int foo(something bar, other baz); 2298 # void (*store_gdt)(x86_descr_ptr *); 2299 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) { 2300 my ($name_len) = length($1); 2301 2302 my $ctx = $s; 2303 substr($ctx, 0, $name_len + 1, ''); 2304 $ctx =~ s/\)[^\)]*$//; 2305 2306 for my $arg (split(/\s*,\s*/, $ctx)) { 2307 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) { 2308 2309 possible($1, "D:" . $s); 2310 } 2311 } 2312 } 2313 2314 } 2315 2316# 2317# Checks which may be anchored in the context. 2318# 2319 2320# Check for switch () and associated case and default 2321# statements should be at the same indent. 2322 if ($line=~/\bswitch\s*\(.*\)/) { 2323 my $err = ''; 2324 my $sep = ''; 2325 my @ctx = ctx_block_outer($linenr, $realcnt); 2326 shift(@ctx); 2327 for my $ctx (@ctx) { 2328 my ($clen, $cindent) = line_stats($ctx); 2329 if ($ctx =~ /^\+\s*(case\s+|default:)/ && 2330 $indent != $cindent) { 2331 $err .= "$sep$ctx\n"; 2332 $sep = ''; 2333 } else { 2334 $sep = "[...]\n"; 2335 } 2336 } 2337 if ($err ne '') { 2338 ERROR("SWITCH_CASE_INDENT_LEVEL", 2339 "switch and case should be at the same indent\n$hereline$err"); 2340 } 2341 } 2342 2343# if/while/etc brace do not go on next line, unless defining a do while loop, 2344# or if that brace on the next line is for something else 2345 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) { 2346 my $pre_ctx = "$1$2"; 2347 2348 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0); 2349 2350 if ($line =~ /^\+\t{6,}/) { 2351 WARN("DEEP_INDENTATION", 2352 "Too many leading tabs - consider code refactoring\n" . $herecurr); 2353 } 2354 2355 my $ctx_cnt = $realcnt - $#ctx - 1; 2356 my $ctx = join("\n", @ctx); 2357 2358 my $ctx_ln = $linenr; 2359 my $ctx_skip = $realcnt; 2360 2361 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt && 2362 defined $lines[$ctx_ln - 1] && 2363 $lines[$ctx_ln - 1] =~ /^-/)) { 2364 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n"; 2365 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/); 2366 $ctx_ln++; 2367 } 2368 2369 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n"; 2370 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n"; 2371 2372 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) { 2373 ERROR("OPEN_BRACE", 2374 "that open brace { should be on the previous line\n" . 2375 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n"); 2376 } 2377 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ && 2378 $ctx =~ /\)\s*\;\s*$/ && 2379 defined $lines[$ctx_ln - 1]) 2380 { 2381 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]); 2382 if ($nindent > $indent) { 2383 WARN("TRAILING_SEMICOLON", 2384 "trailing semicolon indicates no statements, indent implies otherwise\n" . 2385 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n"); 2386 } 2387 } 2388 } 2389 2390# Check relative indent for conditionals and blocks. 2391 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) { 2392 ($stat, $cond, $line_nr_next, $remain_next, $off_next) = 2393 ctx_statement_block($linenr, $realcnt, 0) 2394 if (!defined $stat); 2395 my ($s, $c) = ($stat, $cond); 2396 2397 substr($s, 0, length($c), ''); 2398 2399 # Make sure we remove the line prefixes as we have 2400 # none on the first line, and are going to readd them 2401 # where necessary. 2402 $s =~ s/\n./\n/gs; 2403 2404 # Find out how long the conditional actually is. 2405 my @newlines = ($c =~ /\n/gs); 2406 my $cond_lines = 1 + $#newlines; 2407 2408 # We want to check the first line inside the block 2409 # starting at the end of the conditional, so remove: 2410 # 1) any blank line termination 2411 # 2) any opening brace { on end of the line 2412 # 3) any do (...) { 2413 my $continuation = 0; 2414 my $check = 0; 2415 $s =~ s/^.*\bdo\b//; 2416 $s =~ s/^\s*{//; 2417 if ($s =~ s/^\s*\\//) { 2418 $continuation = 1; 2419 } 2420 if ($s =~ s/^\s*?\n//) { 2421 $check = 1; 2422 $cond_lines++; 2423 } 2424 2425 # Also ignore a loop construct at the end of a 2426 # preprocessor statement. 2427 if (($prevline =~ /^.\s*#\s*define\s/ || 2428 $prevline =~ /\\\s*$/) && $continuation == 0) { 2429 $check = 0; 2430 } 2431 2432 my $cond_ptr = -1; 2433 $continuation = 0; 2434 while ($cond_ptr != $cond_lines) { 2435 $cond_ptr = $cond_lines; 2436 2437 # If we see an #else/#elif then the code 2438 # is not linear. 2439 if ($s =~ /^\s*\#\s*(?:else|elif)/) { 2440 $check = 0; 2441 } 2442 2443 # Ignore: 2444 # 1) blank lines, they should be at 0, 2445 # 2) preprocessor lines, and 2446 # 3) labels. 2447 if ($continuation || 2448 $s =~ /^\s*?\n/ || 2449 $s =~ /^\s*#\s*?/ || 2450 $s =~ /^\s*$Ident\s*:/) { 2451 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0; 2452 if ($s =~ s/^.*?\n//) { 2453 $cond_lines++; 2454 } 2455 } 2456 } 2457 2458 my (undef, $sindent) = line_stats("+" . $s); 2459 my $stat_real = raw_line($linenr, $cond_lines); 2460 2461 # Check if either of these lines are modified, else 2462 # this is not this patch's fault. 2463 if (!defined($stat_real) || 2464 $stat !~ /^\+/ && $stat_real !~ /^\+/) { 2465 $check = 0; 2466 } 2467 if (defined($stat_real) && $cond_lines > 1) { 2468 $stat_real = "[...]\n$stat_real"; 2469 } 2470 2471 #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"; 2472 2473 if ($check && (($sindent % 8) != 0 || 2474 ($sindent <= $indent && $s ne ''))) { 2475 WARN("SUSPECT_CODE_INDENT", 2476 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n"); 2477 } 2478 } 2479 2480 # Track the 'values' across context and added lines. 2481 my $opline = $line; $opline =~ s/^./ /; 2482 my ($curr_values, $curr_vars) = 2483 annotate_values($opline . "\n", $prev_values); 2484 $curr_values = $prev_values . $curr_values; 2485 if ($dbg_values) { 2486 my $outline = $opline; $outline =~ s/\t/ /g; 2487 print "$linenr > .$outline\n"; 2488 print "$linenr > $curr_values\n"; 2489 print "$linenr > $curr_vars\n"; 2490 } 2491 $prev_values = substr($curr_values, -1); 2492 2493#ignore lines not being added 2494 next if ($line =~ /^[^\+]/); 2495 2496# TEST: allow direct testing of the type matcher. 2497 if ($dbg_type) { 2498 if ($line =~ /^.\s*$Declare\s*$/) { 2499 ERROR("TEST_TYPE", 2500 "TEST: is type\n" . $herecurr); 2501 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) { 2502 ERROR("TEST_NOT_TYPE", 2503 "TEST: is not type ($1 is)\n". $herecurr); 2504 } 2505 next; 2506 } 2507# TEST: allow direct testing of the attribute matcher. 2508 if ($dbg_attr) { 2509 if ($line =~ /^.\s*$Modifier\s*$/) { 2510 ERROR("TEST_ATTR", 2511 "TEST: is attr\n" . $herecurr); 2512 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) { 2513 ERROR("TEST_NOT_ATTR", 2514 "TEST: is not attr ($1 is)\n". $herecurr); 2515 } 2516 next; 2517 } 2518 2519# check for initialisation to aggregates open brace on the next line 2520 if ($line =~ /^.\s*{/ && 2521 $prevline =~ /(?:^|[^=])=\s*$/) { 2522 ERROR("OPEN_BRACE", 2523 "that open brace { should be on the previous line\n" . $hereprev); 2524 } 2525 2526# 2527# Checks which are anchored on the added line. 2528# 2529 2530# check for malformed paths in #include statements (uses RAW line) 2531 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) { 2532 my $path = $1; 2533 if ($path =~ m{//}) { 2534 ERROR("MALFORMED_INCLUDE", 2535 "malformed #include filename\n" . $herecurr); 2536 } 2537 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) { 2538 ERROR("UAPI_INCLUDE", 2539 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr); 2540 } 2541 } 2542 2543# no C99 // comments 2544 if ($line =~ m{//}) { 2545 if (ERROR("C99_COMMENTS", 2546 "do not use C99 // comments\n" . $herecurr) && 2547 $fix) { 2548 my $line = $fixed[$linenr - 1]; 2549 if ($line =~ /\/\/(.*)$/) { 2550 my $comment = trim($1); 2551 $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@; 2552 } 2553 } 2554 } 2555 # Remove C99 comments. 2556 $line =~ s@//.*@@; 2557 $opline =~ s@//.*@@; 2558 2559# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider 2560# the whole statement. 2561#print "APW <$lines[$realline_next - 1]>\n"; 2562 if (defined $realline_next && 2563 exists $lines[$realline_next - 1] && 2564 !defined $suppress_export{$realline_next} && 2565 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ || 2566 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) { 2567 # Handle definitions which produce identifiers with 2568 # a prefix: 2569 # XXX(foo); 2570 # EXPORT_SYMBOL(something_foo); 2571 my $name = $1; 2572 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ && 2573 $name =~ /^${Ident}_$2/) { 2574#print "FOO C name<$name>\n"; 2575 $suppress_export{$realline_next} = 1; 2576 2577 } elsif ($stat !~ /(?: 2578 \n.}\s*$| 2579 ^.DEFINE_$Ident\(\Q$name\E\)| 2580 ^.DECLARE_$Ident\(\Q$name\E\)| 2581 ^.LIST_HEAD\(\Q$name\E\)| 2582 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(| 2583 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\() 2584 )/x) { 2585#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n"; 2586 $suppress_export{$realline_next} = 2; 2587 } else { 2588 $suppress_export{$realline_next} = 1; 2589 } 2590 } 2591 if (!defined $suppress_export{$linenr} && 2592 $prevline =~ /^.\s*$/ && 2593 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ || 2594 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) { 2595#print "FOO B <$lines[$linenr - 1]>\n"; 2596 $suppress_export{$linenr} = 2; 2597 } 2598 if (defined $suppress_export{$linenr} && 2599 $suppress_export{$linenr} == 2) { 2600 WARN("EXPORT_SYMBOL", 2601 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr); 2602 } 2603 2604# check for global initialisers. 2605 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) { 2606 if (ERROR("GLOBAL_INITIALISERS", 2607 "do not initialise globals to 0 or NULL\n" . 2608 $herecurr) && 2609 $fix) { 2610 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/; 2611 } 2612 } 2613# check for static initialisers. 2614 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) { 2615 if (ERROR("INITIALISED_STATIC", 2616 "do not initialise statics to 0 or NULL\n" . 2617 $herecurr) && 2618 $fix) { 2619 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/; 2620 } 2621 } 2622 2623# check for static const char * arrays. 2624 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) { 2625 WARN("STATIC_CONST_CHAR_ARRAY", 2626 "static const char * array should probably be static const char * const\n" . 2627 $herecurr); 2628 } 2629 2630# check for static char foo[] = "bar" declarations. 2631 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) { 2632 WARN("STATIC_CONST_CHAR_ARRAY", 2633 "static char array declaration should probably be static const char\n" . 2634 $herecurr); 2635 } 2636 2637# check for declarations of struct pci_device_id 2638 if ($line =~ /\bstruct\s+pci_device_id\s+\w+\s*\[\s*\]\s*\=\s*\{/) { 2639 WARN("DEFINE_PCI_DEVICE_TABLE", 2640 "Use DEFINE_PCI_DEVICE_TABLE for struct pci_device_id\n" . $herecurr); 2641 } 2642 2643# check for new typedefs, only function parameters and sparse annotations 2644# make sense. 2645 if ($line =~ /\btypedef\s/ && 2646 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ && 2647 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ && 2648 $line !~ /\b$typeTypedefs\b/ && 2649 $line !~ /\b__bitwise(?:__|)\b/) { 2650 WARN("NEW_TYPEDEFS", 2651 "do not add new typedefs\n" . $herecurr); 2652 } 2653 2654# * goes on variable not on type 2655 # (char*[ const]) 2656 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) { 2657 #print "AA<$1>\n"; 2658 my ($ident, $from, $to) = ($1, $2, $2); 2659 2660 # Should start with a space. 2661 $to =~ s/^(\S)/ $1/; 2662 # Should not end with a space. 2663 $to =~ s/\s+$//; 2664 # '*'s should not have spaces between. 2665 while ($to =~ s/\*\s+\*/\*\*/) { 2666 } 2667 2668## print "1: from<$from> to<$to> ident<$ident>\n"; 2669 if ($from ne $to) { 2670 if (ERROR("POINTER_LOCATION", 2671 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) && 2672 $fix) { 2673 my $sub_from = $ident; 2674 my $sub_to = $ident; 2675 $sub_to =~ s/\Q$from\E/$to/; 2676 $fixed[$linenr - 1] =~ 2677 s@\Q$sub_from\E@$sub_to@; 2678 } 2679 } 2680 } 2681 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) { 2682 #print "BB<$1>\n"; 2683 my ($match, $from, $to, $ident) = ($1, $2, $2, $3); 2684 2685 # Should start with a space. 2686 $to =~ s/^(\S)/ $1/; 2687 # Should not end with a space. 2688 $to =~ s/\s+$//; 2689 # '*'s should not have spaces between. 2690 while ($to =~ s/\*\s+\*/\*\*/) { 2691 } 2692 # Modifiers should have spaces. 2693 $to =~ s/(\b$Modifier$)/$1 /; 2694 2695## print "2: from<$from> to<$to> ident<$ident>\n"; 2696 if ($from ne $to && $ident !~ /^$Modifier$/) { 2697 if (ERROR("POINTER_LOCATION", 2698 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) && 2699 $fix) { 2700 2701 my $sub_from = $match; 2702 my $sub_to = $match; 2703 $sub_to =~ s/\Q$from\E/$to/; 2704 $fixed[$linenr - 1] =~ 2705 s@\Q$sub_from\E@$sub_to@; 2706 } 2707 } 2708 } 2709 2710# # no BUG() or BUG_ON() 2711# if ($line =~ /\b(BUG|BUG_ON)\b/) { 2712# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n"; 2713# print "$herecurr"; 2714# $clean = 0; 2715# } 2716 2717 if ($line =~ /\bLINUX_VERSION_CODE\b/) { 2718 WARN("LINUX_VERSION_CODE", 2719 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr); 2720 } 2721 2722# check for uses of printk_ratelimit 2723 if ($line =~ /\bprintk_ratelimit\s*\(/) { 2724 WARN("PRINTK_RATELIMITED", 2725"Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr); 2726 } 2727 2728# printk should use KERN_* levels. Note that follow on printk's on the 2729# same line do not need a level, so we use the current block context 2730# to try and find and validate the current printk. In summary the current 2731# printk includes all preceding printk's which have no newline on the end. 2732# we assume the first bad printk is the one to report. 2733 if ($line =~ /\bprintk\((?!KERN_)\s*"/) { 2734 my $ok = 0; 2735 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) { 2736 #print "CHECK<$lines[$ln - 1]\n"; 2737 # we have a preceding printk if it ends 2738 # with "\n" ignore it, else it is to blame 2739 if ($lines[$ln - 1] =~ m{\bprintk\(}) { 2740 if ($rawlines[$ln - 1] !~ m{\\n"}) { 2741 $ok = 1; 2742 } 2743 last; 2744 } 2745 } 2746 if ($ok == 0) { 2747 WARN("PRINTK_WITHOUT_KERN_LEVEL", 2748 "printk() should include KERN_ facility level\n" . $herecurr); 2749 } 2750 } 2751 2752 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) { 2753 my $orig = $1; 2754 my $level = lc($orig); 2755 $level = "warn" if ($level eq "warning"); 2756 my $level2 = $level; 2757 $level2 = "dbg" if ($level eq "debug"); 2758 WARN("PREFER_PR_LEVEL", 2759 "Prefer netdev_$level2(netdev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr); 2760 } 2761 2762 if ($line =~ /\bpr_warning\s*\(/) { 2763 if (WARN("PREFER_PR_LEVEL", 2764 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) && 2765 $fix) { 2766 $fixed[$linenr - 1] =~ 2767 s/\bpr_warning\b/pr_warn/; 2768 } 2769 } 2770 2771 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) { 2772 my $orig = $1; 2773 my $level = lc($orig); 2774 $level = "warn" if ($level eq "warning"); 2775 $level = "dbg" if ($level eq "debug"); 2776 WARN("PREFER_DEV_LEVEL", 2777 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr); 2778 } 2779 2780# function brace can't be on same line, except for #defines of do while, 2781# or if closed on same line 2782 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and 2783 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) { 2784 ERROR("OPEN_BRACE", 2785 "open brace '{' following function declarations go on the next line\n" . $herecurr); 2786 } 2787 2788# open braces for enum, union and struct go on the same line. 2789 if ($line =~ /^.\s*{/ && 2790 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) { 2791 ERROR("OPEN_BRACE", 2792 "open brace '{' following $1 go on the same line\n" . $hereprev); 2793 } 2794 2795# missing space after union, struct or enum definition 2796 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) { 2797 if (WARN("SPACING", 2798 "missing space after $1 definition\n" . $herecurr) && 2799 $fix) { 2800 $fixed[$linenr - 1] =~ 2801 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/; 2802 } 2803 } 2804 2805# check for spacing round square brackets; allowed: 2806# 1. with a type on the left -- int [] a; 2807# 2. at the beginning of a line for slice initialisers -- [0...10] = 5, 2808# 3. inside a curly brace -- = { [0...10] = 5 } 2809 while ($line =~ /(.*?\s)\[/g) { 2810 my ($where, $prefix) = ($-[1], $1); 2811 if ($prefix !~ /$Type\s+$/ && 2812 ($where != 0 || $prefix !~ /^.\s+$/) && 2813 $prefix !~ /[{,]\s+$/) { 2814 if (ERROR("BRACKET_SPACE", 2815 "space prohibited before open square bracket '['\n" . $herecurr) && 2816 $fix) { 2817 $fixed[$linenr - 1] =~ 2818 s/^(\+.*?)\s+\[/$1\[/; 2819 } 2820 } 2821 } 2822 2823# check for spaces between functions and their parentheses. 2824 while ($line =~ /($Ident)\s+\(/g) { 2825 my $name = $1; 2826 my $ctx_before = substr($line, 0, $-[1]); 2827 my $ctx = "$ctx_before$name"; 2828 2829 # Ignore those directives where spaces _are_ permitted. 2830 if ($name =~ /^(?: 2831 if|for|while|switch|return|case| 2832 volatile|__volatile__| 2833 __attribute__|format|__extension__| 2834 asm|__asm__)$/x) 2835 { 2836 # cpp #define statements have non-optional spaces, ie 2837 # if there is a space between the name and the open 2838 # parenthesis it is simply not a parameter group. 2839 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) { 2840 2841 # cpp #elif statement condition may start with a ( 2842 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) { 2843 2844 # If this whole things ends with a type its most 2845 # likely a typedef for a function. 2846 } elsif ($ctx =~ /$Type$/) { 2847 2848 } else { 2849 if (WARN("SPACING", 2850 "space prohibited between function name and open parenthesis '('\n" . $herecurr) && 2851 $fix) { 2852 $fixed[$linenr - 1] =~ 2853 s/\b$name\s+\(/$name\(/; 2854 } 2855 } 2856 } 2857 2858# Check operator spacing. 2859 if (!($line=~/\#\s*include/)) { 2860 my $fixed_line = ""; 2861 my $line_fixed = 0; 2862 2863 my $ops = qr{ 2864 <<=|>>=|<=|>=|==|!=| 2865 \+=|-=|\*=|\/=|%=|\^=|\|=|&=| 2866 =>|->|<<|>>|<|>|=|!|~| 2867 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%| 2868 \?:|\?|: 2869 }x; 2870 my @elements = split(/($ops|;)/, $opline); 2871 2872## print("element count: <" . $#elements . ">\n"); 2873## foreach my $el (@elements) { 2874## print("el: <$el>\n"); 2875## } 2876 2877 my @fix_elements = (); 2878 my $off = 0; 2879 2880 foreach my $el (@elements) { 2881 push(@fix_elements, substr($rawline, $off, length($el))); 2882 $off += length($el); 2883 } 2884 2885 $off = 0; 2886 2887 my $blank = copy_spacing($opline); 2888 my $last_after = -1; 2889 2890 for (my $n = 0; $n < $#elements; $n += 2) { 2891 2892 my $good = $fix_elements[$n] . $fix_elements[$n + 1]; 2893 2894## print("n: <$n> good: <$good>\n"); 2895 2896 $off += length($elements[$n]); 2897 2898 # Pick up the preceding and succeeding characters. 2899 my $ca = substr($opline, 0, $off); 2900 my $cc = ''; 2901 if (length($opline) >= ($off + length($elements[$n + 1]))) { 2902 $cc = substr($opline, $off + length($elements[$n + 1])); 2903 } 2904 my $cb = "$ca$;$cc"; 2905 2906 my $a = ''; 2907 $a = 'V' if ($elements[$n] ne ''); 2908 $a = 'W' if ($elements[$n] =~ /\s$/); 2909 $a = 'C' if ($elements[$n] =~ /$;$/); 2910 $a = 'B' if ($elements[$n] =~ /(\[|\()$/); 2911 $a = 'O' if ($elements[$n] eq ''); 2912 $a = 'E' if ($ca =~ /^\s*$/); 2913 2914 my $op = $elements[$n + 1]; 2915 2916 my $c = ''; 2917 if (defined $elements[$n + 2]) { 2918 $c = 'V' if ($elements[$n + 2] ne ''); 2919 $c = 'W' if ($elements[$n + 2] =~ /^\s/); 2920 $c = 'C' if ($elements[$n + 2] =~ /^$;/); 2921 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/); 2922 $c = 'O' if ($elements[$n + 2] eq ''); 2923 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/); 2924 } else { 2925 $c = 'E'; 2926 } 2927 2928 my $ctx = "${a}x${c}"; 2929 2930 my $at = "(ctx:$ctx)"; 2931 2932 my $ptr = substr($blank, 0, $off) . "^"; 2933 my $hereptr = "$hereline$ptr\n"; 2934 2935 # Pull out the value of this operator. 2936 my $op_type = substr($curr_values, $off + 1, 1); 2937 2938 # Get the full operator variant. 2939 my $opv = $op . substr($curr_vars, $off, 1); 2940 2941 # Ignore operators passed as parameters. 2942 if ($op_type ne 'V' && 2943 $ca =~ /\s$/ && $cc =~ /^\s*,/) { 2944 2945# # Ignore comments 2946# } elsif ($op =~ /^$;+$/) { 2947 2948 # ; should have either the end of line or a space or \ after it 2949 } elsif ($op eq ';') { 2950 if ($ctx !~ /.x[WEBC]/ && 2951 $cc !~ /^\\/ && $cc !~ /^;/) { 2952 if (ERROR("SPACING", 2953 "space required after that '$op' $at\n" . $hereptr)) { 2954 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " "; 2955 $line_fixed = 1; 2956 } 2957 } 2958 2959 # // is a comment 2960 } elsif ($op eq '//') { 2961 2962 # No spaces for: 2963 # -> 2964 # : when part of a bitfield 2965 } elsif ($op eq '->' || $opv eq ':B') { 2966 if ($ctx =~ /Wx.|.xW/) { 2967 if (ERROR("SPACING", 2968 "spaces prohibited around that '$op' $at\n" . $hereptr)) { 2969 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); 2970 if (defined $fix_elements[$n + 2]) { 2971 $fix_elements[$n + 2] =~ s/^\s+//; 2972 } 2973 $line_fixed = 1; 2974 } 2975 } 2976 2977 # , must have a space on the right. 2978 } elsif ($op eq ',') { 2979 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) { 2980 if (ERROR("SPACING", 2981 "space required after that '$op' $at\n" . $hereptr)) { 2982 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " "; 2983 $line_fixed = 1; 2984 $last_after = $n; 2985 } 2986 } 2987 2988 # '*' as part of a type definition -- reported already. 2989 } elsif ($opv eq '*_') { 2990 #warn "'*' is part of type\n"; 2991 2992 # unary operators should have a space before and 2993 # none after. May be left adjacent to another 2994 # unary operator, or a cast 2995 } elsif ($op eq '!' || $op eq '~' || 2996 $opv eq '*U' || $opv eq '-U' || 2997 $opv eq '&U' || $opv eq '&&U') { 2998 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) { 2999 if (ERROR("SPACING", 3000 "space required before that '$op' $at\n" . $hereptr)) { 3001 if ($n != $last_after + 2) { 3002 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]); 3003 $line_fixed = 1; 3004 } 3005 } 3006 } 3007 if ($op eq '*' && $cc =~/\s*$Modifier\b/) { 3008 # A unary '*' may be const 3009 3010 } elsif ($ctx =~ /.xW/) { 3011 if (ERROR("SPACING", 3012 "space prohibited after that '$op' $at\n" . $hereptr)) { 3013 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]); 3014 if (defined $fix_elements[$n + 2]) { 3015 $fix_elements[$n + 2] =~ s/^\s+//; 3016 } 3017 $line_fixed = 1; 3018 } 3019 } 3020 3021 # unary ++ and unary -- are allowed no space on one side. 3022 } elsif ($op eq '++' or $op eq '--') { 3023 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) { 3024 if (ERROR("SPACING", 3025 "space required one side of that '$op' $at\n" . $hereptr)) { 3026 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " "; 3027 $line_fixed = 1; 3028 } 3029 } 3030 if ($ctx =~ /Wx[BE]/ || 3031 ($ctx =~ /Wx./ && $cc =~ /^;/)) { 3032 if (ERROR("SPACING", 3033 "space prohibited before that '$op' $at\n" . $hereptr)) { 3034 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); 3035 $line_fixed = 1; 3036 } 3037 } 3038 if ($ctx =~ /ExW/) { 3039 if (ERROR("SPACING", 3040 "space prohibited after that '$op' $at\n" . $hereptr)) { 3041 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]); 3042 if (defined $fix_elements[$n + 2]) { 3043 $fix_elements[$n + 2] =~ s/^\s+//; 3044 } 3045 $line_fixed = 1; 3046 } 3047 } 3048 3049 # << and >> may either have or not have spaces both sides 3050 } elsif ($op eq '<<' or $op eq '>>' or 3051 $op eq '&' or $op eq '^' or $op eq '|' or 3052 $op eq '+' or $op eq '-' or 3053 $op eq '*' or $op eq '/' or 3054 $op eq '%') 3055 { 3056 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) { 3057 if (ERROR("SPACING", 3058 "need consistent spacing around '$op' $at\n" . $hereptr)) { 3059 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " "; 3060 if (defined $fix_elements[$n + 2]) { 3061 $fix_elements[$n + 2] =~ s/^\s+//; 3062 } 3063 $line_fixed = 1; 3064 } 3065 } 3066 3067 # A colon needs no spaces before when it is 3068 # terminating a case value or a label. 3069 } elsif ($opv eq ':C' || $opv eq ':L') { 3070 if ($ctx =~ /Wx./) { 3071 if (ERROR("SPACING", 3072 "space prohibited before that '$op' $at\n" . $hereptr)) { 3073 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]); 3074 $line_fixed = 1; 3075 } 3076 } 3077 3078 # All the others need spaces both sides. 3079 } elsif ($ctx !~ /[EWC]x[CWE]/) { 3080 my $ok = 0; 3081 3082 # Ignore email addresses <foo@bar> 3083 if (($op eq '<' && 3084 $cc =~ /^\S+\@\S+>/) || 3085 ($op eq '>' && 3086 $ca =~ /<\S+\@\S+$/)) 3087 { 3088 $ok = 1; 3089 } 3090 3091 # messages are ERROR, but ?: are CHK 3092 if ($ok == 0) { 3093 my $msg_type = \&ERROR; 3094 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/); 3095 3096 if (&{$msg_type}("SPACING", 3097 "spaces required around that '$op' $at\n" . $hereptr)) { 3098 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " "; 3099 if (defined $fix_elements[$n + 2]) { 3100 $fix_elements[$n + 2] =~ s/^\s+//; 3101 } 3102 $line_fixed = 1; 3103 } 3104 } 3105 } 3106 $off += length($elements[$n + 1]); 3107 3108## print("n: <$n> GOOD: <$good>\n"); 3109 3110 $fixed_line = $fixed_line . $good; 3111 } 3112 3113 if (($#elements % 2) == 0) { 3114 $fixed_line = $fixed_line . $fix_elements[$#elements]; 3115 } 3116 3117 if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) { 3118 $fixed[$linenr - 1] = $fixed_line; 3119 } 3120 3121 3122 } 3123 3124# check for whitespace before a non-naked semicolon 3125 if ($line =~ /^\+.*\S\s+;/) { 3126 if (WARN("SPACING", 3127 "space prohibited before semicolon\n" . $herecurr) && 3128 $fix) { 3129 1 while $fixed[$linenr - 1] =~ 3130 s/^(\+.*\S)\s+;/$1;/; 3131 } 3132 } 3133 3134# check for multiple assignments 3135 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) { 3136 CHK("MULTIPLE_ASSIGNMENTS", 3137 "multiple assignments should be avoided\n" . $herecurr); 3138 } 3139 3140## # check for multiple declarations, allowing for a function declaration 3141## # continuation. 3142## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ && 3143## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) { 3144## 3145## # Remove any bracketed sections to ensure we do not 3146## # falsly report the parameters of functions. 3147## my $ln = $line; 3148## while ($ln =~ s/\([^\(\)]*\)//g) { 3149## } 3150## if ($ln =~ /,/) { 3151## WARN("MULTIPLE_DECLARATION", 3152## "declaring multiple variables together should be avoided\n" . $herecurr); 3153## } 3154## } 3155 3156#need space before brace following if, while, etc 3157 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) || 3158 $line =~ /do{/) { 3159 if (ERROR("SPACING", 3160 "space required before the open brace '{'\n" . $herecurr) && 3161 $fix) { 3162 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/; 3163 } 3164 } 3165 3166## # check for blank lines before declarations 3167## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ && 3168## $prevrawline =~ /^.\s*$/) { 3169## WARN("SPACING", 3170## "No blank lines before declarations\n" . $hereprev); 3171## } 3172## 3173 3174# closing brace should have a space following it when it has anything 3175# on the line 3176 if ($line =~ /}(?!(?:,|;|\)))\S/) { 3177 if (ERROR("SPACING", 3178 "space required after that close brace '}'\n" . $herecurr) && 3179 $fix) { 3180 $fixed[$linenr - 1] =~ 3181 s/}((?!(?:,|;|\)))\S)/} $1/; 3182 } 3183 } 3184 3185# check spacing on square brackets 3186 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) { 3187 if (ERROR("SPACING", 3188 "space prohibited after that open square bracket '['\n" . $herecurr) && 3189 $fix) { 3190 $fixed[$linenr - 1] =~ 3191 s/\[\s+/\[/; 3192 } 3193 } 3194 if ($line =~ /\s\]/) { 3195 if (ERROR("SPACING", 3196 "space prohibited before that close square bracket ']'\n" . $herecurr) && 3197 $fix) { 3198 $fixed[$linenr - 1] =~ 3199 s/\s+\]/\]/; 3200 } 3201 } 3202 3203# check spacing on parentheses 3204 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ && 3205 $line !~ /for\s*\(\s+;/) { 3206 if (ERROR("SPACING", 3207 "space prohibited after that open parenthesis '('\n" . $herecurr) && 3208 $fix) { 3209 $fixed[$linenr - 1] =~ 3210 s/\(\s+/\(/; 3211 } 3212 } 3213 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ && 3214 $line !~ /for\s*\(.*;\s+\)/ && 3215 $line !~ /:\s+\)/) { 3216 if (ERROR("SPACING", 3217 "space prohibited before that close parenthesis ')'\n" . $herecurr) && 3218 $fix) { 3219 $fixed[$linenr - 1] =~ 3220 s/\s+\)/\)/; 3221 } 3222 } 3223 3224#goto labels aren't indented, allow a single space however 3225 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and 3226 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) { 3227 if (WARN("INDENTED_LABEL", 3228 "labels should not be indented\n" . $herecurr) && 3229 $fix) { 3230 $fixed[$linenr - 1] =~ 3231 s/^(.)\s+/$1/; 3232 } 3233 } 3234 3235# Return is not a function. 3236 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) { 3237 my $spacing = $1; 3238 if ($^V && $^V ge 5.10.0 && 3239 $stat =~ /^.\s*return\s*$balanced_parens\s*;\s*$/) { 3240 ERROR("RETURN_PARENTHESES", 3241 "return is not a function, parentheses are not required\n" . $herecurr); 3242 3243 } elsif ($spacing !~ /\s+/) { 3244 ERROR("SPACING", 3245 "space required before the open parenthesis '('\n" . $herecurr); 3246 } 3247 } 3248 3249# Return of what appears to be an errno should normally be -'ve 3250 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) { 3251 my $name = $1; 3252 if ($name ne 'EOF' && $name ne 'ERROR') { 3253 WARN("USE_NEGATIVE_ERRNO", 3254 "return of an errno should typically be -ve (return -$1)\n" . $herecurr); 3255 } 3256 } 3257 3258# Need a space before open parenthesis after if, while etc 3259 if ($line =~ /\b(if|while|for|switch)\(/) { 3260 if (ERROR("SPACING", 3261 "space required before the open parenthesis '('\n" . $herecurr) && 3262 $fix) { 3263 $fixed[$linenr - 1] =~ 3264 s/\b(if|while|for|switch)\(/$1 \(/; 3265 } 3266 } 3267 3268# Check for illegal assignment in if conditional -- and check for trailing 3269# statements after the conditional. 3270 if ($line =~ /do\s*(?!{)/) { 3271 ($stat, $cond, $line_nr_next, $remain_next, $off_next) = 3272 ctx_statement_block($linenr, $realcnt, 0) 3273 if (!defined $stat); 3274 my ($stat_next) = ctx_statement_block($line_nr_next, 3275 $remain_next, $off_next); 3276 $stat_next =~ s/\n./\n /g; 3277 ##print "stat<$stat> stat_next<$stat_next>\n"; 3278 3279 if ($stat_next =~ /^\s*while\b/) { 3280 # If the statement carries leading newlines, 3281 # then count those as offsets. 3282 my ($whitespace) = 3283 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s); 3284 my $offset = 3285 statement_rawlines($whitespace) - 1; 3286 3287 $suppress_whiletrailers{$line_nr_next + 3288 $offset} = 1; 3289 } 3290 } 3291 if (!defined $suppress_whiletrailers{$linenr} && 3292 defined($stat) && defined($cond) && 3293 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) { 3294 my ($s, $c) = ($stat, $cond); 3295 3296 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) { 3297 ERROR("ASSIGN_IN_IF", 3298 "do not use assignment in if condition\n" . $herecurr); 3299 } 3300 3301 # Find out what is on the end of the line after the 3302 # conditional. 3303 substr($s, 0, length($c), ''); 3304 $s =~ s/\n.*//g; 3305 $s =~ s/$;//g; # Remove any comments 3306 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ && 3307 $c !~ /}\s*while\s*/) 3308 { 3309 # Find out how long the conditional actually is. 3310 my @newlines = ($c =~ /\n/gs); 3311 my $cond_lines = 1 + $#newlines; 3312 my $stat_real = ''; 3313 3314 $stat_real = raw_line($linenr, $cond_lines) 3315 . "\n" if ($cond_lines); 3316 if (defined($stat_real) && $cond_lines > 1) { 3317 $stat_real = "[...]\n$stat_real"; 3318 } 3319 3320 ERROR("TRAILING_STATEMENTS", 3321 "trailing statements should be on next line\n" . $herecurr . $stat_real); 3322 } 3323 } 3324 3325# Check for bitwise tests written as boolean 3326 if ($line =~ / 3327 (?: 3328 (?:\[|\(|\&\&|\|\|) 3329 \s*0[xX][0-9]+\s* 3330 (?:\&\&|\|\|) 3331 | 3332 (?:\&\&|\|\|) 3333 \s*0[xX][0-9]+\s* 3334 (?:\&\&|\|\||\)|\]) 3335 )/x) 3336 { 3337 WARN("HEXADECIMAL_BOOLEAN_TEST", 3338 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr); 3339 } 3340 3341# if and else should not have general statements after it 3342 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) { 3343 my $s = $1; 3344 $s =~ s/$;//g; # Remove any comments 3345 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) { 3346 ERROR("TRAILING_STATEMENTS", 3347 "trailing statements should be on next line\n" . $herecurr); 3348 } 3349 } 3350# if should not continue a brace 3351 if ($line =~ /}\s*if\b/) { 3352 ERROR("TRAILING_STATEMENTS", 3353 "trailing statements should be on next line\n" . 3354 $herecurr); 3355 } 3356# case and default should not have general statements after them 3357 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g && 3358 $line !~ /\G(?: 3359 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$| 3360 \s*return\s+ 3361 )/xg) 3362 { 3363 ERROR("TRAILING_STATEMENTS", 3364 "trailing statements should be on next line\n" . $herecurr); 3365 } 3366 3367 # Check for }<nl>else {, these must be at the same 3368 # indent level to be relevant to each other. 3369 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and 3370 $previndent == $indent) { 3371 ERROR("ELSE_AFTER_BRACE", 3372 "else should follow close brace '}'\n" . $hereprev); 3373 } 3374 3375 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and 3376 $previndent == $indent) { 3377 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0); 3378 3379 # Find out what is on the end of the line after the 3380 # conditional. 3381 substr($s, 0, length($c), ''); 3382 $s =~ s/\n.*//g; 3383 3384 if ($s =~ /^\s*;/) { 3385 ERROR("WHILE_AFTER_BRACE", 3386 "while should follow close brace '}'\n" . $hereprev); 3387 } 3388 } 3389 3390#Specific variable tests 3391 while ($line =~ m{($Constant|$Lval)}g) { 3392 my $var = $1; 3393 3394#gcc binary extension 3395 if ($var =~ /^$Binary$/) { 3396 if (WARN("GCC_BINARY_CONSTANT", 3397 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) && 3398 $fix) { 3399 my $hexval = sprintf("0x%x", oct($var)); 3400 $fixed[$linenr - 1] =~ 3401 s/\b$var\b/$hexval/; 3402 } 3403 } 3404 3405#CamelCase 3406 if ($var !~ /^$Constant$/ && 3407 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ && 3408#Ignore Page<foo> variants 3409 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ && 3410#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show) 3411 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) { 3412 while ($var =~ m{($Ident)}g) { 3413 my $word = $1; 3414 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/); 3415 if ($check) { 3416 seed_camelcase_includes(); 3417 if (!$file && !$camelcase_file_seeded) { 3418 seed_camelcase_file($realfile); 3419 $camelcase_file_seeded = 1; 3420 } 3421 } 3422 if (!defined $camelcase{$word}) { 3423 $camelcase{$word} = 1; 3424 CHK("CAMELCASE", 3425 "Avoid CamelCase: <$word>\n" . $herecurr); 3426 } 3427 } 3428 } 3429 } 3430 3431#no spaces allowed after \ in define 3432 if ($line =~ /\#\s*define.*\\\s+$/) { 3433 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION", 3434 "Whitespace after \\ makes next lines useless\n" . $herecurr) && 3435 $fix) { 3436 $fixed[$linenr - 1] =~ s/\s+$//; 3437 } 3438 } 3439 3440#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line) 3441 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) { 3442 my $file = "$1.h"; 3443 my $checkfile = "include/linux/$file"; 3444 if (-f "$root/$checkfile" && 3445 $realfile ne $checkfile && 3446 $1 !~ /$allowed_asm_includes/) 3447 { 3448 if ($realfile =~ m{^arch/}) { 3449 CHK("ARCH_INCLUDE_LINUX", 3450 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr); 3451 } else { 3452 WARN("INCLUDE_LINUX", 3453 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr); 3454 } 3455 } 3456 } 3457 3458# multi-statement macros should be enclosed in a do while loop, grab the 3459# first statement and ensure its the whole macro if its not enclosed 3460# in a known good container 3461 if ($realfile !~ m@/vmlinux.lds.h$@ && 3462 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) { 3463 my $ln = $linenr; 3464 my $cnt = $realcnt; 3465 my ($off, $dstat, $dcond, $rest); 3466 my $ctx = ''; 3467 ($dstat, $dcond, $ln, $cnt, $off) = 3468 ctx_statement_block($linenr, $realcnt, 0); 3469 $ctx = $dstat; 3470 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n"; 3471 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n"; 3472 3473 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//; 3474 $dstat =~ s/$;//g; 3475 $dstat =~ s/\\\n.//g; 3476 $dstat =~ s/^\s*//s; 3477 $dstat =~ s/\s*$//s; 3478 3479 # Flatten any parentheses and braces 3480 while ($dstat =~ s/\([^\(\)]*\)/1/ || 3481 $dstat =~ s/\{[^\{\}]*\}/1/ || 3482 $dstat =~ s/\[[^\[\]]*\]/1/) 3483 { 3484 } 3485 3486 # Flatten any obvious string concatentation. 3487 while ($dstat =~ s/("X*")\s*$Ident/$1/ || 3488 $dstat =~ s/$Ident\s*("X*")/$1/) 3489 { 3490 } 3491 3492 my $exceptions = qr{ 3493 $Declare| 3494 module_param_named| 3495 MODULE_PARM_DESC| 3496 DECLARE_PER_CPU| 3497 DEFINE_PER_CPU| 3498 __typeof__\(| 3499 union| 3500 struct| 3501 \.$Ident\s*=\s*| 3502 ^\"|\"$ 3503 }x; 3504 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n"; 3505 if ($dstat ne '' && 3506 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(), 3507 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo(); 3508 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz 3509 $dstat !~ /^'X'$/ && # character constants 3510 $dstat !~ /$exceptions/ && 3511 $dstat !~ /^\.$Ident\s*=/ && # .foo = 3512 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo 3513 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...) 3514 $dstat !~ /^for\s*$Constant$/ && # for (...) 3515 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar() 3516 $dstat !~ /^do\s*{/ && # do {... 3517 $dstat !~ /^\({/ && # ({... 3518 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/) 3519 { 3520 $ctx =~ s/\n*$//; 3521 my $herectx = $here . "\n"; 3522 my $cnt = statement_rawlines($ctx); 3523 3524 for (my $n = 0; $n < $cnt; $n++) { 3525 $herectx .= raw_line($linenr, $n) . "\n"; 3526 } 3527 3528 if ($dstat =~ /;/) { 3529 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE", 3530 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx"); 3531 } else { 3532 ERROR("COMPLEX_MACRO", 3533 "Macros with complex values should be enclosed in parenthesis\n" . "$herectx"); 3534 } 3535 } 3536 3537# check for line continuations outside of #defines, preprocessor #, and asm 3538 3539 } else { 3540 if ($prevline !~ /^..*\\$/ && 3541 $line !~ /^\+\s*\#.*\\$/ && # preprocessor 3542 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm 3543 $line =~ /^\+.*\\$/) { 3544 WARN("LINE_CONTINUATIONS", 3545 "Avoid unnecessary line continuations\n" . $herecurr); 3546 } 3547 } 3548 3549# do {} while (0) macro tests: 3550# single-statement macros do not need to be enclosed in do while (0) loop, 3551# macro should not end with a semicolon 3552 if ($^V && $^V ge 5.10.0 && 3553 $realfile !~ m@/vmlinux.lds.h$@ && 3554 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) { 3555 my $ln = $linenr; 3556 my $cnt = $realcnt; 3557 my ($off, $dstat, $dcond, $rest); 3558 my $ctx = ''; 3559 ($dstat, $dcond, $ln, $cnt, $off) = 3560 ctx_statement_block($linenr, $realcnt, 0); 3561 $ctx = $dstat; 3562 3563 $dstat =~ s/\\\n.//g; 3564 3565 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) { 3566 my $stmts = $2; 3567 my $semis = $3; 3568 3569 $ctx =~ s/\n*$//; 3570 my $cnt = statement_rawlines($ctx); 3571 my $herectx = $here . "\n"; 3572 3573 for (my $n = 0; $n < $cnt; $n++) { 3574 $herectx .= raw_line($linenr, $n) . "\n"; 3575 } 3576 3577 if (($stmts =~ tr/;/;/) == 1 && 3578 $stmts !~ /^\s*(if|while|for|switch)\b/) { 3579 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO", 3580 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx"); 3581 } 3582 if (defined $semis && $semis ne "") { 3583 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON", 3584 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx"); 3585 } 3586 } 3587 } 3588 3589# make sure symbols are always wrapped with VMLINUX_SYMBOL() ... 3590# all assignments may have only one of the following with an assignment: 3591# . 3592# ALIGN(...) 3593# VMLINUX_SYMBOL(...) 3594 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) { 3595 WARN("MISSING_VMLINUX_SYMBOL", 3596 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr); 3597 } 3598 3599# check for redundant bracing round if etc 3600 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) { 3601 my ($level, $endln, @chunks) = 3602 ctx_statement_full($linenr, $realcnt, 1); 3603 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n"; 3604 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n"; 3605 if ($#chunks > 0 && $level == 0) { 3606 my @allowed = (); 3607 my $allow = 0; 3608 my $seen = 0; 3609 my $herectx = $here . "\n"; 3610 my $ln = $linenr - 1; 3611 for my $chunk (@chunks) { 3612 my ($cond, $block) = @{$chunk}; 3613 3614 # If the condition carries leading newlines, then count those as offsets. 3615 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s); 3616 my $offset = statement_rawlines($whitespace) - 1; 3617 3618 $allowed[$allow] = 0; 3619 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n"; 3620 3621 # We have looked at and allowed this specific line. 3622 $suppress_ifbraces{$ln + $offset} = 1; 3623 3624 $herectx .= "$rawlines[$ln + $offset]\n[...]\n"; 3625 $ln += statement_rawlines($block) - 1; 3626 3627 substr($block, 0, length($cond), ''); 3628 3629 $seen++ if ($block =~ /^\s*{/); 3630 3631 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n"; 3632 if (statement_lines($cond) > 1) { 3633 #print "APW: ALLOWED: cond<$cond>\n"; 3634 $allowed[$allow] = 1; 3635 } 3636 if ($block =~/\b(?:if|for|while)\b/) { 3637 #print "APW: ALLOWED: block<$block>\n"; 3638 $allowed[$allow] = 1; 3639 } 3640 if (statement_block_size($block) > 1) { 3641 #print "APW: ALLOWED: lines block<$block>\n"; 3642 $allowed[$allow] = 1; 3643 } 3644 $allow++; 3645 } 3646 if ($seen) { 3647 my $sum_allowed = 0; 3648 foreach (@allowed) { 3649 $sum_allowed += $_; 3650 } 3651 if ($sum_allowed == 0) { 3652 WARN("BRACES", 3653 "braces {} are not necessary for any arm of this statement\n" . $herectx); 3654 } elsif ($sum_allowed != $allow && 3655 $seen != $allow) { 3656 CHK("BRACES", 3657 "braces {} should be used on all arms of this statement\n" . $herectx); 3658 } 3659 } 3660 } 3661 } 3662 if (!defined $suppress_ifbraces{$linenr - 1} && 3663 $line =~ /\b(if|while|for|else)\b/) { 3664 my $allowed = 0; 3665 3666 # Check the pre-context. 3667 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) { 3668 #print "APW: ALLOWED: pre<$1>\n"; 3669 $allowed = 1; 3670 } 3671 3672 my ($level, $endln, @chunks) = 3673 ctx_statement_full($linenr, $realcnt, $-[0]); 3674 3675 # Check the condition. 3676 my ($cond, $block) = @{$chunks[0]}; 3677 #print "CHECKING<$linenr> cond<$cond> block<$block>\n"; 3678 if (defined $cond) { 3679 substr($block, 0, length($cond), ''); 3680 } 3681 if (statement_lines($cond) > 1) { 3682 #print "APW: ALLOWED: cond<$cond>\n"; 3683 $allowed = 1; 3684 } 3685 if ($block =~/\b(?:if|for|while)\b/) { 3686 #print "APW: ALLOWED: block<$block>\n"; 3687 $allowed = 1; 3688 } 3689 if (statement_block_size($block) > 1) { 3690 #print "APW: ALLOWED: lines block<$block>\n"; 3691 $allowed = 1; 3692 } 3693 # Check the post-context. 3694 if (defined $chunks[1]) { 3695 my ($cond, $block) = @{$chunks[1]}; 3696 if (defined $cond) { 3697 substr($block, 0, length($cond), ''); 3698 } 3699 if ($block =~ /^\s*\{/) { 3700 #print "APW: ALLOWED: chunk-1 block<$block>\n"; 3701 $allowed = 1; 3702 } 3703 } 3704 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) { 3705 my $herectx = $here . "\n"; 3706 my $cnt = statement_rawlines($block); 3707 3708 for (my $n = 0; $n < $cnt; $n++) { 3709 $herectx .= raw_line($linenr, $n) . "\n"; 3710 } 3711 3712 WARN("BRACES", 3713 "braces {} are not necessary for single statement blocks\n" . $herectx); 3714 } 3715 } 3716 3717# check for unnecessary blank lines around braces 3718 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) { 3719 CHK("BRACES", 3720 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev); 3721 } 3722 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) { 3723 CHK("BRACES", 3724 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev); 3725 } 3726 3727# no volatiles please 3728 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b}; 3729 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) { 3730 WARN("VOLATILE", 3731 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr); 3732 } 3733 3734# warn about #if 0 3735 if ($line =~ /^.\s*\#\s*if\s+0\b/) { 3736 CHK("REDUNDANT_CODE", 3737 "if this code is redundant consider removing it\n" . 3738 $herecurr); 3739 } 3740 3741# check for needless "if (<foo>) fn(<foo>)" uses 3742 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) { 3743 my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;'; 3744 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) { 3745 WARN('NEEDLESS_IF', 3746 "$1(NULL) is safe this check is probably not required\n" . $hereprev); 3747 } 3748 } 3749 3750# check for bad placement of section $InitAttribute (e.g.: __initdata) 3751 if ($line =~ /(\b$InitAttribute\b)/) { 3752 my $attr = $1; 3753 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) { 3754 my $ptr = $1; 3755 my $var = $2; 3756 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ && 3757 ERROR("MISPLACED_INIT", 3758 "$attr should be placed after $var\n" . $herecurr)) || 3759 ($ptr !~ /\b(union|struct)\s+$attr\b/ && 3760 WARN("MISPLACED_INIT", 3761 "$attr should be placed after $var\n" . $herecurr))) && 3762 $fix) { 3763 $fixed[$linenr - 1] =~ 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; 3764 } 3765 } 3766 } 3767 3768# check for $InitAttributeData (ie: __initdata) with const 3769 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) { 3770 my $attr = $1; 3771 $attr =~ /($InitAttributePrefix)(.*)/; 3772 my $attr_prefix = $1; 3773 my $attr_type = $2; 3774 if (ERROR("INIT_ATTRIBUTE", 3775 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) && 3776 $fix) { 3777 $fixed[$linenr - 1] =~ 3778 s/$InitAttributeData/${attr_prefix}initconst/; 3779 } 3780 } 3781 3782# check for $InitAttributeConst (ie: __initconst) without const 3783 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) { 3784 my $attr = $1; 3785 if (ERROR("INIT_ATTRIBUTE", 3786 "Use of $attr requires a separate use of const\n" . $herecurr) && 3787 $fix) { 3788 my $lead = $fixed[$linenr - 1] =~ 3789 /(^\+\s*(?:static\s+))/; 3790 $lead = rtrim($1); 3791 $lead = "$lead " if ($lead !~ /^\+$/); 3792 $lead = "${lead}const "; 3793 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/; 3794 } 3795 } 3796 3797# prefer usleep_range over udelay 3798 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) { 3799 # ignore udelay's < 10, however 3800 if (! ($1 < 10) ) { 3801 CHK("USLEEP_RANGE", 3802 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line); 3803 } 3804 } 3805 3806# warn about unexpectedly long msleep's 3807 if ($line =~ /\bmsleep\s*\((\d+)\);/) { 3808 if ($1 < 20) { 3809 WARN("MSLEEP", 3810 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line); 3811 } 3812 } 3813 3814# check for comparisons of jiffies 3815 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) { 3816 WARN("JIFFIES_COMPARISON", 3817 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr); 3818 } 3819 3820# check for comparisons of get_jiffies_64() 3821 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) { 3822 WARN("JIFFIES_COMPARISON", 3823 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr); 3824 } 3825 3826# warn about #ifdefs in C files 3827# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) { 3828# print "#ifdef in C files should be avoided\n"; 3829# print "$herecurr"; 3830# $clean = 0; 3831# } 3832 3833# warn about spacing in #ifdefs 3834 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) { 3835 if (ERROR("SPACING", 3836 "exactly one space required after that #$1\n" . $herecurr) && 3837 $fix) { 3838 $fixed[$linenr - 1] =~ 3839 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /; 3840 } 3841 3842 } 3843 3844# check for spinlock_t definitions without a comment. 3845 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ || 3846 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) { 3847 my $which = $1; 3848 if (!ctx_has_comment($first_line, $linenr)) { 3849 CHK("UNCOMMENTED_DEFINITION", 3850 "$1 definition without comment\n" . $herecurr); 3851 } 3852 } 3853# check for memory barriers without a comment. 3854 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) { 3855 if (!ctx_has_comment($first_line, $linenr)) { 3856 WARN("MEMORY_BARRIER", 3857 "memory barrier without comment\n" . $herecurr); 3858 } 3859 } 3860# check of hardware specific defines 3861 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) { 3862 CHK("ARCH_DEFINES", 3863 "architecture specific defines should be avoided\n" . $herecurr); 3864 } 3865 3866# Check that the storage class is at the beginning of a declaration 3867 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) { 3868 WARN("STORAGE_CLASS", 3869 "storage class should be at the beginning of the declaration\n" . $herecurr) 3870 } 3871 3872# check the location of the inline attribute, that it is between 3873# storage class and type. 3874 if ($line =~ /\b$Type\s+$Inline\b/ || 3875 $line =~ /\b$Inline\s+$Storage\b/) { 3876 ERROR("INLINE_LOCATION", 3877 "inline keyword should sit between storage class and type\n" . $herecurr); 3878 } 3879 3880# Check for __inline__ and __inline, prefer inline 3881 if ($realfile !~ m@\binclude/uapi/@ && 3882 $line =~ /\b(__inline__|__inline)\b/) { 3883 if (WARN("INLINE", 3884 "plain inline is preferred over $1\n" . $herecurr) && 3885 $fix) { 3886 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/; 3887 3888 } 3889 } 3890 3891# Check for __attribute__ packed, prefer __packed 3892 if ($realfile !~ m@\binclude/uapi/@ && 3893 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) { 3894 WARN("PREFER_PACKED", 3895 "__packed is preferred over __attribute__((packed))\n" . $herecurr); 3896 } 3897 3898# Check for __attribute__ aligned, prefer __aligned 3899 if ($realfile !~ m@\binclude/uapi/@ && 3900 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) { 3901 WARN("PREFER_ALIGNED", 3902 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr); 3903 } 3904 3905# Check for __attribute__ format(printf, prefer __printf 3906 if ($realfile !~ m@\binclude/uapi/@ && 3907 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) { 3908 if (WARN("PREFER_PRINTF", 3909 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) && 3910 $fix) { 3911 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex; 3912 3913 } 3914 } 3915 3916# Check for __attribute__ format(scanf, prefer __scanf 3917 if ($realfile !~ m@\binclude/uapi/@ && 3918 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) { 3919 if (WARN("PREFER_SCANF", 3920 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) && 3921 $fix) { 3922 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex; 3923 } 3924 } 3925 3926# check for sizeof(&) 3927 if ($line =~ /\bsizeof\s*\(\s*\&/) { 3928 WARN("SIZEOF_ADDRESS", 3929 "sizeof(& should be avoided\n" . $herecurr); 3930 } 3931 3932# check for sizeof without parenthesis 3933 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) { 3934 if (WARN("SIZEOF_PARENTHESIS", 3935 "sizeof $1 should be sizeof($1)\n" . $herecurr) && 3936 $fix) { 3937 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex; 3938 } 3939 } 3940 3941# check for line continuations in quoted strings with odd counts of " 3942 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) { 3943 WARN("LINE_CONTINUATIONS", 3944 "Avoid line continuations in quoted strings\n" . $herecurr); 3945 } 3946 3947# check for struct spinlock declarations 3948 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) { 3949 WARN("USE_SPINLOCK_T", 3950 "struct spinlock should be spinlock_t\n" . $herecurr); 3951 } 3952 3953# check for seq_printf uses that could be seq_puts 3954 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) { 3955 my $fmt = get_quoted_string($line, $rawline); 3956 if ($fmt ne "" && $fmt !~ /[^\\]\%/) { 3957 if (WARN("PREFER_SEQ_PUTS", 3958 "Prefer seq_puts to seq_printf\n" . $herecurr) && 3959 $fix) { 3960 $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/; 3961 } 3962 } 3963 } 3964 3965# Check for misused memsets 3966 if ($^V && $^V ge 5.10.0 && 3967 defined $stat && 3968 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) { 3969 3970 my $ms_addr = $2; 3971 my $ms_val = $7; 3972 my $ms_size = $12; 3973 3974 if ($ms_size =~ /^(0x|)0$/i) { 3975 ERROR("MEMSET", 3976 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n"); 3977 } elsif ($ms_size =~ /^(0x|)1$/i) { 3978 WARN("MEMSET", 3979 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n"); 3980 } 3981 } 3982 3983# typecasts on min/max could be min_t/max_t 3984 if ($^V && $^V ge 5.10.0 && 3985 defined $stat && 3986 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) { 3987 if (defined $2 || defined $7) { 3988 my $call = $1; 3989 my $cast1 = deparenthesize($2); 3990 my $arg1 = $3; 3991 my $cast2 = deparenthesize($7); 3992 my $arg2 = $8; 3993 my $cast; 3994 3995 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) { 3996 $cast = "$cast1 or $cast2"; 3997 } elsif ($cast1 ne "") { 3998 $cast = $cast1; 3999 } else { 4000 $cast = $cast2; 4001 } 4002 WARN("MINMAX", 4003 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n"); 4004 } 4005 } 4006 4007# check usleep_range arguments 4008 if ($^V && $^V ge 5.10.0 && 4009 defined $stat && 4010 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) { 4011 my $min = $1; 4012 my $max = $7; 4013 if ($min eq $max) { 4014 WARN("USLEEP_RANGE", 4015 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n"); 4016 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ && 4017 $min > $max) { 4018 WARN("USLEEP_RANGE", 4019 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n"); 4020 } 4021 } 4022 4023# check for naked sscanf 4024 if ($^V && $^V ge 5.10.0 && 4025 defined $stat && 4026 $stat =~ /\bsscanf\b/ && 4027 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ && 4028 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ && 4029 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) { 4030 my $lc = $stat =~ tr@\n@@; 4031 $lc = $lc + $linenr; 4032 my $stat_real = raw_line($linenr, 0); 4033 for (my $count = $linenr + 1; $count <= $lc; $count++) { 4034 $stat_real = $stat_real . "\n" . raw_line($count, 0); 4035 } 4036 WARN("NAKED_SSCANF", 4037 "unchecked sscanf return value\n" . "$here\n$stat_real\n"); 4038 } 4039 4040# check for new externs in .h files. 4041 if ($realfile =~ /\.h$/ && 4042 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) { 4043 if (CHK("AVOID_EXTERNS", 4044 "extern prototypes should be avoided in .h files\n" . $herecurr) && 4045 $fix) { 4046 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/; 4047 } 4048 } 4049 4050# check for new externs in .c files. 4051 if ($realfile =~ /\.c$/ && defined $stat && 4052 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s) 4053 { 4054 my $function_name = $1; 4055 my $paren_space = $2; 4056 4057 my $s = $stat; 4058 if (defined $cond) { 4059 substr($s, 0, length($cond), ''); 4060 } 4061 if ($s =~ /^\s*;/ && 4062 $function_name ne 'uninitialized_var') 4063 { 4064 WARN("AVOID_EXTERNS", 4065 "externs should be avoided in .c files\n" . $herecurr); 4066 } 4067 4068 if ($paren_space =~ /\n/) { 4069 WARN("FUNCTION_ARGUMENTS", 4070 "arguments for function declarations should follow identifier\n" . $herecurr); 4071 } 4072 4073 } elsif ($realfile =~ /\.c$/ && defined $stat && 4074 $stat =~ /^.\s*extern\s+/) 4075 { 4076 WARN("AVOID_EXTERNS", 4077 "externs should be avoided in .c files\n" . $herecurr); 4078 } 4079 4080# checks for new __setup's 4081 if ($rawline =~ /\b__setup\("([^"]*)"/) { 4082 my $name = $1; 4083 4084 if (!grep(/$name/, @setup_docs)) { 4085 CHK("UNDOCUMENTED_SETUP", 4086 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr); 4087 } 4088 } 4089 4090# check for pointless casting of kmalloc return 4091 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) { 4092 WARN("UNNECESSARY_CASTS", 4093 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr); 4094 } 4095 4096# alloc style 4097# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...) 4098 if ($^V && $^V ge 5.10.0 && 4099 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) { 4100 CHK("ALLOC_SIZEOF_STRUCT", 4101 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr); 4102 } 4103 4104# check for krealloc arg reuse 4105 if ($^V && $^V ge 5.10.0 && 4106 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) { 4107 WARN("KREALLOC_ARG_REUSE", 4108 "Reusing the krealloc arg is almost always a bug\n" . $herecurr); 4109 } 4110 4111# check for alloc argument mismatch 4112 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) { 4113 WARN("ALLOC_ARRAY_ARGS", 4114 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr); 4115 } 4116 4117# check for multiple semicolons 4118 if ($line =~ /;\s*;\s*$/) { 4119 if (WARN("ONE_SEMICOLON", 4120 "Statements terminations use 1 semicolon\n" . $herecurr) && 4121 $fix) { 4122 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g; 4123 } 4124 } 4125 4126# check for switch/default statements without a break; 4127 if ($^V && $^V ge 5.10.0 && 4128 defined $stat && 4129 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) { 4130 my $ctx = ''; 4131 my $herectx = $here . "\n"; 4132 my $cnt = statement_rawlines($stat); 4133 for (my $n = 0; $n < $cnt; $n++) { 4134 $herectx .= raw_line($linenr, $n) . "\n"; 4135 } 4136 WARN("DEFAULT_NO_BREAK", 4137 "switch default: should use break\n" . $herectx); 4138 } 4139 4140# check for gcc specific __FUNCTION__ 4141 if ($line =~ /\b__FUNCTION__\b/) { 4142 if (WARN("USE_FUNC", 4143 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) && 4144 $fix) { 4145 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g; 4146 } 4147 } 4148 4149# check for use of yield() 4150 if ($line =~ /\byield\s*\(\s*\)/) { 4151 WARN("YIELD", 4152 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr); 4153 } 4154 4155# check for comparisons against true and false 4156 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) { 4157 my $lead = $1; 4158 my $arg = $2; 4159 my $test = $3; 4160 my $otype = $4; 4161 my $trail = $5; 4162 my $op = "!"; 4163 4164 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i); 4165 4166 my $type = lc($otype); 4167 if ($type =~ /^(?:true|false)$/) { 4168 if (("$test" eq "==" && "$type" eq "true") || 4169 ("$test" eq "!=" && "$type" eq "false")) { 4170 $op = ""; 4171 } 4172 4173 CHK("BOOL_COMPARISON", 4174 "Using comparison to $otype is error prone\n" . $herecurr); 4175 4176## maybe suggesting a correct construct would better 4177## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr); 4178 4179 } 4180 } 4181 4182# check for semaphores initialized locked 4183 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) { 4184 WARN("CONSIDER_COMPLETION", 4185 "consider using a completion\n" . $herecurr); 4186 } 4187 4188# recommend kstrto* over simple_strto* and strict_strto* 4189 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) { 4190 WARN("CONSIDER_KSTRTO", 4191 "$1 is obsolete, use k$3 instead\n" . $herecurr); 4192 } 4193 4194# check for __initcall(), use device_initcall() explicitly please 4195 if ($line =~ /^.\s*__initcall\s*\(/) { 4196 WARN("USE_DEVICE_INITCALL", 4197 "please use device_initcall() instead of __initcall()\n" . $herecurr); 4198 } 4199 4200# check for various ops structs, ensure they are const. 4201 my $struct_ops = qr{acpi_dock_ops| 4202 address_space_operations| 4203 backlight_ops| 4204 block_device_operations| 4205 dentry_operations| 4206 dev_pm_ops| 4207 dma_map_ops| 4208 extent_io_ops| 4209 file_lock_operations| 4210 file_operations| 4211 hv_ops| 4212 ide_dma_ops| 4213 intel_dvo_dev_ops| 4214 item_operations| 4215 iwl_ops| 4216 kgdb_arch| 4217 kgdb_io| 4218 kset_uevent_ops| 4219 lock_manager_operations| 4220 microcode_ops| 4221 mtrr_ops| 4222 neigh_ops| 4223 nlmsvc_binding| 4224 pci_raw_ops| 4225 pipe_buf_operations| 4226 platform_hibernation_ops| 4227 platform_suspend_ops| 4228 proto_ops| 4229 rpc_pipe_ops| 4230 seq_operations| 4231 snd_ac97_build_ops| 4232 soc_pcmcia_socket_ops| 4233 stacktrace_ops| 4234 sysfs_ops| 4235 tty_operations| 4236 usb_mon_operations| 4237 wd_ops}x; 4238 if ($line !~ /\bconst\b/ && 4239 $line =~ /\bstruct\s+($struct_ops)\b/) { 4240 WARN("CONST_STRUCT", 4241 "struct $1 should normally be const\n" . 4242 $herecurr); 4243 } 4244 4245# use of NR_CPUS is usually wrong 4246# ignore definitions of NR_CPUS and usage to define arrays as likely right 4247 if ($line =~ /\bNR_CPUS\b/ && 4248 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ && 4249 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ && 4250 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ && 4251 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ && 4252 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/) 4253 { 4254 WARN("NR_CPUS", 4255 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr); 4256 } 4257 4258# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong. 4259 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) { 4260 ERROR("DEFINE_ARCH_HAS", 4261 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr); 4262 } 4263 4264# check for %L{u,d,i} in strings 4265 my $string; 4266 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) { 4267 $string = substr($rawline, $-[1], $+[1] - $-[1]); 4268 $string =~ s/%%/__/g; 4269 if ($string =~ /(?<!%)%L[udi]/) { 4270 WARN("PRINTF_L", 4271 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr); 4272 last; 4273 } 4274 } 4275 4276# whine mightly about in_atomic 4277 if ($line =~ /\bin_atomic\s*\(/) { 4278 if ($realfile =~ m@^drivers/@) { 4279 ERROR("IN_ATOMIC", 4280 "do not use in_atomic in drivers\n" . $herecurr); 4281 } elsif ($realfile !~ m@^kernel/@) { 4282 WARN("IN_ATOMIC", 4283 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr); 4284 } 4285 } 4286 4287# check for lockdep_set_novalidate_class 4288 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ || 4289 $line =~ /__lockdep_no_validate__\s*\)/ ) { 4290 if ($realfile !~ m@^kernel/lockdep@ && 4291 $realfile !~ m@^include/linux/lockdep@ && 4292 $realfile !~ m@^drivers/base/core@) { 4293 ERROR("LOCKDEP", 4294 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr); 4295 } 4296 } 4297 4298 if ($line =~ /debugfs_create_file.*S_IWUGO/ || 4299 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) { 4300 WARN("EXPORTED_WORLD_WRITABLE", 4301 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr); 4302 } 4303 } 4304 4305 # If we have no input at all, then there is nothing to report on 4306 # so just keep quiet. 4307 if ($#rawlines == -1) { 4308 exit(0); 4309 } 4310 4311 # In mailback mode only produce a report in the negative, for 4312 # things that appear to be patches. 4313 if ($mailback && ($clean == 1 || !$is_patch)) { 4314 exit(0); 4315 } 4316 4317 # This is not a patch, and we are are in 'no-patch' mode so 4318 # just keep quiet. 4319 if (!$chk_patch && !$is_patch) { 4320 exit(0); 4321 } 4322 4323 if (!$is_patch) { 4324 ERROR("NOT_UNIFIED_DIFF", 4325 "Does not appear to be a unified-diff format patch\n"); 4326 } 4327 if ($is_patch && $chk_signoff && $signoff == 0) { 4328 ERROR("MISSING_SIGN_OFF", 4329 "Missing Signed-off-by: line(s)\n"); 4330 } 4331 4332 print report_dump(); 4333 if ($summary && !($clean == 1 && $quiet == 1)) { 4334 print "$filename " if ($summary_file); 4335 print "total: $cnt_error errors, $cnt_warn warnings, " . 4336 (($check)? "$cnt_chk checks, " : "") . 4337 "$cnt_lines lines checked\n"; 4338 print "\n" if ($quiet == 0); 4339 } 4340 4341 if ($quiet == 0) { 4342 4343 if ($^V lt 5.10.0) { 4344 print("NOTE: perl $^V is not modern enough to detect all possible issues.\n"); 4345 print("An upgrade to at least perl v5.10.0 is suggested.\n\n"); 4346 } 4347 4348 # If there were whitespace errors which cleanpatch can fix 4349 # then suggest that. 4350 if ($rpt_cleaners) { 4351 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n"; 4352 print " scripts/cleanfile\n\n"; 4353 $rpt_cleaners = 0; 4354 } 4355 } 4356 4357 hash_show_words(\%use_type, "Used"); 4358 hash_show_words(\%ignore_type, "Ignored"); 4359 4360 if ($clean == 0 && $fix && "@rawlines" ne "@fixed") { 4361 my $newfile = $filename . ".EXPERIMENTAL-checkpatch-fixes"; 4362 my $linecount = 0; 4363 my $f; 4364 4365 open($f, '>', $newfile) 4366 or die "$P: Can't open $newfile for write\n"; 4367 foreach my $fixed_line (@fixed) { 4368 $linecount++; 4369 if ($file) { 4370 if ($linecount > 3) { 4371 $fixed_line =~ s/^\+//; 4372 print $f $fixed_line. "\n"; 4373 } 4374 } else { 4375 print $f $fixed_line . "\n"; 4376 } 4377 } 4378 close($f); 4379 4380 if (!$quiet) { 4381 print << "EOM"; 4382Wrote EXPERIMENTAL --fix correction(s) to '$newfile' 4383 4384Do _NOT_ trust the results written to this file. 4385Do _NOT_ submit these changes without inspecting them for correctness. 4386 4387This EXPERIMENTAL file is simply a convenience to help rewrite patches. 4388No warranties, expressed or implied... 4389 4390EOM 4391 } 4392 } 4393 4394 if ($clean == 1 && $quiet == 0) { 4395 print "$vname has no obvious style problems and is ready for submission.\n" 4396 } 4397 if ($clean == 0 && $quiet == 0) { 4398 print << "EOM"; 4399$vname has style problems, please review. 4400 4401If any of these errors are false positives, please report 4402them to the maintainer, see CHECKPATCH in MAINTAINERS. 4403EOM 4404 } 4405 4406 return $clean; 4407} 4408