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