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