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