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