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