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