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