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