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
12 use Term
::ANSIColor
qw(:constants);
15 my $D = dirname
(abs_path
($P));
19 use Getopt
::Long
qw(:config no_auto_abbrev);
49 my $configuration_file = ".checkpatch.conf";
50 my $max_line_length = 80;
51 my $ignore_perl_version = 0;
52 my $minimum_perl_version = 5.10.0;
53 my $min_conf_desc_length = 4;
54 my $spelling_file = "$D/spelling.txt";
56 my $codespellfile = "/usr/share/codespell/dictionary.txt";
63 Usage
: $P [OPTION
]... [FILE
]...
68 --no-tree run without a kernel tree
69 --no-signoff
do not check
for 'Signed-off-by' line
70 --patch treat FILE as patchfile
(default)
71 --emacs emacs compile window format
72 --terse one line per report
73 --showfile emit diffed file position
, not input file position
74 -g
, --git treat FILE as a single commit
or git revision range
75 single git commit with
:
79 multiple git commits with
:
83 git merges are ignored
84 -f
, --file treat FILE as regular source file
85 --subjective
, --strict enable more subjective tests
86 --list-types list the possible message types
87 --types TYPE
(,TYPE2
...) show only these comma separated message types
88 --ignore TYPE
(,TYPE2
...) ignore various comma separated message types
89 --show-types show the specific message type
in the output
90 --max-line-length
=n set the maximum line
length, if exceeded
, warn
91 --min-conf-desc-length
=n set the min description
length, if shorter
, warn
92 --root
=PATH PATH to the kernel tree root
93 --no-summary suppress the per-file summary
94 --mailback only produce a report
in case of warnings
/errors
95 --summary-file include the filename
in summary
96 --debug KEY
=[0|1] turn on
/off debugging of KEY
, where KEY
is one of
97 'values', 'possible', 'type', and 'attr' (default
99 --test-only
=WORD report only warnings
/errors containing WORD
101 --fix EXPERIMENTAL
- may create horrible results
102 If correctable single-line errors exist
, create
103 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
104 with potential errors corrected to the preferred
106 --fix-inplace EXPERIMENTAL
- may create horrible results
107 Is the same as
--fix
, but overwrites the input
108 file
. It
's your fault if there's
no backup
or git
109 --ignore-perl-version override checking of perl version
. expect
111 --codespell Use the codespell dictionary
for spelling
/typos
112 (default:/usr/share
/codespell/dictionary
.txt
)
113 --codespellfile Use this codespell dictionary
114 --color Use colors
when output
is STDOUT
(default: on
)
115 -h
, --help
, --version display this help
and exit
117 When FILE
is - read standard input
.
125 return grep { !$seen{$_}++ } @_;
135 open(my $script, '<', abs_path
($P)) or
136 die "$P: Can't read '$P' $!\n";
138 my $text = <$script>;
142 for ($text =~ /\b(?:(?:CHK|WARN|ERROR)\s*\(\s*"([^"]+)")/g) {
145 @types = sort(uniq
(@types));
146 print("#\tMessage type\n\n");
147 foreach my $type (@types) {
148 print(++$count . "\t" . $type . "\n");
154 my $conf = which_conf
($configuration_file);
157 open(my $conffile, '<', "$conf")
158 or warn "$P: Can't find a readable $configuration_file file $!\n";
160 while (<$conffile>) {
163 $line =~ s/\s*\n?$//g;
167 next if ($line =~ m/^\s*#/);
168 next if ($line =~ m/^\s*$/);
170 my @words = split(" ", $line);
171 foreach my $word (@words) {
172 last if ($word =~ m/^#/);
173 push (@conf_args, $word);
177 unshift(@ARGV, @conf_args) if @conf_args;
181 'q|quiet+' => \
$quiet,
183 'signoff!' => \
$chk_signoff,
184 'patch!' => \
$chk_patch,
187 'showfile!' => \
$showfile,
190 'subjective!' => \
$check,
191 'strict!' => \
$check,
192 'ignore=s' => \
@ignore,
194 'show-types!' => \
$show_types,
195 'list-types!' => \
$list_types,
196 'max-line-length=i' => \
$max_line_length,
197 'min-conf-desc-length=i' => \
$min_conf_desc_length,
199 'summary!' => \
$summary,
200 'mailback!' => \
$mailback,
201 'summary-file!' => \
$summary_file,
203 'fix-inplace!' => \
$fix_inplace,
204 'ignore-perl-version!' => \
$ignore_perl_version,
205 'debug=s' => \
%debug,
206 'test-only=s' => \
$tst_only,
207 'codespell!' => \
$codespell,
208 'codespellfile=s' => \
$codespellfile,
216 list_types
(0) if ($list_types);
218 $fix = 1 if ($fix_inplace);
219 $check_orig = $check;
223 if ($^V && $^V lt $minimum_perl_version) {
224 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
225 if (!$ignore_perl_version) {
231 print "$P: no input files\n";
235 sub hash_save_array_words
{
236 my ($hashRef, $arrayRef) = @_;
238 my @array = split(/,/, join(',', @$arrayRef));
239 foreach my $word (@array) {
240 $word =~ s/\s*\n?$//g;
243 $word =~ tr/[a-z]/[A-Z]/;
245 next if ($word =~ m/^\s*#/);
246 next if ($word =~ m/^\s*$/);
252 sub hash_show_words
{
253 my ($hashRef, $prefix) = @_;
255 if (keys %$hashRef) {
256 print "\nNOTE: $prefix message types:";
257 foreach my $word (sort keys %$hashRef) {
264 hash_save_array_words
(\
%ignore_type, \
@ignore);
265 hash_save_array_words
(\
%use_type, \
@use);
268 my $dbg_possible = 0;
271 for my $key (keys %debug) {
273 eval "\${dbg_$key} = '$debug{$key}';";
277 my $rpt_cleaners = 0;
286 if (!top_of_kernel_tree
($root)) {
287 die "$P: $root: --root does not point at a valid tree\n";
290 if (top_of_kernel_tree
('.')) {
292 } elsif ($0 =~ m
@(.*)/scripts/[^/]*$@ &&
293 top_of_kernel_tree
($1)) {
298 if (!defined $root) {
299 print "Must be run from the top-level dir. of a kernel tree\n";
304 my $emitted_corrupt = 0;
307 [A-Za-z_
][A-Za-z\d_
]*
308 (?
:\s
*\#\#\s
*[A-Za-z_
][A-Za-z\d_
]*)*
310 our $Storage = qr{extern|static|asmlinkage};
324 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
325 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
326 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
327 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
328 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
330 # Notes to $Attribute:
331 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
352 ____cacheline_aligned
|
353 ____cacheline_aligned_in_smp
|
354 ____cacheline_internodealigned_in_smp
|
358 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
359 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
360 our $Lval = qr{$Ident(?:$Member)*};
362 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
363 our $Binary = qr{(?i)0b[01]+$Int_type?};
364 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
365 our $Int = qr{[0-9]+$Int_type?};
366 our $Octal = qr{0[0-7]+$Int_type?};
367 our $String = qr{"[X\t]*"};
368 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
369 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
370 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
371 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
372 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
373 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
374 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
375 our $Arithmetic = qr{\+|-|\*|\/|%};
379 &&|\
|\
||,|\
^|\
+\
+|--|&|\
||$Arithmetic
382 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
386 our $NonptrTypeMisordered;
387 our $NonptrTypeWithAttr;
391 our $DeclareMisordered;
393 our $NON_ASCII_UTF8 = qr{
394 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
395 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
396 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
397 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
398 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
399 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
400 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
404 [\x09\x0A\x0D\x20-\x7E] # ASCII
408 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
409 our $typeOtherOSTypedefs = qr{(?x
:
410 u_
(?
:char
|short
|int|long
) | # bsd
411 u
(?
:nchar
|short
|int|long
) # sysv
413 our $typeKernelTypedefs = qr{(?x
:
414 (?
:__
)?
(?
:u
|s
|be
|le)(?
:8|16|32|64)|
417 our $typeTypedefs = qr{(?x
:
419 $typeOtherOSTypedefs\b|
420 $typeKernelTypedefs\b
423 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
425 our $logFunctions = qr{(?x
:
426 printk
(?
:_ratelimited
|_once
|)|
427 (?
:[a-z0-9
]+_
){1,2}(?
:printk
|emerg
|alert
|crit
|err
|warning
|warn|notice
|info
|debug
|dbg
|vdbg
|devel
|cont
|WARN
)(?
:_ratelimited
|_once
|)|
428 WARN
(?
:_RATELIMIT
|_ONCE
|)|
431 seq_vprintf
|seq_printf
|seq_puts
434 our $signature_tags = qr{(?xi
:
445 our @typeListMisordered = (
446 qr{char\s+(?:un)?signed},
447 qr{int\s+(?:(?:un)?signed\s+)?short\s},
448 qr{int\s+short(?:\s+(?:un)?signed)},
449 qr{short\s+int(?:\s+(?:un)?signed)},
450 qr{(?:un)?signed\s+int\s+short},
451 qr{short\s+(?:un)?signed},
452 qr{long\s+int\s+(?:un)?signed},
453 qr{int\s+long\s+(?:un)?signed},
454 qr{long\s+(?:un)?signed\s+int},
455 qr{int\s+(?:un)?signed\s+long},
456 qr{int\s+(?:un)?signed},
457 qr{int\s+long\s+long\s+(?:un)?signed},
458 qr{long\s+long\s+int\s+(?:un)?signed},
459 qr{long\s+long\s+(?:un)?signed\s+int},
460 qr{long\s+long\s+(?:un)?signed},
461 qr{long\s+(?:un)?signed},
466 qr{(?:(?:un)?signed\s+)?char},
467 qr{(?:(?:un)?signed\s+)?short\s+int},
468 qr{(?:(?:un)?signed\s+)?short},
469 qr{(?:(?:un)?signed\s+)?int},
470 qr{(?:(?:un)?signed\s+)?long\s+int},
471 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
472 qr{(?:(?:un)?signed\s+)?long\s+long},
473 qr{(?:(?:un)?signed\s+)?long},
482 qr{${Ident}_handler
},
483 qr{${Ident}_handler_fn
},
487 our $C90_int_types = qr{(?x
:
488 long\s
+long\s
+int\s
+(?
:un
)?signed
|
489 long\s
+long\s
+(?
:un
)?signed\s
+int|
490 long\s
+long\s
+(?
:un
)?signed
|
491 (?
:(?
:un
)?signed\s
+)?long\s
+long\s
+int|
492 (?
:(?
:un
)?signed\s
+)?long\s
+long
|
493 int\s
+long\s
+long\s
+(?
:un
)?signed
|
494 int\s
+(?
:(?
:un
)?signed\s
+)?long\s
+long
|
496 long\s
+int\s
+(?
:un
)?signed
|
497 long\s
+(?
:un
)?signed\s
+int|
498 long\s
+(?
:un
)?signed
|
499 (?
:(?
:un
)?signed\s
+)?long\s
+int|
500 (?
:(?
:un
)?signed\s
+)?long
|
501 int\s
+long\s
+(?
:un
)?signed
|
502 int\s
+(?
:(?
:un
)?signed\s
+)?long
|
505 (?
:(?
:un
)?signed\s
+)?
int
508 our @typeListFile = ();
509 our @typeListWithAttr = (
511 qr{struct\s+$InitAttribute\s+$Ident},
512 qr{union\s+$InitAttribute\s+$Ident},
515 our @modifierList = (
518 our @modifierListFile = ();
520 our @mode_permission_funcs = (
522 ["module_param_(?:array|named|string)", 4],
523 ["module_param_array_named", 5],
524 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
525 ["proc_create(?:_data|)", 2],
526 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
529 #Create a search pattern for all these functions to speed up a loop below
530 our $mode_perms_search = "";
531 foreach my $entry (@mode_permission_funcs) {
532 $mode_perms_search .= '|' if ($mode_perms_search ne "");
533 $mode_perms_search .= $entry->[0];
536 our $mode_perms_world_writable = qr{
544 our $allowed_asm_includes = qr{(?x
:
550 # memory.h: ARM has a custom one
552 # Load common spelling mistakes and build regular expression list.
556 if (open(my $spelling, '<', $spelling_file)) {
557 while (<$spelling>) {
560 $line =~ s/\s*\n?$//g;
563 next if ($line =~ m/^\s*#/);
564 next if ($line =~ m/^\s*$/);
566 my ($suspect, $fix) = split(/\|\|/, $line);
568 $spelling_fix{$suspect} = $fix;
572 warn "No typos will be found - file '$spelling_file': $!\n";
576 if (open(my $spelling, '<', $codespellfile)) {
577 while (<$spelling>) {
580 $line =~ s/\s*\n?$//g;
583 next if ($line =~ m/^\s*#/);
584 next if ($line =~ m/^\s*$/);
585 next if ($line =~ m/, disabled/i);
589 my ($suspect, $fix) = split(/->/, $line);
591 $spelling_fix{$suspect} = $fix;
595 warn "No codespell typos will be found - file '$codespellfile': $!\n";
599 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
602 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
603 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
604 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
605 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
606 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
612 (?
:$Modifier\s+|const\s
+)*
614 (?
:typeof
|__typeof__
)\s
*\
([^\
)]*\
)|
618 (?
:\s
+$Modifier|\s
+const
)*
620 $NonptrTypeMisordered = qr{
621 (?
:$Modifier\s+|const\s
+)*
625 (?
:\s
+$Modifier|\s
+const
)*
627 $NonptrTypeWithAttr = qr{
628 (?
:$Modifier\s+|const\s
+)*
630 (?
:typeof
|__typeof__
)\s
*\
([^\
)]*\
)|
634 (?
:\s
+$Modifier|\s
+const
)*
638 (?
:(?
:\s
|\
*|\
[\
])+\s
*const
|(?
:\s
|\
*\s
*(?
:const\s
*)?
|\
[\
])+|(?
:\s
*\
[\s
*\
])+)?
639 (?
:\s
+$Inline|\s
+$Modifier)*
641 $TypeMisordered = qr{
642 $NonptrTypeMisordered
643 (?
:(?
:\s
|\
*|\
[\
])+\s
*const
|(?
:\s
|\
*\s
*(?
:const\s
*)?
|\
[\
])+|(?
:\s
*\
[\s
*\
])+)?
644 (?
:\s
+$Inline|\s
+$Modifier)*
646 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
647 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
651 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s
*};
653 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
654 # requires at least perl version v5.10.0
655 # Any use must be runtime checked with $^V
657 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
658 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s
*};
659 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
661 our $declaration_macros = qr{(?x
:
662 (?
:$Storage\s+)?
(?
:[A-Z_
][A-Z0-9
]*_
){0,2}(?
:DEFINE
|DECLARE
)(?
:_
[A-Z0-9
]+){1,6}\s
*\
(|
663 (?
:$Storage\s+)?LIST_HEAD\s
*\
(|
664 (?
:$Storage\s+)?
${Type
}\s
+uninitialized_var\s
*\
(
669 return "" if (!defined($string));
671 while ($string =~ /^\s*\(.*\)\s*$/) {
672 $string =~ s
@^\s*\(\s
*@@;
673 $string =~ s
@\s*\)\s
*$@@;
676 $string =~ s
@\s+@ @g;
681 sub seed_camelcase_file
{
684 return if (!(-f
$file));
688 open(my $include_file, '<', "$file")
689 or warn "$P: Can't read '$file' $!\n";
690 my $text = <$include_file>;
691 close($include_file);
693 my @lines = split('\n', $text);
695 foreach my $line (@lines) {
696 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
697 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
699 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
701 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
707 my $camelcase_seeded = 0;
708 sub seed_camelcase_includes
{
709 return if ($camelcase_seeded);
712 my $camelcase_cache = "";
713 my @include_files = ();
715 $camelcase_seeded = 1;
718 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
719 chomp $git_last_include_commit;
720 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
722 my $last_mod_date = 0;
723 $files = `find $root/include -name "*.h"`;
724 @include_files = split('\n', $files);
725 foreach my $file (@include_files) {
726 my $date = POSIX
::strftime
("%Y%m%d%H%M",
727 localtime((stat $file)[9]));
728 $last_mod_date = $date if ($last_mod_date < $date);
730 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
733 if ($camelcase_cache ne "" && -f
$camelcase_cache) {
734 open(my $camelcase_file, '<', "$camelcase_cache")
735 or warn "$P: Can't read '$camelcase_cache' $!\n";
736 while (<$camelcase_file>) {
740 close($camelcase_file);
746 $files = `git ls-files "include/*.h"`;
747 @include_files = split('\n', $files);
750 foreach my $file (@include_files) {
751 seed_camelcase_file
($file);
754 if ($camelcase_cache ne "") {
755 unlink glob ".checkpatch-camelcase.*";
756 open(my $camelcase_file, '>', "$camelcase_cache")
757 or warn "$P: Can't write '$camelcase_cache' $!\n";
758 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
759 print $camelcase_file ("$_\n");
761 close($camelcase_file);
765 sub git_commit_info
{
766 my ($commit, $id, $desc) = @_;
768 return ($id, $desc) if ((which
("git") eq "") || !(-e
".git"));
770 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
771 $output =~ s/^\s*//gm;
772 my @lines = split("\n", $output);
774 return ($id, $desc) if ($#lines < 0);
776 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
777 # Maybe one day convert this block of bash into something that returns
778 # all matching commit ids, but it's very slow...
780 # echo "checking commits $1..."
781 # git rev-list --remotes | grep -i "^$1" |
782 # while read line ; do
783 # git log --format='%H %s' -1 $line |
784 # echo "commit $(cut -c 1-12,41-)"
786 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
788 $id = substr($lines[0], 0, 12);
789 $desc = substr($lines[0], 41);
795 $chk_signoff = 0 if ($file);
800 my @fixed_inserted = ();
801 my @fixed_deleted = ();
804 # If input is git commits, extract all commits from the commit expressions.
805 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
806 die "$P: No git repository found\n" if ($git && !-e
".git");
810 foreach my $commit_expr (@ARGV) {
812 if ($commit_expr =~ m/-/) {
813 my @tmp = split(/-/, $commit_expr);
814 die "$P: incorrect git commit expression '$commit_expr' $!\n"
816 $git_range = "-$tmp[1] $tmp[0]";
817 } elsif ($commit_expr =~ m/\.\./) {
818 $git_range = "$commit_expr";
820 $git_range = "-1 $commit_expr";
822 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
823 foreach my $line (split(/\n/, $lines)) {
824 $line =~ /(^\w+) (.*)/;
827 unshift(@commits, $sha1);
828 $git_commits{$sha1} = $subject;
831 die "$P: no git commits after extraction!\n" if (@commits == 0);
836 for my $filename (@ARGV) {
839 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
840 die "$P: $filename: git format-patch failed - $!\n";
842 open($FILE, '-|', "diff -u /dev/null $filename") ||
843 die "$P: $filename: diff failed - $!\n";
844 } elsif ($filename eq '-') {
845 open($FILE, '<&STDIN');
847 open($FILE, '<', "$filename") ||
848 die "$P: $filename: open failed - $!\n";
850 if ($filename eq '-') {
851 $vname = 'Your patch';
853 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
863 if ($#ARGV > 0 && $quiet == 0) {
864 print '-' x length($vname) . "\n";
866 print '-' x length($vname) . "\n";
869 if (!process($filename)) {
875 @fixed_inserted = ();
878 @modifierListFile = ();
884 hash_show_words(\%use_type, "Used");
885 hash_show_words(\%ignore_type, "Ignored");
890 NOTE: perl $^V is not modern enough to detect all possible issues.
891 An upgrade to at least perl v5.10.0 is suggested.
897 NOTE: If any of the errors are false positives, please report
898 them to the maintainer, see CHECKPATCH in MAINTAINERS.
905 sub top_of_kernel_tree {
909 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
910 "README", "Documentation", "arch", "include", "drivers",
911 "fs", "init", "ipc", "kernel", "lib", "scripts",
914 foreach my $check (@tree_check) {
915 if (! -e $root . '/' . $check) {
923 my ($formatted_email) = @_;
929 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
932 $comment = $3 if defined $3;
933 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
935 $comment = $2 if defined $2;
936 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
938 $comment = $2 if defined $2;
939 $formatted_email =~ s/$address.*$//;
940 $name = $formatted_email;
942 $name =~ s/^\"|\"$//g;
943 # If there's a name left after stripping spaces and
944 # leading quotes, and the address doesn't have both
945 # leading and trailing angle brackets, the address
947 # "joe smith joe@smith.com" bad
948 # "joe smith <joe@smith.com" bad
949 if ($name ne "" && $address !~ /^<[^>]+>$/) {
957 $name =~ s/^\"|\"$//g;
958 $address = trim($address);
959 $address =~ s/^\<|\>$//g;
961 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
962 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
966 return ($name, $address, $comment);
970 my ($name, $address) = @_;
975 $name =~ s/^\"|\"$//g;
976 $address = trim($address);
978 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
979 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
984 $formatted_email = "$address";
986 $formatted_email = "$name <$address>";
989 return $formatted_email;
995 foreach my $path (split(/:/, $ENV{PATH})) {
996 if (-e "$path/$bin") {
1007 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1008 if (-e "$path/$conf") {
1009 return "$path/$conf";
1021 for my $c (split(//, $str)) {
1025 for (; ($n % 8) != 0; $n++) {
1037 (my $res = shift) =~ tr/\t/ /c;
1044 # Drop the diff line leader and expand tabs
1046 $line = expand_tabs($line);
1048 # Pick the indent from the front of the line.
1049 my ($white) = ($line =~ /^(\s*)/);
1051 return (length($line), length($white));
1054 my $sanitise_quote = '';
1056 sub sanitise_line_reset {
1057 my ($in_comment) = @_;
1060 $sanitise_quote = '*/';
1062 $sanitise_quote = '';
1075 # Always copy over the diff marker.
1076 $res = substr($line, 0, 1);
1078 for ($off = 1; $off < length($line); $off++) {
1079 $c = substr($line, $off, 1);
1081 # Comments we are wacking completly including the begin
1082 # and end, all to $;.
1083 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1084 $sanitise_quote = '*/';
1086 substr($res, $off, 2, "$;$;");
1090 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1091 $sanitise_quote = '';
1092 substr($res, $off, 2, "$;$;");
1096 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1097 $sanitise_quote = '//';
1099 substr($res, $off, 2, $sanitise_quote);
1104 # A \ in a string means ignore the next character.
1105 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1107 substr($res, $off, 2, 'XX');
1112 if ($c eq "'" || $c eq '"') {
1113 if ($sanitise_quote eq '') {
1114 $sanitise_quote = $c;
1116 substr($res, $off, 1, $c);
1118 } elsif ($sanitise_quote eq $c) {
1119 $sanitise_quote = '';
1123 #print "c<$c> SQ<$sanitise_quote>\n";
1124 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1125 substr($res, $off, 1, $;);
1126 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1127 substr($res, $off, 1, $;);
1128 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1129 substr($res, $off, 1, 'X');
1131 substr($res, $off, 1, $c);
1135 if ($sanitise_quote eq '//') {
1136 $sanitise_quote = '';
1139 # The pathname on a #include may be surrounded by '<' and '>'.
1140 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1141 my $clean = 'X' x length($1);
1142 $res =~ s@\<.*\>@<$clean>@;
1144 # The whole of a #error is a string.
1145 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1146 my $clean = 'X' x length($1);
1147 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1153 sub get_quoted_string {
1154 my ($line, $rawline) = @_;
1156 return "" if ($line !~ m/($String)/g);
1157 return substr($rawline, $-[0], $+[0] - $-[0]);
1160 sub ctx_statement_block {
1161 my ($linenr, $remain, $off) = @_;
1162 my $line = $linenr - 1;
1165 my $coff = $off - 1;
1179 @stack = (['', 0]) if ($#stack == -1);
1181 #warn "CSB: blk<$blk> remain<$remain>\n";
1182 # If we are about to drop off the end, pull in more
1185 for (; $remain > 0; $line++) {
1186 last if (!defined $lines[$line]);
1187 next if ($lines[$line] =~ /^-/);
1190 $blk .= $lines[$line] . "\n";
1191 $len = length($blk);
1195 # Bail if there is no further context.
1196 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1200 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1206 $c = substr($blk, $off, 1);
1207 $remainder = substr($blk, $off);
1209 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1211 # Handle nested #if/#else.
1212 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1213 push(@stack, [ $type, $level ]);
1214 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1215 ($type, $level) = @{$stack[$#stack - 1]};
1216 } elsif ($remainder =~ /^#\s*endif\b/) {
1217 ($type, $level) = @{pop(@stack)};
1220 # Statement ends at the ';' or a close '}' at the
1222 if ($level == 0 && $c eq ';') {
1226 # An else is really a conditional as long as its not else if
1227 if ($level == 0 && $coff_set == 0 &&
1228 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1229 $remainder =~ /^(else)(?:\s|{)/ &&
1230 $remainder !~ /^else\s+if\b/) {
1231 $coff = $off + length($1) - 1;
1233 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1234 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1237 if (($type eq '' || $type eq '(') && $c eq '(') {
1241 if ($type eq '(' && $c eq ')') {
1243 $type = ($level != 0)? '(' : '';
1245 if ($level == 0 && $coff < $soff) {
1248 #warn "CSB: mark coff<$coff>\n";
1251 if (($type eq '' || $type eq '{') && $c eq '{') {
1255 if ($type eq '{' && $c eq '}') {
1257 $type = ($level != 0)? '{' : '';
1260 if (substr($blk, $off + 1, 1) eq ';') {
1266 # Preprocessor commands end at the newline unless escaped.
1267 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1275 # We are truly at the end, so shuffle to the next line.
1282 my $statement = substr($blk, $soff, $off - $soff + 1);
1283 my $condition = substr($blk, $soff, $coff - $soff + 1);
1285 #warn "STATEMENT<$statement>\n";
1286 #warn "CONDITION<$condition>\n";
1288 #print "coff<$coff> soff<$off> loff<$loff>\n";
1290 return ($statement, $condition,
1291 $line, $remain + 1, $off - $loff + 1, $level);
1294 sub statement_lines {
1297 # Strip the diff line prefixes and rip blank lines at start and end.
1298 $stmt =~ s/(^|\n)./$1/g;
1302 my @stmt_lines = ($stmt =~ /\n/g);
1304 return $#stmt_lines + 2;
1307 sub statement_rawlines {
1310 my @stmt_lines = ($stmt =~ /\n/g);
1312 return $#stmt_lines + 2;
1315 sub statement_block_size {
1318 $stmt =~ s/(^|\n)./$1/g;
1324 my @stmt_lines = ($stmt =~ /\n/g);
1325 my @stmt_statements = ($stmt =~ /;/g);
1327 my $stmt_lines = $#stmt_lines + 2;
1328 my $stmt_statements = $#stmt_statements + 1;
1330 if ($stmt_lines > $stmt_statements) {
1333 return $stmt_statements;
1337 sub ctx_statement_full {
1338 my ($linenr, $remain, $off) = @_;
1339 my ($statement, $condition, $level);
1343 # Grab the first conditional/block pair.
1344 ($statement, $condition, $linenr, $remain, $off, $level) =
1345 ctx_statement_block($linenr, $remain, $off);
1346 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1347 push(@chunks, [ $condition, $statement ]);
1348 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1349 return ($level, $linenr, @chunks);
1352 # Pull in the following conditional/block pairs and see if they
1353 # could continue the statement.
1355 ($statement, $condition, $linenr, $remain, $off, $level) =
1356 ctx_statement_block($linenr, $remain, $off);
1357 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1358 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1360 push(@chunks, [ $condition, $statement ]);
1363 return ($level, $linenr, @chunks);
1367 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1369 my $start = $linenr - 1;
1376 my @stack = ($level);
1377 for ($line = $start; $remain > 0; $line++) {
1378 next if ($rawlines[$line] =~ /^-/);
1381 $blk .= $rawlines[$line];
1383 # Handle nested #if/#else.
1384 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1385 push(@stack, $level);
1386 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1387 $level = $stack[$#stack - 1];
1388 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1389 $level = pop(@stack);
1392 foreach my $c (split(//, $lines[$line])) {
1393 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1399 if ($c eq $close && $level > 0) {
1401 last if ($level == 0);
1402 } elsif ($c eq $open) {
1407 if (!$outer || $level <= 1) {
1408 push(@res, $rawlines[$line]);
1411 last if ($level == 0);
1414 return ($level, @res);
1416 sub ctx_block_outer {
1417 my ($linenr, $remain) = @_;
1419 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1423 my ($linenr, $remain) = @_;
1425 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1429 my ($linenr, $remain, $off) = @_;
1431 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1434 sub ctx_block_level {
1435 my ($linenr, $remain) = @_;
1437 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1439 sub ctx_statement_level {
1440 my ($linenr, $remain, $off) = @_;
1442 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1445 sub ctx_locate_comment {
1446 my ($first_line, $end_line) = @_;
1448 # Catch a comment on the end of the line itself.
1449 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1450 return $current_comment if (defined $current_comment);
1452 # Look through the context and try and figure out if there is a
1455 $current_comment = '';
1456 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1457 my $line = $rawlines[$linenr - 1];
1459 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1462 if ($line =~ m@/\*@) {
1465 if (!$in_comment && $current_comment ne '') {
1466 $current_comment = '';
1468 $current_comment .= $line . "\n" if ($in_comment);
1469 if ($line =~ m@\*/@) {
1474 chomp($current_comment);
1475 return($current_comment);
1477 sub ctx_has_comment {
1478 my ($first_line, $end_line) = @_;
1479 my $cmt = ctx_locate_comment($first_line, $end_line);
1481 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1482 ##print "CMMT: $cmt\n";
1484 return ($cmt ne '');
1488 my ($linenr, $cnt) = @_;
1490 my $offset = $linenr - 1;
1495 $line = $rawlines[$offset++];
1496 next if (defined($line) && $line =~ /^-/);
1508 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1511 $coded = sprintf("^%c", unpack('C', $2) + 64);
1520 my $av_preprocessor = 0;
1525 sub annotate_reset {
1526 $av_preprocessor = 0;
1528 @av_paren_type = ('E');
1529 $av_pend_colon = 'O';
1532 sub annotate_values {
1533 my ($stream, $type) = @_;
1536 my $var = '_' x length($stream);
1539 print "$stream\n" if ($dbg_values > 1);
1541 while (length($cur)) {
1542 @av_paren_type = ('E') if ($#av_paren_type < 0);
1543 print " <" . join('', @av_paren_type) .
1544 "> <$type> <$av_pending>" if ($dbg_values > 1);
1545 if ($cur =~ /^(\s+)/o) {
1546 print "WS($1)\n" if ($dbg_values > 1);
1547 if ($1 =~ /\n/ && $av_preprocessor) {
1548 $type = pop(@av_paren_type);
1549 $av_preprocessor = 0;
1552 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1553 print "CAST($1)\n" if ($dbg_values > 1);
1554 push(@av_paren_type, $type);
1557 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1558 print "DECLARE($1)\n" if ($dbg_values > 1);
1561 } elsif ($cur =~ /^($Modifier)\s*/) {
1562 print "MODIFIER($1)\n" if ($dbg_values > 1);
1565 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1566 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1567 $av_preprocessor = 1;
1568 push(@av_paren_type, $type);
1574 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1575 print "UNDEF($1)\n" if ($dbg_values > 1);
1576 $av_preprocessor = 1;
1577 push(@av_paren_type, $type);
1579 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1580 print "PRE_START($1)\n" if ($dbg_values > 1);
1581 $av_preprocessor = 1;
1583 push(@av_paren_type, $type);
1584 push(@av_paren_type, $type);
1587 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1588 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1589 $av_preprocessor = 1;
1591 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1595 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1596 print "PRE_END($1)\n" if ($dbg_values > 1);
1598 $av_preprocessor = 1;
1600 # Assume all arms of the conditional end as this
1601 # one does, and continue as if the #endif was not here.
1602 pop(@av_paren_type);
1603 push(@av_paren_type, $type);
1606 } elsif ($cur =~ /^(\\\n)/o) {
1607 print "PRECONT($1)\n" if ($dbg_values > 1);
1609 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1610 print "ATTR($1)\n" if ($dbg_values > 1);
1611 $av_pending = $type;
1614 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1615 print "SIZEOF($1)\n" if ($dbg_values > 1);
1621 } elsif ($cur =~ /^(if|while|for)\b/o) {
1622 print "COND($1)\n" if ($dbg_values > 1);
1626 } elsif ($cur =~/^(case)/o) {
1627 print "CASE($1)\n" if ($dbg_values > 1);
1628 $av_pend_colon = 'C';
1631 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1632 print "KEYWORD($1)\n" if ($dbg_values > 1);
1635 } elsif ($cur =~ /^(\()/o) {
1636 print "PAREN('$1')\n" if ($dbg_values > 1);
1637 push(@av_paren_type, $av_pending);
1641 } elsif ($cur =~ /^(\))/o) {
1642 my $new_type = pop(@av_paren_type);
1643 if ($new_type ne '_') {
1645 print "PAREN('$1') -> $type\n"
1646 if ($dbg_values > 1);
1648 print "PAREN('$1')\n" if ($dbg_values > 1);
1651 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1652 print "FUNC($1)\n" if ($dbg_values > 1);
1656 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1657 if (defined $2 && $type eq 'C' || $type eq 'T') {
1658 $av_pend_colon = 'B';
1659 } elsif ($type eq 'E') {
1660 $av_pend_colon = 'L';
1662 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1665 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1666 print "IDENT($1)\n" if ($dbg_values > 1);
1669 } elsif ($cur =~ /^($Assignment)/o) {
1670 print "ASSIGN($1)\n" if ($dbg_values > 1);
1673 } elsif ($cur =~/^(;|{|})/) {
1674 print "END($1)\n" if ($dbg_values > 1);
1676 $av_pend_colon = 'O';
1678 } elsif ($cur =~/^(,)/) {
1679 print "COMMA($1)\n" if ($dbg_values > 1);
1682 } elsif ($cur =~ /^(\?)/o) {
1683 print "QUESTION($1)\n" if ($dbg_values > 1);
1686 } elsif ($cur =~ /^(:)/o) {
1687 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1689 substr($var, length($res), 1, $av_pend_colon);
1690 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1695 $av_pend_colon = 'O';
1697 } elsif ($cur =~ /^(\[)/o) {
1698 print "CLOSE($1)\n" if ($dbg_values > 1);
1701 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1704 print "OPV($1)\n" if ($dbg_values > 1);
1711 substr($var, length($res), 1, $variant);
1714 } elsif ($cur =~ /^($Operators)/o) {
1715 print "OP($1)\n" if ($dbg_values > 1);
1716 if ($1 ne '++' && $1 ne '--') {
1720 } elsif ($cur =~ /(^.)/o) {
1721 print "C($1)\n" if ($dbg_values > 1);
1724 $cur = substr($cur, length($1));
1725 $res .= $type x length($1);
1729 return ($res, $var);
1733 my ($possible, $line) = @_;
1734 my $notPermitted = qr{(?:
1751 ^(?:typedef|struct|enum)\b
1753 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1754 if ($possible !~ $notPermitted) {
1755 # Check for modifiers.
1756 $possible =~ s/\s*$Storage\s*//g;
1757 $possible =~ s/\s*$Sparse\s*//g;
1758 if ($possible =~ /^\s*$/) {
1760 } elsif ($possible =~ /\s/) {
1761 $possible =~ s/\s*$Type\s*//g;
1762 for my $modifier (split(' ', $possible)) {
1763 if ($modifier !~ $notPermitted) {
1764 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1765 push(@modifierListFile, $modifier);
1770 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1771 push(@typeListFile, $possible);
1775 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1784 return defined $use_type{$type} if (scalar keys %use_type > 0);
1786 return !defined $ignore_type{$type};
1790 my ($level, $type, $msg) = @_;
1792 if (!show_type($type) ||
1793 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1797 if (-t STDOUT && $color) {
1798 if ($level eq 'ERROR') {
1800 } elsif ($level eq 'WARNING') {
1806 $output .= $prefix . $level . ':';
1808 $output .= BLUE if (-t STDOUT && $color);
1809 $output .= "$type:";
1811 $output .= RESET if (-t STDOUT && $color);
1812 $output .= ' ' . $msg . "\n";
1815 my @lines = split("\n", $output, -1);
1816 splice(@lines, 1, 1);
1817 $output = join("\n", @lines);
1819 $output = (split('\n', $output))[0] . "\n" if ($terse);
1821 push(our @report, $output);
1830 sub fixup_current_range {
1831 my ($lineRef, $offset, $length) = @_;
1833 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1836 my $no = $o + $offset;
1837 my $nl = $l + $length;
1838 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1842 sub fix_inserted_deleted_lines {
1843 my ($linesRef, $insertedRef, $deletedRef) = @_;
1845 my $range_last_linenr = 0;
1846 my $delta_offset = 0;
1851 my $next_insert = 0;
1852 my $next_delete = 0;
1856 my $inserted = @{$insertedRef}[$next_insert++];
1857 my $deleted = @{$deletedRef}[$next_delete++];
1859 foreach my $old_line (@{$linesRef}) {
1861 my $line = $old_line; #don't modify the array
1862 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
1864 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1865 $range_last_linenr = $new_linenr;
1866 fixup_current_range(\$line, $delta_offset, 0);
1869 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1870 $deleted = @{$deletedRef}[$next_delete++];
1872 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1875 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1876 push(@lines, ${$inserted}{'LINE'});
1877 $inserted = @{$insertedRef}[$next_insert++];
1879 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1883 push(@lines, $line);
1893 sub fix_insert_line {
1894 my ($linenr, $line) = @_;
1900 push(@fixed_inserted, $inserted);
1903 sub fix_delete_line {
1904 my ($linenr, $line) = @_;
1911 push(@fixed_deleted, $deleted);
1915 my ($type, $msg) = @_;
1917 if (report("ERROR", $type, $msg)) {
1925 my ($type, $msg) = @_;
1927 if (report("WARNING", $type, $msg)) {
1935 my ($type, $msg) = @_;
1937 if ($check && report("CHECK", $type, $msg)) {
1945 sub check_absolute_file {
1946 my ($absolute, $herecurr) = @_;
1947 my $file = $absolute;
1949 ##print "absolute<$absolute>\n";
1951 # See if any suffix of this path is a path within the tree.
1952 while ($file =~ s@^[^/]*/@@) {
1953 if (-f "$root/$file") {
1954 ##print "file<$file>\n";
1962 # It is, so see if the prefix is acceptable.
1963 my $prefix = $absolute;
1964 substr($prefix, -length($file)) = '';
1966 ##print "prefix<$prefix>\n";
1967 if ($prefix ne ".../") {
1968 WARN("USE_RELATIVE_PATH",
1969 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1976 $string =~ s/^\s+|\s+$//g;
1984 $string =~ s/^\s+//;
1992 $string =~ s/\s+$//;
1997 sub string_find_replace {
1998 my ($string, $find, $replace) = @_;
2000 $string =~ s/$find/$replace/g;
2008 my $source_indent = 8;
2009 my $max_spaces_before_tab = $source_indent - 1;
2010 my $spaces_to_tab = " " x $source_indent;
2012 #convert leading spaces to tabs
2013 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2014 #Remove spaces before a tab
2015 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2020 sub pos_last_openparen {
2025 my $opens = $line =~ tr/\(/\(/;
2026 my $closes = $line =~ tr/\)/\)/;
2028 my $last_openparen = 0;
2030 if (($opens == 0) || ($closes >= $opens)) {
2034 my $len = length($line);
2036 for ($pos = 0; $pos < $len; $pos++) {
2037 my $string = substr($line, $pos);
2038 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2039 $pos += length($1) - 1;
2040 } elsif (substr($line, $pos, 1) eq '(') {
2041 $last_openparen = $pos;
2042 } elsif (index($string, '(') == -1) {
2047 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2051 my $filename = shift;
2057 my $stashrawline="";
2067 my $in_header_lines = $file ? 0 : 1;
2068 my $in_commit_log = 0; #Scanning lines before patch
2069 my $commit_log_possible_stack_dump = 0;
2070 my $commit_log_long_line = 0;
2071 my $commit_log_has_diff = 0;
2072 my $reported_maintainer_file = 0;
2073 my $non_utf8_charset = 0;
2075 my $last_blank_line = 0;
2076 my $last_coalesced_string_linenr = -1;
2084 # Trace the real file/line as we go.
2090 my $comment_edge = 0;
2094 my $prev_values = 'E';
2097 my %suppress_ifbraces;
2098 my %suppress_whiletrailers;
2099 my %suppress_export;
2100 my $suppress_statement = 0;
2102 my %signatures = ();
2104 # Pre-scan the patch sanitizing the lines.
2105 # Pre-scan the patch looking for any __setup documentation.
2107 my @setup_docs = ();
2110 my $camelcase_file_seeded = 0;
2112 sanitise_line_reset();
2114 foreach my $rawline (@rawlines) {
2118 push(@fixed, $rawline) if ($fix);
2120 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2122 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2127 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2136 # Guestimate if this is a continuing comment. Run
2137 # the context looking for a comment "edge". If this
2138 # edge is a close comment then we must be in a comment
2142 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2143 next if (defined $rawlines[$ln - 1] &&
2144 $rawlines[$ln - 1] =~ /^-/);
2146 #print "RAW<$rawlines[$ln - 1]>\n";
2147 last if (!defined $rawlines[$ln - 1]);
2148 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2149 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2154 if (defined $edge && $edge eq '*/') {
2158 # Guestimate if this is a continuing comment. If this
2159 # is the start of a diff block and this line starts
2160 # ' *' then it is very likely a comment.
2161 if (!defined $edge &&
2162 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2167 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2168 sanitise_line_reset($in_comment);
2170 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2171 # Standardise the strings and chars within the input to
2172 # simplify matching -- only bother with positive lines.
2173 $line = sanitise_line($rawline);
2175 push(@lines, $line);
2178 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2183 #print "==>$rawline\n";
2184 #print "-->$line\n";
2186 if ($setup_docs && $line =~ /^\+/) {
2187 push(@setup_docs, $line);
2196 foreach my $line (@lines) {
2199 my $sline = $line; #copy of $line
2200 $sline =~ s/$;/ /g; #with comments as spaces
2202 my $rawline = $rawlines[$linenr - 1];
2204 #extract the line range in the file after the patch is applied
2205 if (!$in_commit_log &&
2206 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2208 $first_line = $linenr + 1;
2218 %suppress_ifbraces = ();
2219 %suppress_whiletrailers = ();
2220 %suppress_export = ();
2221 $suppress_statement = 0;
2224 # track the line number as we move through the hunk, note that
2225 # new versions of GNU diff omit the leading space on completely
2226 # blank context lines so we need to count that too.
2227 } elsif ($line =~ /^( |\+|$)/) {
2229 $realcnt-- if ($realcnt != 0);
2231 # Measure the line length and indent.
2232 ($length, $indent) = line_stats($rawline);
2234 # Track the previous line.
2235 ($prevline, $stashline) = ($stashline, $line);
2236 ($previndent, $stashindent) = ($stashindent, $indent);
2237 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2239 #warn "line<$line>\n";
2241 } elsif ($realcnt == 1) {
2245 my $hunk_line = ($realcnt != 0);
2247 $here = "#$linenr: " if (!$file);
2248 $here = "#$realline: " if ($file);
2251 # extract the filename as it passes
2252 if ($line =~ /^diff --git.*?(\S+)$/) {
2254 $realfile =~ s@^([^/]*)/@@ if (!$file);
2257 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2259 $realfile =~ s@^([^/]*)/@@ if (!$file);
2263 if (!$file && $tree && $p1_prefix ne '' &&
2264 -e "$root/$p1_prefix") {
2265 WARN("PATCH_PREFIX",
2266 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2269 if ($realfile =~ m@^include/asm/@) {
2270 ERROR("MODIFIED_INCLUDE_ASM",
2271 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2276 #make up the handle for any error we report on this line
2278 $prefix = "$realfile:$realline: "
2281 $prefix = "$filename:$realline: ";
2283 $prefix = "$filename:$linenr: ";
2288 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2291 $check = $check_orig;
2296 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2298 my $hereline = "$here\n$rawline\n";
2299 my $herecurr = "$here\n$rawline\n";
2300 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2302 $cnt_lines++ if ($realcnt != 0);
2304 # Check if the commit log has what seems like a diff which can confuse patch
2305 if ($in_commit_log && !$commit_log_has_diff &&
2306 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2307 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2308 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2309 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2310 ERROR("DIFF_IN_COMMIT_MSG",
2311 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2312 $commit_log_has_diff = 1;
2315 # Check for incorrect file permissions
2316 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2317 my $permhere = $here . "FILE: $realfile\n";
2318 if ($realfile !~ m@scripts/@ &&
2319 $realfile !~ /\.(py|pl|awk|sh)$/) {
2320 ERROR("EXECUTE_PERMISSIONS",
2321 "do not set execute permissions for source files\n" . $permhere);
2325 # Check the patch for a signoff:
2326 if ($line =~ /^\s*signed-off-by:/i) {
2331 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2332 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2333 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2334 $reported_maintainer_file = 1;
2337 # Check signature styles
2338 if (!$in_header_lines &&
2339 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2340 my $space_before = $1;
2342 my $space_after = $3;
2344 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2346 if ($sign_off !~ /$signature_tags/) {
2347 WARN("BAD_SIGN_OFF",
2348 "Non-standard signature: $sign_off\n" . $herecurr);
2350 if (defined $space_before && $space_before ne "") {
2351 if (WARN("BAD_SIGN_OFF",
2352 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2354 $fixed[$fixlinenr] =
2355 "$ucfirst_sign_off $email";
2358 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2359 if (WARN("BAD_SIGN_OFF",
2360 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2362 $fixed[$fixlinenr] =
2363 "$ucfirst_sign_off $email";
2367 if (!defined $space_after || $space_after ne " ") {
2368 if (WARN("BAD_SIGN_OFF",
2369 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2371 $fixed[$fixlinenr] =
2372 "$ucfirst_sign_off $email";
2376 my ($email_name, $email_address, $comment) = parse_email($email);
2377 my $suggested_email = format_email(($email_name, $email_address));
2378 if ($suggested_email eq "") {
2379 ERROR("BAD_SIGN_OFF",
2380 "Unrecognized email address: '$email'\n" . $herecurr);
2382 my $dequoted = $suggested_email;
2383 $dequoted =~ s/^"//;
2384 $dequoted =~ s/" </ </;
2385 # Don't force email to have quotes
2386 # Allow just an angle bracketed address
2387 if ("$dequoted$comment" ne $email &&
2388 "<$email_address>$comment" ne $email &&
2389 "$suggested_email$comment" ne $email) {
2390 WARN("BAD_SIGN_OFF",
2391 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2395 # Check for duplicate signatures
2396 my $sig_nospace = $line;
2397 $sig_nospace =~ s/\s//g;
2398 $sig_nospace = lc($sig_nospace);
2399 if (defined $signatures{$sig_nospace}) {
2400 WARN("BAD_SIGN_OFF",
2401 "Duplicate signature\n" . $herecurr);
2403 $signatures{$sig_nospace} = 1;
2407 # Check email subject for common tools that don't need to be mentioned
2408 if ($in_header_lines &&
2409 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2410 WARN("EMAIL_SUBJECT",
2411 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2414 # Check for old stable address
2415 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2416 ERROR("STABLE_ADDRESS",
2417 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2420 # Check for unwanted Gerrit info
2421 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2422 ERROR("GERRIT_CHANGE_ID",
2423 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2426 # Check if the commit log is in a possible stack dump
2427 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2428 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2429 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2431 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2432 # stack dump address
2433 $commit_log_possible_stack_dump = 1;
2436 # Check for line lengths > 75 in commit log, warn once
2437 if ($in_commit_log && !$commit_log_long_line &&
2438 length($line) > 75 &&
2439 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2440 # file delta changes
2441 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2443 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2444 # A Fixes: or Link: line
2445 $commit_log_possible_stack_dump)) {
2446 WARN("COMMIT_LOG_LONG_LINE",
2447 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2448 $commit_log_long_line = 1;
2451 # Reset possible stack dump if a blank line is found
2452 if ($in_commit_log && $commit_log_possible_stack_dump &&
2454 $commit_log_possible_stack_dump = 0;
2457 # Check for git id commit length and improperly formed commit descriptions
2458 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2459 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2460 ($line =~ /\b[0-9a-f]{12,40}\b/i &&
2461 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2462 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2463 my $init_char = "c";
2464 my $orig_commit = "";
2471 my $id = '0123456789ab';
2472 my $orig_desc = "commit description";
2473 my $description = "";
2475 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2477 $orig_commit = lc($2);
2478 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2479 $orig_commit = lc($1);
2482 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2483 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2484 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2485 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2486 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2489 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2490 defined $rawlines[$linenr] &&
2491 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2494 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2495 defined $rawlines[$linenr] &&
2496 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2497 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2499 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2500 $orig_desc .= " " . $1;
2504 ($id, $description) = git_commit_info($orig_commit,
2507 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
2508 ERROR("GIT_COMMIT_ID",
2509 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2513 # Check for added, moved or deleted files
2514 if (!$reported_maintainer_file && !$in_commit_log &&
2515 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2516 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2517 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2518 (defined($1) || defined($2))))) {
2519 $reported_maintainer_file = 1;
2520 WARN("FILE_PATH_CHANGES",
2521 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2524 # Check for wrappage within a valid hunk of the file
2525 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2526 ERROR("CORRUPTED_PATCH",
2527 "patch seems to be corrupt (line wrapped?)\n" .
2528 $herecurr) if (!$emitted_corrupt++);
2531 # Check for absolute kernel paths.
2533 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2536 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2537 check_absolute_file($1, $herecurr)) {
2540 check_absolute_file($file, $herecurr);
2545 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2546 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2547 $rawline !~ m/^$UTF8*$/) {
2548 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2550 my $blank = copy_spacing($rawline);
2551 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2552 my $hereptr = "$hereline$ptr\n";
2555 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2558 # Check if it's the start of a commit log
2559 # (not a header line and we haven't seen the patch filename)
2560 if ($in_header_lines && $realfile =~ /^$/ &&
2561 !($rawline =~ /^\s+\S/ ||
2562 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2563 $in_header_lines = 0;
2567 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2568 # declined it, i.e defined some charset where it is missing.
2569 if ($in_header_lines &&
2570 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2572 $non_utf8_charset = 1;
2575 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2576 $rawline =~ /$NON_ASCII_UTF8/) {
2577 WARN("UTF8_BEFORE_PATCH",
2578 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2581 # Check for various typo / spelling mistakes
2582 if (defined($misspellings) &&
2583 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2584 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2586 my $typo_fix = $spelling_fix{lc($typo)};
2587 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2588 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2589 my $msg_type = \&WARN;
2590 $msg_type = \&CHK if ($file);
2591 if (&{$msg_type}("TYPO_SPELLING",
2592 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2594 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2599 # ignore non-hunk lines and lines being removed
2600 next if (!$hunk_line || $line =~ /^-/);
2602 #trailing whitespace
2603 if ($line =~ /^\+.*\015/) {
2604 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2605 if (ERROR("DOS_LINE_ENDINGS",
2606 "DOS line endings\n" . $herevet) &&
2608 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2610 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2611 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2612 if (ERROR("TRAILING_WHITESPACE",
2613 "trailing whitespace\n" . $herevet) &&
2615 $fixed[$fixlinenr] =~ s/\s+$//;
2621 # Check for FSF mailing addresses.
2622 if ($rawline =~ /\bwrite to the Free/i ||
2623 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2624 $rawline =~ /\b51\s+Franklin\s+St/i) {
2625 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2626 my $msg_type = \&ERROR;
2627 $msg_type = \&CHK if ($file);
2628 &{$msg_type}("FSF_MAILING_ADDRESS",
2629 "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)
2632 # check for Kconfig help text having a real description
2633 # Only applies when adding the entry originally, after that we do not have
2634 # sufficient context to determine whether it is indeed long enough.
2635 if ($realfile =~ /Kconfig/ &&
2636 $line =~ /^\+\s*config\s+/) {
2639 my $ln = $linenr + 1;
2643 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2644 $f = $lines[$ln - 1];
2645 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2646 $is_end = $lines[$ln - 1] =~ /^\+/;
2648 next if ($f =~ /^-/);
2649 last if (!$file && $f =~ /^\@\@/);
2651 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2653 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2660 next if ($f =~ /^$/);
2661 if ($f =~ /^\s*config\s/) {
2667 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2668 WARN("CONFIG_DESCRIPTION",
2669 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2671 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2674 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2675 if ($realfile =~ /Kconfig/ &&
2676 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2677 WARN("CONFIG_EXPERIMENTAL",
2678 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2681 # discourage the use of boolean for type definition attributes of Kconfig options
2682 if ($realfile =~ /Kconfig/ &&
2683 $line =~ /^\+\s*\bboolean\b/) {
2684 WARN("CONFIG_TYPE_BOOLEAN",
2685 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2688 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2689 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2692 'EXTRA_AFLAGS' => 'asflags-y',
2693 'EXTRA_CFLAGS' => 'ccflags-y',
2694 'EXTRA_CPPFLAGS' => 'cppflags-y',
2695 'EXTRA_LDFLAGS' => 'ldflags-y',
2698 WARN("DEPRECATED_VARIABLE",
2699 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead
.\n" . $herecurr) if ($replacement->{$flag});
2702 # check for DT compatible documentation
2703 if (defined $root &&
2704 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2705 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2707 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2709 my $dt_path = $root . "/Documentation/devicetree
/bindings/";
2710 my $vp_file = $dt_path . "vendor-prefixes
.txt
";
2712 foreach my $compat (@compats) {
2713 my $compat2 = $compat;
2714 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2715 my $compat3 = $compat;
2716 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2717 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2719 WARN("UNDOCUMENTED_DT_STRING
",
2720 "DT compatible string
\"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2723 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2725 `grep -Eq "^$vendor\\b" $vp_file`;
2727 WARN("UNDOCUMENTED_DT_STRING",
2728 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2733 # check we are in a valid source file if not then ignore this hunk
2734 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
2736 # line length limit (with some exclusions)
2738 # There are a few types of lines that may extend beyond $max_line_length:
2739 # logging functions like pr_info that end in a string
2740 # lines with a single string
2741 # #defines that are a single string
2743 # There are 3 different line length message types:
2744 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2745 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2746 # LONG_LINE all other lines longer than $max_line_length
2748 # if LONG_LINE is ignored, the other 2 types are also ignored
2751 if ($line =~ /^\+/ && $length > $max_line_length) {
2752 my $msg_type = "LONG_LINE";
2754 # Check the allowed long line types first
2756 # logging functions that end in a string that starts
2757 # before $max_line_length
2758 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2759 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2762 # lines with only strings (w/ possible termination)
2763 # #defines with only strings
2764 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2765 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2768 # Otherwise set the alternate message types
2770 # a comment starts before $max_line_length
2771 } elsif ($line =~ /($;[\s$;]*)$/ &&
2772 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2773 $msg_type = "LONG_LINE_COMMENT"
2775 # a quoted string starts before $max_line_length
2776 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2777 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2778 $msg_type = "LONG_LINE_STRING"
2781 if ($msg_type ne "" &&
2782 (show_type("LONG_LINE") || show_type($msg_type))) {
2784 "line over $max_line_length characters\n" . $herecurr);
2788 # check for adding lines without a newline.
2789 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2790 WARN("MISSING_EOF_NEWLINE",
2791 "adding a line without newline at end of file\n" . $herecurr);
2794 # Blackfin: use hi/lo macros
2795 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2796 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2797 my $herevet = "$here\n" . cat_vet($line) . "\n";
2799 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2801 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2802 my $herevet = "$here\n" . cat_vet($line) . "\n";
2804 "use the HI() macro, not (... >> 16)\n" . $herevet);
2808 # check we are in a valid source file C or perl if not then ignore this hunk
2809 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2811 # at the beginning of a line any tabs must come first and anything
2812 # more than 8 must use tabs.
2813 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2814 $rawline =~ /^\+\s* \s*/) {
2815 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2817 if (ERROR("CODE_INDENT",
2818 "code indent should use tabs where possible\n" . $herevet) &&
2820 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2824 # check for space before tabs.
2825 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2826 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2827 if (WARN("SPACE_BEFORE_TAB",
2828 "please, no space before tabs\n" . $herevet) &&
2830 while ($fixed[$fixlinenr] =~
2831 s/(^\+.*) {8,8}\t/$1\t\t/) {}
2832 while ($fixed[$fixlinenr] =~
2833 s/(^\+.*) +\t/$1\t/) {}
2837 # check for && or || at the start of a line
2838 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2839 CHK("LOGICAL_CONTINUATIONS",
2840 "Logical continuations should be on the previous line\n" . $hereprev);
2843 # check indentation starts on a tab stop
2844 if ($^V && $^V ge 5.10.0 &&
2845 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2846 my $indent = length($1);
2849 "Statements should start on a tabstop\n" . $herecurr) &&
2851 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2856 # check multi-line statement indentation matches previous line
2857 if ($^V && $^V ge 5.10.0 &&
2858 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2859 $prevline =~ /^\+(\t*)(.*)$/;
2863 my $pos = pos_last_openparen($rest);
2865 $line =~ /^(\+| )([ \t]*)/;
2868 my $goodtabindent = $oldindent .
2871 my $goodspaceindent = $oldindent . " " x $pos;
2873 if ($newindent ne $goodtabindent &&
2874 $newindent ne $goodspaceindent) {
2876 if (CHK("PARENTHESIS_ALIGNMENT",
2877 "Alignment should match open parenthesis\n" . $hereprev) &&
2878 $fix && $line =~ /^\+/) {
2879 $fixed[$fixlinenr] =~
2880 s/^\+[ \t]*/\+$goodtabindent/;
2886 # check for space after cast like "(int) foo" or "(struct foo) bar"
2887 # avoid checking a few false positives:
2888 # "sizeof(<type>)" or "__alignof__(<type>)"
2889 # function pointer declarations like "(*foo)(int) = bar;"
2890 # structure definitions like "(struct foo) { 0 };"
2891 # multiline macros that define functions
2892 # known attributes or the __attribute__ keyword
2893 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2894 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2896 "No space is necessary after a cast\n" . $herecurr) &&
2898 $fixed[$fixlinenr] =~
2899 s/(\(\s*$Type\s*\))[ \t]+/$1/;
2903 # Block comment styles
2904 # Networking with an initial /*
2905 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2906 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2907 $rawline =~ /^\+[ \t]*\*/ &&
2909 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2910 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2913 # Block comments use * on subsequent lines
2914 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
2915 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
2916 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
2917 $rawline =~ /^\+/ && #line is new
2918 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2919 WARN("BLOCK_COMMENT_STYLE",
2920 "Block comments use * on subsequent lines\n" . $hereprev);
2923 # Block comments use */ on trailing lines
2924 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2925 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2926 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2927 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
2928 WARN("BLOCK_COMMENT_STYLE",
2929 "Block comments use a trailing */ on a separate line\n" . $herecurr);
2932 # check for missing blank lines after struct/union declarations
2933 # with exceptions for various attributes and macros
2934 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2936 !($line =~ /^\+\s*$/ ||
2937 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2938 $line =~ /^\+\s*MODULE_/i ||
2939 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2940 $line =~ /^\+[a-z_]*init/ ||
2941 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2942 $line =~ /^\+\s*DECLARE/ ||
2943 $line =~ /^\+\s*__setup/)) {
2944 if (CHK("LINE_SPACING",
2945 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2947 fix_insert_line($fixlinenr, "\+");
2951 # check for multiple consecutive blank lines
2952 if ($prevline =~ /^[\+ ]\s*$/ &&
2953 $line =~ /^\+\s*$/ &&
2954 $last_blank_line != ($linenr - 1)) {
2955 if (CHK("LINE_SPACING",
2956 "Please don't use multiple blank lines\n" . $hereprev) &&
2958 fix_delete_line($fixlinenr, $rawline);
2961 $last_blank_line = $linenr;
2964 # check for missing blank lines after declarations
2965 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2966 # actual declarations
2967 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2968 # function pointer declarations
2969 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2970 # foo bar; where foo is some local typedef or #define
2971 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2972 # known declaration macros
2973 $prevline =~ /^\+\s+$declaration_macros/) &&
2974 # for "else if" which can look like "$Ident $Ident"
2975 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2976 # other possible extensions of declaration lines
2977 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2978 # not starting a section or a macro "\" extended line
2979 $prevline =~ /(?:\{\s*|\\)$/) &&
2980 # looks like a declaration
2981 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2982 # function pointer declarations
2983 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2984 # foo bar; where foo is some local typedef or #define
2985 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2986 # known declaration macros
2987 $sline =~ /^\+\s+$declaration_macros/ ||
2988 # start of struct or union or enum
2989 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2990 # start or end of block or continuation of declaration
2991 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2992 # bitfield continuation
2993 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2994 # other possible extensions of declaration lines
2995 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2996 # indentation of previous and current line are the same
2997 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2998 if (WARN("LINE_SPACING",
2999 "Missing a blank line after declarations\n" . $hereprev) &&
3001 fix_insert_line($fixlinenr, "\+");
3005 # check for spaces at the beginning of a line.
3007 # 1) within comments
3008 # 2) indented preprocessor commands
3010 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3011 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3012 if (WARN("LEADING_SPACE",
3013 "please, no spaces at the start of a line\n" . $herevet) &&
3015 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3019 # check we are in a valid C source file if not then ignore this hunk
3020 next if ($realfile !~ /\.(h|c)$/);
3022 # check indentation of any line with a bare else
3023 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3024 # if the previous line is a break or return and is indented 1 tab more...
3025 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3026 my $tabs = length($1) + 1;
3027 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3028 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3029 defined $lines[$linenr] &&
3030 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3031 WARN("UNNECESSARY_ELSE",
3032 "else is not generally useful after a break or return\n" . $hereprev);
3036 # check indentation of a line with a break;
3037 # if the previous line is a goto or return and is indented the same # of tabs
3038 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3040 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3041 WARN("UNNECESSARY_BREAK",
3042 "break is not useful after a goto or return\n" . $hereprev);
3046 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
3047 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
3048 WARN("CONFIG_EXPERIMENTAL",
3049 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
3052 # check for RCS/CVS revision markers
3053 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3055 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3058 # Blackfin: don't use __builtin_bfin_[cs]sync
3059 if ($line =~ /__builtin_bfin_csync/) {
3060 my $herevet = "$here\n" . cat_vet($line) . "\n";
3062 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3064 if ($line =~ /__builtin_bfin_ssync/) {
3065 my $herevet = "$here\n" . cat_vet($line) . "\n";
3067 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3070 # check for old HOTPLUG __dev<foo> section markings
3071 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3072 WARN("HOTPLUG_SECTION",
3073 "Using $1 is unnecessary\n" . $herecurr);
3076 # Check for potential 'bare' types
3077 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3079 #print "LINE<$line>\n";
3080 if ($linenr >= $suppress_statement &&
3081 $realcnt && $sline =~ /.\s*\S/) {
3082 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3083 ctx_statement_block($linenr, $realcnt, 0);
3084 $stat =~ s/\n./\n /g;
3085 $cond =~ s/\n./\n /g;
3087 #print "linenr<$linenr> <$stat>\n";
3088 # If this statement has no statement boundaries within
3089 # it there is no point in retrying a statement scan
3090 # until we hit end of it.
3091 my $frag = $stat; $frag =~ s/;+\s*$//;
3092 if ($frag !~ /(?:{|;)/) {
3093 #print "skip<$line_nr_next>\n";
3094 $suppress_statement = $line_nr_next;
3097 # Find the real next line.
3098 $realline_next = $line_nr_next;
3099 if (defined $realline_next &&
3100 (!defined $lines[$realline_next - 1] ||
3101 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3108 # Ignore goto labels.
3109 if ($s =~ /$Ident:\*$/s) {
3111 # Ignore functions being called
3112 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3114 } elsif ($s =~ /^.\s*else\b/s) {
3116 # declarations always start with types
3117 } 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) {
3120 possible($type, "A:" . $s);
3122 # definitions in global scope can only start with types
3123 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3124 possible($1, "B:" . $s);
3127 # any (foo ... *) is a pointer cast, and foo is a type
3128 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3129 possible($1, "C:" . $s);
3132 # Check for any sort of function declaration.
3133 # int foo(something bar, other baz);
3134 # void (*store_gdt)(x86_descr_ptr *);
3135 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3136 my ($name_len) = length($1);
3139 substr($ctx, 0, $name_len + 1, '');
3140 $ctx =~ s/\)[^\)]*$//;
3142 for my $arg (split(/\s*,\s*/, $ctx)) {
3143 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3145 possible($1, "D:" . $s);
3153 # Checks which may be anchored in the context.
3156 # Check for switch () and associated case and default
3157 # statements should be at the same indent.
3158 if ($line=~/\bswitch\s*\(.*\)/) {
3161 my @ctx = ctx_block_outer($linenr, $realcnt);
3163 for my $ctx (@ctx) {
3164 my ($clen, $cindent) = line_stats($ctx);
3165 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3166 $indent != $cindent) {
3167 $err .= "$sep$ctx\n";
3174 ERROR("SWITCH_CASE_INDENT_LEVEL",
3175 "switch and case should be at the same indent\n$hereline$err");
3179 # if/while/etc brace do not go on next line, unless defining a do while loop,
3180 # or if that brace on the next line is for something else
3181 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3182 my $pre_ctx = "$1$2";
3184 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3186 if ($line =~ /^\+\t{6,}/) {
3187 WARN("DEEP_INDENTATION",
3188 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3191 my $ctx_cnt = $realcnt - $#ctx - 1;
3192 my $ctx = join("\n", @ctx);
3194 my $ctx_ln = $linenr;
3195 my $ctx_skip = $realcnt;
3197 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3198 defined $lines[$ctx_ln - 1] &&
3199 $lines[$ctx_ln - 1] =~ /^-/)) {
3200 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3201 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3205 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3206 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3208 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3210 "that open brace { should be on the previous line\n" .
3211 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3213 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3214 $ctx =~ /\)\s*\;\s*$/ &&
3215 defined $lines[$ctx_ln - 1])
3217 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3218 if ($nindent > $indent) {
3219 WARN("TRAILING_SEMICOLON",
3220 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3221 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3226 # Check relative indent for conditionals and blocks.
3227 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3228 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3229 ctx_statement_block($linenr, $realcnt, 0)
3230 if (!defined $stat);
3231 my ($s, $c) = ($stat, $cond);
3233 substr($s, 0, length($c), '');
3235 # remove inline comments
3239 # Find out how long the conditional actually is.
3240 my @newlines = ($c =~ /\n/gs);
3241 my $cond_lines = 1 + $#newlines;
3243 # Make sure we remove the line prefixes as we have
3244 # none on the first line, and are going to readd them
3247 while ($s =~ /\n\s+\\\n/) {
3248 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3251 # We want to check the first line inside the block
3252 # starting at the end of the conditional, so remove:
3253 # 1) any blank line termination
3254 # 2) any opening brace { on end of the line
3256 my $continuation = 0;
3258 $s =~ s/^.*\bdo\b//;
3260 if ($s =~ s/^\s*\\//) {
3263 if ($s =~ s/^\s*?\n//) {
3268 # Also ignore a loop construct at the end of a
3269 # preprocessor statement.
3270 if (($prevline =~ /^.\s*#\s*define\s/ ||
3271 $prevline =~ /\\\s*$/) && $continuation == 0) {
3277 while ($cond_ptr != $cond_lines) {
3278 $cond_ptr = $cond_lines;
3280 # If we see an #else/#elif then the code
3282 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3287 # 1) blank lines, they should be at 0,
3288 # 2) preprocessor lines, and
3290 if ($continuation ||
3292 $s =~ /^\s*#\s*?/ ||
3293 $s =~ /^\s*$Ident\s*:/) {
3294 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3295 if ($s =~ s/^.*?\n//) {
3301 my (undef, $sindent) = line_stats("+" . $s);
3302 my $stat_real = raw_line($linenr, $cond_lines);
3304 # Check if either of these lines are modified, else
3305 # this is not this patch's fault.
3306 if (!defined($stat_real) ||
3307 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3310 if (defined($stat_real) && $cond_lines > 1) {
3311 $stat_real = "[...]\n$stat_real";
3314 #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";
3316 if ($check && $s ne '' &&
3317 (($sindent % 8) != 0 ||
3318 ($sindent < $indent) ||
3319 ($sindent > $indent + 8))) {
3320 WARN("SUSPECT_CODE_INDENT",
3321 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3325 # Track the 'values' across context and added lines.
3326 my $opline = $line; $opline =~ s/^./ /;
3327 my ($curr_values, $curr_vars) =
3328 annotate_values($opline . "\n", $prev_values);
3329 $curr_values = $prev_values . $curr_values;
3331 my $outline = $opline; $outline =~ s/\t/ /g;
3332 print "$linenr > .$outline\n";
3333 print "$linenr > $curr_values\n";
3334 print "$linenr > $curr_vars\n";
3336 $prev_values = substr($curr_values, -1);
3338 #ignore lines not being added
3339 next if ($line =~ /^[^\+]/);
3341 # check for declarations of signed or unsigned without int
3342 while ($line =~ m{($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3345 $var = "" if (!defined $var);
3346 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3350 $pointer = "" if (!defined $pointer);
3352 if (WARN("UNSPECIFIED_INT",
3353 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3355 my $decl = trim($sign) . " int ";
3356 my $comp_pointer = $pointer;
3357 $comp_pointer =~ s/\s//g;
3358 $decl .= $comp_pointer;
3359 $decl = rtrim($decl) if ($var eq "");
3360 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3365 # TEST: allow direct testing of the type matcher.
3367 if ($line =~ /^.\s*$Declare\s*$/) {
3369 "TEST: is type\n" . $herecurr);
3370 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3371 ERROR("TEST_NOT_TYPE",
3372 "TEST: is not type ($1 is)\n". $herecurr);
3376 # TEST: allow direct testing of the attribute matcher.
3378 if ($line =~ /^.\s*$Modifier\s*$/) {
3380 "TEST: is attr\n" . $herecurr);
3381 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3382 ERROR("TEST_NOT_ATTR",
3383 "TEST: is not attr ($1 is)\n". $herecurr);
3388 # check for initialisation to aggregates open brace on the next line
3389 if ($line =~ /^.\s*{/ &&
3390 $prevline =~ /(?:^|[^=])=\s*$/) {
3391 if (ERROR("OPEN_BRACE",
3392 "that open brace { should be on the previous line\n" . $hereprev) &&
3393 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3394 fix_delete_line($fixlinenr - 1, $prevrawline);
3395 fix_delete_line($fixlinenr, $rawline);
3396 my $fixedline = $prevrawline;
3397 $fixedline =~ s/\s*=\s*$/ = {/;
3398 fix_insert_line($fixlinenr, $fixedline);
3400 $fixedline =~ s/^(.\s*){\s*/$1/;
3401 fix_insert_line($fixlinenr, $fixedline);
3406 # Checks which are anchored on the added line.
3409 # check for malformed paths in #include statements (uses RAW line)
3410 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3412 if ($path =~ m{//}) {
3413 ERROR("MALFORMED_INCLUDE",
3414 "malformed #include filename\n" . $herecurr);
3416 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3417 ERROR("UAPI_INCLUDE",
3418 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3422 # no C99 // comments
3423 if ($line =~ m{//}) {
3424 if (ERROR("C99_COMMENTS",
3425 "do not use C99 // comments\n" . $herecurr) &&
3427 my $line = $fixed[$fixlinenr];
3428 if ($line =~ /\/\/(.*)$/) {
3429 my $comment = trim($1);
3430 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3434 # Remove C99 comments.
3436 $opline =~ s@//.*@@;
3438 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3439 # the whole statement.
3440 #print "APW <$lines[$realline_next - 1]>\n";
3441 if (defined $realline_next &&
3442 exists $lines[$realline_next - 1] &&
3443 !defined $suppress_export{$realline_next} &&
3444 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3445 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3446 # Handle definitions which produce identifiers with
3449 # EXPORT_SYMBOL(something_foo);
3451 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3452 $name =~ /^${Ident}_$2/) {
3453 #print "FOO C name<$name>\n";
3454 $suppress_export{$realline_next} = 1;
3456 } elsif ($stat !~ /(?:
3458 ^.DEFINE_$Ident\(\Q$name\E\)|
3459 ^.DECLARE_$Ident\(\Q$name\E\)|
3460 ^.LIST_HEAD\(\Q$name\E\)|
3461 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3462 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3464 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3465 $suppress_export{$realline_next} = 2;
3467 $suppress_export{$realline_next} = 1;
3470 if (!defined $suppress_export{$linenr} &&
3471 $prevline =~ /^.\s*$/ &&
3472 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3473 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3474 #print "FOO B <$lines[$linenr - 1]>\n";
3475 $suppress_export{$linenr} = 2;
3477 if (defined $suppress_export{$linenr} &&
3478 $suppress_export{$linenr} == 2) {
3479 WARN("EXPORT_SYMBOL",
3480 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3483 # check for global initialisers.
3484 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3485 if (ERROR("GLOBAL_INITIALISERS",
3486 "do not initialise globals to $1\n" . $herecurr) &&
3488 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3491 # check for static initialisers.
3492 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3493 if (ERROR("INITIALISED_STATIC",
3494 "do not initialise statics to $1\n" .
3497 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3501 # check for misordered declarations of char/short/int/long with signed/unsigned
3502 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3504 WARN("MISORDERED_TYPE",
3505 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3508 # check for static const char * arrays.
3509 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3510 WARN("STATIC_CONST_CHAR_ARRAY",
3511 "static const char * array should probably be static const char * const\n" .
3515 # check for static char foo[] = "bar" declarations.
3516 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3517 WARN("STATIC_CONST_CHAR_ARRAY",
3518 "static char array declaration should probably be static const char\n" .
3522 # check for const <foo> const where <foo> is not a pointer or array type
3523 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3525 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3527 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3528 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3530 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3534 # check for non-global char *foo[] = {"bar", ...} declarations.
3535 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3536 WARN("STATIC_CONST_CHAR_ARRAY",
3537 "char * array declaration might be better as static const\n" .
3541 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3542 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3544 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3546 if (WARN("ARRAY_SIZE",
3547 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3549 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3554 # check for function declarations without arguments like "int foo()"
3555 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3556 if (ERROR("FUNCTION_WITHOUT_ARGS",
3557 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3559 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3563 # check for uses of DEFINE_PCI_DEVICE_TABLE
3564 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3565 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3566 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3568 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3572 # check for new typedefs, only function parameters and sparse annotations
3574 if ($line =~ /\btypedef\s/ &&
3575 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3576 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3577 $line !~ /\b$typeTypedefs\b/ &&
3578 $line !~ /\b__bitwise(?:__|)\b/) {
3579 WARN("NEW_TYPEDEFS",
3580 "do not add new typedefs\n" . $herecurr);
3583 # * goes on variable not on type
3585 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3587 my ($ident, $from, $to) = ($1, $2, $2);
3589 # Should start with a space.
3590 $to =~ s/^(\S)/ $1/;
3591 # Should not end with a space.
3593 # '*'s should not have spaces between.
3594 while ($to =~ s/\*\s+\*/\*\*/) {
3597 ## print "1: from<$from> to<$to> ident<$ident>\n";
3599 if (ERROR("POINTER_LOCATION",
3600 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3602 my $sub_from = $ident;
3603 my $sub_to = $ident;
3604 $sub_to =~ s/\Q$from\E/$to/;
3605 $fixed[$fixlinenr] =~
3606 s@\Q$sub_from\E@$sub_to@;
3610 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3612 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3614 # Should start with a space.
3615 $to =~ s/^(\S)/ $1/;
3616 # Should not end with a space.
3618 # '*'s should not have spaces between.
3619 while ($to =~ s/\*\s+\*/\*\*/) {
3621 # Modifiers should have spaces.
3622 $to =~ s/(\b$Modifier$)/$1 /;
3624 ## print "2: from<$from> to<$to> ident<$ident>\n";
3625 if ($from ne $to && $ident !~ /^$Modifier$/) {
3626 if (ERROR("POINTER_LOCATION",
3627 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3630 my $sub_from = $match;
3631 my $sub_to = $match;
3632 $sub_to =~ s/\Q$from\E/$to/;
3633 $fixed[$fixlinenr] =~
3634 s@\Q$sub_from\E@$sub_to@;
3639 # avoid BUG() or BUG_ON()
3640 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3641 my $msg_type = \&WARN;
3642 $msg_type = \&CHK if ($file);
3643 &{$msg_type}("AVOID_BUG",
3644 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3647 # avoid LINUX_VERSION_CODE
3648 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3649 WARN("LINUX_VERSION_CODE",
3650 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3653 # check for uses of printk_ratelimit
3654 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3655 WARN("PRINTK_RATELIMITED",
3656 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3659 # printk should use KERN_* levels. Note that follow on printk's on the
3660 # same line do not need a level, so we use the current block context
3661 # to try and find and validate the current printk. In summary the current
3662 # printk includes all preceding printk's which have no newline on the end.
3663 # we assume the first bad printk is the one to report.
3664 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3666 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3667 #print "CHECK<$lines[$ln - 1]\n";
3668 # we have a preceding printk if it ends
3669 # with "\n" ignore it, else it is to blame
3670 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3671 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3678 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3679 "printk() should include KERN_ facility level\n" . $herecurr);
3683 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3685 my $level = lc($orig);
3686 $level = "warn" if ($level eq "warning");
3687 my $level2 = $level;
3688 $level2 = "dbg" if ($level eq "debug");
3689 WARN("PREFER_PR_LEVEL",
3690 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3693 if ($line =~ /\bpr_warning\s*\(/) {
3694 if (WARN("PREFER_PR_LEVEL",
3695 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3697 $fixed[$fixlinenr] =~
3698 s/\bpr_warning\b/pr_warn/;
3702 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3704 my $level = lc($orig);
3705 $level = "warn" if ($level eq "warning");
3706 $level = "dbg" if ($level eq "debug");
3707 WARN("PREFER_DEV_LEVEL",
3708 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3711 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
3712 # number of false positives, but assembly files are not checked, so at
3713 # least the arch entry code will not trigger this warning.
3714 if ($line =~ /\bENOSYS\b/) {
3716 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3719 # function brace can't be on same line, except for #defines of do while,
3720 # or if closed on same line
3721 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3722 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3723 if (ERROR("OPEN_BRACE",
3724 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3726 fix_delete_line($fixlinenr, $rawline);
3727 my $fixed_line = $rawline;
3728 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3731 fix_insert_line($fixlinenr, ltrim($line1));
3732 fix_insert_line($fixlinenr, "\+{");
3733 if ($line2 !~ /^\s*$/) {
3734 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3739 # open braces for enum, union and struct go on the same line.
3740 if ($line =~ /^.\s*{/ &&
3741 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3742 if (ERROR("OPEN_BRACE",
3743 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3744 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3745 fix_delete_line($fixlinenr - 1, $prevrawline);
3746 fix_delete_line($fixlinenr, $rawline);
3747 my $fixedline = rtrim($prevrawline) . " {";
3748 fix_insert_line($fixlinenr, $fixedline);
3749 $fixedline = $rawline;
3750 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3751 if ($fixedline !~ /^\+\s*$/) {
3752 fix_insert_line($fixlinenr, $fixedline);
3757 # missing space after union, struct or enum definition
3758 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3760 "missing space after $1 definition\n" . $herecurr) &&
3762 $fixed[$fixlinenr] =~
3763 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3767 # Function pointer declarations
3768 # check spacing between type, funcptr, and args
3769 # canonical declaration is "type (*funcptr)(args...)"
3770 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3772 my $pre_pointer_space = $2;
3773 my $post_pointer_space = $3;
3775 my $post_funcname_space = $5;
3776 my $pre_args_space = $6;
3778 # the $Declare variable will capture all spaces after the type
3779 # so check it for a missing trailing missing space but pointer return types
3780 # don't need a space so don't warn for those.
3781 my $post_declare_space = "";
3782 if ($declare =~ /(\s+)$/) {
3783 $post_declare_space = $1;
3784 $declare = rtrim($declare);
3786 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3788 "missing space after return type\n" . $herecurr);
3789 $post_declare_space = " ";
3792 # unnecessary space "type (*funcptr)(args...)"
3793 # This test is not currently implemented because these declarations are
3795 # int foo(int bar, ...)
3796 # and this is form shouldn't/doesn't generate a checkpatch warning.
3798 # elsif ($declare =~ /\s{2,}$/) {
3800 # "Multiple spaces after return type\n" . $herecurr);
3803 # unnecessary space "type ( *funcptr)(args...)"
3804 if (defined $pre_pointer_space &&
3805 $pre_pointer_space =~ /^\s/) {
3807 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3810 # unnecessary space "type (* funcptr)(args...)"
3811 if (defined $post_pointer_space &&
3812 $post_pointer_space =~ /^\s/) {
3814 "Unnecessary space before function pointer name\n" . $herecurr);
3817 # unnecessary space "type (*funcptr )(args...)"
3818 if (defined $post_funcname_space &&
3819 $post_funcname_space =~ /^\s/) {
3821 "Unnecessary space after function pointer name\n" . $herecurr);
3824 # unnecessary space "type (*funcptr) (args...)"
3825 if (defined $pre_args_space &&
3826 $pre_args_space =~ /^\s/) {
3828 "Unnecessary space before function pointer arguments\n" . $herecurr);
3831 if (show_type("SPACING") && $fix) {
3832 $fixed[$fixlinenr] =~
3833 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3837 # check for spacing round square brackets; allowed:
3838 # 1. with a type on the left -- int [] a;
3839 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3840 # 3. inside a curly brace -- = { [0...10] = 5 }
3841 while ($line =~ /(.*?\s)\[/g) {
3842 my ($where, $prefix) = ($-[1], $1);
3843 if ($prefix !~ /$Type\s+$/ &&
3844 ($where != 0 || $prefix !~ /^.\s+$/) &&
3845 $prefix !~ /[{,]\s+$/) {
3846 if (ERROR("BRACKET_SPACE",
3847 "space prohibited before open square bracket '['\n" . $herecurr) &&
3849 $fixed[$fixlinenr] =~
3850 s/^(\+.*?)\s+\[/$1\[/;
3855 # check for spaces between functions and their parentheses.
3856 while ($line =~ /($Ident)\s+\(/g) {
3858 my $ctx_before = substr($line, 0, $-[1]);
3859 my $ctx = "$ctx_before$name";
3861 # Ignore those directives where spaces _are_ permitted.
3863 if|for|while|switch|return|case|
3864 volatile|__volatile__|
3865 __attribute__|format|__extension__|
3868 # cpp #define statements have non-optional spaces, ie
3869 # if there is a space between the name and the open
3870 # parenthesis it is simply not a parameter group.
3871 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3873 # cpp #elif statement condition may start with a (
3874 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3876 # If this whole things ends with a type its most
3877 # likely a typedef for a function.
3878 } elsif ($ctx =~ /$Type$/) {
3882 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3884 $fixed[$fixlinenr] =~
3885 s/\b$name\s+\(/$name\(/;
3890 # Check operator spacing.
3891 if (!($line=~/\#\s*include/)) {
3892 my $fixed_line = "";
3896 <<=|>>=|<=|>=|==|!=|
3897 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3898 =>|->|<<|>>|<|>|=|!|~|
3899 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3902 my @elements = split(/($ops|;)/, $opline);
3904 ## print("element count: <" . $#elements . ">\n");
3905 ## foreach my $el (@elements) {
3906 ## print("el: <$el>\n");
3909 my @fix_elements = ();
3912 foreach my $el (@elements) {
3913 push(@fix_elements, substr($rawline, $off, length($el)));
3914 $off += length($el);
3919 my $blank = copy_spacing($opline);
3920 my $last_after = -1;
3922 for (my $n = 0; $n < $#elements; $n += 2) {
3924 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3926 ## print("n: <$n> good: <$good>\n");
3928 $off += length($elements[$n]);
3930 # Pick up the preceding and succeeding characters.
3931 my $ca = substr($opline, 0, $off);
3933 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3934 $cc = substr($opline, $off + length($elements[$n + 1]));
3936 my $cb = "$ca$;$cc";
3939 $a = 'V' if ($elements[$n] ne '');
3940 $a = 'W' if ($elements[$n] =~ /\s$/);
3941 $a = 'C' if ($elements[$n] =~ /$;$/);
3942 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3943 $a = 'O' if ($elements[$n] eq '');
3944 $a = 'E' if ($ca =~ /^\s*$/);
3946 my $op = $elements[$n + 1];
3949 if (defined $elements[$n + 2]) {
3950 $c = 'V' if ($elements[$n + 2] ne '');
3951 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3952 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3953 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3954 $c = 'O' if ($elements[$n + 2] eq '');
3955 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3960 my $ctx = "${a}x${c}";
3962 my $at = "(ctx:$ctx)";
3964 my $ptr = substr($blank, 0, $off) . "^";
3965 my $hereptr = "$hereline$ptr\n";
3967 # Pull out the value of this operator.
3968 my $op_type = substr($curr_values, $off + 1, 1);
3970 # Get the full operator variant.
3971 my $opv = $op . substr($curr_vars, $off, 1);
3973 # Ignore operators passed as parameters.
3974 if ($op_type ne 'V' &&
3975 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
3978 # } elsif ($op =~ /^$;+$/) {
3980 # ; should have either the end of line or a space or \ after it
3981 } elsif ($op eq ';') {
3982 if ($ctx !~ /.x[WEBC]/ &&
3983 $cc !~ /^\\/ && $cc !~ /^;/) {
3984 if (ERROR("SPACING",
3985 "space required after that '$op' $at\n" . $hereptr)) {
3986 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3992 } elsif ($op eq '//') {
3994 # : when part of a bitfield
3995 } elsif ($opv eq ':B') {
3996 # skip the bitfield test for now
4000 } elsif ($op eq '->') {
4001 if ($ctx =~ /Wx.|.xW/) {
4002 if (ERROR("SPACING",
4003 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4004 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4005 if (defined $fix_elements[$n + 2]) {
4006 $fix_elements[$n + 2] =~ s/^\s+//;
4012 # , must not have a space before and must have a space on the right.
4013 } elsif ($op eq ',') {
4014 my $rtrim_before = 0;
4015 my $space_after = 0;
4016 if ($ctx =~ /Wx./) {
4017 if (ERROR("SPACING",
4018 "space prohibited before that '$op' $at\n" . $hereptr)) {
4023 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4024 if (ERROR("SPACING",
4025 "space required after that '$op' $at\n" . $hereptr)) {
4031 if ($rtrim_before || $space_after) {
4032 if ($rtrim_before) {
4033 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4035 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4042 # '*' as part of a type definition -- reported already.
4043 } elsif ($opv eq '*_') {
4044 #warn "'*' is part of type\n";
4046 # unary operators should have a space before and
4047 # none after. May be left adjacent to another
4048 # unary operator, or a cast
4049 } elsif ($op eq '!' || $op eq '~' ||
4050 $opv eq '*U' || $opv eq '-U' ||
4051 $opv eq '&U' || $opv eq '&&U') {
4052 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4053 if (ERROR("SPACING",
4054 "space required before that '$op' $at\n" . $hereptr)) {
4055 if ($n != $last_after + 2) {
4056 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4061 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4062 # A unary '*' may be const
4064 } elsif ($ctx =~ /.xW/) {
4065 if (ERROR("SPACING",
4066 "space prohibited after that '$op' $at\n" . $hereptr)) {
4067 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4068 if (defined $fix_elements[$n + 2]) {
4069 $fix_elements[$n + 2] =~ s/^\s+//;
4075 # unary ++ and unary -- are allowed no space on one side.
4076 } elsif ($op eq '++' or $op eq '--') {
4077 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4078 if (ERROR("SPACING",
4079 "space required one side of that '$op' $at\n" . $hereptr)) {
4080 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4084 if ($ctx =~ /Wx[BE]/ ||
4085 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4086 if (ERROR("SPACING",
4087 "space prohibited before that '$op' $at\n" . $hereptr)) {
4088 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4092 if ($ctx =~ /ExW/) {
4093 if (ERROR("SPACING",
4094 "space prohibited after that '$op' $at\n" . $hereptr)) {
4095 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4096 if (defined $fix_elements[$n + 2]) {
4097 $fix_elements[$n + 2] =~ s/^\s+//;
4103 # << and >> may either have or not have spaces both sides
4104 } elsif ($op eq '<<' or $op eq '>>' or
4105 $op eq '&' or $op eq '^' or $op eq '|' or
4106 $op eq '+' or $op eq '-' or
4107 $op eq '*' or $op eq '/' or
4111 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4113 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4114 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4115 $fix_elements[$n + 2] =~ s/^\s+//;
4118 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4120 "space preferred before that '$op' $at\n" . $hereptr)) {
4121 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4125 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4126 if (ERROR("SPACING",
4127 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4128 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4129 if (defined $fix_elements[$n + 2]) {
4130 $fix_elements[$n + 2] =~ s/^\s+//;
4136 # A colon needs no spaces before when it is
4137 # terminating a case value or a label.
4138 } elsif ($opv eq ':C' || $opv eq ':L') {
4139 if ($ctx =~ /Wx./) {
4140 if (ERROR("SPACING",
4141 "space prohibited before that '$op' $at\n" . $hereptr)) {
4142 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4147 # All the others need spaces both sides.
4148 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4151 # Ignore email addresses <foo@bar>
4153 $cc =~ /^\S+\@\S+>/) ||
4155 $ca =~ /<\S+\@\S+$/))
4160 # for asm volatile statements
4161 # ignore a colon with another
4162 # colon immediately before or after
4164 ($ca =~ /:$/ || $cc =~ /^:/)) {
4168 # messages are ERROR, but ?: are CHK
4170 my $msg_type = \&ERROR;
4171 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4173 if (&{$msg_type}("SPACING",
4174 "spaces required around that '$op' $at\n" . $hereptr)) {
4175 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4176 if (defined $fix_elements[$n + 2]) {
4177 $fix_elements[$n + 2] =~ s/^\s+//;
4183 $off += length($elements[$n + 1]);
4185 ## print("n: <$n> GOOD: <$good>\n");
4187 $fixed_line = $fixed_line . $good;
4190 if (($#elements % 2) == 0) {
4191 $fixed_line = $fixed_line . $fix_elements[$#elements];
4194 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4195 $fixed[$fixlinenr] = $fixed_line;
4201 # check for whitespace before a non-naked semicolon
4202 if ($line =~ /^\+.*\S\s+;\s*$/) {
4204 "space prohibited before semicolon\n" . $herecurr) &&
4206 1 while $fixed[$fixlinenr] =~
4207 s/^(\+.*\S)\s+;/$1;/;
4211 # check for multiple assignments
4212 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4213 CHK("MULTIPLE_ASSIGNMENTS",
4214 "multiple assignments should be avoided\n" . $herecurr);
4217 ## # check for multiple declarations, allowing for a function declaration
4219 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4220 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4222 ## # Remove any bracketed sections to ensure we do not
4223 ## # falsly report the parameters of functions.
4225 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4227 ## if ($ln =~ /,/) {
4228 ## WARN("MULTIPLE_DECLARATION",
4229 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4233 #need space before brace following if, while, etc
4234 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4236 if (ERROR("SPACING",
4237 "space required before the open brace '{'\n" . $herecurr) &&
4239 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
4243 ## # check for blank lines before declarations
4244 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4245 ## $prevrawline =~ /^.\s*$/) {
4247 ## "No blank lines before declarations\n" . $hereprev);
4251 # closing brace should have a space following it when it has anything
4253 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4254 if (ERROR("SPACING",
4255 "space required after that close brace '}'\n" . $herecurr) &&
4257 $fixed[$fixlinenr] =~
4258 s/}((?!(?:,|;|\)))\S)/} $1/;
4262 # check spacing on square brackets
4263 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4264 if (ERROR("SPACING",
4265 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4267 $fixed[$fixlinenr] =~
4271 if ($line =~ /\s\]/) {
4272 if (ERROR("SPACING",
4273 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4275 $fixed[$fixlinenr] =~
4280 # check spacing on parentheses
4281 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4282 $line !~ /for\s*\(\s+;/) {
4283 if (ERROR("SPACING",
4284 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4286 $fixed[$fixlinenr] =~
4290 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4291 $line !~ /for\s*\(.*;\s+\)/ &&
4292 $line !~ /:\s+\)/) {
4293 if (ERROR("SPACING",
4294 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4296 $fixed[$fixlinenr] =~
4301 # check unnecessary parentheses around addressof/dereference single $Lvals
4302 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4304 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4306 if (CHK("UNNECESSARY_PARENTHESES",
4307 "Unnecessary parentheses around $var\n" . $herecurr) &&
4309 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4313 # check for unnecessary parentheses around function pointer uses
4314 # ie: (foo->bar)(); should be foo->bar();
4315 # but not "if (foo->bar) (" to avoid some false positives
4316 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4318 if (CHK("UNNECESSARY_PARENTHESES",
4319 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4321 my $var2 = deparenthesize($var);
4323 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4327 #goto labels aren't indented, allow a single space however
4328 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4329 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4330 if (WARN("INDENTED_LABEL",
4331 "labels should not be indented\n" . $herecurr) &&
4333 $fixed[$fixlinenr] =~
4338 # return is not a function
4339 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4341 if ($^V && $^V ge 5.10.0 &&
4342 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4344 $value = deparenthesize($value);
4345 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4346 ERROR("RETURN_PARENTHESES",
4347 "return is not a function, parentheses are not required\n" . $herecurr);
4349 } elsif ($spacing !~ /\s+/) {
4351 "space required before the open parenthesis '('\n" . $herecurr);
4355 # unnecessary return in a void function
4356 # at end-of-function, with the previous line a single leading tab, then return;
4357 # and the line before that not a goto label target like "out:"
4358 if ($sline =~ /^[ \+]}\s*$/ &&
4359 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4361 $lines[$linenr - 3] =~ /^[ +]/ &&
4362 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4364 "void function return statements are not generally useful\n" . $hereprev);
4367 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4368 if ($^V && $^V ge 5.10.0 &&
4369 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4370 my $openparens = $1;
4371 my $count = $openparens =~ tr@\(@\(@;
4373 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4374 my $comp = $4; #Not $1 because of $LvalOrFunc
4375 $msg = " - maybe == should be = ?" if ($comp eq "==");
4376 WARN("UNNECESSARY_PARENTHESES",
4377 "Unnecessary parentheses$msg\n" . $herecurr);
4381 # comparisons with a constant or upper case identifier on the left
4382 # avoid cases like "foo + BAR < baz"
4383 # only fix matches surrounded by parentheses to avoid incorrect
4384 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4385 if ($^V && $^V ge 5.10.0 &&
4386 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4391 my $newcomp = $comp;
4392 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4393 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4394 WARN("CONSTANT_COMPARISON",
4395 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4399 } elsif ($comp eq "<=") {
4401 } elsif ($comp eq ">") {
4403 } elsif ($comp eq ">=") {
4406 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4410 # Return of what appears to be an errno should normally be negative
4411 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4413 if ($name ne 'EOF' && $name ne 'ERROR') {
4414 WARN("USE_NEGATIVE_ERRNO",
4415 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4419 # Need a space before open parenthesis after if, while etc
4420 if ($line =~ /\b(if|while|for|switch)\(/) {
4421 if (ERROR("SPACING",
4422 "space required before the open parenthesis '('\n" . $herecurr) &&
4424 $fixed[$fixlinenr] =~
4425 s/\b(if|while|for|switch)\(/$1 \(/;
4429 # Check for illegal assignment in if conditional -- and check for trailing
4430 # statements after the conditional.
4431 if ($line =~ /do\s*(?!{)/) {
4432 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4433 ctx_statement_block($linenr, $realcnt, 0)
4434 if (!defined $stat);
4435 my ($stat_next) = ctx_statement_block($line_nr_next,
4436 $remain_next, $off_next);
4437 $stat_next =~ s/\n./\n /g;
4438 ##print "stat<$stat> stat_next<$stat_next>\n";
4440 if ($stat_next =~ /^\s*while\b/) {
4441 # If the statement carries leading newlines,
4442 # then count those as offsets.
4444 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4446 statement_rawlines($whitespace) - 1;
4448 $suppress_whiletrailers{$line_nr_next +
4452 if (!defined $suppress_whiletrailers{$linenr} &&
4453 defined($stat) && defined($cond) &&
4454 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4455 my ($s, $c) = ($stat, $cond);
4457 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4458 ERROR("ASSIGN_IN_IF",
4459 "do not use assignment in if condition\n" . $herecurr);
4462 # Find out what is on the end of the line after the
4464 substr($s, 0, length($c), '');
4466 $s =~ s/$;//g; # Remove any comments
4467 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4468 $c !~ /}\s*while\s*/)
4470 # Find out how long the conditional actually is.
4471 my @newlines = ($c =~ /\n/gs);
4472 my $cond_lines = 1 + $#newlines;
4475 $stat_real = raw_line($linenr, $cond_lines)
4476 . "\n" if ($cond_lines);
4477 if (defined($stat_real) && $cond_lines > 1) {
4478 $stat_real = "[...]\n$stat_real";
4481 ERROR("TRAILING_STATEMENTS",
4482 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4486 # Check for bitwise tests written as boolean
4498 WARN("HEXADECIMAL_BOOLEAN_TEST",
4499 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4502 # if and else should not have general statements after it
4503 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4505 $s =~ s/$;//g; # Remove any comments
4506 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4507 ERROR("TRAILING_STATEMENTS",
4508 "trailing statements should be on next line\n" . $herecurr);
4511 # if should not continue a brace
4512 if ($line =~ /}\s*if\b/) {
4513 ERROR("TRAILING_STATEMENTS",
4514 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4517 # case and default should not have general statements after them
4518 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4520 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4524 ERROR("TRAILING_STATEMENTS",
4525 "trailing statements should be on next line\n" . $herecurr);
4528 # Check for }<nl>else {, these must be at the same
4529 # indent level to be relevant to each other.
4530 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4531 $previndent == $indent) {
4532 if (ERROR("ELSE_AFTER_BRACE",
4533 "else should follow close brace '}'\n" . $hereprev) &&
4534 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4535 fix_delete_line($fixlinenr - 1, $prevrawline);
4536 fix_delete_line($fixlinenr, $rawline);
4537 my $fixedline = $prevrawline;
4538 $fixedline =~ s/}\s*$//;
4539 if ($fixedline !~ /^\+\s*$/) {
4540 fix_insert_line($fixlinenr, $fixedline);
4542 $fixedline = $rawline;
4543 $fixedline =~ s/^(.\s*)else/$1} else/;
4544 fix_insert_line($fixlinenr, $fixedline);
4548 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4549 $previndent == $indent) {
4550 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4552 # Find out what is on the end of the line after the
4554 substr($s, 0, length($c), '');
4557 if ($s =~ /^\s*;/) {
4558 if (ERROR("WHILE_AFTER_BRACE",
4559 "while should follow close brace '}'\n" . $hereprev) &&
4560 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4561 fix_delete_line($fixlinenr - 1, $prevrawline);
4562 fix_delete_line($fixlinenr, $rawline);
4563 my $fixedline = $prevrawline;
4564 my $trailing = $rawline;
4565 $trailing =~ s/^\+//;
4566 $trailing = trim($trailing);
4567 $fixedline =~ s/}\s*$/} $trailing/;
4568 fix_insert_line($fixlinenr, $fixedline);
4573 #Specific variable tests
4574 while ($line =~ m{($Constant|$Lval)}g) {
4577 #gcc binary extension
4578 if ($var =~ /^$Binary$/) {
4579 if (WARN("GCC_BINARY_CONSTANT",
4580 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4582 my $hexval = sprintf("0x%x", oct($var));
4583 $fixed[$fixlinenr] =~
4584 s/\b$var\b/$hexval/;
4589 if ($var !~ /^$Constant$/ &&
4590 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4591 #Ignore Page<foo> variants
4592 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4593 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4594 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4595 #Ignore some three character SI units explicitly, like MiB and KHz
4596 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4597 while ($var =~ m{($Ident)}g) {
4599 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4601 seed_camelcase_includes();
4602 if (!$file && !$camelcase_file_seeded) {
4603 seed_camelcase_file($realfile);
4604 $camelcase_file_seeded = 1;
4607 if (!defined $camelcase{$word}) {
4608 $camelcase{$word} = 1;
4610 "Avoid CamelCase: <$word>\n" . $herecurr);
4616 #no spaces allowed after \ in define
4617 if ($line =~ /\#\s*define.*\\\s+$/) {
4618 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4619 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4621 $fixed[$fixlinenr] =~ s/\s+$//;
4625 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4626 # itself <asm/foo.h> (uses RAW line)
4627 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4629 my $checkfile = "include/linux/$file";
4630 if (-f "$root/$checkfile" &&
4631 $realfile ne $checkfile &&
4632 $1 !~ /$allowed_asm_includes/)
4634 my $asminclude = `grep -Ec
"#include\\s+<asm/$file>" $root/$checkfile`;
4635 if ($asminclude > 0) {
4636 if ($realfile =~ m{^arch/}) {
4637 CHK
("ARCH_INCLUDE_LINUX",
4638 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4640 WARN
("INCLUDE_LINUX",
4641 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4647 # multi-statement macros should be enclosed in a do while loop, grab the
4648 # first statement and ensure its the whole macro if its not enclosed
4649 # in a known good container
4650 if ($realfile !~ m
@/vmlinux.lds
.h
$@ &&
4651 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4654 my ($off, $dstat, $dcond, $rest);
4656 my $has_flow_statement = 0;
4657 my $has_arg_concat = 0;
4658 ($dstat, $dcond, $ln, $cnt, $off) =
4659 ctx_statement_block
($linenr, $realcnt, 0);
4661 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4662 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4664 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4665 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4667 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4669 $dstat =~ s/\\\n.//g;
4670 $dstat =~ s/^\s*//s;
4671 $dstat =~ s/\s*$//s;
4673 # Flatten any parentheses and braces
4674 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4675 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4676 $dstat =~ s/.\[[^\[\]]*\]/1/)
4680 # Flatten any obvious string concatentation.
4681 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4682 $dstat =~ s/$Ident\s*($String)/$1/)
4686 # Make asm volatile uses seem like a generic function
4687 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4689 my $exceptions = qr{
4702 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4704 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4705 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4706 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4707 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4708 $dstat !~ /$exceptions/ &&
4709 $dstat !~ /^\.$Ident\s*=/ && # .foo =
4710 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4711 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4712 $dstat !~ /^for\s*$Constant$/ && # for (...)
4713 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4714 $dstat !~ /^do\s*{/ && # do {...
4715 $dstat !~ /^\(\{/ && # ({...
4716 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4719 my $herectx = $here . "\n";
4720 my $cnt = statement_rawlines
($ctx);
4722 for (my $n = 0; $n < $cnt; $n++) {
4723 $herectx .= raw_line
($linenr, $n) . "\n";
4726 if ($dstat =~ /;/) {
4727 ERROR
("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4728 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4730 ERROR
("COMPLEX_MACRO",
4731 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4735 # check for macros with flow control, but without ## concatenation
4736 # ## concatenation is commonly a macro that defines a function so ignore those
4737 if ($has_flow_statement && !$has_arg_concat) {
4738 my $herectx = $here . "\n";
4739 my $cnt = statement_rawlines
($ctx);
4741 for (my $n = 0; $n < $cnt; $n++) {
4742 $herectx .= raw_line
($linenr, $n) . "\n";
4744 WARN
("MACRO_WITH_FLOW_CONTROL",
4745 "Macros with flow control statements should be avoided\n" . "$herectx");
4748 # check for line continuations outside of #defines, preprocessor #, and asm
4751 if ($prevline !~ /^..*\\$/ &&
4752 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4753 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
4754 $line =~ /^\+.*\\$/) {
4755 WARN
("LINE_CONTINUATIONS",
4756 "Avoid unnecessary line continuations\n" . $herecurr);
4760 # do {} while (0) macro tests:
4761 # single-statement macros do not need to be enclosed in do while (0) loop,
4762 # macro should not end with a semicolon
4763 if ($^V && $^V ge 5.10.0 &&
4764 $realfile !~ m
@/vmlinux.lds
.h
$@ &&
4765 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4768 my ($off, $dstat, $dcond, $rest);
4770 ($dstat, $dcond, $ln, $cnt, $off) =
4771 ctx_statement_block
($linenr, $realcnt, 0);
4774 $dstat =~ s/\\\n.//g;
4777 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4782 my $cnt = statement_rawlines
($ctx);
4783 my $herectx = $here . "\n";
4785 for (my $n = 0; $n < $cnt; $n++) {
4786 $herectx .= raw_line
($linenr, $n) . "\n";
4789 if (($stmts =~ tr/;/;/) == 1 &&
4790 $stmts !~ /^\s*(if|while|for|switch)\b/) {
4791 WARN
("SINGLE_STATEMENT_DO_WHILE_MACRO",
4792 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4794 if (defined $semis && $semis ne "") {
4795 WARN
("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4796 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4798 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4800 my $cnt = statement_rawlines
($ctx);
4801 my $herectx = $here . "\n";
4803 for (my $n = 0; $n < $cnt; $n++) {
4804 $herectx .= raw_line
($linenr, $n) . "\n";
4807 WARN
("TRAILING_SEMICOLON",
4808 "macros should not use a trailing semicolon\n" . "$herectx");
4812 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4813 # all assignments may have only one of the following with an assignment:
4816 # VMLINUX_SYMBOL(...)
4817 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4818 WARN
("MISSING_VMLINUX_SYMBOL",
4819 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4822 # check for redundant bracing round if etc
4823 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4824 my ($level, $endln, @chunks) =
4825 ctx_statement_full
($linenr, $realcnt, 1);
4826 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4827 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4828 if ($#chunks > 0 && $level == 0) {
4832 my $herectx = $here . "\n";
4833 my $ln = $linenr - 1;
4834 for my $chunk (@chunks) {
4835 my ($cond, $block) = @{$chunk};
4837 # If the condition carries leading newlines, then count those as offsets.
4838 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4839 my $offset = statement_rawlines
($whitespace) - 1;
4841 $allowed[$allow] = 0;
4842 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4844 # We have looked at and allowed this specific line.
4845 $suppress_ifbraces{$ln + $offset} = 1;
4847 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4848 $ln += statement_rawlines
($block) - 1;
4850 substr($block, 0, length($cond), '');
4852 $seen++ if ($block =~ /^\s*{/);
4854 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4855 if (statement_lines
($cond) > 1) {
4856 #print "APW: ALLOWED: cond<$cond>\n";
4857 $allowed[$allow] = 1;
4859 if ($block =~/\b(?:if|for|while)\b/) {
4860 #print "APW: ALLOWED: block<$block>\n";
4861 $allowed[$allow] = 1;
4863 if (statement_block_size
($block) > 1) {
4864 #print "APW: ALLOWED: lines block<$block>\n";
4865 $allowed[$allow] = 1;
4870 my $sum_allowed = 0;
4871 foreach (@allowed) {
4874 if ($sum_allowed == 0) {
4876 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4877 } elsif ($sum_allowed != $allow &&
4880 "braces {} should be used on all arms of this statement\n" . $herectx);
4885 if (!defined $suppress_ifbraces{$linenr - 1} &&
4886 $line =~ /\b(if|while|for|else)\b/) {
4889 # Check the pre-context.
4890 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4891 #print "APW: ALLOWED: pre<$1>\n";
4895 my ($level, $endln, @chunks) =
4896 ctx_statement_full
($linenr, $realcnt, $-[0]);
4898 # Check the condition.
4899 my ($cond, $block) = @{$chunks[0]};
4900 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4901 if (defined $cond) {
4902 substr($block, 0, length($cond), '');
4904 if (statement_lines
($cond) > 1) {
4905 #print "APW: ALLOWED: cond<$cond>\n";
4908 if ($block =~/\b(?:if|for|while)\b/) {
4909 #print "APW: ALLOWED: block<$block>\n";
4912 if (statement_block_size
($block) > 1) {
4913 #print "APW: ALLOWED: lines block<$block>\n";
4916 # Check the post-context.
4917 if (defined $chunks[1]) {
4918 my ($cond, $block) = @{$chunks[1]};
4919 if (defined $cond) {
4920 substr($block, 0, length($cond), '');
4922 if ($block =~ /^\s*\{/) {
4923 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4927 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4928 my $herectx = $here . "\n";
4929 my $cnt = statement_rawlines
($block);
4931 for (my $n = 0; $n < $cnt; $n++) {
4932 $herectx .= raw_line
($linenr, $n) . "\n";
4936 "braces {} are not necessary for single statement blocks\n" . $herectx);
4940 # check for unnecessary blank lines around braces
4941 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4943 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4944 $fix && $prevrawline =~ /^\+/) {
4945 fix_delete_line
($fixlinenr - 1, $prevrawline);
4948 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4950 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4952 fix_delete_line
($fixlinenr, $rawline);
4956 # no volatiles please
4957 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4958 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4960 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4963 # Check for user-visible strings broken across lines, which breaks the ability
4964 # to grep for the string. Make exceptions when the previous string ends in a
4965 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4966 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
4967 if ($line =~ /^\+\s*$String/ &&
4968 $prevline =~ /"\s*$/ &&
4969 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4970 if (WARN
("SPLIT_STRING",
4971 "quoted string split across lines\n" . $hereprev) &&
4973 $prevrawline =~ /^\+.*"\s*$/ &&
4974 $last_coalesced_string_linenr != $linenr - 1) {
4975 my $extracted_string = get_quoted_string
($line, $rawline);
4976 my $comma_close = "";
4977 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4981 fix_delete_line
($fixlinenr - 1, $prevrawline);
4982 fix_delete_line
($fixlinenr, $rawline);
4983 my $fixedline = $prevrawline;
4984 $fixedline =~ s/"\s*$//;
4985 $fixedline .= substr($extracted_string, 1) . trim
($comma_close);
4986 fix_insert_line
($fixlinenr - 1, $fixedline);
4987 $fixedline = $rawline;
4988 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4989 if ($fixedline !~ /\+\s*$/) {
4990 fix_insert_line
($fixlinenr, $fixedline);
4992 $last_coalesced_string_linenr = $linenr;
4996 # check for missing a space in a string concatenation
4997 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4998 WARN
('MISSING_SPACE',
4999 "break quoted strings at a space character\n" . $hereprev);
5002 # check for spaces before a quoted newline
5003 if ($rawline =~ /^.*\".*\s\\n/) {
5004 if (WARN
("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5005 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5007 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5012 # concatenated string without spaces between elements
5013 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5014 CHK
("CONCATENATED_STRING",
5015 "Concatenated strings should use spaces between elements\n" . $herecurr);
5018 # uncoalesced string fragments
5019 if ($line =~ /$String\s*"/) {
5020 WARN
("STRING_FRAGMENTS",
5021 "Consecutive strings are generally better as a single string\n" . $herecurr);
5024 # check for %L{u,d,i} and 0x%[udi] in strings
5026 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5027 $string = substr($rawline, $-[1], $+[1] - $-[1]);
5028 $string =~ s/%%/__/g;
5029 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
5031 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
5034 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
5035 ERROR
("PRINTF_0xDECIMAL",
5036 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5040 # check for line continuations in quoted strings with odd counts of "
5041 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5042 WARN
("LINE_CONTINUATIONS",
5043 "Avoid line continuations in quoted strings\n" . $herecurr);
5047 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5048 CHK
("REDUNDANT_CODE",
5049 "if this code is redundant consider removing it\n" .
5053 # check for needless "if (<foo>) fn(<foo>)" uses
5054 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5055 my $tested = quotemeta($1);
5056 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5057 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5059 if (WARN
('NEEDLESS_IF',
5060 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5063 my $leading_tabs = "";
5064 my $new_leading_tabs = "";
5065 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5070 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5071 $new_leading_tabs = $1;
5072 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5079 fix_delete_line
($fixlinenr - 1, $prevrawline);
5080 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5086 # check for unnecessary "Out of Memory" messages
5087 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5088 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5089 (defined $1 || defined $3) &&
5092 my $testline = $lines[$linenr - 3];
5094 my ($s, $c) = ctx_statement_block
($linenr - 3, $realcnt, 0);
5095 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5097 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
5099 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5103 # check for logging functions with KERN_<LEVEL>
5104 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5105 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5107 if (WARN
("UNNECESSARY_KERN_LEVEL",
5108 "Possible unnecessary $level\n" . $herecurr) &&
5110 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5114 # check for mask then right shift without a parentheses
5115 if ($^V && $^V ge 5.10.0 &&
5116 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5117 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5118 WARN
("MASK_THEN_SHIFT",
5119 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5122 # check for pointer comparisons to NULL
5123 if ($^V && $^V ge 5.10.0) {
5124 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5127 $equal = "" if ($4 eq "!=");
5128 if (CHK
("COMPARISON_TO_NULL",
5129 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5131 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5136 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5137 if ($line =~ /(\b$InitAttribute\b)/) {
5139 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5142 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5143 ERROR
("MISPLACED_INIT",
5144 "$attr should be placed after $var\n" . $herecurr)) ||
5145 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5146 WARN
("MISPLACED_INIT",
5147 "$attr should be placed after $var\n" . $herecurr))) &&
5149 $fixed[$fixlinenr] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
5154 # check for $InitAttributeData (ie: __initdata) with const
5155 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5157 $attr =~ /($InitAttributePrefix)(.*)/;
5158 my $attr_prefix = $1;
5160 if (ERROR
("INIT_ATTRIBUTE",
5161 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5163 $fixed[$fixlinenr] =~
5164 s/$InitAttributeData/${attr_prefix}initconst/;
5168 # check for $InitAttributeConst (ie: __initconst) without const
5169 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5171 if (ERROR
("INIT_ATTRIBUTE",
5172 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5174 my $lead = $fixed[$fixlinenr] =~
5175 /(^\+\s*(?:static\s+))/;
5177 $lead = "$lead " if ($lead !~ /^\+$/);
5178 $lead = "${lead}const ";
5179 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5183 # check for __read_mostly with const non-pointer (should just be const)
5184 if ($line =~ /\b__read_mostly\b/ &&
5185 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5186 if (ERROR
("CONST_READ_MOSTLY",
5187 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5189 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5193 # don't use __constant_<foo> functions outside of include/uapi/
5194 if ($realfile !~ m
@^include/uapi/@ &&
5195 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5196 my $constant_func = $1;
5197 my $func = $constant_func;
5198 $func =~ s/^__constant_//;
5199 if (WARN
("CONSTANT_CONVERSION",
5200 "$constant_func should be $func\n" . $herecurr) &&
5202 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5206 # prefer usleep_range over udelay
5207 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5209 # ignore udelay's < 10, however
5210 if (! ($delay < 10) ) {
5212 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5214 if ($delay > 2000) {
5216 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5220 # warn about unexpectedly long msleep's
5221 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5224 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5228 # check for comparisons of jiffies
5229 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5230 WARN
("JIFFIES_COMPARISON",
5231 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5234 # check for comparisons of get_jiffies_64()
5235 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5236 WARN
("JIFFIES_COMPARISON",
5237 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5240 # warn about #ifdefs in C files
5241 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5242 # print "#ifdef in C files should be avoided\n";
5243 # print "$herecurr";
5247 # warn about spacing in #ifdefs
5248 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5249 if (ERROR
("SPACING",
5250 "exactly one space required after that #$1\n" . $herecurr) &&
5252 $fixed[$fixlinenr] =~
5253 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5258 # check for spinlock_t definitions without a comment.
5259 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5260 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5262 if (!ctx_has_comment
($first_line, $linenr)) {
5263 CHK
("UNCOMMENTED_DEFINITION",
5264 "$1 definition without comment\n" . $herecurr);
5267 # check for memory barriers without a comment.
5273 read_barrier_depends
5275 my $barrier_stems = qr{
5283 my $all_barriers = qr{
5285 smp_
(?
:$barrier_stems)|
5286 virt_
(?
:$barrier_stems)
5289 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5290 if (!ctx_has_comment
($first_line, $linenr)) {
5291 WARN
("MEMORY_BARRIER",
5292 "memory barrier without comment\n" . $herecurr);
5296 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5298 if ($realfile !~ m
@^include/asm-generic
/@ &&
5299 $realfile !~ m
@/barrier\.h
$@ &&
5300 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5301 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5302 WARN
("MEMORY_BARRIER",
5303 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5306 # check for waitqueue_active without a comment.
5307 if ($line =~ /\bwaitqueue_active\s*\(/) {
5308 if (!ctx_has_comment
($first_line, $linenr)) {
5309 WARN
("WAITQUEUE_ACTIVE",
5310 "waitqueue_active without comment\n" . $herecurr);
5314 # Check for expedited grace periods that interrupt non-idle non-nohz
5315 # online CPUs. These expedited can therefore degrade real-time response
5316 # if used carelessly, and should be avoided where not absolutely
5317 # needed. It is always OK to use synchronize_rcu_expedited() and
5318 # synchronize_sched_expedited() at boot time (before real-time applications
5319 # start) and in error situations where real-time response is compromised in
5320 # any case. Note that synchronize_srcu_expedited() does -not- interrupt
5321 # other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5322 # Of course, nothing comes for free, and srcu_read_lock() and
5323 # srcu_read_unlock() do contain full memory barriers in payment for
5324 # synchronize_srcu_expedited() non-interruption properties.
5325 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5326 WARN
("EXPEDITED_RCU_GRACE_PERIOD",
5327 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5331 # check of hardware specific defines
5332 if ($line =~ m
@^.\s
*\#\s
*if.*\b(__i386__
|__powerpc64__
|__sun__
|__s390x__
)\b@ && $realfile !~ m
@include/asm-@) {
5334 "architecture specific defines should be avoided\n" . $herecurr);
5337 # Check that the storage class is at the beginning of a declaration
5338 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
5339 WARN
("STORAGE_CLASS",
5340 "storage class should be at the beginning of the declaration\n" . $herecurr)
5343 # check the location of the inline attribute, that it is between
5344 # storage class and type.
5345 if ($line =~ /\b$Type\s+$Inline\b/ ||
5346 $line =~ /\b$Inline\s+$Storage\b/) {
5347 ERROR
("INLINE_LOCATION",
5348 "inline keyword should sit between storage class and type\n" . $herecurr);
5351 # Check for __inline__ and __inline, prefer inline
5352 if ($realfile !~ m
@\binclude/uapi/@ &&
5353 $line =~ /\b(__inline__|__inline)\b/) {
5355 "plain inline is preferred over $1\n" . $herecurr) &&
5357 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5362 # Check for __attribute__ packed, prefer __packed
5363 if ($realfile !~ m
@\binclude/uapi/@ &&
5364 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5365 WARN
("PREFER_PACKED",
5366 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5369 # Check for __attribute__ aligned, prefer __aligned
5370 if ($realfile !~ m
@\binclude/uapi/@ &&
5371 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5372 WARN
("PREFER_ALIGNED",
5373 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5376 # Check for __attribute__ format(printf, prefer __printf
5377 if ($realfile !~ m
@\binclude/uapi/@ &&
5378 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5379 if (WARN
("PREFER_PRINTF",
5380 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5382 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5387 # Check for __attribute__ format(scanf, prefer __scanf
5388 if ($realfile !~ m
@\binclude/uapi/@ &&
5389 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5390 if (WARN
("PREFER_SCANF",
5391 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5393 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5397 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5398 if ($^V && $^V ge 5.10.0 &&
5399 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5400 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5401 $line =~ /\b__weak\b/)) {
5402 ERROR
("WEAK_DECLARATION",
5403 "Using weak declarations can have unintended link defects\n" . $herecurr);
5406 # check for c99 types like uint8_t used outside of uapi/
5407 if ($realfile !~ m
@\binclude/uapi/@ &&
5408 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5410 if ($type =~ /\b($typeC99Typedefs)\b/) {
5412 my $kernel_type = 'u';
5413 $kernel_type = 's' if ($type =~ /^_*[si]/);
5416 if (CHK
("PREFER_KERNEL_TYPES",
5417 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5419 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5424 # check for cast of C90 native int or longer types constants
5425 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5428 if (WARN
("TYPECAST_INT_CONSTANT",
5429 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5432 my $newconst = $const;
5433 $newconst =~ s/${Int_type}$//;
5434 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5435 if ($cast =~ /\blong\s+long\b/) {
5437 } elsif ($cast =~ /\blong\b/) {
5440 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5444 # check for sizeof(&)
5445 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5446 WARN
("SIZEOF_ADDRESS",
5447 "sizeof(& should be avoided\n" . $herecurr);
5450 # check for sizeof without parenthesis
5451 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5452 if (WARN
("SIZEOF_PARENTHESIS",
5453 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5455 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5459 # check for struct spinlock declarations
5460 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5461 WARN
("USE_SPINLOCK_T",
5462 "struct spinlock should be spinlock_t\n" . $herecurr);
5465 # check for seq_printf uses that could be seq_puts
5466 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5467 my $fmt = get_quoted_string
($line, $rawline);
5470 if (WARN
("PREFER_SEQ_PUTS",
5471 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5473 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5478 # Check for misused memsets
5479 if ($^V && $^V ge 5.10.0 &&
5481 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5487 if ($ms_size =~ /^(0x|)0$/i) {
5489 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5490 } elsif ($ms_size =~ /^(0x|)1$/i) {
5492 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5496 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5497 if ($^V && $^V ge 5.10.0 &&
5499 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5500 if (WARN
("PREFER_ETHER_ADDR_COPY",
5501 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5503 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5507 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5508 if ($^V && $^V ge 5.10.0 &&
5510 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5511 WARN
("PREFER_ETHER_ADDR_EQUAL",
5512 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5515 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5516 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5517 if ($^V && $^V ge 5.10.0 &&
5519 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5523 if ($ms_val =~ /^(?:0x|)0+$/i) {
5524 if (WARN
("PREFER_ETH_ZERO_ADDR",
5525 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5527 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5529 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5530 if (WARN
("PREFER_ETH_BROADCAST_ADDR",
5531 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5533 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5538 # typecasts on min/max could be min_t/max_t
5539 if ($^V && $^V ge 5.10.0 &&
5541 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5542 if (defined $2 || defined $7) {
5544 my $cast1 = deparenthesize
($2);
5546 my $cast2 = deparenthesize
($7);
5550 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5551 $cast = "$cast1 or $cast2";
5552 } elsif ($cast1 ne "") {
5558 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5562 # check usleep_range arguments
5563 if ($^V && $^V ge 5.10.0 &&
5565 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5569 WARN
("USLEEP_RANGE",
5570 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5571 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5573 WARN
("USLEEP_RANGE",
5574 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5578 # check for naked sscanf
5579 if ($^V && $^V ge 5.10.0 &&
5581 $line =~ /\bsscanf\b/ &&
5582 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5583 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5584 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5585 my $lc = $stat =~ tr
@\n@@;
5586 $lc = $lc + $linenr;
5587 my $stat_real = raw_line
($linenr, 0);
5588 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5589 $stat_real = $stat_real . "\n" . raw_line
($count, 0);
5591 WARN
("NAKED_SSCANF",
5592 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5595 # check for simple sscanf that should be kstrto<foo>
5596 if ($^V && $^V ge 5.10.0 &&
5598 $line =~ /\bsscanf\b/) {
5599 my $lc = $stat =~ tr
@\n@@;
5600 $lc = $lc + $linenr;
5601 my $stat_real = raw_line
($linenr, 0);
5602 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5603 $stat_real = $stat_real . "\n" . raw_line
($count, 0);
5605 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5607 my $count = $format =~ tr
@%@%@;
5609 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5610 WARN
("SSCANF_TO_KSTRTO",
5611 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5616 # check for new externs in .h files.
5617 if ($realfile =~ /\.h$/ &&
5618 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5619 if (CHK
("AVOID_EXTERNS",
5620 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5622 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5626 # check for new externs in .c files.
5627 if ($realfile =~ /\.c$/ && defined $stat &&
5628 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5630 my $function_name = $1;
5631 my $paren_space = $2;
5634 if (defined $cond) {
5635 substr($s, 0, length($cond), '');
5637 if ($s =~ /^\s*;/ &&
5638 $function_name ne 'uninitialized_var')
5640 WARN
("AVOID_EXTERNS",
5641 "externs should be avoided in .c files\n" . $herecurr);
5644 if ($paren_space =~ /\n/) {
5645 WARN
("FUNCTION_ARGUMENTS",
5646 "arguments for function declarations should follow identifier\n" . $herecurr);
5649 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5650 $stat =~ /^.\s*extern\s+/)
5652 WARN
("AVOID_EXTERNS",
5653 "externs should be avoided in .c files\n" . $herecurr);
5656 # checks for new __setup's
5657 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5660 if (!grep(/$name/, @setup_docs)) {
5661 CHK
("UNDOCUMENTED_SETUP",
5662 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
5666 # check for pointless casting of kmalloc return
5667 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5668 WARN
("UNNECESSARY_CASTS",
5669 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5673 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5674 if ($^V && $^V ge 5.10.0 &&
5675 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5676 CHK
("ALLOC_SIZEOF_STRUCT",
5677 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5680 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5681 if ($^V && $^V ge 5.10.0 &&
5682 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5686 my $newfunc = "kmalloc_array";
5687 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5690 if ($a1 =~ /^sizeof\s*\S/) {
5694 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5695 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5696 if (WARN
("ALLOC_WITH_MULTIPLY",
5697 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5699 $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
5705 # check for krealloc arg reuse
5706 if ($^V && $^V ge 5.10.0 &&
5707 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5708 WARN
("KREALLOC_ARG_REUSE",
5709 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5712 # check for alloc argument mismatch
5713 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5714 WARN
("ALLOC_ARRAY_ARGS",
5715 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5718 # check for multiple semicolons
5719 if ($line =~ /;\s*;\s*$/) {
5720 if (WARN
("ONE_SEMICOLON",
5721 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5723 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5727 # check for #defines like: 1 << <digit> that could be BIT(digit)
5728 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5730 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5731 if (CHK
("BIT_MACRO",
5732 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5734 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5738 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
5739 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
5741 if (WARN
("PREFER_IS_ENABLED",
5742 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
5744 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
5748 # check for case / default statements not preceded by break/fallthrough/switch
5749 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5751 my $has_statement = 0;
5753 my $prevline = $linenr;
5754 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5756 my $rline = $rawlines[$prevline - 1];
5757 my $fline = $lines[$prevline - 1];
5758 last if ($fline =~ /^\@\@/);
5759 next if ($fline =~ /^\-/);
5760 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5761 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5762 next if ($fline =~ /^.[\s$;]*$/);
5765 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5767 if (!$has_break && $has_statement) {
5768 WARN
("MISSING_BREAK",
5769 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5773 # check for switch/default statements without a break;
5774 if ($^V && $^V ge 5.10.0 &&
5776 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5778 my $herectx = $here . "\n";
5779 my $cnt = statement_rawlines
($stat);
5780 for (my $n = 0; $n < $cnt; $n++) {
5781 $herectx .= raw_line
($linenr, $n) . "\n";
5783 WARN
("DEFAULT_NO_BREAK",
5784 "switch default: should use break\n" . $herectx);
5787 # check for gcc specific __FUNCTION__
5788 if ($line =~ /\b__FUNCTION__\b/) {
5789 if (WARN
("USE_FUNC",
5790 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5792 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5796 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
5797 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5799 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5802 # check for use of yield()
5803 if ($line =~ /\byield\s*\(\s*\)/) {
5805 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5808 # check for comparisons against true and false
5809 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5817 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5819 my $type = lc($otype);
5820 if ($type =~ /^(?:true|false)$/) {
5821 if (("$test" eq "==" && "$type" eq "true") ||
5822 ("$test" eq "!=" && "$type" eq "false")) {
5826 CHK
("BOOL_COMPARISON",
5827 "Using comparison to $otype is error prone\n" . $herecurr);
5829 ## maybe suggesting a correct construct would better
5830 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5835 # check for semaphores initialized locked
5836 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
5837 WARN
("CONSIDER_COMPLETION",
5838 "consider using a completion\n" . $herecurr);
5841 # recommend kstrto* over simple_strto* and strict_strto*
5842 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5843 WARN
("CONSIDER_KSTRTO",
5844 "$1 is obsolete, use k$3 instead\n" . $herecurr);
5847 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
5848 if ($line =~ /^.\s*__initcall\s*\(/) {
5849 WARN
("USE_DEVICE_INITCALL",
5850 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5853 # check for various structs that are normally const (ops, kgdb, device_tree)
5854 my $const_structs = qr{
5856 address_space_operations
|
5858 block_device_operations
|
5863 file_lock_operations
|
5873 lock_manager_operations
|
5880 pipe_buf_operations
|
5881 platform_hibernation_ops
|
5882 platform_suspend_ops
|
5887 soc_pcmcia_socket_ops
|
5894 if ($line !~ /\bconst\b/ &&
5895 $line =~ /\bstruct\s+($const_structs)\b/) {
5896 WARN
("CONST_STRUCT",
5897 "struct $1 should normally be const\n" .
5901 # use of NR_CPUS is usually wrong
5902 # ignore definitions of NR_CPUS and usage to define arrays as likely right
5903 if ($line =~ /\bNR_CPUS\b/ &&
5904 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5905 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
5906 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5907 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5908 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
5911 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
5914 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5915 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5916 ERROR
("DEFINE_ARCH_HAS",
5917 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5920 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
5921 if ($^V && $^V ge 5.10.0 &&
5922 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5923 WARN
("LIKELY_MISUSE",
5924 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5927 # whine mightly about in_atomic
5928 if ($line =~ /\bin_atomic\s*\(/) {
5929 if ($realfile =~ m
@^drivers/@) {
5931 "do not use in_atomic in drivers\n" . $herecurr);
5932 } elsif ($realfile !~ m
@^kernel/@) {
5934 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5938 # whine about ACCESS_ONCE
5939 if ($^V && $^V ge 5.10.0 &&
5940 $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
5944 $par =~ s/^\(\s*(.*)\s*\)$/$1/;
5946 if (WARN
("PREFER_WRITE_ONCE",
5947 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
5949 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
5952 if (WARN
("PREFER_READ_ONCE",
5953 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
5955 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
5960 # check for lockdep_set_novalidate_class
5961 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5962 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5963 if ($realfile !~ m
@^kernel/lockdep@ &&
5964 $realfile !~ m
@^include/linux/lockdep@ &&
5965 $realfile !~ m
@^drivers/base/core@) {
5967 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5971 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5972 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
5973 WARN
("EXPORTED_WORLD_WRITABLE",
5974 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5977 # Mode permission misuses where it seems decimal should be octal
5978 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5979 if ($^V && $^V ge 5.10.0 &&
5980 $line =~ /$mode_perms_search/) {
5981 foreach my $entry (@mode_permission_funcs) {
5982 my $func = $entry->[0];
5983 my $arg_pos = $entry->[1];
5988 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5990 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5991 if ($line =~ /$test/) {
5993 $val = $6 if ($skip_args ne "");
5995 if ($val !~ /^0$/ &&
5996 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5997 length($val) ne 4)) {
5998 ERROR
("NON_OCTAL_PERMISSIONS",
5999 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
6000 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6001 ERROR
("EXPORTED_WORLD_WRITABLE",
6002 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6008 # validate content of MODULE_LICENSE against list from include/linux/module.h
6009 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6010 my $extracted_string = get_quoted_string
($line, $rawline);
6011 my $valid_licenses = qr{
6014 GPL\
and\ additional\ rights
|
6020 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6021 WARN
("MODULE_LICENSE",
6022 "unknown module license " . $extracted_string . "\n" . $herecurr);
6027 # If we have no input at all, then there is nothing to report on
6028 # so just keep quiet.
6029 if ($#rawlines == -1) {
6033 # In mailback mode only produce a report in the negative, for
6034 # things that appear to be patches.
6035 if ($mailback && ($clean == 1 || !$is_patch)) {
6039 # This is not a patch, and we are are in 'no-patch' mode so
6041 if (!$chk_patch && !$is_patch) {
6045 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
6046 ERROR
("NOT_UNIFIED_DIFF",
6047 "Does not appear to be a unified-diff format patch\n");
6049 if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
6050 ERROR
("MISSING_SIGN_OFF",
6051 "Missing Signed-off-by: line(s)\n");
6054 print report_dump
();
6055 if ($summary && !($clean == 1 && $quiet == 1)) {
6056 print "$filename " if ($summary_file);
6057 print "total: $cnt_error errors, $cnt_warn warnings, " .
6058 (($check)?
"$cnt_chk checks, " : "") .
6059 "$cnt_lines lines checked\n";
6063 # If there were any defects found and not already fixing them
6064 if (!$clean and !$fix) {
6067 NOTE
: For some of the reported defects
, checkpatch may be able to
6068 mechanically convert to the typical style using
--fix
or --fix-inplace
.
6071 # If there were whitespace errors which cleanpatch can fix
6072 # then suggest that.
6073 if ($rpt_cleaners) {
6077 NOTE
: Whitespace errors detected
.
6078 You may wish to
use scripts
/cleanpatch or scripts/cleanfile
6083 if ($clean == 0 && $fix &&
6084 ("@rawlines" ne "@fixed" ||
6085 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6086 my $newfile = $filename;
6087 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6091 @fixed = fix_inserted_deleted_lines
(\
@fixed, \
@fixed_inserted, \
@fixed_deleted);
6093 open($f, '>', $newfile)
6094 or die "$P: Can't open $newfile for write\n";
6095 foreach my $fixed_line (@fixed) {
6098 if ($linecount > 3) {
6099 $fixed_line =~ s/^\+//;
6100 print $f $fixed_line . "\n";
6103 print $f $fixed_line . "\n";
6111 Wrote EXPERIMENTAL
--fix correction
(s
) to
'$newfile'
6113 Do _NOT_ trust the results written to this file
.
6114 Do _NOT_ submit these changes without inspecting them
for correctness
.
6116 This EXPERIMENTAL file
is simply a convenience to help rewrite patches
.
6117 No warranties
, expressed
or implied
...
6125 print "$vname has no obvious style problems and is ready for submission.\n";
6127 print "$vname has style problems, please review.\n";