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