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