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