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
16 use Getopt::Long qw(:config no_auto_abbrev);
42 my $configuration_file = ".checkpatch.conf";
43 my $max_line_length = 80;
44 my $ignore_perl_version = 0;
45 my $minimum_perl_version = 5.10.0;
51 Usage: $P [OPTION]... [FILE]...
56 --no-tree run without a kernel tree
57 --no-signoff do not check for 'Signed-off-by' line
58 --patch treat FILE as patchfile (default)
59 --emacs emacs compile window format
60 --terse one line per report
61 -f, --file treat FILE as regular source file
62 --subjective, --strict enable more subjective tests
63 --types TYPE(,TYPE2...) show only these comma separated message types
64 --ignore TYPE(,TYPE2...) ignore various comma separated message types
65 --max-line-length=n set the maximum line length, if exceeded, warn
66 --show-types show the message "types" in the output
67 --root=PATH PATH to the kernel tree root
68 --no-summary suppress the per-file summary
69 --mailback only produce a report in case of warnings/errors
70 --summary-file include the filename in summary
71 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
72 'values', 'possible', 'type', and 'attr' (default
74 --test-only=WORD report only warnings/errors containing WORD
76 --fix EXPERIMENTAL - may create horrible results
77 If correctable single-line errors exist, create
78 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
79 with potential errors corrected to the preferred
81 --fix-inplace EXPERIMENTAL - may create horrible results
82 Is the same as --fix, but overwrites the input
83 file. It's your fault if there's no backup or git
84 --ignore-perl-version override checking of perl version. expect
86 -h, --help, --version display this help and exit
88 When FILE is - read standard input.
94 my $conf = which_conf($configuration_file);
97 open(my $conffile, '<', "$conf")
98 or warn "$P: Can't find a readable $configuration_file file $!\n";
100 while (<$conffile>) {
103 $line =~ s/\s*\n?$//g;
107 next if ($line =~ m/^\s*#/);
108 next if ($line =~ m/^\s*$/);
110 my @words = split(" ", $line);
111 foreach my $word (@words) {
112 last if ($word =~ m/^#/);
113 push (@conf_args, $word);
117 unshift(@ARGV, @conf_args) if @conf_args;
121 'q|quiet+' => \$quiet,
123 'signoff!' => \$chk_signoff,
124 'patch!' => \$chk_patch,
128 'subjective!' => \$check,
129 'strict!' => \$check,
130 'ignore=s' => \@ignore,
132 'show-types!' => \$show_types,
133 'max-line-length=i' => \$max_line_length,
135 'summary!' => \$summary,
136 'mailback!' => \$mailback,
137 'summary-file!' => \$summary_file,
139 'fix-inplace!' => \$fix_inplace,
140 'ignore-perl-version!' => \$ignore_perl_version,
141 'debug=s' => \%debug,
142 'test-only=s' => \$tst_only,
149 $fix = 1 if ($fix_inplace);
150 $check_orig = $check;
154 if ($^V && $^V lt $minimum_perl_version) {
155 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
156 if (!$ignore_perl_version) {
162 print "$P: no input files\n";
166 sub hash_save_array_words {
167 my ($hashRef, $arrayRef) = @_;
169 my @array = split(/,/, join(',', @$arrayRef));
170 foreach my $word (@array) {
171 $word =~ s/\s*\n?$//g;
174 $word =~ tr/[a-z]/[A-Z]/;
176 next if ($word =~ m/^\s*#/);
177 next if ($word =~ m/^\s*$/);
183 sub hash_show_words {
184 my ($hashRef, $prefix) = @_;
186 if ($quiet == 0 && keys %$hashRef) {
187 print "NOTE: $prefix message types:";
188 foreach my $word (sort keys %$hashRef) {
195 hash_save_array_words(\%ignore_type, \@ignore);
196 hash_save_array_words(\%use_type, \@use);
199 my $dbg_possible = 0;
202 for my $key (keys %debug) {
204 eval "\${dbg_$key} = '$debug{$key}';";
208 my $rpt_cleaners = 0;
217 if (!top_of_kernel_tree($root)) {
218 die "$P: $root: --root does not point at a valid tree\n";
221 if (top_of_kernel_tree('.')) {
223 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
224 top_of_kernel_tree($1)) {
229 if (!defined $root) {
230 print "Must be run from the top-level dir. of a kernel tree\n";
235 my $emitted_corrupt = 0;
238 [A-Za-z_][A-Za-z\d_]*
239 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
241 our $Storage = qr{extern|static|asmlinkage};
253 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
254 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
255 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
256 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
257 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
259 # Notes to $Attribute:
260 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
280 ____cacheline_aligned|
281 ____cacheline_aligned_in_smp|
282 ____cacheline_internodealigned_in_smp|
286 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
287 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
288 our $Lval = qr{$Ident(?:$Member)*};
290 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
291 our $Binary = qr{(?i)0b[01]+$Int_type?};
292 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
293 our $Int = qr{[0-9]+$Int_type?};
294 our $Octal = qr{0[0-7]+$Int_type?};
295 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
296 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
297 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
298 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
299 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
300 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
301 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
302 our $Arithmetic = qr{\+|-|\*|\/|%};
306 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
309 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
312 our $NonptrTypeWithAttr;
316 our $NON_ASCII_UTF8 = qr{
317 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
318 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
319 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
320 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
321 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
322 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
323 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
327 [\x09\x0A\x0D\x20-\x7E] # ASCII
331 our $typeTypedefs = qr{(?x:
332 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
336 our $logFunctions = qr{(?x:
337 printk(?:_ratelimited|_once|)|
338 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
339 WARN(?:_RATELIMIT|_ONCE|)|
342 seq_vprintf|seq_printf|seq_puts
345 our $signature_tags = qr{(?xi:
358 qr{(?:unsigned\s+)?char},
359 qr{(?:unsigned\s+)?short},
360 qr{(?:unsigned\s+)?int},
361 qr{(?:unsigned\s+)?long},
362 qr{(?:unsigned\s+)?long\s+int},
363 qr{(?:unsigned\s+)?long\s+long},
364 qr{(?:unsigned\s+)?long\s+long\s+int},
373 qr{${Ident}_handler},
374 qr{${Ident}_handler_fn},
376 our @typeListWithAttr = (
378 qr{struct\s+$InitAttribute\s+$Ident},
379 qr{union\s+$InitAttribute\s+$Ident},
382 our @modifierList = (
386 our @mode_permission_funcs = (
388 ["module_param_(?:array|named|string)", 4],
389 ["module_param_array_named", 5],
390 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
391 ["proc_create(?:_data|)", 2],
392 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
395 #Create a search pattern for all these functions to speed up a loop below
396 our $mode_perms_search = "";
397 foreach my $entry (@mode_permission_funcs) {
398 $mode_perms_search .= '|' if ($mode_perms_search ne "");
399 $mode_perms_search .= $entry->[0];
402 our $declaration_macros = qr{(?x:
403 (?:$Storage\s+)?(?:DECLARE|DEFINE)_[A-Z]+\s*\(|
404 (?:$Storage\s+)?LIST_HEAD\s*\(
407 our $allowed_asm_includes = qr{(?x:
411 # memory.h: ARM has a custom one
414 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
415 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
416 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
417 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
419 (?:$Modifier\s+|const\s+)*
421 (?:typeof|__typeof__)\s*\([^\)]*\)|
425 (?:\s+$Modifier|\s+const)*
427 $NonptrTypeWithAttr = qr{
428 (?:$Modifier\s+|const\s+)*
430 (?:typeof|__typeof__)\s*\([^\)]*\)|
434 (?:\s+$Modifier|\s+const)*
438 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
439 (?:\s+$Inline|\s+$Modifier)*
441 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
445 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
447 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
448 # requires at least perl version v5.10.0
449 # Any use must be runtime checked with $^V
451 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
452 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
453 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
457 return "" if (!defined($string));
459 while ($string =~ /^\s*\(.*\)\s*$/) {
460 $string =~ s@^\s*\(\s*@@;
461 $string =~ s@\s*\)\s*$@@;
464 $string =~ s@\s+@ @g;
469 sub seed_camelcase_file {
472 return if (!(-f $file));
476 open(my $include_file, '<', "$file")
477 or warn "$P: Can't read '$file' $!\n";
478 my $text = <$include_file>;
479 close($include_file);
481 my @lines = split('\n', $text);
483 foreach my $line (@lines) {
484 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
485 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
487 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
489 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
495 my $camelcase_seeded = 0;
496 sub seed_camelcase_includes {
497 return if ($camelcase_seeded);
500 my $camelcase_cache = "";
501 my @include_files = ();
503 $camelcase_seeded = 1;
506 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
507 chomp $git_last_include_commit;
508 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
510 my $last_mod_date = 0;
511 $files = `find $root/include -name "*.h"`;
512 @include_files = split('\n', $files);
513 foreach my $file (@include_files) {
514 my $date = POSIX::strftime("%Y%m%d%H%M",
515 localtime((stat $file)[9]));
516 $last_mod_date = $date if ($last_mod_date < $date);
518 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
521 if ($camelcase_cache ne "" && -f $camelcase_cache) {
522 open(my $camelcase_file, '<', "$camelcase_cache")
523 or warn "$P: Can't read '$camelcase_cache' $!\n";
524 while (<$camelcase_file>) {
528 close($camelcase_file);
534 $files = `git ls-files "include/*.h"`;
535 @include_files = split('\n', $files);
538 foreach my $file (@include_files) {
539 seed_camelcase_file($file);
542 if ($camelcase_cache ne "") {
543 unlink glob ".checkpatch-camelcase.*";
544 open(my $camelcase_file, '>', "$camelcase_cache")
545 or warn "$P: Can't write '$camelcase_cache' $!\n";
546 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
547 print $camelcase_file ("$_\n");
549 close($camelcase_file);
553 $chk_signoff = 0 if ($file);
559 for my $filename (@ARGV) {
562 open($FILE, '-|', "diff -u /dev/null $filename") ||
563 die "$P: $filename: diff failed - $!\n";
564 } elsif ($filename eq '-') {
565 open($FILE, '<&STDIN');
567 open($FILE, '<', "$filename") ||
568 die "$P: $filename: open failed - $!\n";
570 if ($filename eq '-') {
571 $vname = 'Your patch';
580 if (!process($filename)) {
590 sub top_of_kernel_tree {
594 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
595 "README", "Documentation", "arch", "include", "drivers",
596 "fs", "init", "ipc", "kernel", "lib", "scripts",
599 foreach my $check (@tree_check) {
600 if (! -e $root . '/' . $check) {
608 my ($formatted_email) = @_;
614 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
617 $comment = $3 if defined $3;
618 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
620 $comment = $2 if defined $2;
621 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
623 $comment = $2 if defined $2;
624 $formatted_email =~ s/$address.*$//;
625 $name = $formatted_email;
627 $name =~ s/^\"|\"$//g;
628 # If there's a name left after stripping spaces and
629 # leading quotes, and the address doesn't have both
630 # leading and trailing angle brackets, the address
632 # "joe smith joe@smith.com" bad
633 # "joe smith <joe@smith.com" bad
634 if ($name ne "" && $address !~ /^<[^>]+>$/) {
642 $name =~ s/^\"|\"$//g;
643 $address = trim($address);
644 $address =~ s/^\<|\>$//g;
646 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
647 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
651 return ($name, $address, $comment);
655 my ($name, $address) = @_;
660 $name =~ s/^\"|\"$//g;
661 $address = trim($address);
663 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
664 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
669 $formatted_email = "$address";
671 $formatted_email = "$name <$address>";
674 return $formatted_email;
680 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
681 if (-e "$path/$conf") {
682 return "$path/$conf";
694 for my $c (split(//, $str)) {
698 for (; ($n % 8) != 0; $n++) {
710 (my $res = shift) =~ tr/\t/ /c;
717 # Drop the diff line leader and expand tabs
719 $line = expand_tabs($line);
721 # Pick the indent from the front of the line.
722 my ($white) = ($line =~ /^(\s*)/);
724 return (length($line), length($white));
727 my $sanitise_quote = '';
729 sub sanitise_line_reset {
730 my ($in_comment) = @_;
733 $sanitise_quote = '*/';
735 $sanitise_quote = '';
748 # Always copy over the diff marker.
749 $res = substr($line, 0, 1);
751 for ($off = 1; $off < length($line); $off++) {
752 $c = substr($line, $off, 1);
754 # Comments we are wacking completly including the begin
755 # and end, all to $;.
756 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
757 $sanitise_quote = '*/';
759 substr($res, $off, 2, "$;$;");
763 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
764 $sanitise_quote = '';
765 substr($res, $off, 2, "$;$;");
769 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
770 $sanitise_quote = '//';
772 substr($res, $off, 2, $sanitise_quote);
777 # A \ in a string means ignore the next character.
778 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
780 substr($res, $off, 2, 'XX');
785 if ($c eq "'" || $c eq '"') {
786 if ($sanitise_quote eq '') {
787 $sanitise_quote = $c;
789 substr($res, $off, 1, $c);
791 } elsif ($sanitise_quote eq $c) {
792 $sanitise_quote = '';
796 #print "c<$c> SQ<$sanitise_quote>\n";
797 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
798 substr($res, $off, 1, $;);
799 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
800 substr($res, $off, 1, $;);
801 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
802 substr($res, $off, 1, 'X');
804 substr($res, $off, 1, $c);
808 if ($sanitise_quote eq '//') {
809 $sanitise_quote = '';
812 # The pathname on a #include may be surrounded by '<' and '>'.
813 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
814 my $clean = 'X' x length($1);
815 $res =~ s@\<.*\>@<$clean>@;
817 # The whole of a #error is a string.
818 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
819 my $clean = 'X' x length($1);
820 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
826 sub get_quoted_string {
827 my ($line, $rawline) = @_;
829 return "" if ($line !~ m/(\"[X]+\")/g);
830 return substr($rawline, $-[0], $+[0] - $-[0]);
833 sub ctx_statement_block {
834 my ($linenr, $remain, $off) = @_;
835 my $line = $linenr - 1;
852 @stack = (['', 0]) if ($#stack == -1);
854 #warn "CSB: blk<$blk> remain<$remain>\n";
855 # If we are about to drop off the end, pull in more
858 for (; $remain > 0; $line++) {
859 last if (!defined $lines[$line]);
860 next if ($lines[$line] =~ /^-/);
863 $blk .= $lines[$line] . "\n";
868 # Bail if there is no further context.
869 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
873 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
879 $c = substr($blk, $off, 1);
880 $remainder = substr($blk, $off);
882 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
884 # Handle nested #if/#else.
885 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
886 push(@stack, [ $type, $level ]);
887 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
888 ($type, $level) = @{$stack[$#stack - 1]};
889 } elsif ($remainder =~ /^#\s*endif\b/) {
890 ($type, $level) = @{pop(@stack)};
893 # Statement ends at the ';' or a close '}' at the
895 if ($level == 0 && $c eq ';') {
899 # An else is really a conditional as long as its not else if
900 if ($level == 0 && $coff_set == 0 &&
901 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
902 $remainder =~ /^(else)(?:\s|{)/ &&
903 $remainder !~ /^else\s+if\b/) {
904 $coff = $off + length($1) - 1;
906 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
907 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
910 if (($type eq '' || $type eq '(') && $c eq '(') {
914 if ($type eq '(' && $c eq ')') {
916 $type = ($level != 0)? '(' : '';
918 if ($level == 0 && $coff < $soff) {
921 #warn "CSB: mark coff<$coff>\n";
924 if (($type eq '' || $type eq '{') && $c eq '{') {
928 if ($type eq '{' && $c eq '}') {
930 $type = ($level != 0)? '{' : '';
933 if (substr($blk, $off + 1, 1) eq ';') {
939 # Preprocessor commands end at the newline unless escaped.
940 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
948 # We are truly at the end, so shuffle to the next line.
955 my $statement = substr($blk, $soff, $off - $soff + 1);
956 my $condition = substr($blk, $soff, $coff - $soff + 1);
958 #warn "STATEMENT<$statement>\n";
959 #warn "CONDITION<$condition>\n";
961 #print "coff<$coff> soff<$off> loff<$loff>\n";
963 return ($statement, $condition,
964 $line, $remain + 1, $off - $loff + 1, $level);
967 sub statement_lines {
970 # Strip the diff line prefixes and rip blank lines at start and end.
971 $stmt =~ s/(^|\n)./$1/g;
975 my @stmt_lines = ($stmt =~ /\n/g);
977 return $#stmt_lines + 2;
980 sub statement_rawlines {
983 my @stmt_lines = ($stmt =~ /\n/g);
985 return $#stmt_lines + 2;
988 sub statement_block_size {
991 $stmt =~ s/(^|\n)./$1/g;
997 my @stmt_lines = ($stmt =~ /\n/g);
998 my @stmt_statements = ($stmt =~ /;/g);
1000 my $stmt_lines = $#stmt_lines + 2;
1001 my $stmt_statements = $#stmt_statements + 1;
1003 if ($stmt_lines > $stmt_statements) {
1006 return $stmt_statements;
1010 sub ctx_statement_full {
1011 my ($linenr, $remain, $off) = @_;
1012 my ($statement, $condition, $level);
1016 # Grab the first conditional/block pair.
1017 ($statement, $condition, $linenr, $remain, $off, $level) =
1018 ctx_statement_block($linenr, $remain, $off);
1019 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1020 push(@chunks, [ $condition, $statement ]);
1021 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1022 return ($level, $linenr, @chunks);
1025 # Pull in the following conditional/block pairs and see if they
1026 # could continue the statement.
1028 ($statement, $condition, $linenr, $remain, $off, $level) =
1029 ctx_statement_block($linenr, $remain, $off);
1030 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1031 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1033 push(@chunks, [ $condition, $statement ]);
1036 return ($level, $linenr, @chunks);
1040 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1042 my $start = $linenr - 1;
1049 my @stack = ($level);
1050 for ($line = $start; $remain > 0; $line++) {
1051 next if ($rawlines[$line] =~ /^-/);
1054 $blk .= $rawlines[$line];
1056 # Handle nested #if/#else.
1057 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1058 push(@stack, $level);
1059 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1060 $level = $stack[$#stack - 1];
1061 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1062 $level = pop(@stack);
1065 foreach my $c (split(//, $lines[$line])) {
1066 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1072 if ($c eq $close && $level > 0) {
1074 last if ($level == 0);
1075 } elsif ($c eq $open) {
1080 if (!$outer || $level <= 1) {
1081 push(@res, $rawlines[$line]);
1084 last if ($level == 0);
1087 return ($level, @res);
1089 sub ctx_block_outer {
1090 my ($linenr, $remain) = @_;
1092 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1096 my ($linenr, $remain) = @_;
1098 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1102 my ($linenr, $remain, $off) = @_;
1104 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1107 sub ctx_block_level {
1108 my ($linenr, $remain) = @_;
1110 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1112 sub ctx_statement_level {
1113 my ($linenr, $remain, $off) = @_;
1115 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1118 sub ctx_locate_comment {
1119 my ($first_line, $end_line) = @_;
1121 # Catch a comment on the end of the line itself.
1122 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1123 return $current_comment if (defined $current_comment);
1125 # Look through the context and try and figure out if there is a
1128 $current_comment = '';
1129 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1130 my $line = $rawlines[$linenr - 1];
1132 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1135 if ($line =~ m@/\*@) {
1138 if (!$in_comment && $current_comment ne '') {
1139 $current_comment = '';
1141 $current_comment .= $line . "\n" if ($in_comment);
1142 if ($line =~ m@\*/@) {
1147 chomp($current_comment);
1148 return($current_comment);
1150 sub ctx_has_comment {
1151 my ($first_line, $end_line) = @_;
1152 my $cmt = ctx_locate_comment($first_line, $end_line);
1154 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1155 ##print "CMMT: $cmt\n";
1157 return ($cmt ne '');
1161 my ($linenr, $cnt) = @_;
1163 my $offset = $linenr - 1;
1168 $line = $rawlines[$offset++];
1169 next if (defined($line) && $line =~ /^-/);
1181 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1184 $coded = sprintf("^%c", unpack('C', $2) + 64);
1193 my $av_preprocessor = 0;
1198 sub annotate_reset {
1199 $av_preprocessor = 0;
1201 @av_paren_type = ('E');
1202 $av_pend_colon = 'O';
1205 sub annotate_values {
1206 my ($stream, $type) = @_;
1209 my $var = '_' x length($stream);
1212 print "$stream\n" if ($dbg_values > 1);
1214 while (length($cur)) {
1215 @av_paren_type = ('E') if ($#av_paren_type < 0);
1216 print " <" . join('', @av_paren_type) .
1217 "> <$type> <$av_pending>" if ($dbg_values > 1);
1218 if ($cur =~ /^(\s+)/o) {
1219 print "WS($1)\n" if ($dbg_values > 1);
1220 if ($1 =~ /\n/ && $av_preprocessor) {
1221 $type = pop(@av_paren_type);
1222 $av_preprocessor = 0;
1225 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1226 print "CAST($1)\n" if ($dbg_values > 1);
1227 push(@av_paren_type, $type);
1230 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1231 print "DECLARE($1)\n" if ($dbg_values > 1);
1234 } elsif ($cur =~ /^($Modifier)\s*/) {
1235 print "MODIFIER($1)\n" if ($dbg_values > 1);
1238 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1239 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1240 $av_preprocessor = 1;
1241 push(@av_paren_type, $type);
1247 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1248 print "UNDEF($1)\n" if ($dbg_values > 1);
1249 $av_preprocessor = 1;
1250 push(@av_paren_type, $type);
1252 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1253 print "PRE_START($1)\n" if ($dbg_values > 1);
1254 $av_preprocessor = 1;
1256 push(@av_paren_type, $type);
1257 push(@av_paren_type, $type);
1260 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1261 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1262 $av_preprocessor = 1;
1264 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1268 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1269 print "PRE_END($1)\n" if ($dbg_values > 1);
1271 $av_preprocessor = 1;
1273 # Assume all arms of the conditional end as this
1274 # one does, and continue as if the #endif was not here.
1275 pop(@av_paren_type);
1276 push(@av_paren_type, $type);
1279 } elsif ($cur =~ /^(\\\n)/o) {
1280 print "PRECONT($1)\n" if ($dbg_values > 1);
1282 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1283 print "ATTR($1)\n" if ($dbg_values > 1);
1284 $av_pending = $type;
1287 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1288 print "SIZEOF($1)\n" if ($dbg_values > 1);
1294 } elsif ($cur =~ /^(if|while|for)\b/o) {
1295 print "COND($1)\n" if ($dbg_values > 1);
1299 } elsif ($cur =~/^(case)/o) {
1300 print "CASE($1)\n" if ($dbg_values > 1);
1301 $av_pend_colon = 'C';
1304 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1305 print "KEYWORD($1)\n" if ($dbg_values > 1);
1308 } elsif ($cur =~ /^(\()/o) {
1309 print "PAREN('$1')\n" if ($dbg_values > 1);
1310 push(@av_paren_type, $av_pending);
1314 } elsif ($cur =~ /^(\))/o) {
1315 my $new_type = pop(@av_paren_type);
1316 if ($new_type ne '_') {
1318 print "PAREN('$1') -> $type\n"
1319 if ($dbg_values > 1);
1321 print "PAREN('$1')\n" if ($dbg_values > 1);
1324 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1325 print "FUNC($1)\n" if ($dbg_values > 1);
1329 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1330 if (defined $2 && $type eq 'C' || $type eq 'T') {
1331 $av_pend_colon = 'B';
1332 } elsif ($type eq 'E') {
1333 $av_pend_colon = 'L';
1335 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1338 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1339 print "IDENT($1)\n" if ($dbg_values > 1);
1342 } elsif ($cur =~ /^($Assignment)/o) {
1343 print "ASSIGN($1)\n" if ($dbg_values > 1);
1346 } elsif ($cur =~/^(;|{|})/) {
1347 print "END($1)\n" if ($dbg_values > 1);
1349 $av_pend_colon = 'O';
1351 } elsif ($cur =~/^(,)/) {
1352 print "COMMA($1)\n" if ($dbg_values > 1);
1355 } elsif ($cur =~ /^(\?)/o) {
1356 print "QUESTION($1)\n" if ($dbg_values > 1);
1359 } elsif ($cur =~ /^(:)/o) {
1360 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1362 substr($var, length($res), 1, $av_pend_colon);
1363 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1368 $av_pend_colon = 'O';
1370 } elsif ($cur =~ /^(\[)/o) {
1371 print "CLOSE($1)\n" if ($dbg_values > 1);
1374 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1377 print "OPV($1)\n" if ($dbg_values > 1);
1384 substr($var, length($res), 1, $variant);
1387 } elsif ($cur =~ /^($Operators)/o) {
1388 print "OP($1)\n" if ($dbg_values > 1);
1389 if ($1 ne '++' && $1 ne '--') {
1393 } elsif ($cur =~ /(^.)/o) {
1394 print "C($1)\n" if ($dbg_values > 1);
1397 $cur = substr($cur, length($1));
1398 $res .= $type x length($1);
1402 return ($res, $var);
1406 my ($possible, $line) = @_;
1407 my $notPermitted = qr{(?:
1424 ^(?:typedef|struct|enum)\b
1426 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1427 if ($possible !~ $notPermitted) {
1428 # Check for modifiers.
1429 $possible =~ s/\s*$Storage\s*//g;
1430 $possible =~ s/\s*$Sparse\s*//g;
1431 if ($possible =~ /^\s*$/) {
1433 } elsif ($possible =~ /\s/) {
1434 $possible =~ s/\s*$Type\s*//g;
1435 for my $modifier (split(' ', $possible)) {
1436 if ($modifier !~ $notPermitted) {
1437 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1438 push(@modifierList, $modifier);
1443 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1444 push(@typeList, $possible);
1448 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1457 return defined $use_type{$type} if (scalar keys %use_type > 0);
1459 return !defined $ignore_type{$type};
1463 my ($level, $type, $msg) = @_;
1465 if (!show_type($type) ||
1466 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1471 $line = "$prefix$level:$type: $msg\n";
1473 $line = "$prefix$level: $msg\n";
1475 $line = (split('\n', $line))[0] . "\n" if ($terse);
1477 push(our @report, $line);
1487 my ($type, $msg) = @_;
1489 if (report("ERROR", $type, $msg)) {
1497 my ($type, $msg) = @_;
1499 if (report("WARNING", $type, $msg)) {
1507 my ($type, $msg) = @_;
1509 if ($check && report("CHECK", $type, $msg)) {
1517 sub check_absolute_file {
1518 my ($absolute, $herecurr) = @_;
1519 my $file = $absolute;
1521 ##print "absolute<$absolute>\n";
1523 # See if any suffix of this path is a path within the tree.
1524 while ($file =~ s@^[^/]*/@@) {
1525 if (-f "$root/$file") {
1526 ##print "file<$file>\n";
1534 # It is, so see if the prefix is acceptable.
1535 my $prefix = $absolute;
1536 substr($prefix, -length($file)) = '';
1538 ##print "prefix<$prefix>\n";
1539 if ($prefix ne ".../") {
1540 WARN("USE_RELATIVE_PATH",
1541 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1548 $string =~ s/^\s+|\s+$//g;
1556 $string =~ s/^\s+//;
1564 $string =~ s/\s+$//;
1569 sub string_find_replace {
1570 my ($string, $find, $replace) = @_;
1572 $string =~ s/$find/$replace/g;
1580 my $source_indent = 8;
1581 my $max_spaces_before_tab = $source_indent - 1;
1582 my $spaces_to_tab = " " x $source_indent;
1584 #convert leading spaces to tabs
1585 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1586 #Remove spaces before a tab
1587 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1592 sub pos_last_openparen {
1597 my $opens = $line =~ tr/\(/\(/;
1598 my $closes = $line =~ tr/\)/\)/;
1600 my $last_openparen = 0;
1602 if (($opens == 0) || ($closes >= $opens)) {
1606 my $len = length($line);
1608 for ($pos = 0; $pos < $len; $pos++) {
1609 my $string = substr($line, $pos);
1610 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1611 $pos += length($1) - 1;
1612 } elsif (substr($line, $pos, 1) eq '(') {
1613 $last_openparen = $pos;
1614 } elsif (index($string, '(') == -1) {
1619 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
1623 my $filename = shift;
1629 my $stashrawline="";
1640 my $in_header_lines = $file ? 0 : 1;
1641 my $in_commit_log = 0; #Scanning lines before patch
1643 my $non_utf8_charset = 0;
1645 my $last_blank_line = 0;
1653 # Trace the real file/line as we go.
1659 my $comment_edge = 0;
1663 my $prev_values = 'E';
1666 my %suppress_ifbraces;
1667 my %suppress_whiletrailers;
1668 my %suppress_export;
1669 my $suppress_statement = 0;
1671 my %signatures = ();
1673 # Pre-scan the patch sanitizing the lines.
1674 # Pre-scan the patch looking for any __setup documentation.
1676 my @setup_docs = ();
1679 my $camelcase_file_seeded = 0;
1681 sanitise_line_reset();
1683 foreach my $rawline (@rawlines) {
1687 push(@fixed, $rawline) if ($fix);
1689 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1691 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1696 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1705 # Guestimate if this is a continuing comment. Run
1706 # the context looking for a comment "edge". If this
1707 # edge is a close comment then we must be in a comment
1711 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1712 next if (defined $rawlines[$ln - 1] &&
1713 $rawlines[$ln - 1] =~ /^-/);
1715 #print "RAW<$rawlines[$ln - 1]>\n";
1716 last if (!defined $rawlines[$ln - 1]);
1717 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1718 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1723 if (defined $edge && $edge eq '*/') {
1727 # Guestimate if this is a continuing comment. If this
1728 # is the start of a diff block and this line starts
1729 # ' *' then it is very likely a comment.
1730 if (!defined $edge &&
1731 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1736 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1737 sanitise_line_reset($in_comment);
1739 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1740 # Standardise the strings and chars within the input to
1741 # simplify matching -- only bother with positive lines.
1742 $line = sanitise_line($rawline);
1744 push(@lines, $line);
1747 $realcnt-- if ($line =~ /^(?:\+| |$)/);
1752 #print "==>$rawline\n";
1753 #print "-->$line\n";
1755 if ($setup_docs && $line =~ /^\+/) {
1756 push(@setup_docs, $line);
1764 foreach my $line (@lines) {
1766 my $sline = $line; #copy of $line
1767 $sline =~ s/$;/ /g; #with comments as spaces
1769 my $rawline = $rawlines[$linenr - 1];
1771 #extract the line range in the file after the patch is applied
1772 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1774 $first_line = $linenr + 1;
1784 %suppress_ifbraces = ();
1785 %suppress_whiletrailers = ();
1786 %suppress_export = ();
1787 $suppress_statement = 0;
1790 # track the line number as we move through the hunk, note that
1791 # new versions of GNU diff omit the leading space on completely
1792 # blank context lines so we need to count that too.
1793 } elsif ($line =~ /^( |\+|$)/) {
1795 $realcnt-- if ($realcnt != 0);
1797 # Measure the line length and indent.
1798 ($length, $indent) = line_stats($rawline);
1800 # Track the previous line.
1801 ($prevline, $stashline) = ($stashline, $line);
1802 ($previndent, $stashindent) = ($stashindent, $indent);
1803 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1805 #warn "line<$line>\n";
1807 } elsif ($realcnt == 1) {
1811 my $hunk_line = ($realcnt != 0);
1813 #make up the handle for any error we report on this line
1814 $prefix = "$filename:$realline: " if ($emacs && $file);
1815 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1817 $here = "#$linenr: " if (!$file);
1818 $here = "#$realline: " if ($file);
1821 # extract the filename as it passes
1822 if ($line =~ /^diff --git.*?(\S+)$/) {
1824 $realfile =~ s@^([^/]*)/@@ if (!$file);
1827 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1829 $realfile =~ s@^([^/]*)/@@ if (!$file);
1833 if (!$file && $tree && $p1_prefix ne '' &&
1834 -e "$root/$p1_prefix") {
1835 WARN("PATCH_PREFIX",
1836 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1839 if ($realfile =~ m@^include/asm/@) {
1840 ERROR("MODIFIED_INCLUDE_ASM",
1841 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1847 if ($realfile =~ m@^(drivers/net/|net/)@) {
1850 $check = $check_orig;
1855 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1857 my $hereline = "$here\n$rawline\n";
1858 my $herecurr = "$here\n$rawline\n";
1859 my $hereprev = "$here\n$prevrawline\n$rawline\n";
1861 $cnt_lines++ if ($realcnt != 0);
1863 # Check for incorrect file permissions
1864 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1865 my $permhere = $here . "FILE: $realfile\n";
1866 if ($realfile !~ m@scripts/@ &&
1867 $realfile !~ /\.(py|pl|awk|sh)$/) {
1868 ERROR("EXECUTE_PERMISSIONS",
1869 "do not set execute permissions for source files\n" . $permhere);
1873 # Check the patch for a signoff:
1874 if ($line =~ /^\s*signed-off-by:/i) {
1879 # Check signature styles
1880 if (!$in_header_lines &&
1881 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
1882 my $space_before = $1;
1884 my $space_after = $3;
1886 my $ucfirst_sign_off = ucfirst(lc($sign_off));
1888 if ($sign_off !~ /$signature_tags/) {
1889 WARN("BAD_SIGN_OFF",
1890 "Non-standard signature: $sign_off\n" . $herecurr);
1892 if (defined $space_before && $space_before ne "") {
1893 if (WARN("BAD_SIGN_OFF",
1894 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
1896 $fixed[$linenr - 1] =
1897 "$ucfirst_sign_off $email";
1900 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
1901 if (WARN("BAD_SIGN_OFF",
1902 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
1904 $fixed[$linenr - 1] =
1905 "$ucfirst_sign_off $email";
1909 if (!defined $space_after || $space_after ne " ") {
1910 if (WARN("BAD_SIGN_OFF",
1911 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
1913 $fixed[$linenr - 1] =
1914 "$ucfirst_sign_off $email";
1918 my ($email_name, $email_address, $comment) = parse_email($email);
1919 my $suggested_email = format_email(($email_name, $email_address));
1920 if ($suggested_email eq "") {
1921 ERROR("BAD_SIGN_OFF",
1922 "Unrecognized email address: '$email'\n" . $herecurr);
1924 my $dequoted = $suggested_email;
1925 $dequoted =~ s/^"//;
1926 $dequoted =~ s/" </ </;
1927 # Don't force email to have quotes
1928 # Allow just an angle bracketed address
1929 if ("$dequoted$comment" ne $email &&
1930 "<$email_address>$comment" ne $email &&
1931 "$suggested_email$comment" ne $email) {
1932 WARN("BAD_SIGN_OFF",
1933 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1937 # Check for duplicate signatures
1938 my $sig_nospace = $line;
1939 $sig_nospace =~ s/\s//g;
1940 $sig_nospace = lc($sig_nospace);
1941 if (defined $signatures{$sig_nospace}) {
1942 WARN("BAD_SIGN_OFF",
1943 "Duplicate signature\n" . $herecurr);
1945 $signatures{$sig_nospace} = 1;
1949 # Check for old stable address
1950 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
1951 ERROR("STABLE_ADDRESS",
1952 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
1955 # Check for unwanted Gerrit info
1956 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
1957 ERROR("GERRIT_CHANGE_ID",
1958 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
1961 # Check for wrappage within a valid hunk of the file
1962 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1963 ERROR("CORRUPTED_PATCH",
1964 "patch seems to be corrupt (line wrapped?)\n" .
1965 $herecurr) if (!$emitted_corrupt++);
1968 # Check for absolute kernel paths.
1970 while ($line =~ m{(?:^|\s)(/\S*)}g) {
1973 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1974 check_absolute_file($1, $herecurr)) {
1977 check_absolute_file($file, $herecurr);
1982 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1983 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1984 $rawline !~ m/^$UTF8*$/) {
1985 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1987 my $blank = copy_spacing($rawline);
1988 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1989 my $hereptr = "$hereline$ptr\n";
1992 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1995 # Check if it's the start of a commit log
1996 # (not a header line and we haven't seen the patch filename)
1997 if ($in_header_lines && $realfile =~ /^$/ &&
1998 !($rawline =~ /^\s+\S/ ||
1999 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2000 $in_header_lines = 0;
2004 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2005 # declined it, i.e defined some charset where it is missing.
2006 if ($in_header_lines &&
2007 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2009 $non_utf8_charset = 1;
2012 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2013 $rawline =~ /$NON_ASCII_UTF8/) {
2014 WARN("UTF8_BEFORE_PATCH",
2015 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2018 # ignore non-hunk lines and lines being removed
2019 next if (!$hunk_line || $line =~ /^-/);
2021 #trailing whitespace
2022 if ($line =~ /^\+.*\015/) {
2023 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2024 if (ERROR("DOS_LINE_ENDINGS",
2025 "DOS line endings\n" . $herevet) &&
2027 $fixed[$linenr - 1] =~ s/[\s\015]+$//;
2029 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2030 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2031 if (ERROR("TRAILING_WHITESPACE",
2032 "trailing whitespace\n" . $herevet) &&
2034 $fixed[$linenr - 1] =~ s/\s+$//;
2040 # Check for FSF mailing addresses.
2041 if ($rawline =~ /\bwrite to the Free/i ||
2042 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2043 $rawline =~ /\b51\s+Franklin\s+St/i) {
2044 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2045 my $msg_type = \&ERROR;
2046 $msg_type = \&CHK if ($file);
2047 &{$msg_type}("FSF_MAILING_ADDRESS",
2048 "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)
2051 # check for Kconfig help text having a real description
2052 # Only applies when adding the entry originally, after that we do not have
2053 # sufficient context to determine whether it is indeed long enough.
2054 if ($realfile =~ /Kconfig/ &&
2055 $line =~ /^\+\s*config\s+/) {
2058 my $ln = $linenr + 1;
2062 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2063 $f = $lines[$ln - 1];
2064 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2065 $is_end = $lines[$ln - 1] =~ /^\+/;
2067 next if ($f =~ /^-/);
2068 last if (!$file && $f =~ /^\@\@/);
2070 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2072 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2079 next if ($f =~ /^$/);
2080 if ($f =~ /^\s*config\s/) {
2086 WARN("CONFIG_DESCRIPTION",
2087 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
2088 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2091 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2092 if ($realfile =~ /Kconfig/ &&
2093 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2094 WARN("CONFIG_EXPERIMENTAL",
2095 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2098 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2099 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2102 'EXTRA_AFLAGS' => 'asflags-y',
2103 'EXTRA_CFLAGS' => 'ccflags-y',
2104 'EXTRA_CPPFLAGS' => 'cppflags-y',
2105 'EXTRA_LDFLAGS' => 'ldflags-y',
2108 WARN("DEPRECATED_VARIABLE",
2109 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2112 # check for DT compatible documentation
2113 if (defined $root &&
2114 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2115 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2117 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2119 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2120 my $vp_file = $dt_path . "vendor-prefixes.txt";
2122 foreach my $compat (@compats) {
2123 my $compat2 = $compat;
2124 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2125 my $compat3 = $compat;
2126 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2127 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2129 WARN("UNDOCUMENTED_DT_STRING",
2130 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2133 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2135 `grep -Eq "^$vendor\\b" $vp_file`;
2137 WARN("UNDOCUMENTED_DT_STRING",
2138 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2143 # check we are in a valid source file if not then ignore this hunk
2144 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
2147 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2148 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2149 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2150 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
2151 $length > $max_line_length)
2154 "line over $max_line_length characters\n" . $herecurr);
2157 # Check for user-visible strings broken across lines, which breaks the ability
2158 # to grep for the string. Make exceptions when the previous string ends in a
2159 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2160 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
2161 if ($line =~ /^\+\s*"/ &&
2162 $prevline =~ /"\s*$/ &&
2163 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
2164 WARN("SPLIT_STRING",
2165 "quoted string split across lines\n" . $hereprev);
2168 # check for spaces before a quoted newline
2169 if ($rawline =~ /^.*\".*\s\\n/) {
2170 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2171 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2173 $fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2178 # check for adding lines without a newline.
2179 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2180 WARN("MISSING_EOF_NEWLINE",
2181 "adding a line without newline at end of file\n" . $herecurr);
2184 # Blackfin: use hi/lo macros
2185 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2186 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2187 my $herevet = "$here\n" . cat_vet($line) . "\n";
2189 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2191 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2192 my $herevet = "$here\n" . cat_vet($line) . "\n";
2194 "use the HI() macro, not (... >> 16)\n" . $herevet);
2198 # check we are in a valid source file C or perl if not then ignore this hunk
2199 next if ($realfile !~ /\.(h|c|pl)$/);
2201 # at the beginning of a line any tabs must come first and anything
2202 # more than 8 must use tabs.
2203 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2204 $rawline =~ /^\+\s* \s*/) {
2205 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2207 if (ERROR("CODE_INDENT",
2208 "code indent should use tabs where possible\n" . $herevet) &&
2210 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2214 # check for space before tabs.
2215 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2216 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2217 if (WARN("SPACE_BEFORE_TAB",
2218 "please, no space before tabs\n" . $herevet) &&
2220 while ($fixed[$linenr - 1] =~
2221 s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2222 while ($fixed[$linenr - 1] =~
2223 s/(^\+.*) +\t/$1\t/) {}
2227 # check for && or || at the start of a line
2228 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2229 CHK("LOGICAL_CONTINUATIONS",
2230 "Logical continuations should be on the previous line\n" . $hereprev);
2233 # check multi-line statement indentation matches previous line
2234 if ($^V && $^V ge 5.10.0 &&
2235 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2236 $prevline =~ /^\+(\t*)(.*)$/;
2240 my $pos = pos_last_openparen($rest);
2242 $line =~ /^(\+| )([ \t]*)/;
2245 my $goodtabindent = $oldindent .
2248 my $goodspaceindent = $oldindent . " " x $pos;
2250 if ($newindent ne $goodtabindent &&
2251 $newindent ne $goodspaceindent) {
2253 if (CHK("PARENTHESIS_ALIGNMENT",
2254 "Alignment should match open parenthesis\n" . $hereprev) &&
2255 $fix && $line =~ /^\+/) {
2256 $fixed[$linenr - 1] =~
2257 s/^\+[ \t]*/\+$goodtabindent/;
2263 if ($line =~ /^\+.*\(\s*$Type\s*\)[ \t]+(?!$Assignment|$Arithmetic)/) {
2265 "No space is necessary after a cast\n" . $herecurr) &&
2267 $fixed[$linenr - 1] =~
2268 s/(\(\s*$Type\s*\))[ \t]+/$1/;
2272 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2273 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2274 $rawline =~ /^\+[ \t]*\*/ &&
2276 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2277 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2280 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2281 $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /*
2282 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
2283 $rawline =~ /^\+/ && #line is new
2284 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2285 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2286 "networking block comments start with * on subsequent lines\n" . $hereprev);
2289 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2290 $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2291 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2292 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2293 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
2294 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2295 "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2298 # check for missing blank lines after struct/union declarations
2299 # with exceptions for various attributes and macros
2300 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2302 !($line =~ /^\+\s*$/ ||
2303 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2304 $line =~ /^\+\s*MODULE_/i ||
2305 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2306 $line =~ /^\+[a-z_]*init/ ||
2307 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2308 $line =~ /^\+\s*DECLARE/ ||
2309 $line =~ /^\+\s*__setup/)) {
2311 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev);
2314 # check for multiple consecutive blank lines
2315 if ($prevline =~ /^[\+ ]\s*$/ &&
2316 $line =~ /^\+\s*$/ &&
2317 $last_blank_line != ($linenr - 1)) {
2319 "Please don't use multiple blank lines\n" . $hereprev);
2320 $last_blank_line = $linenr;
2323 # check for missing blank lines after declarations
2324 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2325 # actual declarations
2326 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2327 # function pointer declarations
2328 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2329 # foo bar; where foo is some local typedef or #define
2330 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2331 # known declaration macros
2332 $prevline =~ /^\+\s+$declaration_macros/) &&
2333 # for "else if" which can look like "$Ident $Ident"
2334 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2335 # other possible extensions of declaration lines
2336 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2337 # not starting a section or a macro "\" extended line
2338 $prevline =~ /(?:\{\s*|\\)$/) &&
2339 # looks like a declaration
2340 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2341 # function pointer declarations
2342 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2343 # foo bar; where foo is some local typedef or #define
2344 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2345 # known declaration macros
2346 $sline =~ /^\+\s+$declaration_macros/ ||
2347 # start of struct or union or enum
2348 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2349 # start or end of block or continuation of declaration
2350 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2351 # bitfield continuation
2352 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2353 # other possible extensions of declaration lines
2354 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2355 # indentation of previous and current line are the same
2356 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2357 WARN("LINE_SPACING",
2358 "Missing a blank line after declarations\n" . $hereprev);
2361 # check for spaces at the beginning of a line.
2363 # 1) within comments
2364 # 2) indented preprocessor commands
2366 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
2367 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2368 if (WARN("LEADING_SPACE",
2369 "please, no spaces at the start of a line\n" . $herevet) &&
2371 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2375 # check we are in a valid C source file if not then ignore this hunk
2376 next if ($realfile !~ /\.(h|c)$/);
2378 # check indentation of any line with a bare else
2379 # if the previous line is a break or return and is indented 1 tab more...
2380 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2381 my $tabs = length($1) + 1;
2382 if ($prevline =~ /^\+\t{$tabs,$tabs}(?:break|return)\b/) {
2383 WARN("UNNECESSARY_ELSE",
2384 "else is not generally useful after a break or return\n" . $hereprev);
2388 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2389 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2390 WARN("CONFIG_EXPERIMENTAL",
2391 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2394 # check for RCS/CVS revision markers
2395 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2397 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2400 # Blackfin: don't use __builtin_bfin_[cs]sync
2401 if ($line =~ /__builtin_bfin_csync/) {
2402 my $herevet = "$here\n" . cat_vet($line) . "\n";
2404 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2406 if ($line =~ /__builtin_bfin_ssync/) {
2407 my $herevet = "$here\n" . cat_vet($line) . "\n";
2409 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2412 # check for old HOTPLUG __dev<foo> section markings
2413 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2414 WARN("HOTPLUG_SECTION",
2415 "Using $1 is unnecessary\n" . $herecurr);
2418 # Check for potential 'bare' types
2419 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2421 #print "LINE<$line>\n";
2422 if ($linenr >= $suppress_statement &&
2423 $realcnt && $sline =~ /.\s*\S/) {
2424 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2425 ctx_statement_block($linenr, $realcnt, 0);
2426 $stat =~ s/\n./\n /g;
2427 $cond =~ s/\n./\n /g;
2429 #print "linenr<$linenr> <$stat>\n";
2430 # If this statement has no statement boundaries within
2431 # it there is no point in retrying a statement scan
2432 # until we hit end of it.
2433 my $frag = $stat; $frag =~ s/;+\s*$//;
2434 if ($frag !~ /(?:{|;)/) {
2435 #print "skip<$line_nr_next>\n";
2436 $suppress_statement = $line_nr_next;
2439 # Find the real next line.
2440 $realline_next = $line_nr_next;
2441 if (defined $realline_next &&
2442 (!defined $lines[$realline_next - 1] ||
2443 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2450 # Ignore goto labels.
2451 if ($s =~ /$Ident:\*$/s) {
2453 # Ignore functions being called
2454 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2456 } elsif ($s =~ /^.\s*else\b/s) {
2458 # declarations always start with types
2459 } 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) {
2462 possible($type, "A:" . $s);
2464 # definitions in global scope can only start with types
2465 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2466 possible($1, "B:" . $s);
2469 # any (foo ... *) is a pointer cast, and foo is a type
2470 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2471 possible($1, "C:" . $s);
2474 # Check for any sort of function declaration.
2475 # int foo(something bar, other baz);
2476 # void (*store_gdt)(x86_descr_ptr *);
2477 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2478 my ($name_len) = length($1);
2481 substr($ctx, 0, $name_len + 1, '');
2482 $ctx =~ s/\)[^\)]*$//;
2484 for my $arg (split(/\s*,\s*/, $ctx)) {
2485 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2487 possible($1, "D:" . $s);
2495 # Checks which may be anchored in the context.
2498 # Check for switch () and associated case and default
2499 # statements should be at the same indent.
2500 if ($line=~/\bswitch\s*\(.*\)/) {
2503 my @ctx = ctx_block_outer($linenr, $realcnt);
2505 for my $ctx (@ctx) {
2506 my ($clen, $cindent) = line_stats($ctx);
2507 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2508 $indent != $cindent) {
2509 $err .= "$sep$ctx\n";
2516 ERROR("SWITCH_CASE_INDENT_LEVEL",
2517 "switch and case should be at the same indent\n$hereline$err");
2521 # if/while/etc brace do not go on next line, unless defining a do while loop,
2522 # or if that brace on the next line is for something else
2523 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2524 my $pre_ctx = "$1$2";
2526 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2528 if ($line =~ /^\+\t{6,}/) {
2529 WARN("DEEP_INDENTATION",
2530 "Too many leading tabs - consider code refactoring\n" . $herecurr);
2533 my $ctx_cnt = $realcnt - $#ctx - 1;
2534 my $ctx = join("\n", @ctx);
2536 my $ctx_ln = $linenr;
2537 my $ctx_skip = $realcnt;
2539 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2540 defined $lines[$ctx_ln - 1] &&
2541 $lines[$ctx_ln - 1] =~ /^-/)) {
2542 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2543 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2547 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2548 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2550 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2552 "that open brace { should be on the previous line\n" .
2553 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2555 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2556 $ctx =~ /\)\s*\;\s*$/ &&
2557 defined $lines[$ctx_ln - 1])
2559 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2560 if ($nindent > $indent) {
2561 WARN("TRAILING_SEMICOLON",
2562 "trailing semicolon indicates no statements, indent implies otherwise\n" .
2563 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2568 # Check relative indent for conditionals and blocks.
2569 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2570 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2571 ctx_statement_block($linenr, $realcnt, 0)
2572 if (!defined $stat);
2573 my ($s, $c) = ($stat, $cond);
2575 substr($s, 0, length($c), '');
2577 # Make sure we remove the line prefixes as we have
2578 # none on the first line, and are going to readd them
2582 # Find out how long the conditional actually is.
2583 my @newlines = ($c =~ /\n/gs);
2584 my $cond_lines = 1 + $#newlines;
2586 # We want to check the first line inside the block
2587 # starting at the end of the conditional, so remove:
2588 # 1) any blank line termination
2589 # 2) any opening brace { on end of the line
2591 my $continuation = 0;
2593 $s =~ s/^.*\bdo\b//;
2595 if ($s =~ s/^\s*\\//) {
2598 if ($s =~ s/^\s*?\n//) {
2603 # Also ignore a loop construct at the end of a
2604 # preprocessor statement.
2605 if (($prevline =~ /^.\s*#\s*define\s/ ||
2606 $prevline =~ /\\\s*$/) && $continuation == 0) {
2612 while ($cond_ptr != $cond_lines) {
2613 $cond_ptr = $cond_lines;
2615 # If we see an #else/#elif then the code
2617 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2622 # 1) blank lines, they should be at 0,
2623 # 2) preprocessor lines, and
2625 if ($continuation ||
2627 $s =~ /^\s*#\s*?/ ||
2628 $s =~ /^\s*$Ident\s*:/) {
2629 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2630 if ($s =~ s/^.*?\n//) {
2636 my (undef, $sindent) = line_stats("+" . $s);
2637 my $stat_real = raw_line($linenr, $cond_lines);
2639 # Check if either of these lines are modified, else
2640 # this is not this patch's fault.
2641 if (!defined($stat_real) ||
2642 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2645 if (defined($stat_real) && $cond_lines > 1) {
2646 $stat_real = "[...]\n$stat_real";
2649 #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";
2651 if ($check && (($sindent % 8) != 0 ||
2652 ($sindent <= $indent && $s ne ''))) {
2653 WARN("SUSPECT_CODE_INDENT",
2654 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2658 # Track the 'values' across context and added lines.
2659 my $opline = $line; $opline =~ s/^./ /;
2660 my ($curr_values, $curr_vars) =
2661 annotate_values($opline . "\n", $prev_values);
2662 $curr_values = $prev_values . $curr_values;
2664 my $outline = $opline; $outline =~ s/\t/ /g;
2665 print "$linenr > .$outline\n";
2666 print "$linenr > $curr_values\n";
2667 print "$linenr > $curr_vars\n";
2669 $prev_values = substr($curr_values, -1);
2671 #ignore lines not being added
2672 next if ($line =~ /^[^\+]/);
2674 # TEST: allow direct testing of the type matcher.
2676 if ($line =~ /^.\s*$Declare\s*$/) {
2678 "TEST: is type\n" . $herecurr);
2679 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2680 ERROR("TEST_NOT_TYPE",
2681 "TEST: is not type ($1 is)\n". $herecurr);
2685 # TEST: allow direct testing of the attribute matcher.
2687 if ($line =~ /^.\s*$Modifier\s*$/) {
2689 "TEST: is attr\n" . $herecurr);
2690 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2691 ERROR("TEST_NOT_ATTR",
2692 "TEST: is not attr ($1 is)\n". $herecurr);
2697 # check for initialisation to aggregates open brace on the next line
2698 if ($line =~ /^.\s*{/ &&
2699 $prevline =~ /(?:^|[^=])=\s*$/) {
2701 "that open brace { should be on the previous line\n" . $hereprev);
2705 # Checks which are anchored on the added line.
2708 # check for malformed paths in #include statements (uses RAW line)
2709 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2711 if ($path =~ m{//}) {
2712 ERROR("MALFORMED_INCLUDE",
2713 "malformed #include filename\n" . $herecurr);
2715 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2716 ERROR("UAPI_INCLUDE",
2717 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
2721 # no C99 // comments
2722 if ($line =~ m{//}) {
2723 if (ERROR("C99_COMMENTS",
2724 "do not use C99 // comments\n" . $herecurr) &&
2726 my $line = $fixed[$linenr - 1];
2727 if ($line =~ /\/\/(.*)$/) {
2728 my $comment = trim($1);
2729 $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;
2733 # Remove C99 comments.
2735 $opline =~ s@//.*@@;
2737 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2738 # the whole statement.
2739 #print "APW <$lines[$realline_next - 1]>\n";
2740 if (defined $realline_next &&
2741 exists $lines[$realline_next - 1] &&
2742 !defined $suppress_export{$realline_next} &&
2743 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2744 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2745 # Handle definitions which produce identifiers with
2748 # EXPORT_SYMBOL(something_foo);
2750 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
2751 $name =~ /^${Ident}_$2/) {
2752 #print "FOO C name<$name>\n";
2753 $suppress_export{$realline_next} = 1;
2755 } elsif ($stat !~ /(?:
2757 ^.DEFINE_$Ident\(\Q$name\E\)|
2758 ^.DECLARE_$Ident\(\Q$name\E\)|
2759 ^.LIST_HEAD\(\Q$name\E\)|
2760 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2761 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
2763 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2764 $suppress_export{$realline_next} = 2;
2766 $suppress_export{$realline_next} = 1;
2769 if (!defined $suppress_export{$linenr} &&
2770 $prevline =~ /^.\s*$/ &&
2771 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2772 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2773 #print "FOO B <$lines[$linenr - 1]>\n";
2774 $suppress_export{$linenr} = 2;
2776 if (defined $suppress_export{$linenr} &&
2777 $suppress_export{$linenr} == 2) {
2778 WARN("EXPORT_SYMBOL",
2779 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2782 # check for global initialisers.
2783 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
2784 if (ERROR("GLOBAL_INITIALISERS",
2785 "do not initialise globals to 0 or NULL\n" .
2788 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
2791 # check for static initialisers.
2792 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2793 if (ERROR("INITIALISED_STATIC",
2794 "do not initialise statics to 0 or NULL\n" .
2797 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
2801 # check for static const char * arrays.
2802 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2803 WARN("STATIC_CONST_CHAR_ARRAY",
2804 "static const char * array should probably be static const char * const\n" .
2808 # check for static char foo[] = "bar" declarations.
2809 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2810 WARN("STATIC_CONST_CHAR_ARRAY",
2811 "static char array declaration should probably be static const char\n" .
2815 # check for non-global char *foo[] = {"bar", ...} declarations.
2816 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
2817 WARN("STATIC_CONST_CHAR_ARRAY",
2818 "char * array declaration might be better as static const\n" .
2822 # check for function declarations without arguments like "int foo()"
2823 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
2824 if (ERROR("FUNCTION_WITHOUT_ARGS",
2825 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
2827 $fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
2831 # check for uses of DEFINE_PCI_DEVICE_TABLE
2832 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
2833 if (WARN("DEFINE_PCI_DEVICE_TABLE",
2834 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
2836 $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
2840 # check for new typedefs, only function parameters and sparse annotations
2842 if ($line =~ /\btypedef\s/ &&
2843 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2844 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2845 $line !~ /\b$typeTypedefs\b/ &&
2846 $line !~ /\b__bitwise(?:__|)\b/) {
2847 WARN("NEW_TYPEDEFS",
2848 "do not add new typedefs\n" . $herecurr);
2851 # * goes on variable not on type
2853 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
2855 my ($ident, $from, $to) = ($1, $2, $2);
2857 # Should start with a space.
2858 $to =~ s/^(\S)/ $1/;
2859 # Should not end with a space.
2861 # '*'s should not have spaces between.
2862 while ($to =~ s/\*\s+\*/\*\*/) {
2865 ## print "1: from<$from> to<$to> ident<$ident>\n";
2867 if (ERROR("POINTER_LOCATION",
2868 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
2870 my $sub_from = $ident;
2871 my $sub_to = $ident;
2872 $sub_to =~ s/\Q$from\E/$to/;
2873 $fixed[$linenr - 1] =~
2874 s@\Q$sub_from\E@$sub_to@;
2878 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
2880 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
2882 # Should start with a space.
2883 $to =~ s/^(\S)/ $1/;
2884 # Should not end with a space.
2886 # '*'s should not have spaces between.
2887 while ($to =~ s/\*\s+\*/\*\*/) {
2889 # Modifiers should have spaces.
2890 $to =~ s/(\b$Modifier$)/$1 /;
2892 ## print "2: from<$from> to<$to> ident<$ident>\n";
2893 if ($from ne $to && $ident !~ /^$Modifier$/) {
2894 if (ERROR("POINTER_LOCATION",
2895 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
2898 my $sub_from = $match;
2899 my $sub_to = $match;
2900 $sub_to =~ s/\Q$from\E/$to/;
2901 $fixed[$linenr - 1] =~
2902 s@\Q$sub_from\E@$sub_to@;
2907 # # no BUG() or BUG_ON()
2908 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2909 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2910 # print "$herecurr";
2914 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2915 WARN("LINUX_VERSION_CODE",
2916 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2919 # check for uses of printk_ratelimit
2920 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2921 WARN("PRINTK_RATELIMITED",
2922 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2925 # printk should use KERN_* levels. Note that follow on printk's on the
2926 # same line do not need a level, so we use the current block context
2927 # to try and find and validate the current printk. In summary the current
2928 # printk includes all preceding printk's which have no newline on the end.
2929 # we assume the first bad printk is the one to report.
2930 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2932 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2933 #print "CHECK<$lines[$ln - 1]\n";
2934 # we have a preceding printk if it ends
2935 # with "\n" ignore it, else it is to blame
2936 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2937 if ($rawlines[$ln - 1] !~ m{\\n"}) {
2944 WARN("PRINTK_WITHOUT_KERN_LEVEL",
2945 "printk() should include KERN_ facility level\n" . $herecurr);
2949 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
2951 my $level = lc($orig);
2952 $level = "warn" if ($level eq "warning");
2953 my $level2 = $level;
2954 $level2 = "dbg" if ($level eq "debug");
2955 WARN("PREFER_PR_LEVEL",
2956 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
2959 if ($line =~ /\bpr_warning\s*\(/) {
2960 if (WARN("PREFER_PR_LEVEL",
2961 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
2963 $fixed[$linenr - 1] =~
2964 s/\bpr_warning\b/pr_warn/;
2968 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
2970 my $level = lc($orig);
2971 $level = "warn" if ($level eq "warning");
2972 $level = "dbg" if ($level eq "debug");
2973 WARN("PREFER_DEV_LEVEL",
2974 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
2977 # function brace can't be on same line, except for #defines of do while,
2978 # or if closed on same line
2979 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2980 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2982 "open brace '{' following function declarations go on the next line\n" . $herecurr);
2985 # open braces for enum, union and struct go on the same line.
2986 if ($line =~ /^.\s*{/ &&
2987 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2989 "open brace '{' following $1 go on the same line\n" . $hereprev);
2992 # missing space after union, struct or enum definition
2993 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
2995 "missing space after $1 definition\n" . $herecurr) &&
2997 $fixed[$linenr - 1] =~
2998 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3002 # Function pointer declarations
3003 # check spacing between type, funcptr, and args
3004 # canonical declaration is "type (*funcptr)(args...)"
3005 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3007 my $pre_pointer_space = $2;
3008 my $post_pointer_space = $3;
3010 my $post_funcname_space = $5;
3011 my $pre_args_space = $6;
3013 # the $Declare variable will capture all spaces after the type
3014 # so check it for a missing trailing missing space but pointer return types
3015 # don't need a space so don't warn for those.
3016 my $post_declare_space = "";
3017 if ($declare =~ /(\s+)$/) {
3018 $post_declare_space = $1;
3019 $declare = rtrim($declare);
3021 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3023 "missing space after return type\n" . $herecurr);
3024 $post_declare_space = " ";
3027 # unnecessary space "type (*funcptr)(args...)"
3028 # This test is not currently implemented because these declarations are
3030 # int foo(int bar, ...)
3031 # and this is form shouldn't/doesn't generate a checkpatch warning.
3033 # elsif ($declare =~ /\s{2,}$/) {
3035 # "Multiple spaces after return type\n" . $herecurr);
3038 # unnecessary space "type ( *funcptr)(args...)"
3039 if (defined $pre_pointer_space &&
3040 $pre_pointer_space =~ /^\s/) {
3042 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3045 # unnecessary space "type (* funcptr)(args...)"
3046 if (defined $post_pointer_space &&
3047 $post_pointer_space =~ /^\s/) {
3049 "Unnecessary space before function pointer name\n" . $herecurr);
3052 # unnecessary space "type (*funcptr )(args...)"
3053 if (defined $post_funcname_space &&
3054 $post_funcname_space =~ /^\s/) {
3056 "Unnecessary space after function pointer name\n" . $herecurr);
3059 # unnecessary space "type (*funcptr) (args...)"
3060 if (defined $pre_args_space &&
3061 $pre_args_space =~ /^\s/) {
3063 "Unnecessary space before function pointer arguments\n" . $herecurr);
3066 if (show_type("SPACING") && $fix) {
3067 $fixed[$linenr - 1] =~
3068 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3072 # check for spacing round square brackets; allowed:
3073 # 1. with a type on the left -- int [] a;
3074 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3075 # 3. inside a curly brace -- = { [0...10] = 5 }
3076 while ($line =~ /(.*?\s)\[/g) {
3077 my ($where, $prefix) = ($-[1], $1);
3078 if ($prefix !~ /$Type\s+$/ &&
3079 ($where != 0 || $prefix !~ /^.\s+$/) &&
3080 $prefix !~ /[{,]\s+$/) {
3081 if (ERROR("BRACKET_SPACE",
3082 "space prohibited before open square bracket '['\n" . $herecurr) &&
3084 $fixed[$linenr - 1] =~
3085 s/^(\+.*?)\s+\[/$1\[/;
3090 # check for spaces between functions and their parentheses.
3091 while ($line =~ /($Ident)\s+\(/g) {
3093 my $ctx_before = substr($line, 0, $-[1]);
3094 my $ctx = "$ctx_before$name";
3096 # Ignore those directives where spaces _are_ permitted.
3098 if|for|while|switch|return|case|
3099 volatile|__volatile__|
3100 __attribute__|format|__extension__|
3103 # cpp #define statements have non-optional spaces, ie
3104 # if there is a space between the name and the open
3105 # parenthesis it is simply not a parameter group.
3106 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3108 # cpp #elif statement condition may start with a (
3109 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3111 # If this whole things ends with a type its most
3112 # likely a typedef for a function.
3113 } elsif ($ctx =~ /$Type$/) {
3117 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3119 $fixed[$linenr - 1] =~
3120 s/\b$name\s+\(/$name\(/;
3125 # Check operator spacing.
3126 if (!($line=~/\#\s*include/)) {
3127 my $fixed_line = "";
3131 <<=|>>=|<=|>=|==|!=|
3132 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3133 =>|->|<<|>>|<|>|=|!|~|
3134 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3137 my @elements = split(/($ops|;)/, $opline);
3139 ## print("element count: <" . $#elements . ">\n");
3140 ## foreach my $el (@elements) {
3141 ## print("el: <$el>\n");
3144 my @fix_elements = ();
3147 foreach my $el (@elements) {
3148 push(@fix_elements, substr($rawline, $off, length($el)));
3149 $off += length($el);
3154 my $blank = copy_spacing($opline);
3155 my $last_after = -1;
3157 for (my $n = 0; $n < $#elements; $n += 2) {
3159 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3161 ## print("n: <$n> good: <$good>\n");
3163 $off += length($elements[$n]);
3165 # Pick up the preceding and succeeding characters.
3166 my $ca = substr($opline, 0, $off);
3168 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3169 $cc = substr($opline, $off + length($elements[$n + 1]));
3171 my $cb = "$ca$;$cc";
3174 $a = 'V' if ($elements[$n] ne '');
3175 $a = 'W' if ($elements[$n] =~ /\s$/);
3176 $a = 'C' if ($elements[$n] =~ /$;$/);
3177 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3178 $a = 'O' if ($elements[$n] eq '');
3179 $a = 'E' if ($ca =~ /^\s*$/);
3181 my $op = $elements[$n + 1];
3184 if (defined $elements[$n + 2]) {
3185 $c = 'V' if ($elements[$n + 2] ne '');
3186 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3187 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3188 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3189 $c = 'O' if ($elements[$n + 2] eq '');
3190 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3195 my $ctx = "${a}x${c}";
3197 my $at = "(ctx:$ctx)";
3199 my $ptr = substr($blank, 0, $off) . "^";
3200 my $hereptr = "$hereline$ptr\n";
3202 # Pull out the value of this operator.
3203 my $op_type = substr($curr_values, $off + 1, 1);
3205 # Get the full operator variant.
3206 my $opv = $op . substr($curr_vars, $off, 1);
3208 # Ignore operators passed as parameters.
3209 if ($op_type ne 'V' &&
3210 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3213 # } elsif ($op =~ /^$;+$/) {
3215 # ; should have either the end of line or a space or \ after it
3216 } elsif ($op eq ';') {
3217 if ($ctx !~ /.x[WEBC]/ &&
3218 $cc !~ /^\\/ && $cc !~ /^;/) {
3219 if (ERROR("SPACING",
3220 "space required after that '$op' $at\n" . $hereptr)) {
3221 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3227 } elsif ($op eq '//') {
3229 # : when part of a bitfield
3230 } elsif ($opv eq ':B') {
3231 # skip the bitfield test for now
3235 } elsif ($op eq '->') {
3236 if ($ctx =~ /Wx.|.xW/) {
3237 if (ERROR("SPACING",
3238 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3239 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3240 if (defined $fix_elements[$n + 2]) {
3241 $fix_elements[$n + 2] =~ s/^\s+//;
3247 # , must have a space on the right.
3248 } elsif ($op eq ',') {
3249 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3250 if (ERROR("SPACING",
3251 "space required after that '$op' $at\n" . $hereptr)) {
3252 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3258 # '*' as part of a type definition -- reported already.
3259 } elsif ($opv eq '*_') {
3260 #warn "'*' is part of type\n";
3262 # unary operators should have a space before and
3263 # none after. May be left adjacent to another
3264 # unary operator, or a cast
3265 } elsif ($op eq '!' || $op eq '~' ||
3266 $opv eq '*U' || $opv eq '-U' ||
3267 $opv eq '&U' || $opv eq '&&U') {
3268 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3269 if (ERROR("SPACING",
3270 "space required before that '$op' $at\n" . $hereptr)) {
3271 if ($n != $last_after + 2) {
3272 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3277 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3278 # A unary '*' may be const
3280 } elsif ($ctx =~ /.xW/) {
3281 if (ERROR("SPACING",
3282 "space prohibited after that '$op' $at\n" . $hereptr)) {
3283 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3284 if (defined $fix_elements[$n + 2]) {
3285 $fix_elements[$n + 2] =~ s/^\s+//;
3291 # unary ++ and unary -- are allowed no space on one side.
3292 } elsif ($op eq '++' or $op eq '--') {
3293 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3294 if (ERROR("SPACING",
3295 "space required one side of that '$op' $at\n" . $hereptr)) {
3296 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3300 if ($ctx =~ /Wx[BE]/ ||
3301 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3302 if (ERROR("SPACING",
3303 "space prohibited before that '$op' $at\n" . $hereptr)) {
3304 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3308 if ($ctx =~ /ExW/) {
3309 if (ERROR("SPACING",
3310 "space prohibited after that '$op' $at\n" . $hereptr)) {
3311 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3312 if (defined $fix_elements[$n + 2]) {
3313 $fix_elements[$n + 2] =~ s/^\s+//;
3319 # << and >> may either have or not have spaces both sides
3320 } elsif ($op eq '<<' or $op eq '>>' or
3321 $op eq '&' or $op eq '^' or $op eq '|' or
3322 $op eq '+' or $op eq '-' or
3323 $op eq '*' or $op eq '/' or
3326 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3327 if (ERROR("SPACING",
3328 "need consistent spacing around '$op' $at\n" . $hereptr)) {
3329 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3330 if (defined $fix_elements[$n + 2]) {
3331 $fix_elements[$n + 2] =~ s/^\s+//;
3337 # A colon needs no spaces before when it is
3338 # terminating a case value or a label.
3339 } elsif ($opv eq ':C' || $opv eq ':L') {
3340 if ($ctx =~ /Wx./) {
3341 if (ERROR("SPACING",
3342 "space prohibited before that '$op' $at\n" . $hereptr)) {
3343 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3348 # All the others need spaces both sides.
3349 } elsif ($ctx !~ /[EWC]x[CWE]/) {
3352 # Ignore email addresses <foo@bar>
3354 $cc =~ /^\S+\@\S+>/) ||
3356 $ca =~ /<\S+\@\S+$/))
3361 # messages are ERROR, but ?: are CHK
3363 my $msg_type = \&ERROR;
3364 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3366 if (&{$msg_type}("SPACING",
3367 "spaces required around that '$op' $at\n" . $hereptr)) {
3368 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3369 if (defined $fix_elements[$n + 2]) {
3370 $fix_elements[$n + 2] =~ s/^\s+//;
3376 $off += length($elements[$n + 1]);
3378 ## print("n: <$n> GOOD: <$good>\n");
3380 $fixed_line = $fixed_line . $good;
3383 if (($#elements % 2) == 0) {
3384 $fixed_line = $fixed_line . $fix_elements[$#elements];
3387 if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {
3388 $fixed[$linenr - 1] = $fixed_line;
3394 # check for whitespace before a non-naked semicolon
3395 if ($line =~ /^\+.*\S\s+;\s*$/) {
3397 "space prohibited before semicolon\n" . $herecurr) &&
3399 1 while $fixed[$linenr - 1] =~
3400 s/^(\+.*\S)\s+;/$1;/;
3404 # check for multiple assignments
3405 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3406 CHK("MULTIPLE_ASSIGNMENTS",
3407 "multiple assignments should be avoided\n" . $herecurr);
3410 ## # check for multiple declarations, allowing for a function declaration
3412 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3413 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3415 ## # Remove any bracketed sections to ensure we do not
3416 ## # falsly report the parameters of functions.
3418 ## while ($ln =~ s/\([^\(\)]*\)//g) {
3420 ## if ($ln =~ /,/) {
3421 ## WARN("MULTIPLE_DECLARATION",
3422 ## "declaring multiple variables together should be avoided\n" . $herecurr);
3426 #need space before brace following if, while, etc
3427 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3429 if (ERROR("SPACING",
3430 "space required before the open brace '{'\n" . $herecurr) &&
3432 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
3436 ## # check for blank lines before declarations
3437 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3438 ## $prevrawline =~ /^.\s*$/) {
3440 ## "No blank lines before declarations\n" . $hereprev);
3444 # closing brace should have a space following it when it has anything
3446 if ($line =~ /}(?!(?:,|;|\)))\S/) {
3447 if (ERROR("SPACING",
3448 "space required after that close brace '}'\n" . $herecurr) &&
3450 $fixed[$linenr - 1] =~
3451 s/}((?!(?:,|;|\)))\S)/} $1/;
3455 # check spacing on square brackets
3456 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3457 if (ERROR("SPACING",
3458 "space prohibited after that open square bracket '['\n" . $herecurr) &&
3460 $fixed[$linenr - 1] =~
3464 if ($line =~ /\s\]/) {
3465 if (ERROR("SPACING",
3466 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3468 $fixed[$linenr - 1] =~
3473 # check spacing on parentheses
3474 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3475 $line !~ /for\s*\(\s+;/) {
3476 if (ERROR("SPACING",
3477 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3479 $fixed[$linenr - 1] =~
3483 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3484 $line !~ /for\s*\(.*;\s+\)/ &&
3485 $line !~ /:\s+\)/) {
3486 if (ERROR("SPACING",
3487 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3489 $fixed[$linenr - 1] =~
3494 # check unnecessary parentheses around addressof/dereference single $Lvals
3495 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
3497 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
3498 CHK("UNNECESSARY_PARENTHESES",
3499 "Unnecessary parentheses around $1\n" . $herecurr);
3502 #goto labels aren't indented, allow a single space however
3503 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3504 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3505 if (WARN("INDENTED_LABEL",
3506 "labels should not be indented\n" . $herecurr) &&
3508 $fixed[$linenr - 1] =~
3513 # return is not a function
3514 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
3516 if ($^V && $^V ge 5.10.0 &&
3517 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
3519 $value = deparenthesize($value);
3520 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
3521 ERROR("RETURN_PARENTHESES",
3522 "return is not a function, parentheses are not required\n" . $herecurr);
3524 } elsif ($spacing !~ /\s+/) {
3526 "space required before the open parenthesis '('\n" . $herecurr);
3530 # unnecessary return in a void function
3531 # at end-of-function, with the previous line a single leading tab, then return;
3532 # and the line before that not a goto label target like "out:"
3533 if ($sline =~ /^[ \+]}\s*$/ &&
3534 $prevline =~ /^\+\treturn\s*;\s*$/ &&
3536 $lines[$linenr - 3] =~ /^[ +]/ &&
3537 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
3539 "void function return statements are not generally useful\n" . $hereprev);
3542 # if statements using unnecessary parentheses - ie: if ((foo == bar))
3543 if ($^V && $^V ge 5.10.0 &&
3544 $line =~ /\bif\s*((?:\(\s*){2,})/) {
3545 my $openparens = $1;
3546 my $count = $openparens =~ tr@\(@\(@;
3548 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3549 my $comp = $4; #Not $1 because of $LvalOrFunc
3550 $msg = " - maybe == should be = ?" if ($comp eq "==");
3551 WARN("UNNECESSARY_PARENTHESES",
3552 "Unnecessary parentheses$msg\n" . $herecurr);
3556 # Return of what appears to be an errno should normally be -'ve
3557 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3559 if ($name ne 'EOF' && $name ne 'ERROR') {
3560 WARN("USE_NEGATIVE_ERRNO",
3561 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3565 # Need a space before open parenthesis after if, while etc
3566 if ($line =~ /\b(if|while|for|switch)\(/) {
3567 if (ERROR("SPACING",
3568 "space required before the open parenthesis '('\n" . $herecurr) &&
3570 $fixed[$linenr - 1] =~
3571 s/\b(if|while|for|switch)\(/$1 \(/;
3575 # Check for illegal assignment in if conditional -- and check for trailing
3576 # statements after the conditional.
3577 if ($line =~ /do\s*(?!{)/) {
3578 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3579 ctx_statement_block($linenr, $realcnt, 0)
3580 if (!defined $stat);
3581 my ($stat_next) = ctx_statement_block($line_nr_next,
3582 $remain_next, $off_next);
3583 $stat_next =~ s/\n./\n /g;
3584 ##print "stat<$stat> stat_next<$stat_next>\n";
3586 if ($stat_next =~ /^\s*while\b/) {
3587 # If the statement carries leading newlines,
3588 # then count those as offsets.
3590 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3592 statement_rawlines($whitespace) - 1;
3594 $suppress_whiletrailers{$line_nr_next +
3598 if (!defined $suppress_whiletrailers{$linenr} &&
3599 defined($stat) && defined($cond) &&
3600 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3601 my ($s, $c) = ($stat, $cond);
3603 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3604 ERROR("ASSIGN_IN_IF",
3605 "do not use assignment in if condition\n" . $herecurr);
3608 # Find out what is on the end of the line after the
3610 substr($s, 0, length($c), '');
3612 $s =~ s/$;//g; # Remove any comments
3613 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3614 $c !~ /}\s*while\s*/)
3616 # Find out how long the conditional actually is.
3617 my @newlines = ($c =~ /\n/gs);
3618 my $cond_lines = 1 + $#newlines;
3621 $stat_real = raw_line($linenr, $cond_lines)
3622 . "\n" if ($cond_lines);
3623 if (defined($stat_real) && $cond_lines > 1) {
3624 $stat_real = "[...]\n$stat_real";
3627 ERROR("TRAILING_STATEMENTS",
3628 "trailing statements should be on next line\n" . $herecurr . $stat_real);
3632 # Check for bitwise tests written as boolean
3644 WARN("HEXADECIMAL_BOOLEAN_TEST",
3645 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3648 # if and else should not have general statements after it
3649 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3651 $s =~ s/$;//g; # Remove any comments
3652 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3653 ERROR("TRAILING_STATEMENTS",
3654 "trailing statements should be on next line\n" . $herecurr);
3657 # if should not continue a brace
3658 if ($line =~ /}\s*if\b/) {
3659 ERROR("TRAILING_STATEMENTS",
3660 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
3663 # case and default should not have general statements after them
3664 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3666 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3670 ERROR("TRAILING_STATEMENTS",
3671 "trailing statements should be on next line\n" . $herecurr);
3674 # Check for }<nl>else {, these must be at the same
3675 # indent level to be relevant to each other.
3676 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3677 $previndent == $indent) {
3678 ERROR("ELSE_AFTER_BRACE",
3679 "else should follow close brace '}'\n" . $hereprev);
3682 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3683 $previndent == $indent) {
3684 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3686 # Find out what is on the end of the line after the
3688 substr($s, 0, length($c), '');
3691 if ($s =~ /^\s*;/) {
3692 ERROR("WHILE_AFTER_BRACE",
3693 "while should follow close brace '}'\n" . $hereprev);
3697 #Specific variable tests
3698 while ($line =~ m{($Constant|$Lval)}g) {
3701 #gcc binary extension
3702 if ($var =~ /^$Binary$/) {
3703 if (WARN("GCC_BINARY_CONSTANT",
3704 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3706 my $hexval = sprintf("0x%x", oct($var));
3707 $fixed[$linenr - 1] =~
3708 s/\b$var\b/$hexval/;
3713 if ($var !~ /^$Constant$/ &&
3714 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
3715 #Ignore Page<foo> variants
3716 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
3717 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3718 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
3719 while ($var =~ m{($Ident)}g) {
3721 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
3723 seed_camelcase_includes();
3724 if (!$file && !$camelcase_file_seeded) {
3725 seed_camelcase_file($realfile);
3726 $camelcase_file_seeded = 1;
3729 if (!defined $camelcase{$word}) {
3730 $camelcase{$word} = 1;
3732 "Avoid CamelCase: <$word>\n" . $herecurr);
3738 #no spaces allowed after \ in define
3739 if ($line =~ /\#\s*define.*\\\s+$/) {
3740 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3741 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3743 $fixed[$linenr - 1] =~ s/\s+$//;
3747 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3748 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
3750 my $checkfile = "include/linux/$file";
3751 if (-f "$root/$checkfile" &&
3752 $realfile ne $checkfile &&
3753 $1 !~ /$allowed_asm_includes/)
3755 if ($realfile =~ m{^arch/}) {
3756 CHK("ARCH_INCLUDE_LINUX",
3757 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3759 WARN("INCLUDE_LINUX",
3760 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3765 # multi-statement macros should be enclosed in a do while loop, grab the
3766 # first statement and ensure its the whole macro if its not enclosed
3767 # in a known good container
3768 if ($realfile !~ m@/vmlinux.lds.h$@ &&
3769 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
3772 my ($off, $dstat, $dcond, $rest);
3774 ($dstat, $dcond, $ln, $cnt, $off) =
3775 ctx_statement_block($linenr, $realcnt, 0);
3777 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3778 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3780 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
3782 $dstat =~ s/\\\n.//g;
3783 $dstat =~ s/^\s*//s;
3784 $dstat =~ s/\s*$//s;
3786 # Flatten any parentheses and braces
3787 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3788 $dstat =~ s/\{[^\{\}]*\}/1/ ||
3789 $dstat =~ s/\[[^\[\]]*\]/1/)
3793 # Flatten any obvious string concatentation.
3794 while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3795 $dstat =~ s/$Ident\s*("X*")/$1/)
3799 my $exceptions = qr{
3811 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3813 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
3814 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
3815 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3816 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
3817 $dstat !~ /$exceptions/ &&
3818 $dstat !~ /^\.$Ident\s*=/ && # .foo =
3819 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
3820 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
3821 $dstat !~ /^for\s*$Constant$/ && # for (...)
3822 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
3823 $dstat !~ /^do\s*{/ && # do {...
3824 $dstat !~ /^\({/ && # ({...
3825 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
3828 my $herectx = $here . "\n";
3829 my $cnt = statement_rawlines($ctx);
3831 for (my $n = 0; $n < $cnt; $n++) {
3832 $herectx .= raw_line($linenr, $n) . "\n";
3835 if ($dstat =~ /;/) {
3836 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3837 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3839 ERROR("COMPLEX_MACRO",
3840 "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3844 # check for line continuations outside of #defines, preprocessor #, and asm
3847 if ($prevline !~ /^..*\\$/ &&
3848 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
3849 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
3850 $line =~ /^\+.*\\$/) {
3851 WARN("LINE_CONTINUATIONS",
3852 "Avoid unnecessary line continuations\n" . $herecurr);
3856 # do {} while (0) macro tests:
3857 # single-statement macros do not need to be enclosed in do while (0) loop,
3858 # macro should not end with a semicolon
3859 if ($^V && $^V ge 5.10.0 &&
3860 $realfile !~ m@/vmlinux.lds.h$@ &&
3861 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3864 my ($off, $dstat, $dcond, $rest);
3866 ($dstat, $dcond, $ln, $cnt, $off) =
3867 ctx_statement_block($linenr, $realcnt, 0);
3870 $dstat =~ s/\\\n.//g;
3872 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3877 my $cnt = statement_rawlines($ctx);
3878 my $herectx = $here . "\n";
3880 for (my $n = 0; $n < $cnt; $n++) {
3881 $herectx .= raw_line($linenr, $n) . "\n";
3884 if (($stmts =~ tr/;/;/) == 1 &&
3885 $stmts !~ /^\s*(if|while|for|switch)\b/) {
3886 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3887 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3889 if (defined $semis && $semis ne "") {
3890 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3891 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3893 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
3895 my $cnt = statement_rawlines($ctx);
3896 my $herectx = $here . "\n";
3898 for (my $n = 0; $n < $cnt; $n++) {
3899 $herectx .= raw_line($linenr, $n) . "\n";
3902 WARN("TRAILING_SEMICOLON",
3903 "macros should not use a trailing semicolon\n" . "$herectx");
3907 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3908 # all assignments may have only one of the following with an assignment:
3911 # VMLINUX_SYMBOL(...)
3912 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
3913 WARN("MISSING_VMLINUX_SYMBOL",
3914 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3917 # check for redundant bracing round if etc
3918 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3919 my ($level, $endln, @chunks) =
3920 ctx_statement_full($linenr, $realcnt, 1);
3921 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3922 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3923 if ($#chunks > 0 && $level == 0) {
3927 my $herectx = $here . "\n";
3928 my $ln = $linenr - 1;
3929 for my $chunk (@chunks) {
3930 my ($cond, $block) = @{$chunk};
3932 # If the condition carries leading newlines, then count those as offsets.
3933 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3934 my $offset = statement_rawlines($whitespace) - 1;
3936 $allowed[$allow] = 0;
3937 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3939 # We have looked at and allowed this specific line.
3940 $suppress_ifbraces{$ln + $offset} = 1;
3942 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3943 $ln += statement_rawlines($block) - 1;
3945 substr($block, 0, length($cond), '');
3947 $seen++ if ($block =~ /^\s*{/);
3949 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3950 if (statement_lines($cond) > 1) {
3951 #print "APW: ALLOWED: cond<$cond>\n";
3952 $allowed[$allow] = 1;
3954 if ($block =~/\b(?:if|for|while)\b/) {
3955 #print "APW: ALLOWED: block<$block>\n";
3956 $allowed[$allow] = 1;
3958 if (statement_block_size($block) > 1) {
3959 #print "APW: ALLOWED: lines block<$block>\n";
3960 $allowed[$allow] = 1;
3965 my $sum_allowed = 0;
3966 foreach (@allowed) {
3969 if ($sum_allowed == 0) {
3971 "braces {} are not necessary for any arm of this statement\n" . $herectx);
3972 } elsif ($sum_allowed != $allow &&
3975 "braces {} should be used on all arms of this statement\n" . $herectx);
3980 if (!defined $suppress_ifbraces{$linenr - 1} &&
3981 $line =~ /\b(if|while|for|else)\b/) {
3984 # Check the pre-context.
3985 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3986 #print "APW: ALLOWED: pre<$1>\n";
3990 my ($level, $endln, @chunks) =
3991 ctx_statement_full($linenr, $realcnt, $-[0]);
3993 # Check the condition.
3994 my ($cond, $block) = @{$chunks[0]};
3995 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3996 if (defined $cond) {
3997 substr($block, 0, length($cond), '');
3999 if (statement_lines($cond) > 1) {
4000 #print "APW: ALLOWED: cond<$cond>\n";
4003 if ($block =~/\b(?:if|for|while)\b/) {
4004 #print "APW: ALLOWED: block<$block>\n";
4007 if (statement_block_size($block) > 1) {
4008 #print "APW: ALLOWED: lines block<$block>\n";
4011 # Check the post-context.
4012 if (defined $chunks[1]) {
4013 my ($cond, $block) = @{$chunks[1]};
4014 if (defined $cond) {
4015 substr($block, 0, length($cond), '');
4017 if ($block =~ /^\s*\{/) {
4018 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4022 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4023 my $herectx = $here . "\n";
4024 my $cnt = statement_rawlines($block);
4026 for (my $n = 0; $n < $cnt; $n++) {
4027 $herectx .= raw_line($linenr, $n) . "\n";
4031 "braces {} are not necessary for single statement blocks\n" . $herectx);
4035 # check for unnecessary blank lines around braces
4036 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4038 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
4040 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4042 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
4045 # no volatiles please
4046 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4047 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4049 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4053 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
4054 CHK("REDUNDANT_CODE",
4055 "if this code is redundant consider removing it\n" .
4059 # check for needless "if (<foo>) fn(<foo>)" uses
4060 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4061 my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4062 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4064 "$1(NULL) is safe this check is probably not required\n" . $hereprev);
4068 # check for unnecessary "Out of Memory" messages
4069 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4070 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4071 (defined $1 || defined $3) &&
4074 my $testline = $lines[$linenr - 3];
4076 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4077 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4079 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4081 "Possible unnecessary 'out of memory' message\n" . $hereprev);
4085 # check for bad placement of section $InitAttribute (e.g.: __initdata)
4086 if ($line =~ /(\b$InitAttribute\b)/) {
4088 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4091 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4092 ERROR("MISPLACED_INIT",
4093 "$attr should be placed after $var\n" . $herecurr)) ||
4094 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4095 WARN("MISPLACED_INIT",
4096 "$attr should be placed after $var\n" . $herecurr))) &&
4098 $fixed[$linenr - 1] =~ 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;
4103 # check for $InitAttributeData (ie: __initdata) with const
4104 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4106 $attr =~ /($InitAttributePrefix)(.*)/;
4107 my $attr_prefix = $1;
4109 if (ERROR("INIT_ATTRIBUTE",
4110 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4112 $fixed[$linenr - 1] =~
4113 s/$InitAttributeData/${attr_prefix}initconst/;
4117 # check for $InitAttributeConst (ie: __initconst) without const
4118 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4120 if (ERROR("INIT_ATTRIBUTE",
4121 "Use of $attr requires a separate use of const\n" . $herecurr) &&
4123 my $lead = $fixed[$linenr - 1] =~
4124 /(^\+\s*(?:static\s+))/;
4126 $lead = "$lead " if ($lead !~ /^\+$/);
4127 $lead = "${lead}const ";
4128 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
4132 # don't use __constant_<foo> functions outside of include/uapi/
4133 if ($realfile !~ m@^include/uapi/@ &&
4134 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4135 my $constant_func = $1;
4136 my $func = $constant_func;
4137 $func =~ s/^__constant_//;
4138 if (WARN("CONSTANT_CONVERSION",
4139 "$constant_func should be $func\n" . $herecurr) &&
4141 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;
4145 # prefer usleep_range over udelay
4146 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
4148 # ignore udelay's < 10, however
4149 if (! ($delay < 10) ) {
4151 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4153 if ($delay > 2000) {
4155 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
4159 # warn about unexpectedly long msleep's
4160 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4163 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4167 # check for comparisons of jiffies
4168 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4169 WARN("JIFFIES_COMPARISON",
4170 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4173 # check for comparisons of get_jiffies_64()
4174 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4175 WARN("JIFFIES_COMPARISON",
4176 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4179 # warn about #ifdefs in C files
4180 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4181 # print "#ifdef in C files should be avoided\n";
4182 # print "$herecurr";
4186 # warn about spacing in #ifdefs
4187 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4188 if (ERROR("SPACING",
4189 "exactly one space required after that #$1\n" . $herecurr) &&
4191 $fixed[$linenr - 1] =~
4192 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4197 # check for spinlock_t definitions without a comment.
4198 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4199 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4201 if (!ctx_has_comment($first_line, $linenr)) {
4202 CHK("UNCOMMENTED_DEFINITION",
4203 "$1 definition without comment\n" . $herecurr);
4206 # check for memory barriers without a comment.
4207 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4208 if (!ctx_has_comment($first_line, $linenr)) {
4209 WARN("MEMORY_BARRIER",
4210 "memory barrier without comment\n" . $herecurr);
4213 # check of hardware specific defines
4214 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4216 "architecture specific defines should be avoided\n" . $herecurr);
4219 # Check that the storage class is at the beginning of a declaration
4220 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4221 WARN("STORAGE_CLASS",
4222 "storage class should be at the beginning of the declaration\n" . $herecurr)
4225 # check the location of the inline attribute, that it is between
4226 # storage class and type.
4227 if ($line =~ /\b$Type\s+$Inline\b/ ||
4228 $line =~ /\b$Inline\s+$Storage\b/) {
4229 ERROR("INLINE_LOCATION",
4230 "inline keyword should sit between storage class and type\n" . $herecurr);
4233 # Check for __inline__ and __inline, prefer inline
4234 if ($realfile !~ m@\binclude/uapi/@ &&
4235 $line =~ /\b(__inline__|__inline)\b/) {
4237 "plain inline is preferred over $1\n" . $herecurr) &&
4239 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4244 # Check for __attribute__ packed, prefer __packed
4245 if ($realfile !~ m@\binclude/uapi/@ &&
4246 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4247 WARN("PREFER_PACKED",
4248 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4251 # Check for __attribute__ aligned, prefer __aligned
4252 if ($realfile !~ m@\binclude/uapi/@ &&
4253 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4254 WARN("PREFER_ALIGNED",
4255 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4258 # Check for __attribute__ format(printf, prefer __printf
4259 if ($realfile !~ m@\binclude/uapi/@ &&
4260 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4261 if (WARN("PREFER_PRINTF",
4262 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4264 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4269 # Check for __attribute__ format(scanf, prefer __scanf
4270 if ($realfile !~ m@\binclude/uapi/@ &&
4271 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4272 if (WARN("PREFER_SCANF",
4273 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4275 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4279 # check for sizeof(&)
4280 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4281 WARN("SIZEOF_ADDRESS",
4282 "sizeof(& should be avoided\n" . $herecurr);
4285 # check for sizeof without parenthesis
4286 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4287 if (WARN("SIZEOF_PARENTHESIS",
4288 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4290 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4294 # check for line continuations in quoted strings with odd counts of "
4295 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4296 WARN("LINE_CONTINUATIONS",
4297 "Avoid line continuations in quoted strings\n" . $herecurr);
4300 # check for struct spinlock declarations
4301 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4302 WARN("USE_SPINLOCK_T",
4303 "struct spinlock should be spinlock_t\n" . $herecurr);
4306 # check for seq_printf uses that could be seq_puts
4307 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4308 my $fmt = get_quoted_string($line, $rawline);
4309 if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4310 if (WARN("PREFER_SEQ_PUTS",
4311 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4313 $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4318 # Check for misused memsets
4319 if ($^V && $^V ge 5.10.0 &&
4321 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4327 if ($ms_size =~ /^(0x|)0$/i) {
4329 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4330 } elsif ($ms_size =~ /^(0x|)1$/i) {
4332 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4336 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4337 if ($^V && $^V ge 5.10.0 &&
4338 $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4339 if (WARN("PREFER_ETHER_ADDR_COPY",
4340 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4342 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4346 # typecasts on min/max could be min_t/max_t
4347 if ($^V && $^V ge 5.10.0 &&
4349 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4350 if (defined $2 || defined $7) {
4352 my $cast1 = deparenthesize($2);
4354 my $cast2 = deparenthesize($7);
4358 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4359 $cast = "$cast1 or $cast2";
4360 } elsif ($cast1 ne "") {
4366 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4370 # check usleep_range arguments
4371 if ($^V && $^V ge 5.10.0 &&
4373 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4377 WARN("USLEEP_RANGE",
4378 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4379 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4381 WARN("USLEEP_RANGE",
4382 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4386 # check for naked sscanf
4387 if ($^V && $^V ge 5.10.0 &&
4389 $line =~ /\bsscanf\b/ &&
4390 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4391 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4392 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4393 my $lc = $stat =~ tr@\n@@;
4394 $lc = $lc + $linenr;
4395 my $stat_real = raw_line($linenr, 0);
4396 for (my $count = $linenr + 1; $count <= $lc; $count++) {
4397 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4399 WARN("NAKED_SSCANF",
4400 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4403 # check for simple sscanf that should be kstrto<foo>
4404 if ($^V && $^V ge 5.10.0 &&
4406 $line =~ /\bsscanf\b/) {
4407 my $lc = $stat =~ tr@\n@@;
4408 $lc = $lc + $linenr;
4409 my $stat_real = raw_line($linenr, 0);
4410 for (my $count = $linenr + 1; $count <= $lc; $count++) {
4411 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4413 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
4415 my $count = $format =~ tr@%@%@;
4417 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
4418 WARN("SSCANF_TO_KSTRTO",
4419 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
4424 # check for new externs in .h files.
4425 if ($realfile =~ /\.h$/ &&
4426 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4427 if (CHK("AVOID_EXTERNS",
4428 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4430 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4434 # check for new externs in .c files.
4435 if ($realfile =~ /\.c$/ && defined $stat &&
4436 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4438 my $function_name = $1;
4439 my $paren_space = $2;
4442 if (defined $cond) {
4443 substr($s, 0, length($cond), '');
4445 if ($s =~ /^\s*;/ &&
4446 $function_name ne 'uninitialized_var')
4448 WARN("AVOID_EXTERNS",
4449 "externs should be avoided in .c files\n" . $herecurr);
4452 if ($paren_space =~ /\n/) {
4453 WARN("FUNCTION_ARGUMENTS",
4454 "arguments for function declarations should follow identifier\n" . $herecurr);
4457 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4458 $stat =~ /^.\s*extern\s+/)
4460 WARN("AVOID_EXTERNS",
4461 "externs should be avoided in .c files\n" . $herecurr);
4464 # checks for new __setup's
4465 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4468 if (!grep(/$name/, @setup_docs)) {
4469 CHK("UNDOCUMENTED_SETUP",
4470 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4474 # check for pointless casting of kmalloc return
4475 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4476 WARN("UNNECESSARY_CASTS",
4477 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4481 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4482 if ($^V && $^V ge 5.10.0 &&
4483 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4484 CHK("ALLOC_SIZEOF_STRUCT",
4485 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4488 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
4489 if ($^V && $^V ge 5.10.0 &&
4490 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
4494 my $newfunc = "kmalloc_array";
4495 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
4498 if ($a1 =~ /^sizeof\s*\S/) {
4502 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
4503 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
4504 if (WARN("ALLOC_WITH_MULTIPLY",
4505 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
4507 $fixed[$linenr - 1] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
4513 # check for krealloc arg reuse
4514 if ($^V && $^V ge 5.10.0 &&
4515 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4516 WARN("KREALLOC_ARG_REUSE",
4517 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4520 # check for alloc argument mismatch
4521 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4522 WARN("ALLOC_ARRAY_ARGS",
4523 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4526 # check for multiple semicolons
4527 if ($line =~ /;\s*;\s*$/) {
4528 if (WARN("ONE_SEMICOLON",
4529 "Statements terminations use 1 semicolon\n" . $herecurr) &&
4531 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4535 # check for case / default statements not preceeded by break/fallthrough/switch
4536 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4538 my $has_statement = 0;
4540 my $prevline = $linenr;
4541 while ($prevline > 1 && $count < 3 && !$has_break) {
4543 my $rline = $rawlines[$prevline - 1];
4544 my $fline = $lines[$prevline - 1];
4545 last if ($fline =~ /^\@\@/);
4546 next if ($fline =~ /^\-/);
4547 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4548 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4549 next if ($fline =~ /^.[\s$;]*$/);
4552 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4554 if (!$has_break && $has_statement) {
4555 WARN("MISSING_BREAK",
4556 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4560 # check for switch/default statements without a break;
4561 if ($^V && $^V ge 5.10.0 &&
4563 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4565 my $herectx = $here . "\n";
4566 my $cnt = statement_rawlines($stat);
4567 for (my $n = 0; $n < $cnt; $n++) {
4568 $herectx .= raw_line($linenr, $n) . "\n";
4570 WARN("DEFAULT_NO_BREAK",
4571 "switch default: should use break\n" . $herectx);
4574 # check for gcc specific __FUNCTION__
4575 if ($line =~ /\b__FUNCTION__\b/) {
4576 if (WARN("USE_FUNC",
4577 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
4579 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4583 # check for use of yield()
4584 if ($line =~ /\byield\s*\(\s*\)/) {
4586 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
4589 # check for comparisons against true and false
4590 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4598 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4600 my $type = lc($otype);
4601 if ($type =~ /^(?:true|false)$/) {
4602 if (("$test" eq "==" && "$type" eq "true") ||
4603 ("$test" eq "!=" && "$type" eq "false")) {
4607 CHK("BOOL_COMPARISON",
4608 "Using comparison to $otype is error prone\n" . $herecurr);
4610 ## maybe suggesting a correct construct would better
4611 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4616 # check for semaphores initialized locked
4617 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4618 WARN("CONSIDER_COMPLETION",
4619 "consider using a completion\n" . $herecurr);
4622 # recommend kstrto* over simple_strto* and strict_strto*
4623 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
4624 WARN("CONSIDER_KSTRTO",
4625 "$1 is obsolete, use k$3 instead\n" . $herecurr);
4628 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
4629 if ($line =~ /^.\s*__initcall\s*\(/) {
4630 WARN("USE_DEVICE_INITCALL",
4631 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
4634 # check for various ops structs, ensure they are const.
4635 my $struct_ops = qr{acpi_dock_ops|
4636 address_space_operations|
4638 block_device_operations|
4643 file_lock_operations|
4653 lock_manager_operations|
4659 pipe_buf_operations|
4660 platform_hibernation_ops|
4661 platform_suspend_ops|
4666 soc_pcmcia_socket_ops|
4672 if ($line !~ /\bconst\b/ &&
4673 $line =~ /\bstruct\s+($struct_ops)\b/) {
4674 WARN("CONST_STRUCT",
4675 "struct $1 should normally be const\n" .
4679 # use of NR_CPUS is usually wrong
4680 # ignore definitions of NR_CPUS and usage to define arrays as likely right
4681 if ($line =~ /\bNR_CPUS\b/ &&
4682 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4683 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4684 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4685 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4686 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4689 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4692 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4693 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4694 ERROR("DEFINE_ARCH_HAS",
4695 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4698 # check for %L{u,d,i} in strings
4700 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4701 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4702 $string =~ s/%%/__/g;
4703 if ($string =~ /(?<!%)%L[udi]/) {
4705 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4710 # whine mightly about in_atomic
4711 if ($line =~ /\bin_atomic\s*\(/) {
4712 if ($realfile =~ m@^drivers/@) {
4714 "do not use in_atomic in drivers\n" . $herecurr);
4715 } elsif ($realfile !~ m@^kernel/@) {
4717 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
4721 # check for lockdep_set_novalidate_class
4722 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4723 $line =~ /__lockdep_no_validate__\s*\)/ ) {
4724 if ($realfile !~ m@^kernel/lockdep@ &&
4725 $realfile !~ m@^include/linux/lockdep@ &&
4726 $realfile !~ m@^drivers/base/core@) {
4728 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
4732 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4733 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
4734 WARN("EXPORTED_WORLD_WRITABLE",
4735 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4738 # Mode permission misuses where it seems decimal should be octal
4739 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
4740 if ($^V && $^V ge 5.10.0 &&
4741 $line =~ /$mode_perms_search/) {
4742 foreach my $entry (@mode_permission_funcs) {
4743 my $func = $entry->[0];
4744 my $arg_pos = $entry->[1];
4749 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
4751 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
4752 if ($line =~ /$test/) {
4754 $val = $6 if ($skip_args ne "");
4756 if ($val !~ /^0$/ &&
4757 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
4758 length($val) ne 4)) {
4759 ERROR("NON_OCTAL_PERMISSIONS",
4760 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
4767 # If we have no input at all, then there is nothing to report on
4768 # so just keep quiet.
4769 if ($#rawlines == -1) {
4773 # In mailback mode only produce a report in the negative, for
4774 # things that appear to be patches.
4775 if ($mailback && ($clean == 1 || !$is_patch)) {
4779 # This is not a patch, and we are are in 'no-patch' mode so
4781 if (!$chk_patch && !$is_patch) {
4786 ERROR("NOT_UNIFIED_DIFF",
4787 "Does not appear to be a unified-diff format patch\n");
4789 if ($is_patch && $chk_signoff && $signoff == 0) {
4790 ERROR("MISSING_SIGN_OFF",
4791 "Missing Signed-off-by: line(s)\n");
4794 print report_dump();
4795 if ($summary && !($clean == 1 && $quiet == 1)) {
4796 print "$filename " if ($summary_file);
4797 print "total: $cnt_error errors, $cnt_warn warnings, " .
4798 (($check)? "$cnt_chk checks, " : "") .
4799 "$cnt_lines lines checked\n";
4800 print "\n" if ($quiet == 0);
4805 if ($^V lt 5.10.0) {
4806 print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4807 print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4810 # If there were whitespace errors which cleanpatch can fix
4811 # then suggest that.
4812 if ($rpt_cleaners) {
4813 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4814 print " scripts/cleanfile\n\n";
4819 hash_show_words(\%use_type, "Used");
4820 hash_show_words(\%ignore_type, "Ignored");
4822 if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
4823 my $newfile = $filename;
4824 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
4828 open($f, '>', $newfile)
4829 or die "$P: Can't open $newfile for write\n";
4830 foreach my $fixed_line (@fixed) {
4833 if ($linecount > 3) {
4834 $fixed_line =~ s/^\+//;
4835 print $f $fixed_line. "\n";
4838 print $f $fixed_line . "\n";
4845 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4847 Do _NOT_ trust the results written to this file.
4848 Do _NOT_ submit these changes without inspecting them for correctness.
4850 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4851 No warranties, expressed or implied...
4857 if ($clean == 1 && $quiet == 0) {
4858 print "$vname has no obvious style problems and is ready for submission.\n"
4860 if ($clean == 0 && $quiet == 0) {
4862 $vname has style problems, please review.
4864 If any of these errors are false positives, please report
4865 them to the maintainer, see CHECKPATCH in MAINTAINERS.