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; 9 10my $P = $0; 11$P =~ s@.*/@@g; 12 13my $V = '0.31'; 14 15use Getopt::Long qw(:config no_auto_abbrev); 16 17my $quiet = 0; 18my $tree = 1; 19my $chk_signoff = 1; 20my $chk_patch = 1; 21my $tst_only; 22my $emacs = 0; 23my $terse = 0; 24my $file = 0; 25my $check = 0; 26my $summary = 1; 27my $mailback = 0; 28my $summary_file = 0; 29my $root; 30my %debug; 31my $help = 0; 32 33sub help { 34 my ($exitcode) = @_; 35 36 print << "EOM"; 37Usage: $P [OPTION]... [FILE]... 38Version: $V 39 40Options: 41 -q, --quiet quiet 42 --no-tree run without a kernel tree 43 --no-signoff do not check for 'Signed-off-by' line 44 --patch treat FILE as patchfile (default) 45 --emacs emacs compile window format 46 --terse one line per report 47 -f, --file treat FILE as regular source file 48 --subjective, --strict enable more subjective tests 49 --root=PATH PATH to the kernel tree root 50 --no-summary suppress the per-file summary 51 --mailback only produce a report in case of warnings/errors 52 --summary-file include the filename in summary 53 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of 54 'values', 'possible', 'type', and 'attr' (default 55 is all off) 56 --test-only=WORD report only warnings/errors containing WORD 57 literally 58 -h, --help, --version display this help and exit 59 60When FILE is - read standard input. 61EOM 62 63 exit($exitcode); 64} 65 66GetOptions( 67 'q|quiet+' => \$quiet, 68 'tree!' => \$tree, 69 'signoff!' => \$chk_signoff, 70 'patch!' => \$chk_patch, 71 'emacs!' => \$emacs, 72 'terse!' => \$terse, 73 'f|file!' => \$file, 74 'subjective!' => \$check, 75 'strict!' => \$check, 76 'root=s' => \$root, 77 'summary!' => \$summary, 78 'mailback!' => \$mailback, 79 'summary-file!' => \$summary_file, 80 81 'debug=s' => \%debug, 82 'test-only=s' => \$tst_only, 83 'h|help' => \$help, 84 'version' => \$help 85) or help(1); 86 87help(0) if ($help); 88 89my $exit = 0; 90 91if ($#ARGV < 0) { 92 print "$P: no input files\n"; 93 exit(1); 94} 95 96my $dbg_values = 0; 97my $dbg_possible = 0; 98my $dbg_type = 0; 99my $dbg_attr = 0; 100for my $key (keys %debug) { 101 ## no critic 102 eval "\${dbg_$key} = '$debug{$key}';"; 103 die "$@" if ($@); 104} 105 106my $rpt_cleaners = 0; 107 108if ($terse) { 109 $emacs = 1; 110 $quiet++; 111} 112 113if ($tree) { 114 if (defined $root) { 115 if (!top_of_kernel_tree($root)) { 116 die "$P: $root: --root does not point at a valid tree\n"; 117 } 118 } else { 119 if (top_of_kernel_tree('.')) { 120 $root = '.'; 121 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ && 122 top_of_kernel_tree($1)) { 123 $root = $1; 124 } 125 } 126 127 if (!defined $root) { 128 print "Must be run from the top-level dir. of a kernel tree\n"; 129 exit(2); 130 } 131} 132 133my $emitted_corrupt = 0; 134 135our $Ident = qr{ 136 [A-Za-z_][A-Za-z\d_]* 137 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)* 138 }x; 139our $Storage = qr{extern|static|asmlinkage}; 140our $Sparse = qr{ 141 __user| 142 __kernel| 143 __force| 144 __iomem| 145 __must_check| 146 __init_refok| 147 __kprobes| 148 __ref 149 }x; 150 151# Notes to $Attribute: 152# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check 153our $Attribute = qr{ 154 const| 155 __percpu| 156 __nocast| 157 __safe| 158 __bitwise__| 159 __packed__| 160 __packed2__| 161 __naked| 162 __maybe_unused| 163 __always_unused| 164 __noreturn| 165 __used| 166 __cold| 167 __noclone| 168 __deprecated| 169 __read_mostly| 170 __kprobes| 171 __(?:mem|cpu|dev|)(?:initdata|initconst|init\b)| 172 ____cacheline_aligned| 173 ____cacheline_aligned_in_smp| 174 ____cacheline_internodealigned_in_smp| 175 __weak 176 }x; 177our $Modifier; 178our $Inline = qr{inline|__always_inline|noinline}; 179our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]}; 180our $Lval = qr{$Ident(?:$Member)*}; 181 182our $Constant = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*}; 183our $Assignment = qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)}; 184our $Compare = qr{<=|>=|==|!=|<|>}; 185our $Operators = qr{ 186 <=|>=|==|!=| 187 =>|->|<<|>>|<|>|!|~| 188 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|% 189 }x; 190 191our $NonptrType; 192our $Type; 193our $Declare; 194 195our $UTF8 = qr { 196 [\x09\x0A\x0D\x20-\x7E] # ASCII 197 | [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte 198 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs 199 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte 200 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates 201 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3 202 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15 203 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16 204}x; 205 206our $typeTypedefs = qr{(?x: 207 (?:__)?(?:u|s|be|le)(?:8|16|32|64)| 208 atomic_t 209)}; 210 211our $logFunctions = qr{(?x: 212 printk| 213 pr_(debug|dbg|vdbg|devel|info|warning|err|notice|alert|crit|emerg|cont)| 214 (dev|netdev|netif)_(printk|dbg|vdbg|info|warn|err|notice|alert|crit|emerg|WARN)| 215 WARN| 216 panic 217)}; 218 219our @typeList = ( 220 qr{void}, 221 qr{(?:unsigned\s+)?char}, 222 qr{(?:unsigned\s+)?short}, 223 qr{(?:unsigned\s+)?int}, 224 qr{(?:unsigned\s+)?long}, 225 qr{(?:unsigned\s+)?long\s+int}, 226 qr{(?:unsigned\s+)?long\s+long}, 227 qr{(?:unsigned\s+)?long\s+long\s+int}, 228 qr{unsigned}, 229 qr{float}, 230 qr{double}, 231 qr{bool}, 232 qr{struct\s+$Ident}, 233 qr{union\s+$Ident}, 234 qr{enum\s+$Ident}, 235 qr{${Ident}_t}, 236 qr{${Ident}_handler}, 237 qr{${Ident}_handler_fn}, 238); 239our @modifierList = ( 240 qr{fastcall}, 241); 242 243our $allowed_asm_includes = qr{(?x: 244 irq| 245 memory 246)}; 247# memory.h: ARM has a custom one 248 249sub build_types { 250 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)"; 251 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)"; 252 $Modifier = qr{(?:$Attribute|$Sparse|$mods)}; 253 $NonptrType = qr{ 254 (?:$Modifier\s+|const\s+)* 255 (?: 256 (?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)| 257 (?:$typeTypedefs\b)| 258 (?:${all}\b) 259 ) 260 (?:\s+$Modifier|\s+const)* 261 }x; 262 $Type = qr{ 263 $NonptrType 264 (?:[\s\*]+\s*const|[\s\*]+|(?:\s*\[\s*\])+)? 265 (?:\s+$Inline|\s+$Modifier)* 266 }x; 267 $Declare = qr{(?:$Storage\s+)?$Type}; 268} 269build_types(); 270 271$chk_signoff = 0 if ($file); 272 273my @dep_includes = (); 274my @dep_functions = (); 275my $removal = "Documentation/feature-removal-schedule.txt"; 276if ($tree && -f "$root/$removal") { 277 open(my $REMOVE, '<', "$root/$removal") || 278 die "$P: $removal: open failed - $!\n"; 279 while (<$REMOVE>) { 280 if (/^Check:\s+(.*\S)/) { 281 for my $entry (split(/[, ]+/, $1)) { 282 if ($entry =~ m@include/(.*)@) { 283 push(@dep_includes, $1); 284 285 } elsif ($entry !~ m@/@) { 286 push(@dep_functions, $entry); 287 } 288 } 289 } 290 } 291 close($REMOVE); 292} 293 294my @rawlines = (); 295my @lines = (); 296my $vname; 297for my $filename (@ARGV) { 298 my $FILE; 299 if ($file) { 300 open($FILE, '-|', "diff -u /dev/null $filename") || 301 die "$P: $filename: diff failed - $!\n"; 302 } elsif ($filename eq '-') { 303 open($FILE, '<&STDIN'); 304 } else { 305 open($FILE, '<', "$filename") || 306 die "$P: $filename: open failed - $!\n"; 307 } 308 if ($filename eq '-') { 309 $vname = 'Your patch'; 310 } else { 311 $vname = $filename; 312 } 313 while (<$FILE>) { 314 chomp; 315 push(@rawlines, $_); 316 } 317 close($FILE); 318 if (!process($filename)) { 319 $exit = 1; 320 } 321 @rawlines = (); 322 @lines = (); 323} 324 325exit($exit); 326 327sub top_of_kernel_tree { 328 my ($root) = @_; 329 330 my @tree_check = ( 331 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile", 332 "README", "Documentation", "arch", "include", "drivers", 333 "fs", "init", "ipc", "kernel", "lib", "scripts", 334 ); 335 336 foreach my $check (@tree_check) { 337 if (! -e $root . '/' . $check) { 338 return 0; 339 } 340 } 341 return 1; 342} 343 344sub expand_tabs { 345 my ($str) = @_; 346 347 my $res = ''; 348 my $n = 0; 349 for my $c (split(//, $str)) { 350 if ($c eq "\t") { 351 $res .= ' '; 352 $n++; 353 for (; ($n % 8) != 0; $n++) { 354 $res .= ' '; 355 } 356 next; 357 } 358 $res .= $c; 359 $n++; 360 } 361 362 return $res; 363} 364sub copy_spacing { 365 (my $res = shift) =~ tr/\t/ /c; 366 return $res; 367} 368 369sub line_stats { 370 my ($line) = @_; 371 372 # Drop the diff line leader and expand tabs 373 $line =~ s/^.//; 374 $line = expand_tabs($line); 375 376 # Pick the indent from the front of the line. 377 my ($white) = ($line =~ /^(\s*)/); 378 379 return (length($line), length($white)); 380} 381 382my $sanitise_quote = ''; 383 384sub sanitise_line_reset { 385 my ($in_comment) = @_; 386 387 if ($in_comment) { 388 $sanitise_quote = '*/'; 389 } else { 390 $sanitise_quote = ''; 391 } 392} 393sub sanitise_line { 394 my ($line) = @_; 395 396 my $res = ''; 397 my $l = ''; 398 399 my $qlen = 0; 400 my $off = 0; 401 my $c; 402 403 # Always copy over the diff marker. 404 $res = substr($line, 0, 1); 405 406 for ($off = 1; $off < length($line); $off++) { 407 $c = substr($line, $off, 1); 408 409 # Comments we are wacking completly including the begin 410 # and end, all to $;. 411 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') { 412 $sanitise_quote = '*/'; 413 414 substr($res, $off, 2, "$;$;"); 415 $off++; 416 next; 417 } 418 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') { 419 $sanitise_quote = ''; 420 substr($res, $off, 2, "$;$;"); 421 $off++; 422 next; 423 } 424 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') { 425 $sanitise_quote = '//'; 426 427 substr($res, $off, 2, $sanitise_quote); 428 $off++; 429 next; 430 } 431 432 # A \ in a string means ignore the next character. 433 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') && 434 $c eq "\\") { 435 substr($res, $off, 2, 'XX'); 436 $off++; 437 next; 438 } 439 # Regular quotes. 440 if ($c eq "'" || $c eq '"') { 441 if ($sanitise_quote eq '') { 442 $sanitise_quote = $c; 443 444 substr($res, $off, 1, $c); 445 next; 446 } elsif ($sanitise_quote eq $c) { 447 $sanitise_quote = ''; 448 } 449 } 450 451 #print "c<$c> SQ<$sanitise_quote>\n"; 452 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") { 453 substr($res, $off, 1, $;); 454 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") { 455 substr($res, $off, 1, $;); 456 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") { 457 substr($res, $off, 1, 'X'); 458 } else { 459 substr($res, $off, 1, $c); 460 } 461 } 462 463 if ($sanitise_quote eq '//') { 464 $sanitise_quote = ''; 465 } 466 467 # The pathname on a #include may be surrounded by '<' and '>'. 468 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) { 469 my $clean = 'X' x length($1); 470 $res =~ s@\<.*\>@<$clean>@; 471 472 # The whole of a #error is a string. 473 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) { 474 my $clean = 'X' x length($1); 475 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@; 476 } 477 478 return $res; 479} 480 481sub ctx_statement_block { 482 my ($linenr, $remain, $off) = @_; 483 my $line = $linenr - 1; 484 my $blk = ''; 485 my $soff = $off; 486 my $coff = $off - 1; 487 my $coff_set = 0; 488 489 my $loff = 0; 490 491 my $type = ''; 492 my $level = 0; 493 my @stack = (); 494 my $p; 495 my $c; 496 my $len = 0; 497 498 my $remainder; 499 while (1) { 500 @stack = (['', 0]) if ($#stack == -1); 501 502 #warn "CSB: blk<$blk> remain<$remain>\n"; 503 # If we are about to drop off the end, pull in more 504 # context. 505 if ($off >= $len) { 506 for (; $remain > 0; $line++) { 507 last if (!defined $lines[$line]); 508 next if ($lines[$line] =~ /^-/); 509 $remain--; 510 $loff = $len; 511 $blk .= $lines[$line] . "\n"; 512 $len = length($blk); 513 $line++; 514 last; 515 } 516 # Bail if there is no further context. 517 #warn "CSB: blk<$blk> off<$off> len<$len>\n"; 518 if ($off >= $len) { 519 last; 520 } 521 } 522 $p = $c; 523 $c = substr($blk, $off, 1); 524 $remainder = substr($blk, $off); 525 526 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n"; 527 528 # Handle nested #if/#else. 529 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) { 530 push(@stack, [ $type, $level ]); 531 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) { 532 ($type, $level) = @{$stack[$#stack - 1]}; 533 } elsif ($remainder =~ /^#\s*endif\b/) { 534 ($type, $level) = @{pop(@stack)}; 535 } 536 537 # Statement ends at the ';' or a close '}' at the 538 # outermost level. 539 if ($level == 0 && $c eq ';') { 540 last; 541 } 542 543 # An else is really a conditional as long as its not else if 544 if ($level == 0 && $coff_set == 0 && 545 (!defined($p) || $p =~ /(?:\s|\}|\+)/) && 546 $remainder =~ /^(else)(?:\s|{)/ && 547 $remainder !~ /^else\s+if\b/) { 548 $coff = $off + length($1) - 1; 549 $coff_set = 1; 550 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n"; 551 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n"; 552 } 553 554 if (($type eq '' || $type eq '(') && $c eq '(') { 555 $level++; 556 $type = '('; 557 } 558 if ($type eq '(' && $c eq ')') { 559 $level--; 560 $type = ($level != 0)? '(' : ''; 561 562 if ($level == 0 && $coff < $soff) { 563 $coff = $off; 564 $coff_set = 1; 565 #warn "CSB: mark coff<$coff>\n"; 566 } 567 } 568 if (($type eq '' || $type eq '{') && $c eq '{') { 569 $level++; 570 $type = '{'; 571 } 572 if ($type eq '{' && $c eq '}') { 573 $level--; 574 $type = ($level != 0)? '{' : ''; 575 576 if ($level == 0) { 577 if (substr($blk, $off + 1, 1) eq ';') { 578 $off++; 579 } 580 last; 581 } 582 } 583 $off++; 584 } 585 # We are truly at the end, so shuffle to the next line. 586 if ($off == $len) { 587 $loff = $len + 1; 588 $line++; 589 $remain--; 590 } 591 592 my $statement = substr($blk, $soff, $off - $soff + 1); 593 my $condition = substr($blk, $soff, $coff - $soff + 1); 594 595 #warn "STATEMENT<$statement>\n"; 596 #warn "CONDITION<$condition>\n"; 597 598 #print "coff<$coff> soff<$off> loff<$loff>\n"; 599 600 return ($statement, $condition, 601 $line, $remain + 1, $off - $loff + 1, $level); 602} 603 604sub statement_lines { 605 my ($stmt) = @_; 606 607 # Strip the diff line prefixes and rip blank lines at start and end. 608 $stmt =~ s/(^|\n)./$1/g; 609 $stmt =~ s/^\s*//; 610 $stmt =~ s/\s*$//; 611 612 my @stmt_lines = ($stmt =~ /\n/g); 613 614 return $#stmt_lines + 2; 615} 616 617sub statement_rawlines { 618 my ($stmt) = @_; 619 620 my @stmt_lines = ($stmt =~ /\n/g); 621 622 return $#stmt_lines + 2; 623} 624 625sub statement_block_size { 626 my ($stmt) = @_; 627 628 $stmt =~ s/(^|\n)./$1/g; 629 $stmt =~ s/^\s*{//; 630 $stmt =~ s/}\s*$//; 631 $stmt =~ s/^\s*//; 632 $stmt =~ s/\s*$//; 633 634 my @stmt_lines = ($stmt =~ /\n/g); 635 my @stmt_statements = ($stmt =~ /;/g); 636 637 my $stmt_lines = $#stmt_lines + 2; 638 my $stmt_statements = $#stmt_statements + 1; 639 640 if ($stmt_lines > $stmt_statements) { 641 return $stmt_lines; 642 } else { 643 return $stmt_statements; 644 } 645} 646 647sub ctx_statement_full { 648 my ($linenr, $remain, $off) = @_; 649 my ($statement, $condition, $level); 650 651 my (@chunks); 652 653 # Grab the first conditional/block pair. 654 ($statement, $condition, $linenr, $remain, $off, $level) = 655 ctx_statement_block($linenr, $remain, $off); 656 #print "F: c<$condition> s<$statement> remain<$remain>\n"; 657 push(@chunks, [ $condition, $statement ]); 658 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) { 659 return ($level, $linenr, @chunks); 660 } 661 662 # Pull in the following conditional/block pairs and see if they 663 # could continue the statement. 664 for (;;) { 665 ($statement, $condition, $linenr, $remain, $off, $level) = 666 ctx_statement_block($linenr, $remain, $off); 667 #print "C: c<$condition> s<$statement> remain<$remain>\n"; 668 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s)); 669 #print "C: push\n"; 670 push(@chunks, [ $condition, $statement ]); 671 } 672 673 return ($level, $linenr, @chunks); 674} 675 676sub ctx_block_get { 677 my ($linenr, $remain, $outer, $open, $close, $off) = @_; 678 my $line; 679 my $start = $linenr - 1; 680 my $blk = ''; 681 my @o; 682 my @c; 683 my @res = (); 684 685 my $level = 0; 686 my @stack = ($level); 687 for ($line = $start; $remain > 0; $line++) { 688 next if ($rawlines[$line] =~ /^-/); 689 $remain--; 690 691 $blk .= $rawlines[$line]; 692 693 # Handle nested #if/#else. 694 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) { 695 push(@stack, $level); 696 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) { 697 $level = $stack[$#stack - 1]; 698 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) { 699 $level = pop(@stack); 700 } 701 702 foreach my $c (split(//, $lines[$line])) { 703 ##print "C<$c>L<$level><$open$close>O<$off>\n"; 704 if ($off > 0) { 705 $off--; 706 next; 707 } 708 709 if ($c eq $close && $level > 0) { 710 $level--; 711 last if ($level == 0); 712 } elsif ($c eq $open) { 713 $level++; 714 } 715 } 716 717 if (!$outer || $level <= 1) { 718 push(@res, $rawlines[$line]); 719 } 720 721 last if ($level == 0); 722 } 723 724 return ($level, @res); 725} 726sub ctx_block_outer { 727 my ($linenr, $remain) = @_; 728 729 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0); 730 return @r; 731} 732sub ctx_block { 733 my ($linenr, $remain) = @_; 734 735 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0); 736 return @r; 737} 738sub ctx_statement { 739 my ($linenr, $remain, $off) = @_; 740 741 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off); 742 return @r; 743} 744sub ctx_block_level { 745 my ($linenr, $remain) = @_; 746 747 return ctx_block_get($linenr, $remain, 0, '{', '}', 0); 748} 749sub ctx_statement_level { 750 my ($linenr, $remain, $off) = @_; 751 752 return ctx_block_get($linenr, $remain, 0, '(', ')', $off); 753} 754 755sub ctx_locate_comment { 756 my ($first_line, $end_line) = @_; 757 758 # Catch a comment on the end of the line itself. 759 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@); 760 return $current_comment if (defined $current_comment); 761 762 # Look through the context and try and figure out if there is a 763 # comment. 764 my $in_comment = 0; 765 $current_comment = ''; 766 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) { 767 my $line = $rawlines[$linenr - 1]; 768 #warn " $line\n"; 769 if ($linenr == $first_line and $line =~ m@^.\s*\*@) { 770 $in_comment = 1; 771 } 772 if ($line =~ m@/\*@) { 773 $in_comment = 1; 774 } 775 if (!$in_comment && $current_comment ne '') { 776 $current_comment = ''; 777 } 778 $current_comment .= $line . "\n" if ($in_comment); 779 if ($line =~ m@\*/@) { 780 $in_comment = 0; 781 } 782 } 783 784 chomp($current_comment); 785 return($current_comment); 786} 787sub ctx_has_comment { 788 my ($first_line, $end_line) = @_; 789 my $cmt = ctx_locate_comment($first_line, $end_line); 790 791 ##print "LINE: $rawlines[$end_line - 1 ]\n"; 792 ##print "CMMT: $cmt\n"; 793 794 return ($cmt ne ''); 795} 796 797sub raw_line { 798 my ($linenr, $cnt) = @_; 799 800 my $offset = $linenr - 1; 801 $cnt++; 802 803 my $line; 804 while ($cnt) { 805 $line = $rawlines[$offset++]; 806 next if (defined($line) && $line =~ /^-/); 807 $cnt--; 808 } 809 810 return $line; 811} 812 813sub cat_vet { 814 my ($vet) = @_; 815 my ($res, $coded); 816 817 $res = ''; 818 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) { 819 $res .= $1; 820 if ($2 ne '') { 821 $coded = sprintf("^%c", unpack('C', $2) + 64); 822 $res .= $coded; 823 } 824 } 825 $res =~ s/$/\$/; 826 827 return $res; 828} 829 830my $av_preprocessor = 0; 831my $av_pending; 832my @av_paren_type; 833my $av_pend_colon; 834 835sub annotate_reset { 836 $av_preprocessor = 0; 837 $av_pending = '_'; 838 @av_paren_type = ('E'); 839 $av_pend_colon = 'O'; 840} 841 842sub annotate_values { 843 my ($stream, $type) = @_; 844 845 my $res; 846 my $var = '_' x length($stream); 847 my $cur = $stream; 848 849 print "$stream\n" if ($dbg_values > 1); 850 851 while (length($cur)) { 852 @av_paren_type = ('E') if ($#av_paren_type < 0); 853 print " <" . join('', @av_paren_type) . 854 "> <$type> <$av_pending>" if ($dbg_values > 1); 855 if ($cur =~ /^(\s+)/o) { 856 print "WS($1)\n" if ($dbg_values > 1); 857 if ($1 =~ /\n/ && $av_preprocessor) { 858 $type = pop(@av_paren_type); 859 $av_preprocessor = 0; 860 } 861 862 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') { 863 print "CAST($1)\n" if ($dbg_values > 1); 864 push(@av_paren_type, $type); 865 $type = 'C'; 866 867 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) { 868 print "DECLARE($1)\n" if ($dbg_values > 1); 869 $type = 'T'; 870 871 } elsif ($cur =~ /^($Modifier)\s*/) { 872 print "MODIFIER($1)\n" if ($dbg_values > 1); 873 $type = 'T'; 874 875 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) { 876 print "DEFINE($1,$2)\n" if ($dbg_values > 1); 877 $av_preprocessor = 1; 878 push(@av_paren_type, $type); 879 if ($2 ne '') { 880 $av_pending = 'N'; 881 } 882 $type = 'E'; 883 884 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) { 885 print "UNDEF($1)\n" if ($dbg_values > 1); 886 $av_preprocessor = 1; 887 push(@av_paren_type, $type); 888 889 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) { 890 print "PRE_START($1)\n" if ($dbg_values > 1); 891 $av_preprocessor = 1; 892 893 push(@av_paren_type, $type); 894 push(@av_paren_type, $type); 895 $type = 'E'; 896 897 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) { 898 print "PRE_RESTART($1)\n" if ($dbg_values > 1); 899 $av_preprocessor = 1; 900 901 push(@av_paren_type, $av_paren_type[$#av_paren_type]); 902 903 $type = 'E'; 904 905 } elsif ($cur =~ /^(\#\s*(?:endif))/o) { 906 print "PRE_END($1)\n" if ($dbg_values > 1); 907 908 $av_preprocessor = 1; 909 910 # Assume all arms of the conditional end as this 911 # one does, and continue as if the #endif was not here. 912 pop(@av_paren_type); 913 push(@av_paren_type, $type); 914 $type = 'E'; 915 916 } elsif ($cur =~ /^(\\\n)/o) { 917 print "PRECONT($1)\n" if ($dbg_values > 1); 918 919 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) { 920 print "ATTR($1)\n" if ($dbg_values > 1); 921 $av_pending = $type; 922 $type = 'N'; 923 924 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) { 925 print "SIZEOF($1)\n" if ($dbg_values > 1); 926 if (defined $2) { 927 $av_pending = 'V'; 928 } 929 $type = 'N'; 930 931 } elsif ($cur =~ /^(if|while|for)\b/o) { 932 print "COND($1)\n" if ($dbg_values > 1); 933 $av_pending = 'E'; 934 $type = 'N'; 935 936 } elsif ($cur =~/^(case)/o) { 937 print "CASE($1)\n" if ($dbg_values > 1); 938 $av_pend_colon = 'C'; 939 $type = 'N'; 940 941 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) { 942 print "KEYWORD($1)\n" if ($dbg_values > 1); 943 $type = 'N'; 944 945 } elsif ($cur =~ /^(\()/o) { 946 print "PAREN('$1')\n" if ($dbg_values > 1); 947 push(@av_paren_type, $av_pending); 948 $av_pending = '_'; 949 $type = 'N'; 950 951 } elsif ($cur =~ /^(\))/o) { 952 my $new_type = pop(@av_paren_type); 953 if ($new_type ne '_') { 954 $type = $new_type; 955 print "PAREN('$1') -> $type\n" 956 if ($dbg_values > 1); 957 } else { 958 print "PAREN('$1')\n" if ($dbg_values > 1); 959 } 960 961 } elsif ($cur =~ /^($Ident)\s*\(/o) { 962 print "FUNC($1)\n" if ($dbg_values > 1); 963 $type = 'V'; 964 $av_pending = 'V'; 965 966 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) { 967 if (defined $2 && $type eq 'C' || $type eq 'T') { 968 $av_pend_colon = 'B'; 969 } elsif ($type eq 'E') { 970 $av_pend_colon = 'L'; 971 } 972 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1); 973 $type = 'V'; 974 975 } elsif ($cur =~ /^($Ident|$Constant)/o) { 976 print "IDENT($1)\n" if ($dbg_values > 1); 977 $type = 'V'; 978 979 } elsif ($cur =~ /^($Assignment)/o) { 980 print "ASSIGN($1)\n" if ($dbg_values > 1); 981 $type = 'N'; 982 983 } elsif ($cur =~/^(;|{|})/) { 984 print "END($1)\n" if ($dbg_values > 1); 985 $type = 'E'; 986 $av_pend_colon = 'O'; 987 988 } elsif ($cur =~/^(,)/) { 989 print "COMMA($1)\n" if ($dbg_values > 1); 990 $type = 'C'; 991 992 } elsif ($cur =~ /^(\?)/o) { 993 print "QUESTION($1)\n" if ($dbg_values > 1); 994 $type = 'N'; 995 996 } elsif ($cur =~ /^(:)/o) { 997 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1); 998 999 substr($var, length($res), 1, $av_pend_colon); 1000 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1001 $type = 'E'; 1002 } else { 1003 $type = 'N'; 1004 } 1005 $av_pend_colon = 'O'; 1006 1007 } elsif ($cur =~ /^(\[)/o) { 1008 print "CLOSE($1)\n" if ($dbg_values > 1); 1009 $type = 'N'; 1010 1011 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) { 1012 my $variant; 1013 1014 print "OPV($1)\n" if ($dbg_values > 1); 1015 if ($type eq 'V') { 1016 $variant = 'B'; 1017 } else { 1018 $variant = 'U'; 1019 } 1020 1021 substr($var, length($res), 1, $variant); 1022 $type = 'N'; 1023 1024 } elsif ($cur =~ /^($Operators)/o) { 1025 print "OP($1)\n" if ($dbg_values > 1); 1026 if ($1 ne '++' && $1 ne '--') { 1027 $type = 'N'; 1028 } 1029 1030 } elsif ($cur =~ /(^.)/o) { 1031 print "C($1)\n" if ($dbg_values > 1); 1032 } 1033 if (defined $1) { 1034 $cur = substr($cur, length($1)); 1035 $res .= $type x length($1); 1036 } 1037 } 1038 1039 return ($res, $var); 1040} 1041 1042sub possible { 1043 my ($possible, $line) = @_; 1044 my $notPermitted = qr{(?: 1045 ^(?: 1046 $Modifier| 1047 $Storage| 1048 $Type| 1049 DEFINE_\S+ 1050 )$| 1051 ^(?: 1052 goto| 1053 return| 1054 case| 1055 else| 1056 asm|__asm__| 1057 do 1058 )(?:\s|$)| 1059 ^(?:typedef|struct|enum)\b 1060 )}x; 1061 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2); 1062 if ($possible !~ $notPermitted) { 1063 # Check for modifiers. 1064 $possible =~ s/\s*$Storage\s*//g; 1065 $possible =~ s/\s*$Sparse\s*//g; 1066 if ($possible =~ /^\s*$/) { 1067 1068 } elsif ($possible =~ /\s/) { 1069 $possible =~ s/\s*$Type\s*//g; 1070 for my $modifier (split(' ', $possible)) { 1071 if ($modifier !~ $notPermitted) { 1072 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible); 1073 push(@modifierList, $modifier); 1074 } 1075 } 1076 1077 } else { 1078 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible); 1079 push(@typeList, $possible); 1080 } 1081 build_types(); 1082 } else { 1083 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1); 1084 } 1085} 1086 1087my $prefix = ''; 1088 1089sub report { 1090 if (defined $tst_only && $_[0] !~ /\Q$tst_only\E/) { 1091 return 0; 1092 } 1093 my $line = $prefix . $_[0]; 1094 1095 $line = (split('\n', $line))[0] . "\n" if ($terse); 1096 1097 push(our @report, $line); 1098 1099 return 1; 1100} 1101sub report_dump { 1102 our @report; 1103} 1104sub ERROR { 1105 if (report("ERROR: $_[0]\n")) { 1106 our $clean = 0; 1107 our $cnt_error++; 1108 } 1109} 1110sub WARN { 1111 if (report("WARNING: $_[0]\n")) { 1112 our $clean = 0; 1113 our $cnt_warn++; 1114 } 1115} 1116sub CHK { 1117 if ($check && report("CHECK: $_[0]\n")) { 1118 our $clean = 0; 1119 our $cnt_chk++; 1120 } 1121} 1122 1123sub check_absolute_file { 1124 my ($absolute, $herecurr) = @_; 1125 my $file = $absolute; 1126 1127 ##print "absolute<$absolute>\n"; 1128 1129 # See if any suffix of this path is a path within the tree. 1130 while ($file =~ s@^[^/]*/@@) { 1131 if (-f "$root/$file") { 1132 ##print "file<$file>\n"; 1133 last; 1134 } 1135 } 1136 if (! -f _) { 1137 return 0; 1138 } 1139 1140 # It is, so see if the prefix is acceptable. 1141 my $prefix = $absolute; 1142 substr($prefix, -length($file)) = ''; 1143 1144 ##print "prefix<$prefix>\n"; 1145 if ($prefix ne ".../") { 1146 WARN("use relative pathname instead of absolute in changelog text\n" . $herecurr); 1147 } 1148} 1149 1150sub process { 1151 my $filename = shift; 1152 1153 my $linenr=0; 1154 my $prevline=""; 1155 my $prevrawline=""; 1156 my $stashline=""; 1157 my $stashrawline=""; 1158 1159 my $length; 1160 my $indent; 1161 my $previndent=0; 1162 my $stashindent=0; 1163 1164 our $clean = 1; 1165 my $signoff = 0; 1166 my $is_patch = 0; 1167 1168 our @report = (); 1169 our $cnt_lines = 0; 1170 our $cnt_error = 0; 1171 our $cnt_warn = 0; 1172 our $cnt_chk = 0; 1173 1174 # Trace the real file/line as we go. 1175 my $realfile = ''; 1176 my $realline = 0; 1177 my $realcnt = 0; 1178 my $here = ''; 1179 my $in_comment = 0; 1180 my $comment_edge = 0; 1181 my $first_line = 0; 1182 my $p1_prefix = ''; 1183 1184 my $prev_values = 'E'; 1185 1186 # suppression flags 1187 my %suppress_ifbraces; 1188 my %suppress_whiletrailers; 1189 my %suppress_export; 1190 1191 # Pre-scan the patch sanitizing the lines. 1192 # Pre-scan the patch looking for any __setup documentation. 1193 # 1194 my @setup_docs = (); 1195 my $setup_docs = 0; 1196 1197 sanitise_line_reset(); 1198 my $line; 1199 foreach my $rawline (@rawlines) { 1200 $linenr++; 1201 $line = $rawline; 1202 1203 if ($rawline=~/^\+\+\+\s+(\S+)/) { 1204 $setup_docs = 0; 1205 if ($1 =~ m@Documentation/kernel-parameters.txt$@) { 1206 $setup_docs = 1; 1207 } 1208 #next; 1209 } 1210 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) { 1211 $realline=$1-1; 1212 if (defined $2) { 1213 $realcnt=$3+1; 1214 } else { 1215 $realcnt=1+1; 1216 } 1217 $in_comment = 0; 1218 1219 # Guestimate if this is a continuing comment. Run 1220 # the context looking for a comment "edge". If this 1221 # edge is a close comment then we must be in a comment 1222 # at context start. 1223 my $edge; 1224 my $cnt = $realcnt; 1225 for (my $ln = $linenr + 1; $cnt > 0; $ln++) { 1226 next if (defined $rawlines[$ln - 1] && 1227 $rawlines[$ln - 1] =~ /^-/); 1228 $cnt--; 1229 #print "RAW<$rawlines[$ln - 1]>\n"; 1230 last if (!defined $rawlines[$ln - 1]); 1231 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ && 1232 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) { 1233 ($edge) = $1; 1234 last; 1235 } 1236 } 1237 if (defined $edge && $edge eq '*/') { 1238 $in_comment = 1; 1239 } 1240 1241 # Guestimate if this is a continuing comment. If this 1242 # is the start of a diff block and this line starts 1243 # ' *' then it is very likely a comment. 1244 if (!defined $edge && 1245 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@) 1246 { 1247 $in_comment = 1; 1248 } 1249 1250 ##print "COMMENT:$in_comment edge<$edge> $rawline\n"; 1251 sanitise_line_reset($in_comment); 1252 1253 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) { 1254 # Standardise the strings and chars within the input to 1255 # simplify matching -- only bother with positive lines. 1256 $line = sanitise_line($rawline); 1257 } 1258 push(@lines, $line); 1259 1260 if ($realcnt > 1) { 1261 $realcnt-- if ($line =~ /^(?:\+| |$)/); 1262 } else { 1263 $realcnt = 0; 1264 } 1265 1266 #print "==>$rawline\n"; 1267 #print "-->$line\n"; 1268 1269 if ($setup_docs && $line =~ /^\+/) { 1270 push(@setup_docs, $line); 1271 } 1272 } 1273 1274 $prefix = ''; 1275 1276 $realcnt = 0; 1277 $linenr = 0; 1278 foreach my $line (@lines) { 1279 $linenr++; 1280 1281 my $rawline = $rawlines[$linenr - 1]; 1282 1283#extract the line range in the file after the patch is applied 1284 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) { 1285 $is_patch = 1; 1286 $first_line = $linenr + 1; 1287 $realline=$1-1; 1288 if (defined $2) { 1289 $realcnt=$3+1; 1290 } else { 1291 $realcnt=1+1; 1292 } 1293 annotate_reset(); 1294 $prev_values = 'E'; 1295 1296 %suppress_ifbraces = (); 1297 %suppress_whiletrailers = (); 1298 %suppress_export = (); 1299 next; 1300 1301# track the line number as we move through the hunk, note that 1302# new versions of GNU diff omit the leading space on completely 1303# blank context lines so we need to count that too. 1304 } elsif ($line =~ /^( |\+|$)/) { 1305 $realline++; 1306 $realcnt-- if ($realcnt != 0); 1307 1308 # Measure the line length and indent. 1309 ($length, $indent) = line_stats($rawline); 1310 1311 # Track the previous line. 1312 ($prevline, $stashline) = ($stashline, $line); 1313 ($previndent, $stashindent) = ($stashindent, $indent); 1314 ($prevrawline, $stashrawline) = ($stashrawline, $rawline); 1315 1316 #warn "line<$line>\n"; 1317 1318 } elsif ($realcnt == 1) { 1319 $realcnt--; 1320 } 1321 1322 my $hunk_line = ($realcnt != 0); 1323 1324#make up the handle for any error we report on this line 1325 $prefix = "$filename:$realline: " if ($emacs && $file); 1326 $prefix = "$filename:$linenr: " if ($emacs && !$file); 1327 1328 $here = "#$linenr: " if (!$file); 1329 $here = "#$realline: " if ($file); 1330 1331 # extract the filename as it passes 1332 if ($line =~ /^diff --git.*?(\S+)$/) { 1333 $realfile = $1; 1334 $realfile =~ s@^([^/]*)/@@; 1335 1336 } elsif ($line =~ /^\+\+\+\s+(\S+)/) { 1337 $realfile = $1; 1338 $realfile =~ s@^([^/]*)/@@; 1339 1340 $p1_prefix = $1; 1341 if (!$file && $tree && $p1_prefix ne '' && 1342 -e "$root/$p1_prefix") { 1343 WARN("patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n"); 1344 } 1345 1346 if ($realfile =~ m@^include/asm/@) { 1347 ERROR("do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n"); 1348 } 1349 next; 1350 } 1351 1352 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0); 1353 1354 my $hereline = "$here\n$rawline\n"; 1355 my $herecurr = "$here\n$rawline\n"; 1356 my $hereprev = "$here\n$prevrawline\n$rawline\n"; 1357 1358 $cnt_lines++ if ($realcnt != 0); 1359 1360# Check for incorrect file permissions 1361 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) { 1362 my $permhere = $here . "FILE: $realfile\n"; 1363 if ($realfile =~ /(Makefile|Kconfig|\.c|\.h|\.S|\.tmpl)$/) { 1364 ERROR("do not set execute permissions for source files\n" . $permhere); 1365 } 1366 } 1367 1368#check the patch for a signoff: 1369 if ($line =~ /^\s*signed-off-by:/i) { 1370 # This is a signoff, if ugly, so do not double report. 1371 $signoff++; 1372 if (!($line =~ /^\s*Signed-off-by:/)) { 1373 WARN("Signed-off-by: is the preferred form\n" . 1374 $herecurr); 1375 } 1376 if ($line =~ /^\s*signed-off-by:\S/i) { 1377 WARN("space required after Signed-off-by:\n" . 1378 $herecurr); 1379 } 1380 } 1381 1382# Check for wrappage within a valid hunk of the file 1383 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) { 1384 ERROR("patch seems to be corrupt (line wrapped?)\n" . 1385 $herecurr) if (!$emitted_corrupt++); 1386 } 1387 1388# Check for absolute kernel paths. 1389 if ($tree) { 1390 while ($line =~ m{(?:^|\s)(/\S*)}g) { 1391 my $file = $1; 1392 1393 if ($file =~ m{^(.*?)(?::\d+)+:?$} && 1394 check_absolute_file($1, $herecurr)) { 1395 # 1396 } else { 1397 check_absolute_file($file, $herecurr); 1398 } 1399 } 1400 } 1401 1402# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php 1403 if (($realfile =~ /^$/ || $line =~ /^\+/) && 1404 $rawline !~ m/^$UTF8*$/) { 1405 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/); 1406 1407 my $blank = copy_spacing($rawline); 1408 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^"; 1409 my $hereptr = "$hereline$ptr\n"; 1410 1411 ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr); 1412 } 1413 1414# ignore non-hunk lines and lines being removed 1415 next if (!$hunk_line || $line =~ /^-/); 1416 1417#trailing whitespace 1418 if ($line =~ /^\+.*\015/) { 1419 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 1420 ERROR("DOS line endings\n" . $herevet); 1421 1422 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) { 1423 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 1424 ERROR("trailing whitespace\n" . $herevet); 1425 $rpt_cleaners = 1; 1426 } 1427 1428# check for Kconfig help text having a real description 1429# Only applies when adding the entry originally, after that we do not have 1430# sufficient context to determine whether it is indeed long enough. 1431 if ($realfile =~ /Kconfig/ && 1432 $line =~ /\+\s*(?:---)?help(?:---)?$/) { 1433 my $length = 0; 1434 my $cnt = $realcnt; 1435 my $ln = $linenr + 1; 1436 my $f; 1437 my $is_end = 0; 1438 while ($cnt > 0 && defined $lines[$ln - 1]) { 1439 $f = $lines[$ln - 1]; 1440 $cnt-- if ($lines[$ln - 1] !~ /^-/); 1441 $is_end = $lines[$ln - 1] =~ /^\+/; 1442 $ln++; 1443 1444 next if ($f =~ /^-/); 1445 $f =~ s/^.//; 1446 $f =~ s/#.*//; 1447 $f =~ s/^\s+//; 1448 next if ($f =~ /^$/); 1449 if ($f =~ /^\s*config\s/) { 1450 $is_end = 1; 1451 last; 1452 } 1453 $length++; 1454 } 1455 WARN("please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_end && $length < 4); 1456 #print "is_end<$is_end> length<$length>\n"; 1457 } 1458 1459# check we are in a valid source file if not then ignore this hunk 1460 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/); 1461 1462#80 column limit 1463 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ && 1464 $rawline !~ /^.\s*\*\s*\@$Ident\s/ && 1465 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:,|\)\s*;)\s*$/ || 1466 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) && 1467 $length > 80) 1468 { 1469 WARN("line over 80 characters\n" . $herecurr); 1470 } 1471 1472# check for spaces before a quoted newline 1473 if ($rawline =~ /^.*\".*\s\\n/) { 1474 WARN("unnecessary whitespace before a quoted newline\n" . $herecurr); 1475 } 1476 1477# check for adding lines without a newline. 1478 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) { 1479 WARN("adding a line without newline at end of file\n" . $herecurr); 1480 } 1481 1482# Blackfin: use hi/lo macros 1483 if ($realfile =~ m@arch/blackfin/.*\.S$@) { 1484 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) { 1485 my $herevet = "$here\n" . cat_vet($line) . "\n"; 1486 ERROR("use the LO() macro, not (... & 0xFFFF)\n" . $herevet); 1487 } 1488 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) { 1489 my $herevet = "$here\n" . cat_vet($line) . "\n"; 1490 ERROR("use the HI() macro, not (... >> 16)\n" . $herevet); 1491 } 1492 } 1493 1494# check we are in a valid source file C or perl if not then ignore this hunk 1495 next if ($realfile !~ /\.(h|c|pl)$/); 1496 1497# at the beginning of a line any tabs must come first and anything 1498# more than 8 must use tabs. 1499 if ($rawline =~ /^\+\s* \t\s*\S/ || 1500 $rawline =~ /^\+\s* \s*/) { 1501 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 1502 ERROR("code indent should use tabs where possible\n" . $herevet); 1503 $rpt_cleaners = 1; 1504 } 1505 1506# check for space before tabs. 1507 if ($rawline =~ /^\+/ && $rawline =~ / \t/) { 1508 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 1509 WARN("please, no space before tabs\n" . $herevet); 1510 } 1511 1512# check for spaces at the beginning of a line. 1513# Exceptions: 1514# 1) within comments 1515# 2) indented preprocessor commands 1516# 3) hanging labels 1517 if ($rawline =~ /^\+ / && $line !~ /\+ *(?:$;|#|$Ident:)/) { 1518 my $herevet = "$here\n" . cat_vet($rawline) . "\n"; 1519 WARN("please, no spaces at the start of a line\n" . $herevet); 1520 } 1521 1522# check we are in a valid C source file if not then ignore this hunk 1523 next if ($realfile !~ /\.(h|c)$/); 1524 1525# check for RCS/CVS revision markers 1526 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) { 1527 WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr); 1528 } 1529 1530# Blackfin: don't use __builtin_bfin_[cs]sync 1531 if ($line =~ /__builtin_bfin_csync/) { 1532 my $herevet = "$here\n" . cat_vet($line) . "\n"; 1533 ERROR("use the CSYNC() macro in asm/blackfin.h\n" . $herevet); 1534 } 1535 if ($line =~ /__builtin_bfin_ssync/) { 1536 my $herevet = "$here\n" . cat_vet($line) . "\n"; 1537 ERROR("use the SSYNC() macro in asm/blackfin.h\n" . $herevet); 1538 } 1539 1540# Check for potential 'bare' types 1541 my ($stat, $cond, $line_nr_next, $remain_next, $off_next, 1542 $realline_next); 1543 if ($realcnt && $line =~ /.\s*\S/) { 1544 ($stat, $cond, $line_nr_next, $remain_next, $off_next) = 1545 ctx_statement_block($linenr, $realcnt, 0); 1546 $stat =~ s/\n./\n /g; 1547 $cond =~ s/\n./\n /g; 1548 1549 # Find the real next line. 1550 $realline_next = $line_nr_next; 1551 if (defined $realline_next && 1552 (!defined $lines[$realline_next - 1] || 1553 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) { 1554 $realline_next++; 1555 } 1556 1557 my $s = $stat; 1558 $s =~ s/{.*$//s; 1559 1560 # Ignore goto labels. 1561 if ($s =~ /$Ident:\*$/s) { 1562 1563 # Ignore functions being called 1564 } elsif ($s =~ /^.\s*$Ident\s*\(/s) { 1565 1566 } elsif ($s =~ /^.\s*else\b/s) { 1567 1568 # declarations always start with types 1569 } 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) { 1570 my $type = $1; 1571 $type =~ s/\s+/ /g; 1572 possible($type, "A:" . $s); 1573 1574 # definitions in global scope can only start with types 1575 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) { 1576 possible($1, "B:" . $s); 1577 } 1578 1579 # any (foo ... *) is a pointer cast, and foo is a type 1580 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) { 1581 possible($1, "C:" . $s); 1582 } 1583 1584 # Check for any sort of function declaration. 1585 # int foo(something bar, other baz); 1586 # void (*store_gdt)(x86_descr_ptr *); 1587 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) { 1588 my ($name_len) = length($1); 1589 1590 my $ctx = $s; 1591 substr($ctx, 0, $name_len + 1, ''); 1592 $ctx =~ s/\)[^\)]*$//; 1593 1594 for my $arg (split(/\s*,\s*/, $ctx)) { 1595 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) { 1596 1597 possible($1, "D:" . $s); 1598 } 1599 } 1600 } 1601 1602 } 1603 1604# 1605# Checks which may be anchored in the context. 1606# 1607 1608# Check for switch () and associated case and default 1609# statements should be at the same indent. 1610 if ($line=~/\bswitch\s*\(.*\)/) { 1611 my $err = ''; 1612 my $sep = ''; 1613 my @ctx = ctx_block_outer($linenr, $realcnt); 1614 shift(@ctx); 1615 for my $ctx (@ctx) { 1616 my ($clen, $cindent) = line_stats($ctx); 1617 if ($ctx =~ /^\+\s*(case\s+|default:)/ && 1618 $indent != $cindent) { 1619 $err .= "$sep$ctx\n"; 1620 $sep = ''; 1621 } else { 1622 $sep = "[...]\n"; 1623 } 1624 } 1625 if ($err ne '') { 1626 ERROR("switch and case should be at the same indent\n$hereline$err"); 1627 } 1628 } 1629 1630# if/while/etc brace do not go on next line, unless defining a do while loop, 1631# or if that brace on the next line is for something else 1632 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) { 1633 my $pre_ctx = "$1$2"; 1634 1635 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0); 1636 my $ctx_cnt = $realcnt - $#ctx - 1; 1637 my $ctx = join("\n", @ctx); 1638 1639 my $ctx_ln = $linenr; 1640 my $ctx_skip = $realcnt; 1641 1642 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt && 1643 defined $lines[$ctx_ln - 1] && 1644 $lines[$ctx_ln - 1] =~ /^-/)) { 1645 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n"; 1646 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/); 1647 $ctx_ln++; 1648 } 1649 1650 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n"; 1651 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n"; 1652 1653 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) { 1654 ERROR("that open brace { should be on the previous line\n" . 1655 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n"); 1656 } 1657 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ && 1658 $ctx =~ /\)\s*\;\s*$/ && 1659 defined $lines[$ctx_ln - 1]) 1660 { 1661 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]); 1662 if ($nindent > $indent) { 1663 WARN("trailing semicolon indicates no statements, indent implies otherwise\n" . 1664 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n"); 1665 } 1666 } 1667 } 1668 1669# Check relative indent for conditionals and blocks. 1670 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) { 1671 my ($s, $c) = ($stat, $cond); 1672 1673 substr($s, 0, length($c), ''); 1674 1675 # Make sure we remove the line prefixes as we have 1676 # none on the first line, and are going to readd them 1677 # where necessary. 1678 $s =~ s/\n./\n/gs; 1679 1680 # Find out how long the conditional actually is. 1681 my @newlines = ($c =~ /\n/gs); 1682 my $cond_lines = 1 + $#newlines; 1683 1684 # We want to check the first line inside the block 1685 # starting at the end of the conditional, so remove: 1686 # 1) any blank line termination 1687 # 2) any opening brace { on end of the line 1688 # 3) any do (...) { 1689 my $continuation = 0; 1690 my $check = 0; 1691 $s =~ s/^.*\bdo\b//; 1692 $s =~ s/^\s*{//; 1693 if ($s =~ s/^\s*\\//) { 1694 $continuation = 1; 1695 } 1696 if ($s =~ s/^\s*?\n//) { 1697 $check = 1; 1698 $cond_lines++; 1699 } 1700 1701 # Also ignore a loop construct at the end of a 1702 # preprocessor statement. 1703 if (($prevline =~ /^.\s*#\s*define\s/ || 1704 $prevline =~ /\\\s*$/) && $continuation == 0) { 1705 $check = 0; 1706 } 1707 1708 my $cond_ptr = -1; 1709 $continuation = 0; 1710 while ($cond_ptr != $cond_lines) { 1711 $cond_ptr = $cond_lines; 1712 1713 # If we see an #else/#elif then the code 1714 # is not linear. 1715 if ($s =~ /^\s*\#\s*(?:else|elif)/) { 1716 $check = 0; 1717 } 1718 1719 # Ignore: 1720 # 1) blank lines, they should be at 0, 1721 # 2) preprocessor lines, and 1722 # 3) labels. 1723 if ($continuation || 1724 $s =~ /^\s*?\n/ || 1725 $s =~ /^\s*#\s*?/ || 1726 $s =~ /^\s*$Ident\s*:/) { 1727 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0; 1728 if ($s =~ s/^.*?\n//) { 1729 $cond_lines++; 1730 } 1731 } 1732 } 1733 1734 my (undef, $sindent) = line_stats("+" . $s); 1735 my $stat_real = raw_line($linenr, $cond_lines); 1736 1737 # Check if either of these lines are modified, else 1738 # this is not this patch's fault. 1739 if (!defined($stat_real) || 1740 $stat !~ /^\+/ && $stat_real !~ /^\+/) { 1741 $check = 0; 1742 } 1743 if (defined($stat_real) && $cond_lines > 1) { 1744 $stat_real = "[...]\n$stat_real"; 1745 } 1746 1747 #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"; 1748 1749 if ($check && (($sindent % 8) != 0 || 1750 ($sindent <= $indent && $s ne ''))) { 1751 WARN("suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n"); 1752 } 1753 } 1754 1755 # Track the 'values' across context and added lines. 1756 my $opline = $line; $opline =~ s/^./ /; 1757 my ($curr_values, $curr_vars) = 1758 annotate_values($opline . "\n", $prev_values); 1759 $curr_values = $prev_values . $curr_values; 1760 if ($dbg_values) { 1761 my $outline = $opline; $outline =~ s/\t/ /g; 1762 print "$linenr > .$outline\n"; 1763 print "$linenr > $curr_values\n"; 1764 print "$linenr > $curr_vars\n"; 1765 } 1766 $prev_values = substr($curr_values, -1); 1767 1768#ignore lines not being added 1769 if ($line=~/^[^\+]/) {next;} 1770 1771# TEST: allow direct testing of the type matcher. 1772 if ($dbg_type) { 1773 if ($line =~ /^.\s*$Declare\s*$/) { 1774 ERROR("TEST: is type\n" . $herecurr); 1775 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) { 1776 ERROR("TEST: is not type ($1 is)\n". $herecurr); 1777 } 1778 next; 1779 } 1780# TEST: allow direct testing of the attribute matcher. 1781 if ($dbg_attr) { 1782 if ($line =~ /^.\s*$Modifier\s*$/) { 1783 ERROR("TEST: is attr\n" . $herecurr); 1784 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) { 1785 ERROR("TEST: is not attr ($1 is)\n". $herecurr); 1786 } 1787 next; 1788 } 1789 1790# check for initialisation to aggregates open brace on the next line 1791 if ($line =~ /^.\s*{/ && 1792 $prevline =~ /(?:^|[^=])=\s*$/) { 1793 ERROR("that open brace { should be on the previous line\n" . $hereprev); 1794 } 1795 1796# 1797# Checks which are anchored on the added line. 1798# 1799 1800# check for malformed paths in #include statements (uses RAW line) 1801 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) { 1802 my $path = $1; 1803 if ($path =~ m{//}) { 1804 ERROR("malformed #include filename\n" . 1805 $herecurr); 1806 } 1807 } 1808 1809# no C99 // comments 1810 if ($line =~ m{//}) { 1811 ERROR("do not use C99 // comments\n" . $herecurr); 1812 } 1813 # Remove C99 comments. 1814 $line =~ s@//.*@@; 1815 $opline =~ s@//.*@@; 1816 1817# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider 1818# the whole statement. 1819#print "APW <$lines[$realline_next - 1]>\n"; 1820 if (defined $realline_next && 1821 exists $lines[$realline_next - 1] && 1822 !defined $suppress_export{$realline_next} && 1823 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ || 1824 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) { 1825 # Handle definitions which produce identifiers with 1826 # a prefix: 1827 # XXX(foo); 1828 # EXPORT_SYMBOL(something_foo); 1829 my $name = $1; 1830 if ($stat =~ /^.([A-Z_]+)\s*\(\s*($Ident)/ && 1831 $name =~ /^${Ident}_$2/) { 1832#print "FOO C name<$name>\n"; 1833 $suppress_export{$realline_next} = 1; 1834 1835 } elsif ($stat !~ /(?: 1836 \n.}\s*$| 1837 ^.DEFINE_$Ident\(\Q$name\E\)| 1838 ^.DECLARE_$Ident\(\Q$name\E\)| 1839 ^.LIST_HEAD\(\Q$name\E\)| 1840 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(| 1841 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\() 1842 )/x) { 1843#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n"; 1844 $suppress_export{$realline_next} = 2; 1845 } else { 1846 $suppress_export{$realline_next} = 1; 1847 } 1848 } 1849 if (!defined $suppress_export{$linenr} && 1850 $prevline =~ /^.\s*$/ && 1851 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ || 1852 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) { 1853#print "FOO B <$lines[$linenr - 1]>\n"; 1854 $suppress_export{$linenr} = 2; 1855 } 1856 if (defined $suppress_export{$linenr} && 1857 $suppress_export{$linenr} == 2) { 1858 WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr); 1859 } 1860 1861# check for global initialisers. 1862 if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) { 1863 ERROR("do not initialise globals to 0 or NULL\n" . 1864 $herecurr); 1865 } 1866# check for static initialisers. 1867 if ($line =~ /\bstatic\s.*=\s*(0|NULL|false)\s*;/) { 1868 ERROR("do not initialise statics to 0 or NULL\n" . 1869 $herecurr); 1870 } 1871 1872# check for static const char * arrays. 1873 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) { 1874 WARN("static const char * array should probably be static const char * const\n" . 1875 $herecurr); 1876 } 1877 1878# check for static char foo[] = "bar" declarations. 1879 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) { 1880 WARN("static char array declaration should probably be static const char\n" . 1881 $herecurr); 1882 } 1883 1884# check for declarations of struct pci_device_id 1885 if ($line =~ /\bstruct\s+pci_device_id\s+\w+\s*\[\s*\]\s*\=\s*\{/) { 1886 WARN("Use DEFINE_PCI_DEVICE_TABLE for struct pci_device_id\n" . $herecurr); 1887 } 1888 1889# check for new typedefs, only function parameters and sparse annotations 1890# make sense. 1891 if ($line =~ /\btypedef\s/ && 1892 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ && 1893 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ && 1894 $line !~ /\b$typeTypedefs\b/ && 1895 $line !~ /\b__bitwise(?:__|)\b/) { 1896 WARN("do not add new typedefs\n" . $herecurr); 1897 } 1898 1899# * goes on variable not on type 1900 # (char*[ const]) 1901 if ($line =~ m{\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\)}) { 1902 my ($from, $to) = ($1, $1); 1903 1904 # Should start with a space. 1905 $to =~ s/^(\S)/ $1/; 1906 # Should not end with a space. 1907 $to =~ s/\s+$//; 1908 # '*'s should not have spaces between. 1909 while ($to =~ s/\*\s+\*/\*\*/) { 1910 } 1911 1912 #print "from<$from> to<$to>\n"; 1913 if ($from ne $to) { 1914 ERROR("\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr); 1915 } 1916 } elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) { 1917 my ($from, $to, $ident) = ($1, $1, $2); 1918 1919 # Should start with a space. 1920 $to =~ s/^(\S)/ $1/; 1921 # Should not end with a space. 1922 $to =~ s/\s+$//; 1923 # '*'s should not have spaces between. 1924 while ($to =~ s/\*\s+\*/\*\*/) { 1925 } 1926 # Modifiers should have spaces. 1927 $to =~ s/(\b$Modifier$)/$1 /; 1928 1929 #print "from<$from> to<$to> ident<$ident>\n"; 1930 if ($from ne $to && $ident !~ /^$Modifier$/) { 1931 ERROR("\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr); 1932 } 1933 } 1934 1935# # no BUG() or BUG_ON() 1936# if ($line =~ /\b(BUG|BUG_ON)\b/) { 1937# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n"; 1938# print "$herecurr"; 1939# $clean = 0; 1940# } 1941 1942 if ($line =~ /\bLINUX_VERSION_CODE\b/) { 1943 WARN("LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr); 1944 } 1945 1946# printk should use KERN_* levels. Note that follow on printk's on the 1947# same line do not need a level, so we use the current block context 1948# to try and find and validate the current printk. In summary the current 1949# printk includes all preceeding printk's which have no newline on the end. 1950# we assume the first bad printk is the one to report. 1951 if ($line =~ /\bprintk\((?!KERN_)\s*"/) { 1952 my $ok = 0; 1953 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) { 1954 #print "CHECK<$lines[$ln - 1]\n"; 1955 # we have a preceeding printk if it ends 1956 # with "\n" ignore it, else it is to blame 1957 if ($lines[$ln - 1] =~ m{\bprintk\(}) { 1958 if ($rawlines[$ln - 1] !~ m{\\n"}) { 1959 $ok = 1; 1960 } 1961 last; 1962 } 1963 } 1964 if ($ok == 0) { 1965 WARN("printk() should include KERN_ facility level\n" . $herecurr); 1966 } 1967 } 1968 1969# function brace can't be on same line, except for #defines of do while, 1970# or if closed on same line 1971 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and 1972 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) { 1973 ERROR("open brace '{' following function declarations go on the next line\n" . $herecurr); 1974 } 1975 1976# open braces for enum, union and struct go on the same line. 1977 if ($line =~ /^.\s*{/ && 1978 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) { 1979 ERROR("open brace '{' following $1 go on the same line\n" . $hereprev); 1980 } 1981 1982# missing space after union, struct or enum definition 1983 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?(?:\s+$Ident)?[=\{]/) { 1984 WARN("missing space after $1 definition\n" . $herecurr); 1985 } 1986 1987# check for spacing round square brackets; allowed: 1988# 1. with a type on the left -- int [] a; 1989# 2. at the beginning of a line for slice initialisers -- [0...10] = 5, 1990# 3. inside a curly brace -- = { [0...10] = 5 } 1991 while ($line =~ /(.*?\s)\[/g) { 1992 my ($where, $prefix) = ($-[1], $1); 1993 if ($prefix !~ /$Type\s+$/ && 1994 ($where != 0 || $prefix !~ /^.\s+$/) && 1995 $prefix !~ /{\s+$/) { 1996 ERROR("space prohibited before open square bracket '['\n" . $herecurr); 1997 } 1998 } 1999 2000# check for spaces between functions and their parentheses.
2001 while ($line =~ /($Ident)\s+\(/g) { 2002 my $name = $1; 2003 my $ctx_before = substr($line, 0, $-[1]); 2004 my $ctx = "$ctx_before$name"; 2005 2006 # Ignore those directives where spaces _are_ permitted. 2007 if ($name =~ /^(?: 2008 if|for|while|switch|return|case| 2009 volatile|__volatile__| 2010 __attribute__|format|__extension__| 2011 asm|__asm__)$/x) 2012 { 2013 2014 # cpp #define statements have non-optional spaces, ie 2015 # if there is a space between the name and the open 2016 # parenthesis it is simply not a parameter group. 2017 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) { 2018 2019 # cpp #elif statement condition may start with a ( 2020 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) { 2021 2022 # If this whole things ends with a type its most 2023 # likely a typedef for a function. 2024 } elsif ($ctx =~ /$Type$/) { 2025 2026 } else { 2027 WARN("space prohibited between function name and open parenthesis '('\n" . $herecurr); 2028 } 2029 } 2030# Check operator spacing. 2031 if (!($line=~/\#\s*include/)) { 2032 my $ops = qr{ 2033 <<=|>>=|<=|>=|==|!=| 2034 \+=|-=|\*=|\/=|%=|\^=|\|=|&=| 2035 =>|->|<<|>>|<|>|=|!|~| 2036 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%| 2037 \?|: 2038 }x; 2039 my @elements = split(/($ops|;)/, $opline); 2040 my $off = 0; 2041 2042 my $blank = copy_spacing($opline); 2043 2044 for (my $n = 0; $n < $#elements; $n += 2) { 2045 $off += length($elements[$n]); 2046 2047 # Pick up the preceeding and succeeding characters. 2048 my $ca = substr($opline, 0, $off); 2049 my $cc = ''; 2050 if (length($opline) >= ($off + length($elements[$n + 1]))) { 2051 $cc = substr($opline, $off + length($elements[$n + 1])); 2052 } 2053 my $cb = "$ca$;$cc"; 2054 2055 my $a = ''; 2056 $a = 'V' if ($elements[$n] ne ''); 2057 $a = 'W' if ($elements[$n] =~ /\s$/); 2058 $a = 'C' if ($elements[$n] =~ /$;$/); 2059 $a = 'B' if ($elements[$n] =~ /(\[|\()$/); 2060 $a = 'O' if ($elements[$n] eq ''); 2061 $a = 'E' if ($ca =~ /^\s*$/); 2062 2063 my $op = $elements[$n + 1]; 2064 2065 my $c = ''; 2066 if (defined $elements[$n + 2]) { 2067 $c = 'V' if ($elements[$n + 2] ne ''); 2068 $c = 'W' if ($elements[$n + 2] =~ /^\s/); 2069 $c = 'C' if ($elements[$n + 2] =~ /^$;/); 2070 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/); 2071 $c = 'O' if ($elements[$n + 2] eq ''); 2072 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/); 2073 } else { 2074 $c = 'E'; 2075 } 2076 2077 my $ctx = "${a}x${c}"; 2078 2079 my $at = "(ctx:$ctx)"; 2080 2081 my $ptr = substr($blank, 0, $off) . "^"; 2082 my $hereptr = "$hereline$ptr\n"; 2083 2084 # Pull out the value of this operator. 2085 my $op_type = substr($curr_values, $off + 1, 1); 2086 2087 # Get the full operator variant. 2088 my $opv = $op . substr($curr_vars, $off, 1); 2089 2090 # Ignore operators passed as parameters. 2091 if ($op_type ne 'V' && 2092 $ca =~ /\s$/ && $cc =~ /^\s*,/) { 2093 2094# # Ignore comments 2095# } elsif ($op =~ /^$;+$/) { 2096 2097 # ; should have either the end of line or a space or \ after it 2098 } elsif ($op eq ';') { 2099 if ($ctx !~ /.x[WEBC]/ && 2100 $cc !~ /^\\/ && $cc !~ /^;/) { 2101 ERROR("space required after that '$op' $at\n" . $hereptr); 2102 } 2103 2104 # // is a comment 2105 } elsif ($op eq '//') { 2106 2107 # No spaces for: 2108 # -> 2109 # : when part of a bitfield 2110 } elsif ($op eq '->' || $opv eq ':B') { 2111 if ($ctx =~ /Wx.|.xW/) { 2112 ERROR("spaces prohibited around that '$op' $at\n" . $hereptr); 2113 } 2114 2115 # , must have a space on the right. 2116 } elsif ($op eq ',') { 2117 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) { 2118 ERROR("space required after that '$op' $at\n" . $hereptr); 2119 } 2120 2121 # '*' as part of a type definition -- reported already. 2122 } elsif ($opv eq '*_') { 2123 #warn "'*' is part of type\n"; 2124 2125 # unary operators should have a space before and 2126 # none after. May be left adjacent to another 2127 # unary operator, or a cast 2128 } elsif ($op eq '!' || $op eq '~' || 2129 $opv eq '*U' || $opv eq '-U' || 2130 $opv eq '&U' || $opv eq '&&U') { 2131 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) { 2132 ERROR("space required before that '$op' $at\n" . $hereptr); 2133 } 2134 if ($op eq '*' && $cc =~/\s*$Modifier\b/) { 2135 # A unary '*' may be const 2136 2137 } elsif ($ctx =~ /.xW/) { 2138 ERROR("space prohibited after that '$op' $at\n" . $hereptr); 2139 } 2140 2141 # unary ++ and unary -- are allowed no space on one side. 2142 } elsif ($op eq '++' or $op eq '--') { 2143 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) { 2144 ERROR("space required one side of that '$op' $at\n" . $hereptr); 2145 } 2146 if ($ctx =~ /Wx[BE]/ || 2147 ($ctx =~ /Wx./ && $cc =~ /^;/)) { 2148 ERROR("space prohibited before that '$op' $at\n" . $hereptr); 2149 } 2150 if ($ctx =~ /ExW/) { 2151 ERROR("space prohibited after that '$op' $at\n" . $hereptr); 2152 } 2153 2154 2155 # << and >> may either have or not have spaces both sides 2156 } elsif ($op eq '<<' or $op eq '>>' or 2157 $op eq '&' or $op eq '^' or $op eq '|' or 2158 $op eq '+' or $op eq '-' or 2159 $op eq '*' or $op eq '/' or 2160 $op eq '%') 2161 { 2162 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) { 2163 ERROR("need consistent spacing around '$op' $at\n" . 2164 $hereptr); 2165 } 2166 2167 # A colon needs no spaces before when it is 2168 # terminating a case value or a label. 2169 } elsif ($opv eq ':C' || $opv eq ':L') { 2170 if ($ctx =~ /Wx./) { 2171 ERROR("space prohibited before that '$op' $at\n" . $hereptr); 2172 } 2173 2174 # All the others need spaces both sides. 2175 } elsif ($ctx !~ /[EWC]x[CWE]/) { 2176 my $ok = 0; 2177 2178 # Ignore email addresses <foo@bar> 2179 if (($op eq '<' && 2180 $cc =~ /^\S+\@\S+>/) || 2181 ($op eq '>' && 2182 $ca =~ /<\S+\@\S+$/)) 2183 { 2184 $ok = 1; 2185 } 2186 2187 # Ignore ?: 2188 if (($opv eq ':O' && $ca =~ /\?$/) || 2189 ($op eq '?' && $cc =~ /^:/)) { 2190 $ok = 1; 2191 } 2192 2193 if ($ok == 0) { 2194 ERROR("spaces required around that '$op' $at\n" . $hereptr); 2195 } 2196 } 2197 $off += length($elements[$n + 1]); 2198 } 2199 } 2200 2201# check for multiple assignments 2202 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) { 2203 CHK("multiple assignments should be avoided\n" . $herecurr); 2204 } 2205 2206## # check for multiple declarations, allowing for a function declaration 2207## # continuation. 2208## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ && 2209## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) { 2210## 2211## # Remove any bracketed sections to ensure we do not 2212## # falsly report the parameters of functions. 2213## my $ln = $line; 2214## while ($ln =~ s/\([^\(\)]*\)//g) { 2215## } 2216## if ($ln =~ /,/) { 2217## WARN("declaring multiple variables together should be avoided\n" . $herecurr); 2218## } 2219## } 2220 2221#need space before brace following if, while, etc 2222 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) || 2223 $line =~ /do{/) { 2224 ERROR("space required before the open brace '{'\n" . $herecurr); 2225 } 2226 2227# closing brace should have a space following it when it has anything 2228# on the line 2229 if ($line =~ /}(?!(?:,|;|\)))\S/) { 2230 ERROR("space required after that close brace '}'\n" . $herecurr); 2231 } 2232 2233# check spacing on square brackets 2234 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) { 2235 ERROR("space prohibited after that open square bracket '['\n" . $herecurr); 2236 } 2237 if ($line =~ /\s\]/) { 2238 ERROR("space prohibited before that close square bracket ']'\n" . $herecurr); 2239 } 2240 2241# check spacing on parentheses 2242 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ && 2243 $line !~ /for\s*\(\s+;/) { 2244 ERROR("space prohibited after that open parenthesis '('\n" . $herecurr); 2245 } 2246 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ && 2247 $line !~ /for\s*\(.*;\s+\)/ && 2248 $line !~ /:\s+\)/) { 2249 ERROR("space prohibited before that close parenthesis ')'\n" . $herecurr); 2250 } 2251 2252#goto labels aren't indented, allow a single space however 2253 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and 2254 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) { 2255 WARN("labels should not be indented\n" . $herecurr); 2256 } 2257 2258# Return is not a function. 2259 if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) { 2260 my $spacing = $1; 2261 my $value = $2; 2262 2263 # Flatten any parentheses 2264 $value =~ s/\(/ \(/g; 2265 $value =~ s/\)/\) /g; 2266 while ($value =~ s/\[[^\{\}]*\]/1/ || 2267 $value !~ /(?:$Ident|-?$Constant)\s* 2268 $Compare\s* 2269 (?:$Ident|-?$Constant)/x && 2270 $value =~ s/\([^\(\)]*\)/1/) { 2271 } 2272#print "value<$value>\n"; 2273 if ($value =~ /^\s*(?:$Ident|-?$Constant)\s*$/) { 2274 ERROR("return is not a function, parentheses are not required\n" . $herecurr); 2275 2276 } elsif ($spacing !~ /\s+/) { 2277 ERROR("space required before the open parenthesis '('\n" . $herecurr); 2278 } 2279 } 2280# Return of what appears to be an errno should normally be -'ve 2281 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) { 2282 my $name = $1; 2283 if ($name ne 'EOF' && $name ne 'ERROR') { 2284 WARN("return of an errno should typically be -ve (return -$1)\n" . $herecurr); 2285 } 2286 } 2287 2288# Need a space before open parenthesis after if, while etc 2289 if ($line=~/\b(if|while|for|switch)\(/) { 2290 ERROR("space required before the open parenthesis '('\n" . $herecurr); 2291 } 2292 2293# Check for illegal assignment in if conditional -- and check for trailing 2294# statements after the conditional. 2295 if ($line =~ /do\s*(?!{)/) { 2296 my ($stat_next) = ctx_statement_block($line_nr_next, 2297 $remain_next, $off_next); 2298 $stat_next =~ s/\n./\n /g; 2299 ##print "stat<$stat> stat_next<$stat_next>\n"; 2300 2301 if ($stat_next =~ /^\s*while\b/) { 2302 # If the statement carries leading newlines, 2303 # then count those as offsets. 2304 my ($whitespace) = 2305 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s); 2306 my $offset = 2307 statement_rawlines($whitespace) - 1; 2308 2309 $suppress_whiletrailers{$line_nr_next + 2310 $offset} = 1; 2311 } 2312 } 2313 if (!defined $suppress_whiletrailers{$linenr} && 2314 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) { 2315 my ($s, $c) = ($stat, $cond); 2316 2317 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) { 2318 ERROR("do not use assignment in if condition\n" . $herecurr); 2319 } 2320 2321 # Find out what is on the end of the line after the 2322 # conditional. 2323 substr($s, 0, length($c), ''); 2324 $s =~ s/\n.*//g; 2325 $s =~ s/$;//g; # Remove any comments 2326 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ && 2327 $c !~ /}\s*while\s*/) 2328 { 2329 # Find out how long the conditional actually is. 2330 my @newlines = ($c =~ /\n/gs); 2331 my $cond_lines = 1 + $#newlines; 2332 my $stat_real = ''; 2333 2334 $stat_real = raw_line($linenr, $cond_lines) 2335 . "\n" if ($cond_lines); 2336 if (defined($stat_real) && $cond_lines > 1) { 2337 $stat_real = "[...]\n$stat_real"; 2338 } 2339 2340 ERROR("trailing statements should be on next line\n" . $herecurr . $stat_real); 2341 } 2342 } 2343 2344# Check for bitwise tests written as boolean 2345 if ($line =~ / 2346 (?: 2347 (?:\[|\(|\&\&|\|\|) 2348 \s*0[xX][0-9]+\s* 2349 (?:\&\&|\|\|) 2350 | 2351 (?:\&\&|\|\|) 2352 \s*0[xX][0-9]+\s* 2353 (?:\&\&|\|\||\)|\]) 2354 )/x) 2355 { 2356 WARN("boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr); 2357 } 2358 2359# if and else should not have general statements after it 2360 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) { 2361 my $s = $1; 2362 $s =~ s/$;//g; # Remove any comments 2363 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) { 2364 ERROR("trailing statements should be on next line\n" . $herecurr); 2365 } 2366 } 2367# if should not continue a brace 2368 if ($line =~ /}\s*if\b/) { 2369 ERROR("trailing statements should be on next line\n" . 2370 $herecurr); 2371 } 2372# case and default should not have general statements after them 2373 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g && 2374 $line !~ /\G(?: 2375 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$| 2376 \s*return\s+ 2377 )/xg) 2378 { 2379 ERROR("trailing statements should be on next line\n" . $herecurr); 2380 } 2381 2382 # Check for }<nl>else {, these must be at the same 2383 # indent level to be relevant to each other. 2384 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and 2385 $previndent == $indent) { 2386 ERROR("else should follow close brace '}'\n" . $hereprev); 2387 } 2388 2389 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and 2390 $previndent == $indent) { 2391 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0); 2392 2393 # Find out what is on the end of the line after the 2394 # conditional. 2395 substr($s, 0, length($c), ''); 2396 $s =~ s/\n.*//g; 2397 2398 if ($s =~ /^\s*;/) { 2399 ERROR("while should follow close brace '}'\n" . $hereprev); 2400 } 2401 } 2402 2403#studly caps, commented out until figure out how to distinguish between use of existing and adding new 2404# if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) { 2405# print "No studly caps, use _\n"; 2406# print "$herecurr"; 2407# $clean = 0; 2408# } 2409 2410#no spaces allowed after \ in define 2411 if ($line=~/\#\s*define.*\\\s$/) { 2412 WARN("Whitepspace after \\ makes next lines useless\n" . $herecurr); 2413 } 2414 2415#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line) 2416 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) { 2417 my $file = "$1.h"; 2418 my $checkfile = "include/linux/$file"; 2419 if (-f "$root/$checkfile" && 2420 $realfile ne $checkfile && 2421 $1 !~ /$allowed_asm_includes/) 2422 { 2423 if ($realfile =~ m{^arch/}) { 2424 CHK("Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr); 2425 } else { 2426 WARN("Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr); 2427 } 2428 } 2429 } 2430 2431# multi-statement macros should be enclosed in a do while loop, grab the 2432# first statement and ensure its the whole macro if its not enclosed 2433# in a known good container 2434 if ($realfile !~ m@/vmlinux.lds.h$@ && 2435 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) { 2436 my $ln = $linenr; 2437 my $cnt = $realcnt; 2438 my ($off, $dstat, $dcond, $rest); 2439 my $ctx = ''; 2440 2441 my $args = defined($1); 2442 2443 # Find the end of the macro and limit our statement 2444 # search to that. 2445 while ($cnt > 0 && defined $lines[$ln - 1] && 2446 $lines[$ln - 1] =~ /^(?:-|..*\\$)/) 2447 { 2448 $ctx .= $rawlines[$ln - 1] . "\n"; 2449 $cnt-- if ($lines[$ln - 1] !~ /^-/); 2450 $ln++; 2451 } 2452 $ctx .= $rawlines[$ln - 1]; 2453 2454 ($dstat, $dcond, $ln, $cnt, $off) = 2455 ctx_statement_block($linenr, $ln - $linenr + 1, 0); 2456 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n"; 2457 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n"; 2458 2459 # Extract the remainder of the define (if any) and 2460 # rip off surrounding spaces, and trailing \'s. 2461 $rest = ''; 2462 while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) { 2463 #print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n"; 2464 if ($off != 0 || $lines[$ln - 1] !~ /^-/) { 2465 $rest .= substr($lines[$ln - 1], $off) . "\n"; 2466 $cnt--; 2467 } 2468 $ln++; 2469 $off = 0; 2470 } 2471 $rest =~ s/\\\n.//g; 2472 $rest =~ s/^\s*//s; 2473 $rest =~ s/\s*$//s; 2474 2475 # Clean up the original statement. 2476 if ($args) { 2477 substr($dstat, 0, length($dcond), ''); 2478 } else { 2479 $dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//; 2480 } 2481 $dstat =~ s/$;//g; 2482 $dstat =~ s/\\\n.//g; 2483 $dstat =~ s/^\s*//s; 2484 $dstat =~ s/\s*$//s; 2485 2486 # Flatten any parentheses and braces 2487 while ($dstat =~ s/\([^\(\)]*\)/1/ || 2488 $dstat =~ s/\{[^\{\}]*\}/1/ || 2489 $dstat =~ s/\[[^\{\}]*\]/1/) 2490 { 2491 } 2492 2493 my $exceptions = qr{ 2494 $Declare| 2495 module_param_named| 2496 MODULE_PARAM_DESC| 2497 DECLARE_PER_CPU| 2498 DEFINE_PER_CPU| 2499 __typeof__\(| 2500 union| 2501 struct| 2502 \.$Ident\s*=\s*| 2503 ^\"|\"$ 2504 }x; 2505 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n"; 2506 if ($rest ne '' && $rest ne ',') { 2507 if ($rest !~ /while\s*\(/ && 2508 $dstat !~ /$exceptions/) 2509 { 2510 ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n"); 2511 } 2512 2513 } elsif ($ctx !~ /;/) { 2514 if ($dstat ne '' && 2515 $dstat !~ /^(?:$Ident|-?$Constant)$/ && 2516 $dstat !~ /$exceptions/ && 2517 $dstat !~ /^\.$Ident\s*=/ && 2518 $dstat =~ /$Operators/) 2519 { 2520 ERROR("Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n"); 2521 } 2522 } 2523 } 2524 2525# make sure symbols are always wrapped with VMLINUX_SYMBOL() ... 2526# all assignments may have only one of the following with an assignment: 2527# . 2528# ALIGN(...) 2529# VMLINUX_SYMBOL(...) 2530 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) { 2531 WARN("vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr); 2532 } 2533 2534# check for redundant bracing round if etc 2535 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) { 2536 my ($level, $endln, @chunks) = 2537 ctx_statement_full($linenr, $realcnt, 1); 2538 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n"; 2539 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n"; 2540 if ($#chunks > 0 && $level == 0) { 2541 my $allowed = 0; 2542 my $seen = 0; 2543 my $herectx = $here . "\n"; 2544 my $ln = $linenr - 1; 2545 for my $chunk (@chunks) { 2546 my ($cond, $block) = @{$chunk}; 2547 2548 # If the condition carries leading newlines, then count those as offsets. 2549 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s); 2550 my $offset = statement_rawlines($whitespace) - 1; 2551 2552 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n"; 2553 2554 # We have looked at and allowed this specific line. 2555 $suppress_ifbraces{$ln + $offset} = 1; 2556 2557 $herectx .= "$rawlines[$ln + $offset]\n[...]\n"; 2558 $ln += statement_rawlines($block) - 1; 2559 2560 substr($block, 0, length($cond), ''); 2561 2562 $seen++ if ($block =~ /^\s*{/); 2563 2564 #print "cond<$cond> block<$block> allowed<$allowed>\n"; 2565 if (statement_lines($cond) > 1) { 2566 #print "APW: ALLOWED: cond<$cond>\n"; 2567 $allowed = 1; 2568 } 2569 if ($block =~/\b(?:if|for|while)\b/) { 2570 #print "APW: ALLOWED: block<$block>\n"; 2571 $allowed = 1; 2572 } 2573 if (statement_block_size($block) > 1) { 2574 #print "APW: ALLOWED: lines block<$block>\n"; 2575 $allowed = 1; 2576 } 2577 } 2578 if ($seen && !$allowed) { 2579 WARN("braces {} are not necessary for any arm of this statement\n" . $herectx); 2580 } 2581 } 2582 } 2583 if (!defined $suppress_ifbraces{$linenr - 1} && 2584 $line =~ /\b(if|while|for|else)\b/) { 2585 my $allowed = 0; 2586 2587 # Check the pre-context. 2588 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) { 2589 #print "APW: ALLOWED: pre<$1>\n"; 2590 $allowed = 1; 2591 } 2592 2593 my ($level, $endln, @chunks) = 2594 ctx_statement_full($linenr, $realcnt, $-[0]); 2595 2596 # Check the condition. 2597 my ($cond, $block) = @{$chunks[0]}; 2598 #print "CHECKING<$linenr> cond<$cond> block<$block>\n"; 2599 if (defined $cond) { 2600 substr($block, 0, length($cond), ''); 2601 } 2602 if (statement_lines($cond) > 1) { 2603 #print "APW: ALLOWED: cond<$cond>\n"; 2604 $allowed = 1; 2605 } 2606 if ($block =~/\b(?:if|for|while)\b/) { 2607 #print "APW: ALLOWED: block<$block>\n"; 2608 $allowed = 1; 2609 } 2610 if (statement_block_size($block) > 1) { 2611 #print "APW: ALLOWED: lines block<$block>\n"; 2612 $allowed = 1; 2613 } 2614 # Check the post-context. 2615 if (defined $chunks[1]) { 2616 my ($cond, $block) = @{$chunks[1]}; 2617 if (defined $cond) { 2618 substr($block, 0, length($cond), ''); 2619 } 2620 if ($block =~ /^\s*\{/) { 2621 #print "APW: ALLOWED: chunk-1 block<$block>\n"; 2622 $allowed = 1; 2623 } 2624 } 2625 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) { 2626 my $herectx = $here . "\n";; 2627 my $cnt = statement_rawlines($block); 2628 2629 for (my $n = 0; $n < $cnt; $n++) { 2630 $herectx .= raw_line($linenr, $n) . "\n";; 2631 } 2632 2633 WARN("braces {} are not necessary for single statement blocks\n" . $herectx); 2634 } 2635 } 2636 2637# don't include deprecated include files (uses RAW line) 2638 for my $inc (@dep_includes) { 2639 if ($rawline =~ m@^.\s*\#\s*include\s*\<$inc>@) { 2640 ERROR("Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr); 2641 } 2642 } 2643 2644# don't use deprecated functions 2645 for my $func (@dep_functions) { 2646 if ($line =~ /\b$func\b/) { 2647 ERROR("Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr); 2648 } 2649 } 2650 2651# no volatiles please 2652 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b}; 2653 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) { 2654 WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr); 2655 } 2656 2657# SPIN_LOCK_UNLOCKED & RW_LOCK_UNLOCKED are deprecated 2658 if ($line =~ /\b(SPIN_LOCK_UNLOCKED|RW_LOCK_UNLOCKED)/) { 2659 ERROR("Use of $1 is deprecated: see Documentation/spinlocks.txt\n" . $herecurr); 2660 } 2661 2662# warn about #if 0 2663 if ($line =~ /^.\s*\#\s*if\s+0\b/) { 2664 CHK("if this code is redundant consider removing it\n" . 2665 $herecurr); 2666 } 2667 2668# check for needless kfree() checks 2669 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) { 2670 my $expr = $1; 2671 if ($line =~ /\bkfree\(\Q$expr\E\);/) { 2672 WARN("kfree(NULL) is safe this check is probably not required\n" . $hereprev); 2673 } 2674 } 2675# check for needless usb_free_urb() checks 2676 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) { 2677 my $expr = $1; 2678 if ($line =~ /\busb_free_urb\(\Q$expr\E\);/) { 2679 WARN("usb_free_urb(NULL) is safe this check is probably not required\n" . $hereprev); 2680 } 2681 } 2682 2683# prefer usleep_range over udelay 2684 if ($line =~ /\budelay\s*\(\s*(\w+)\s*\)/) { 2685 # ignore udelay's < 10, however 2686 if (! (($1 =~ /(\d+)/) && ($1 < 10)) ) { 2687 CHK("usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line); 2688 } 2689 } 2690 2691# warn about unexpectedly long msleep's 2692 if ($line =~ /\bmsleep\s*\((\d+)\);/) { 2693 if ($1 < 20) { 2694 WARN("msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line); 2695 } 2696 } 2697 2698# warn about #ifdefs in C files 2699# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) { 2700# print "#ifdef in C files should be avoided\n"; 2701# print "$herecurr"; 2702# $clean = 0; 2703# } 2704 2705# warn about spacing in #ifdefs 2706 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) { 2707 ERROR("exactly one space required after that #$1\n" . $herecurr); 2708 } 2709 2710# check for spinlock_t definitions without a comment. 2711 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ || 2712 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) { 2713 my $which = $1; 2714 if (!ctx_has_comment($first_line, $linenr)) { 2715 CHK("$1 definition without comment\n" . $herecurr); 2716 } 2717 } 2718# check for memory barriers without a comment. 2719 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) { 2720 if (!ctx_has_comment($first_line, $linenr)) { 2721 CHK("memory barrier without comment\n" . $herecurr); 2722 } 2723 } 2724# check of hardware specific defines 2725 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) { 2726 CHK("architecture specific defines should be avoided\n" . $herecurr); 2727 } 2728 2729# Check that the storage class is at the beginning of a declaration 2730 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) { 2731 WARN("storage class should be at the beginning of the declaration\n" . $herecurr) 2732 } 2733 2734# check the location of the inline attribute, that it is between 2735# storage class and type. 2736 if ($line =~ /\b$Type\s+$Inline\b/ || 2737 $line =~ /\b$Inline\s+$Storage\b/) { 2738 ERROR("inline keyword should sit between storage class and type\n" . $herecurr); 2739 } 2740 2741# Check for __inline__ and __inline, prefer inline 2742 if ($line =~ /\b(__inline__|__inline)\b/) { 2743 WARN("plain inline is preferred over $1\n" . $herecurr); 2744 } 2745 2746# Check for __attribute__ packed, prefer __packed 2747 if ($line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) { 2748 WARN("__packed is preferred over __attribute__((packed))\n" . $herecurr); 2749 } 2750 2751# check for sizeof(&) 2752 if ($line =~ /\bsizeof\s*\(\s*\&/) { 2753 WARN("sizeof(& should be avoided\n" . $herecurr); 2754 } 2755 2756# check for new externs in .c files. 2757 if ($realfile =~ /\.c$/ && defined $stat && 2758 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s) 2759 { 2760 my $function_name = $1; 2761 my $paren_space = $2; 2762 2763 my $s = $stat; 2764 if (defined $cond) { 2765 substr($s, 0, length($cond), ''); 2766 } 2767 if ($s =~ /^\s*;/ && 2768 $function_name ne 'uninitialized_var') 2769 { 2770 WARN("externs should be avoided in .c files\n" . $herecurr); 2771 } 2772 2773 if ($paren_space =~ /\n/) { 2774 WARN("arguments for function declarations should follow identifier\n" . $herecurr); 2775 } 2776 2777 } elsif ($realfile =~ /\.c$/ && defined $stat && 2778 $stat =~ /^.\s*extern\s+/) 2779 { 2780 WARN("externs should be avoided in .c files\n" . $herecurr); 2781 } 2782 2783# checks for new __setup's 2784 if ($rawline =~ /\b__setup\("([^"]*)"/) { 2785 my $name = $1; 2786 2787 if (!grep(/$name/, @setup_docs)) { 2788 CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr); 2789 } 2790 } 2791 2792# check for pointless casting of kmalloc return 2793 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) { 2794 WARN("unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr); 2795 } 2796 2797# check for multiple semicolons 2798 if ($line =~ /;\s*;\s*$/) { 2799 WARN("Statements terminations use 1 semicolon\n" . $herecurr); 2800 } 2801 2802# check for gcc specific __FUNCTION__ 2803 if ($line =~ /__FUNCTION__/) { 2804 WARN("__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr); 2805 } 2806 2807# check for semaphores initialized locked 2808 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) { 2809 WARN("consider using a completion\n" . $herecurr); 2810 2811 } 2812# recommend strict_strto* over simple_strto* 2813 if ($line =~ /\bsimple_(strto.*?)\s*\(/) { 2814 WARN("consider using strict_$1 in preference to simple_$1\n" . $herecurr); 2815 } 2816# check for __initcall(), use device_initcall() explicitly please 2817 if ($line =~ /^.\s*__initcall\s*\(/) { 2818 WARN("please use device_initcall() instead of __initcall()\n" . $herecurr); 2819 } 2820# check for various ops structs, ensure they are const. 2821 my $struct_ops = qr{acpi_dock_ops| 2822 address_space_operations| 2823 backlight_ops| 2824 block_device_operations| 2825 dentry_operations| 2826 dev_pm_ops| 2827 dma_map_ops| 2828 extent_io_ops| 2829 file_lock_operations| 2830 file_operations| 2831 hv_ops| 2832 ide_dma_ops| 2833 intel_dvo_dev_ops| 2834 item_operations| 2835 iwl_ops| 2836 kgdb_arch| 2837 kgdb_io| 2838 kset_uevent_ops| 2839 lock_manager_operations| 2840 microcode_ops| 2841 mtrr_ops| 2842 neigh_ops| 2843 nlmsvc_binding| 2844 pci_raw_ops| 2845 pipe_buf_operations| 2846 platform_hibernation_ops| 2847 platform_suspend_ops| 2848 proto_ops| 2849 rpc_pipe_ops| 2850 seq_operations| 2851 snd_ac97_build_ops| 2852 soc_pcmcia_socket_ops| 2853 stacktrace_ops| 2854 sysfs_ops| 2855 tty_operations| 2856 usb_mon_operations| 2857 wd_ops}x; 2858 if ($line !~ /\bconst\b/ && 2859 $line =~ /\bstruct\s+($struct_ops)\b/) { 2860 WARN("struct $1 should normally be const\n" . 2861 $herecurr); 2862 } 2863 2864# use of NR_CPUS is usually wrong 2865# ignore definitions of NR_CPUS and usage to define arrays as likely right 2866 if ($line =~ /\bNR_CPUS\b/ && 2867 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ && 2868 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ && 2869 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ && 2870 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ && 2871 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/) 2872 { 2873 WARN("usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr); 2874 } 2875 2876# check for %L{u,d,i} in strings 2877 my $string; 2878 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) { 2879 $string = substr($rawline, $-[1], $+[1] - $-[1]); 2880 $string =~ s/%%/__/g; 2881 if ($string =~ /(?<!%)%L[udi]/) { 2882 WARN("\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr); 2883 last; 2884 } 2885 } 2886 2887# whine mightly about in_atomic 2888 if ($line =~ /\bin_atomic\s*\(/) { 2889 if ($realfile =~ m@^drivers/@) { 2890 ERROR("do not use in_atomic in drivers\n" . $herecurr); 2891 } elsif ($realfile !~ m@^kernel/@) { 2892 WARN("use of in_atomic() is incorrect outside core kernel code\n" . $herecurr); 2893 } 2894 } 2895 2896# check for lockdep_set_novalidate_class 2897 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ || 2898 $line =~ /__lockdep_no_validate__\s*\)/ ) { 2899 if ($realfile !~ m@^kernel/lockdep@ && 2900 $realfile !~ m@^include/linux/lockdep@ && 2901 $realfile !~ m@^drivers/base/core@) { 2902 ERROR("lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr); 2903 } 2904 } 2905 2906 if ($line =~ /debugfs_create_file.*S_IWUGO/ || 2907 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) { 2908 WARN("Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr); 2909 } 2910 } 2911 2912 # If we have no input at all, then there is nothing to report on 2913 # so just keep quiet. 2914 if ($#rawlines == -1) { 2915 exit(0); 2916 } 2917 2918 # In mailback mode only produce a report in the negative, for 2919 # things that appear to be patches. 2920 if ($mailback && ($clean == 1 || !$is_patch)) { 2921 exit(0); 2922 } 2923 2924 # This is not a patch, and we are are in 'no-patch' mode so 2925 # just keep quiet. 2926 if (!$chk_patch && !$is_patch) { 2927 exit(0); 2928 } 2929 2930 if (!$is_patch) { 2931 ERROR("Does not appear to be a unified-diff format patch\n"); 2932 } 2933 if ($is_patch && $chk_signoff && $signoff == 0) { 2934 ERROR("Missing Signed-off-by: line(s)\n"); 2935 } 2936 2937 print report_dump(); 2938 if ($summary && !($clean == 1 && $quiet == 1)) { 2939 print "$filename " if ($summary_file); 2940 print "total: $cnt_error errors, $cnt_warn warnings, " . 2941 (($check)? "$cnt_chk checks, " : "") . 2942 "$cnt_lines lines checked\n"; 2943 print "\n" if ($quiet == 0); 2944 } 2945 2946 if ($quiet == 0) { 2947 # If there were whitespace errors which cleanpatch can fix 2948 # then suggest that. 2949 if ($rpt_cleaners) { 2950 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n"; 2951 print " scripts/cleanfile\n\n"; 2952 } 2953 } 2954 2955 if ($clean == 1 && $quiet == 0) { 2956 print "$vname has no obvious style problems and is ready for submission.\n" 2957 } 2958 if ($clean == 0 && $quiet == 0) { 2959 print "$vname has style problems, please review. If any of these errors\n"; 2960 print "are false positives report them to the maintainer, see\n"; 2961 print "CHECKPATCH in MAINTAINERS.\n"; 2962 } 2963 2964 return $clean; 2965} 2966