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