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