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