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