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