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