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