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};
323 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
324 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
325 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
326 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
327 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
329 # Notes to $Attribute:
330 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
351 ____cacheline_aligned
|
352 ____cacheline_aligned_in_smp
|
353 ____cacheline_internodealigned_in_smp
|
357 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
358 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
359 our $Lval = qr{$Ident(?:$Member)*};
361 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
362 our $Binary = qr{(?i)0b[01]+$Int_type?};
363 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
364 our $Int = qr{[0-9]+$Int_type?};
365 our $Octal = qr{0[0-7]+$Int_type?};
366 our $String = qr{"[X\t]*"};
367 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
368 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
369 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
370 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
371 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
372 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
373 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
374 our $Arithmetic = qr{\+|-|\*|\/|%};
378 &&|\
|\
||,|\
^|\
+\
+|--|&|\
||$Arithmetic
381 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
385 our $NonptrTypeMisordered;
386 our $NonptrTypeWithAttr;
390 our $DeclareMisordered;
392 our $NON_ASCII_UTF8 = qr{
393 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
394 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
395 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
396 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
397 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
398 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
399 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
403 [\x09\x0A\x0D\x20-\x7E] # ASCII
407 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
408 our $typeOtherOSTypedefs = qr{(?x
:
409 u_
(?
:char
|short
|int|long
) | # bsd
410 u
(?
:nchar
|short
|int|long
) # sysv
412 our $typeKernelTypedefs = qr{(?x
:
413 (?
:__
)?
(?
:u
|s
|be
|le)(?
:8|16|32|64)|
416 our $typeTypedefs = qr{(?x
:
418 $typeOtherOSTypedefs\b|
419 $typeKernelTypedefs\b
422 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
424 our $logFunctions = qr{(?x
:
425 printk
(?
:_ratelimited
|_once
|)|
426 (?
:[a-z0-9
]+_
){1,2}(?
:printk
|emerg
|alert
|crit
|err
|warning
|warn|notice
|info
|debug
|dbg
|vdbg
|devel
|cont
|WARN
)(?
:_ratelimited
|_once
|)|
427 WARN
(?
:_RATELIMIT
|_ONCE
|)|
430 seq_vprintf
|seq_printf
|seq_puts
433 our $signature_tags = qr{(?xi
:
444 our @typeListMisordered = (
445 qr{char\s+(?:un)?signed},
446 qr{int\s+(?:(?:un)?signed\s+)?short\s},
447 qr{int\s+short(?:\s+(?:un)?signed)},
448 qr{short\s+int(?:\s+(?:un)?signed)},
449 qr{(?:un)?signed\s+int\s+short},
450 qr{short\s+(?:un)?signed},
451 qr{long\s+int\s+(?:un)?signed},
452 qr{int\s+long\s+(?:un)?signed},
453 qr{long\s+(?:un)?signed\s+int},
454 qr{int\s+(?:un)?signed\s+long},
455 qr{int\s+(?:un)?signed},
456 qr{int\s+long\s+long\s+(?:un)?signed},
457 qr{long\s+long\s+int\s+(?:un)?signed},
458 qr{long\s+long\s+(?:un)?signed\s+int},
459 qr{long\s+long\s+(?:un)?signed},
460 qr{long\s+(?:un)?signed},
465 qr{(?:(?:un)?signed\s+)?char},
466 qr{(?:(?:un)?signed\s+)?short\s+int},
467 qr{(?:(?:un)?signed\s+)?short},
468 qr{(?:(?:un)?signed\s+)?int},
469 qr{(?:(?:un)?signed\s+)?long\s+int},
470 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
471 qr{(?:(?:un)?signed\s+)?long\s+long},
472 qr{(?:(?:un)?signed\s+)?long},
481 qr{${Ident}_handler
},
482 qr{${Ident}_handler_fn
},
486 our $C90_int_types = qr{(?x
:
487 long\s
+long\s
+int\s
+(?
:un
)?signed
|
488 long\s
+long\s
+(?
:un
)?signed\s
+int|
489 long\s
+long\s
+(?
:un
)?signed
|
490 (?
:(?
:un
)?signed\s
+)?long\s
+long\s
+int|
491 (?
:(?
:un
)?signed\s
+)?long\s
+long
|
492 int\s
+long\s
+long\s
+(?
:un
)?signed
|
493 int\s
+(?
:(?
:un
)?signed\s
+)?long\s
+long
|
495 long\s
+int\s
+(?
:un
)?signed
|
496 long\s
+(?
:un
)?signed\s
+int|
497 long\s
+(?
:un
)?signed
|
498 (?
:(?
:un
)?signed\s
+)?long\s
+int|
499 (?
:(?
:un
)?signed\s
+)?long
|
500 int\s
+long\s
+(?
:un
)?signed
|
501 int\s
+(?
:(?
:un
)?signed\s
+)?long
|
504 (?
:(?
:un
)?signed\s
+)?
int
507 our @typeListFile = ();
508 our @typeListWithAttr = (
510 qr{struct\s+$InitAttribute\s+$Ident},
511 qr{union\s+$InitAttribute\s+$Ident},
514 our @modifierList = (
517 our @modifierListFile = ();
519 our @mode_permission_funcs = (
521 ["module_param_(?:array|named|string)", 4],
522 ["module_param_array_named", 5],
523 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
524 ["proc_create(?:_data|)", 2],
525 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
528 #Create a search pattern for all these functions to speed up a loop below
529 our $mode_perms_search = "";
530 foreach my $entry (@mode_permission_funcs) {
531 $mode_perms_search .= '|' if ($mode_perms_search ne "");
532 $mode_perms_search .= $entry->[0];
535 our $mode_perms_world_writable = qr{
543 our $allowed_asm_includes = qr{(?x
:
549 # memory.h: ARM has a custom one
551 # Load common spelling mistakes and build regular expression list.
555 if (open(my $spelling, '<', $spelling_file)) {
556 while (<$spelling>) {
559 $line =~ s/\s*\n?$//g;
562 next if ($line =~ m/^\s*#/);
563 next if ($line =~ m/^\s*$/);
565 my ($suspect, $fix) = split(/\|\|/, $line);
567 $spelling_fix{$suspect} = $fix;
571 warn "No typos will be found - file '$spelling_file': $!\n";
575 if (open(my $spelling, '<', $codespellfile)) {
576 while (<$spelling>) {
579 $line =~ s/\s*\n?$//g;
582 next if ($line =~ m/^\s*#/);
583 next if ($line =~ m/^\s*$/);
584 next if ($line =~ m/, disabled/i);
588 my ($suspect, $fix) = split(/->/, $line);
590 $spelling_fix{$suspect} = $fix;
594 warn "No codespell typos will be found - file '$codespellfile': $!\n";
598 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
601 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
602 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
603 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
604 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
605 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
611 (?
:$Modifier\s+|const\s
+)*
613 (?
:typeof
|__typeof__
)\s
*\
([^\
)]*\
)|
617 (?
:\s
+$Modifier|\s
+const
)*
619 $NonptrTypeMisordered = qr{
620 (?
:$Modifier\s+|const\s
+)*
624 (?
:\s
+$Modifier|\s
+const
)*
626 $NonptrTypeWithAttr = qr{
627 (?
:$Modifier\s+|const\s
+)*
629 (?
:typeof
|__typeof__
)\s
*\
([^\
)]*\
)|
633 (?
:\s
+$Modifier|\s
+const
)*
637 (?
:(?
:\s
|\
*|\
[\
])+\s
*const
|(?
:\s
|\
*\s
*(?
:const\s
*)?
|\
[\
])+|(?
:\s
*\
[\s
*\
])+)?
638 (?
:\s
+$Inline|\s
+$Modifier)*
640 $TypeMisordered = qr{
641 $NonptrTypeMisordered
642 (?
:(?
:\s
|\
*|\
[\
])+\s
*const
|(?
:\s
|\
*\s
*(?
:const\s
*)?
|\
[\
])+|(?
:\s
*\
[\s
*\
])+)?
643 (?
:\s
+$Inline|\s
+$Modifier)*
645 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
646 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
650 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s
*};
652 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
653 # requires at least perl version v5.10.0
654 # Any use must be runtime checked with $^V
656 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
657 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s
*};
658 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
660 our $declaration_macros = qr{(?x
:
661 (?
:$Storage\s+)?
(?
:[A-Z_
][A-Z0-9
]*_
){0,2}(?
:DEFINE
|DECLARE
)(?
:_
[A-Z0-9
]+){1,6}\s
*\
(|
662 (?
:$Storage\s+)?LIST_HEAD\s
*\
(|
663 (?
:$Storage\s+)?
${Type
}\s
+uninitialized_var\s
*\
(
668 return "" if (!defined($string));
670 while ($string =~ /^\s*\(.*\)\s*$/) {
671 $string =~ s
@^\s*\(\s
*@@;
672 $string =~ s
@\s*\)\s
*$@@;
675 $string =~ s
@\s+@ @g;
680 sub seed_camelcase_file
{
683 return if (!(-f
$file));
687 open(my $include_file, '<', "$file")
688 or warn "$P: Can't read '$file' $!\n";
689 my $text = <$include_file>;
690 close($include_file);
692 my @lines = split('\n', $text);
694 foreach my $line (@lines) {
695 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
696 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
698 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
700 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
706 my $camelcase_seeded = 0;
707 sub seed_camelcase_includes
{
708 return if ($camelcase_seeded);
711 my $camelcase_cache = "";
712 my @include_files = ();
714 $camelcase_seeded = 1;
717 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
718 chomp $git_last_include_commit;
719 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
721 my $last_mod_date = 0;
722 $files = `find $root/include -name "*.h"`;
723 @include_files = split('\n', $files);
724 foreach my $file (@include_files) {
725 my $date = POSIX
::strftime
("%Y%m%d%H%M",
726 localtime((stat $file)[9]));
727 $last_mod_date = $date if ($last_mod_date < $date);
729 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
732 if ($camelcase_cache ne "" && -f
$camelcase_cache) {
733 open(my $camelcase_file, '<', "$camelcase_cache")
734 or warn "$P: Can't read '$camelcase_cache' $!\n";
735 while (<$camelcase_file>) {
739 close($camelcase_file);
745 $files = `git ls-files "include/*.h"`;
746 @include_files = split('\n', $files);
749 foreach my $file (@include_files) {
750 seed_camelcase_file
($file);
753 if ($camelcase_cache ne "") {
754 unlink glob ".checkpatch-camelcase.*";
755 open(my $camelcase_file, '>', "$camelcase_cache")
756 or warn "$P: Can't write '$camelcase_cache' $!\n";
757 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
758 print $camelcase_file ("$_\n");
760 close($camelcase_file);
764 sub git_commit_info
{
765 my ($commit, $id, $desc) = @_;
767 return ($id, $desc) if ((which
("git") eq "") || !(-e
".git"));
769 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
770 $output =~ s/^\s*//gm;
771 my @lines = split("\n", $output);
773 return ($id, $desc) if ($#lines < 0);
775 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
776 # Maybe one day convert this block of bash into something that returns
777 # all matching commit ids, but it's very slow...
779 # echo "checking commits $1..."
780 # git rev-list --remotes | grep -i "^$1" |
781 # while read line ; do
782 # git log --format='%H %s' -1 $line |
783 # echo "commit $(cut -c 1-12,41-)"
785 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
787 $id = substr($lines[0], 0, 12);
788 $desc = substr($lines[0], 41);
794 $chk_signoff = 0 if ($file);
799 my @fixed_inserted = ();
800 my @fixed_deleted = ();
803 # If input is git commits, extract all commits from the commit expressions.
804 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
805 die "$P: No git repository found\n" if ($git && !-e
".git");
809 foreach my $commit_expr (@ARGV) {
811 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
812 $git_range = "-$2 $1";
813 } elsif ($commit_expr =~ m/\.\./) {
814 $git_range = "$commit_expr";
816 $git_range = "-1 $commit_expr";
818 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
819 foreach my $line (split(/\n/, $lines)) {
820 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
821 next if (!defined($1) || !defined($2));
824 unshift(@commits, $sha1);
825 $git_commits{$sha1} = $subject;
828 die "$P: no git commits after extraction!\n" if (@commits == 0);
833 for my $filename (@ARGV) {
836 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
837 die "$P: $filename: git format-patch failed - $!\n";
839 open($FILE, '-|', "diff -u /dev/null $filename") ||
840 die "$P: $filename: diff failed - $!\n";
841 } elsif ($filename eq '-') {
842 open($FILE, '<&STDIN');
844 open($FILE, '<', "$filename") ||
845 die "$P: $filename: open failed - $!\n";
847 if ($filename eq '-') {
848 $vname = 'Your patch';
850 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
860 if ($#ARGV > 0 && $quiet == 0) {
861 print '-' x length($vname) . "\n";
863 print '-' x length($vname) . "\n";
866 if (!process($filename)) {
872 @fixed_inserted = ();
875 @modifierListFile = ();
881 hash_show_words(\%use_type, "Used");
882 hash_show_words(\%ignore_type, "Ignored");
887 NOTE: perl $^V is not modern enough to detect all possible issues.
888 An upgrade to at least perl v5.10.0 is suggested.
894 NOTE: If any of the errors are false positives, please report
895 them to the maintainer, see CHECKPATCH in MAINTAINERS.
902 sub top_of_kernel_tree {
906 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
907 "README", "Documentation", "arch", "include", "drivers",
908 "fs", "init", "ipc", "kernel", "lib", "scripts",
911 foreach my $check (@tree_check) {
912 if (! -e $root . '/' . $check) {
920 my ($formatted_email) = @_;
926 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
929 $comment = $3 if defined $3;
930 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
932 $comment = $2 if defined $2;
933 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
935 $comment = $2 if defined $2;
936 $formatted_email =~ s/$address.*$//;
937 $name = $formatted_email;
939 $name =~ s/^\"|\"$//g;
940 # If there's a name left after stripping spaces and
941 # leading quotes, and the address doesn't have both
942 # leading and trailing angle brackets, the address
944 # "joe smith joe@smith.com" bad
945 # "joe smith <joe@smith.com" bad
946 if ($name ne "" && $address !~ /^<[^>]+>$/) {
954 $name =~ s/^\"|\"$//g;
955 $address = trim($address);
956 $address =~ s/^\<|\>$//g;
958 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
959 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
963 return ($name, $address, $comment);
967 my ($name, $address) = @_;
972 $name =~ s/^\"|\"$//g;
973 $address = trim($address);
975 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
976 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
981 $formatted_email = "$address";
983 $formatted_email = "$name <$address>";
986 return $formatted_email;
992 foreach my $path (split(/:/, $ENV{PATH})) {
993 if (-e "$path/$bin") {
1004 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1005 if (-e "$path/$conf") {
1006 return "$path/$conf";
1018 for my $c (split(//, $str)) {
1022 for (; ($n % 8) != 0; $n++) {
1034 (my $res = shift) =~ tr/\t/ /c;
1041 # Drop the diff line leader and expand tabs
1043 $line = expand_tabs($line);
1045 # Pick the indent from the front of the line.
1046 my ($white) = ($line =~ /^(\s*)/);
1048 return (length($line), length($white));
1051 my $sanitise_quote = '';
1053 sub sanitise_line_reset {
1054 my ($in_comment) = @_;
1057 $sanitise_quote = '*/';
1059 $sanitise_quote = '';
1072 # Always copy over the diff marker.
1073 $res = substr($line, 0, 1);
1075 for ($off = 1; $off < length($line); $off++) {
1076 $c = substr($line, $off, 1);
1078 # Comments we are wacking completly including the begin
1079 # and end, all to $;.
1080 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1081 $sanitise_quote = '*/';
1083 substr($res, $off, 2, "$;$;");
1087 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1088 $sanitise_quote = '';
1089 substr($res, $off, 2, "$;$;");
1093 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1094 $sanitise_quote = '//';
1096 substr($res, $off, 2, $sanitise_quote);
1101 # A \ in a string means ignore the next character.
1102 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1104 substr($res, $off, 2, 'XX');
1109 if ($c eq "'" || $c eq '"') {
1110 if ($sanitise_quote eq '') {
1111 $sanitise_quote = $c;
1113 substr($res, $off, 1, $c);
1115 } elsif ($sanitise_quote eq $c) {
1116 $sanitise_quote = '';
1120 #print "c<$c> SQ<$sanitise_quote>\n";
1121 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1122 substr($res, $off, 1, $;);
1123 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1124 substr($res, $off, 1, $;);
1125 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1126 substr($res, $off, 1, 'X');
1128 substr($res, $off, 1, $c);
1132 if ($sanitise_quote eq '//') {
1133 $sanitise_quote = '';
1136 # The pathname on a #include may be surrounded by '<' and '>'.
1137 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1138 my $clean = 'X' x length($1);
1139 $res =~ s@\<.*\>@<$clean>@;
1141 # The whole of a #error is a string.
1142 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1143 my $clean = 'X' x length($1);
1144 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1150 sub get_quoted_string {
1151 my ($line, $rawline) = @_;
1153 return "" if ($line !~ m/($String)/g);
1154 return substr($rawline, $-[0], $+[0] - $-[0]);
1157 sub ctx_statement_block {
1158 my ($linenr, $remain, $off) = @_;
1159 my $line = $linenr - 1;
1162 my $coff = $off - 1;
1176 @stack = (['', 0]) if ($#stack == -1);
1178 #warn "CSB: blk<$blk> remain<$remain>\n";
1179 # If we are about to drop off the end, pull in more
1182 for (; $remain > 0; $line++) {
1183 last if (!defined $lines[$line]);
1184 next if ($lines[$line] =~ /^-/);
1187 $blk .= $lines[$line] . "\n";
1188 $len = length($blk);
1192 # Bail if there is no further context.
1193 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1197 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1203 $c = substr($blk, $off, 1);
1204 $remainder = substr($blk, $off);
1206 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1208 # Handle nested #if/#else.
1209 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1210 push(@stack, [ $type, $level ]);
1211 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1212 ($type, $level) = @{$stack[$#stack - 1]};
1213 } elsif ($remainder =~ /^#\s*endif\b/) {
1214 ($type, $level) = @{pop(@stack)};
1217 # Statement ends at the ';' or a close '}' at the
1219 if ($level == 0 && $c eq ';') {
1223 # An else is really a conditional as long as its not else if
1224 if ($level == 0 && $coff_set == 0 &&
1225 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1226 $remainder =~ /^(else)(?:\s|{)/ &&
1227 $remainder !~ /^else\s+if\b/) {
1228 $coff = $off + length($1) - 1;
1230 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1231 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1234 if (($type eq '' || $type eq '(') && $c eq '(') {
1238 if ($type eq '(' && $c eq ')') {
1240 $type = ($level != 0)? '(' : '';
1242 if ($level == 0 && $coff < $soff) {
1245 #warn "CSB: mark coff<$coff>\n";
1248 if (($type eq '' || $type eq '{') && $c eq '{') {
1252 if ($type eq '{' && $c eq '}') {
1254 $type = ($level != 0)? '{' : '';
1257 if (substr($blk, $off + 1, 1) eq ';') {
1263 # Preprocessor commands end at the newline unless escaped.
1264 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1272 # We are truly at the end, so shuffle to the next line.
1279 my $statement = substr($blk, $soff, $off - $soff + 1);
1280 my $condition = substr($blk, $soff, $coff - $soff + 1);
1282 #warn "STATEMENT<$statement>\n";
1283 #warn "CONDITION<$condition>\n";
1285 #print "coff<$coff> soff<$off> loff<$loff>\n";
1287 return ($statement, $condition,
1288 $line, $remain + 1, $off - $loff + 1, $level);
1291 sub statement_lines {
1294 # Strip the diff line prefixes and rip blank lines at start and end.
1295 $stmt =~ s/(^|\n)./$1/g;
1299 my @stmt_lines = ($stmt =~ /\n/g);
1301 return $#stmt_lines + 2;
1304 sub statement_rawlines {
1307 my @stmt_lines = ($stmt =~ /\n/g);
1309 return $#stmt_lines + 2;
1312 sub statement_block_size {
1315 $stmt =~ s/(^|\n)./$1/g;
1321 my @stmt_lines = ($stmt =~ /\n/g);
1322 my @stmt_statements = ($stmt =~ /;/g);
1324 my $stmt_lines = $#stmt_lines + 2;
1325 my $stmt_statements = $#stmt_statements + 1;
1327 if ($stmt_lines > $stmt_statements) {
1330 return $stmt_statements;
1334 sub ctx_statement_full {
1335 my ($linenr, $remain, $off) = @_;
1336 my ($statement, $condition, $level);
1340 # Grab the first conditional/block pair.
1341 ($statement, $condition, $linenr, $remain, $off, $level) =
1342 ctx_statement_block($linenr, $remain, $off);
1343 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1344 push(@chunks, [ $condition, $statement ]);
1345 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1346 return ($level, $linenr, @chunks);
1349 # Pull in the following conditional/block pairs and see if they
1350 # could continue the statement.
1352 ($statement, $condition, $linenr, $remain, $off, $level) =
1353 ctx_statement_block($linenr, $remain, $off);
1354 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1355 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1357 push(@chunks, [ $condition, $statement ]);
1360 return ($level, $linenr, @chunks);
1364 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1366 my $start = $linenr - 1;
1373 my @stack = ($level);
1374 for ($line = $start; $remain > 0; $line++) {
1375 next if ($rawlines[$line] =~ /^-/);
1378 $blk .= $rawlines[$line];
1380 # Handle nested #if/#else.
1381 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1382 push(@stack, $level);
1383 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1384 $level = $stack[$#stack - 1];
1385 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1386 $level = pop(@stack);
1389 foreach my $c (split(//, $lines[$line])) {
1390 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1396 if ($c eq $close && $level > 0) {
1398 last if ($level == 0);
1399 } elsif ($c eq $open) {
1404 if (!$outer || $level <= 1) {
1405 push(@res, $rawlines[$line]);
1408 last if ($level == 0);
1411 return ($level, @res);
1413 sub ctx_block_outer {
1414 my ($linenr, $remain) = @_;
1416 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1420 my ($linenr, $remain) = @_;
1422 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1426 my ($linenr, $remain, $off) = @_;
1428 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1431 sub ctx_block_level {
1432 my ($linenr, $remain) = @_;
1434 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1436 sub ctx_statement_level {
1437 my ($linenr, $remain, $off) = @_;
1439 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1442 sub ctx_locate_comment {
1443 my ($first_line, $end_line) = @_;
1445 # Catch a comment on the end of the line itself.
1446 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1447 return $current_comment if (defined $current_comment);
1449 # Look through the context and try and figure out if there is a
1452 $current_comment = '';
1453 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1454 my $line = $rawlines[$linenr - 1];
1456 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1459 if ($line =~ m@/\*@) {
1462 if (!$in_comment && $current_comment ne '') {
1463 $current_comment = '';
1465 $current_comment .= $line . "\n" if ($in_comment);
1466 if ($line =~ m@\*/@) {
1471 chomp($current_comment);
1472 return($current_comment);
1474 sub ctx_has_comment {
1475 my ($first_line, $end_line) = @_;
1476 my $cmt = ctx_locate_comment($first_line, $end_line);
1478 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1479 ##print "CMMT: $cmt\n";
1481 return ($cmt ne '');
1485 my ($linenr, $cnt) = @_;
1487 my $offset = $linenr - 1;
1492 $line = $rawlines[$offset++];
1493 next if (defined($line) && $line =~ /^-/);
1505 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1508 $coded = sprintf("^%c", unpack('C', $2) + 64);
1517 my $av_preprocessor = 0;
1522 sub annotate_reset {
1523 $av_preprocessor = 0;
1525 @av_paren_type = ('E');
1526 $av_pend_colon = 'O';
1529 sub annotate_values {
1530 my ($stream, $type) = @_;
1533 my $var = '_' x length($stream);
1536 print "$stream\n" if ($dbg_values > 1);
1538 while (length($cur)) {
1539 @av_paren_type = ('E') if ($#av_paren_type < 0);
1540 print " <" . join('', @av_paren_type) .
1541 "> <$type> <$av_pending>" if ($dbg_values > 1);
1542 if ($cur =~ /^(\s+)/o) {
1543 print "WS($1)\n" if ($dbg_values > 1);
1544 if ($1 =~ /\n/ && $av_preprocessor) {
1545 $type = pop(@av_paren_type);
1546 $av_preprocessor = 0;
1549 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1550 print "CAST($1)\n" if ($dbg_values > 1);
1551 push(@av_paren_type, $type);
1554 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1555 print "DECLARE($1)\n" if ($dbg_values > 1);
1558 } elsif ($cur =~ /^($Modifier)\s*/) {
1559 print "MODIFIER($1)\n" if ($dbg_values > 1);
1562 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1563 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1564 $av_preprocessor = 1;
1565 push(@av_paren_type, $type);
1571 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1572 print "UNDEF($1)\n" if ($dbg_values > 1);
1573 $av_preprocessor = 1;
1574 push(@av_paren_type, $type);
1576 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1577 print "PRE_START($1)\n" if ($dbg_values > 1);
1578 $av_preprocessor = 1;
1580 push(@av_paren_type, $type);
1581 push(@av_paren_type, $type);
1584 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1585 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1586 $av_preprocessor = 1;
1588 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1592 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1593 print "PRE_END($1)\n" if ($dbg_values > 1);
1595 $av_preprocessor = 1;
1597 # Assume all arms of the conditional end as this
1598 # one does, and continue as if the #endif was not here.
1599 pop(@av_paren_type);
1600 push(@av_paren_type, $type);
1603 } elsif ($cur =~ /^(\\\n)/o) {
1604 print "PRECONT($1)\n" if ($dbg_values > 1);
1606 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1607 print "ATTR($1)\n" if ($dbg_values > 1);
1608 $av_pending = $type;
1611 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1612 print "SIZEOF($1)\n" if ($dbg_values > 1);
1618 } elsif ($cur =~ /^(if|while|for)\b/o) {
1619 print "COND($1)\n" if ($dbg_values > 1);
1623 } elsif ($cur =~/^(case)/o) {
1624 print "CASE($1)\n" if ($dbg_values > 1);
1625 $av_pend_colon = 'C';
1628 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1629 print "KEYWORD($1)\n" if ($dbg_values > 1);
1632 } elsif ($cur =~ /^(\()/o) {
1633 print "PAREN('$1')\n" if ($dbg_values > 1);
1634 push(@av_paren_type, $av_pending);
1638 } elsif ($cur =~ /^(\))/o) {
1639 my $new_type = pop(@av_paren_type);
1640 if ($new_type ne '_') {
1642 print "PAREN('$1') -> $type\n"
1643 if ($dbg_values > 1);
1645 print "PAREN('$1')\n" if ($dbg_values > 1);
1648 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1649 print "FUNC($1)\n" if ($dbg_values > 1);
1653 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1654 if (defined $2 && $type eq 'C' || $type eq 'T') {
1655 $av_pend_colon = 'B';
1656 } elsif ($type eq 'E') {
1657 $av_pend_colon = 'L';
1659 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1662 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1663 print "IDENT($1)\n" if ($dbg_values > 1);
1666 } elsif ($cur =~ /^($Assignment)/o) {
1667 print "ASSIGN($1)\n" if ($dbg_values > 1);
1670 } elsif ($cur =~/^(;|{|})/) {
1671 print "END($1)\n" if ($dbg_values > 1);
1673 $av_pend_colon = 'O';
1675 } elsif ($cur =~/^(,)/) {
1676 print "COMMA($1)\n" if ($dbg_values > 1);
1679 } elsif ($cur =~ /^(\?)/o) {
1680 print "QUESTION($1)\n" if ($dbg_values > 1);
1683 } elsif ($cur =~ /^(:)/o) {
1684 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1686 substr($var, length($res), 1, $av_pend_colon);
1687 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1692 $av_pend_colon = 'O';
1694 } elsif ($cur =~ /^(\[)/o) {
1695 print "CLOSE($1)\n" if ($dbg_values > 1);
1698 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1701 print "OPV($1)\n" if ($dbg_values > 1);
1708 substr($var, length($res), 1, $variant);
1711 } elsif ($cur =~ /^($Operators)/o) {
1712 print "OP($1)\n" if ($dbg_values > 1);
1713 if ($1 ne '++' && $1 ne '--') {
1717 } elsif ($cur =~ /(^.)/o) {
1718 print "C($1)\n" if ($dbg_values > 1);
1721 $cur = substr($cur, length($1));
1722 $res .= $type x length($1);
1726 return ($res, $var);
1730 my ($possible, $line) = @_;
1731 my $notPermitted = qr{(?:
1748 ^(?:typedef|struct|enum)\b
1750 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1751 if ($possible !~ $notPermitted) {
1752 # Check for modifiers.
1753 $possible =~ s/\s*$Storage\s*//g;
1754 $possible =~ s/\s*$Sparse\s*//g;
1755 if ($possible =~ /^\s*$/) {
1757 } elsif ($possible =~ /\s/) {
1758 $possible =~ s/\s*$Type\s*//g;
1759 for my $modifier (split(' ', $possible)) {
1760 if ($modifier !~ $notPermitted) {
1761 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1762 push(@modifierListFile, $modifier);
1767 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1768 push(@typeListFile, $possible);
1772 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1781 return defined $use_type{$type} if (scalar keys %use_type > 0);
1783 return !defined $ignore_type{$type};
1787 my ($level, $type, $msg) = @_;
1789 if (!show_type($type) ||
1790 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1794 if (-t STDOUT && $color) {
1795 if ($level eq 'ERROR') {
1797 } elsif ($level eq 'WARNING') {
1803 $output .= $prefix . $level . ':';
1805 $output .= BLUE if (-t STDOUT && $color);
1806 $output .= "$type:";
1808 $output .= RESET if (-t STDOUT && $color);
1809 $output .= ' ' . $msg . "\n";
1812 my @lines = split("\n", $output, -1);
1813 splice(@lines, 1, 1);
1814 $output = join("\n", @lines);
1816 $output = (split('\n', $output))[0] . "\n" if ($terse);
1818 push(our @report, $output);
1827 sub fixup_current_range {
1828 my ($lineRef, $offset, $length) = @_;
1830 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1833 my $no = $o + $offset;
1834 my $nl = $l + $length;
1835 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1839 sub fix_inserted_deleted_lines {
1840 my ($linesRef, $insertedRef, $deletedRef) = @_;
1842 my $range_last_linenr = 0;
1843 my $delta_offset = 0;
1848 my $next_insert = 0;
1849 my $next_delete = 0;
1853 my $inserted = @{$insertedRef}[$next_insert++];
1854 my $deleted = @{$deletedRef}[$next_delete++];
1856 foreach my $old_line (@{$linesRef}) {
1858 my $line = $old_line; #don't modify the array
1859 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
1861 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1862 $range_last_linenr = $new_linenr;
1863 fixup_current_range(\$line, $delta_offset, 0);
1866 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1867 $deleted = @{$deletedRef}[$next_delete++];
1869 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1872 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1873 push(@lines, ${$inserted}{'LINE'});
1874 $inserted = @{$insertedRef}[$next_insert++];
1876 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1880 push(@lines, $line);
1890 sub fix_insert_line {
1891 my ($linenr, $line) = @_;
1897 push(@fixed_inserted, $inserted);
1900 sub fix_delete_line {
1901 my ($linenr, $line) = @_;
1908 push(@fixed_deleted, $deleted);
1912 my ($type, $msg) = @_;
1914 if (report("ERROR", $type, $msg)) {
1922 my ($type, $msg) = @_;
1924 if (report("WARNING", $type, $msg)) {
1932 my ($type, $msg) = @_;
1934 if ($check && report("CHECK", $type, $msg)) {
1942 sub check_absolute_file {
1943 my ($absolute, $herecurr) = @_;
1944 my $file = $absolute;
1946 ##print "absolute<$absolute>\n";
1948 # See if any suffix of this path is a path within the tree.
1949 while ($file =~ s@^[^/]*/@@) {
1950 if (-f "$root/$file") {
1951 ##print "file<$file>\n";
1959 # It is, so see if the prefix is acceptable.
1960 my $prefix = $absolute;
1961 substr($prefix, -length($file)) = '';
1963 ##print "prefix<$prefix>\n";
1964 if ($prefix ne ".../") {
1965 WARN("USE_RELATIVE_PATH",
1966 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1973 $string =~ s/^\s+|\s+$//g;
1981 $string =~ s/^\s+//;
1989 $string =~ s/\s+$//;
1994 sub string_find_replace {
1995 my ($string, $find, $replace) = @_;
1997 $string =~ s/$find/$replace/g;
2005 my $source_indent = 8;
2006 my $max_spaces_before_tab = $source_indent - 1;
2007 my $spaces_to_tab = " " x $source_indent;
2009 #convert leading spaces to tabs
2010 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2011 #Remove spaces before a tab
2012 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2017 sub pos_last_openparen {
2022 my $opens = $line =~ tr/\(/\(/;
2023 my $closes = $line =~ tr/\)/\)/;
2025 my $last_openparen = 0;
2027 if (($opens == 0) || ($closes >= $opens)) {
2031 my $len = length($line);
2033 for ($pos = 0; $pos < $len; $pos++) {
2034 my $string = substr($line, $pos);
2035 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2036 $pos += length($1) - 1;
2037 } elsif (substr($line, $pos, 1) eq '(') {
2038 $last_openparen = $pos;
2039 } elsif (index($string, '(') == -1) {
2044 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2048 my $filename = shift;
2054 my $stashrawline="";
2064 my $in_header_lines = $file ? 0 : 1;
2065 my $in_commit_log = 0; #Scanning lines before patch
2066 my $commit_log_possible_stack_dump = 0;
2067 my $commit_log_long_line = 0;
2068 my $commit_log_has_diff = 0;
2069 my $reported_maintainer_file = 0;
2070 my $non_utf8_charset = 0;
2072 my $last_blank_line = 0;
2073 my $last_coalesced_string_linenr = -1;
2081 # Trace the real file/line as we go.
2087 my $comment_edge = 0;
2091 my $prev_values = 'E';
2094 my %suppress_ifbraces;
2095 my %suppress_whiletrailers;
2096 my %suppress_export;
2097 my $suppress_statement = 0;
2099 my %signatures = ();
2101 # Pre-scan the patch sanitizing the lines.
2102 # Pre-scan the patch looking for any __setup documentation.
2104 my @setup_docs = ();
2107 my $camelcase_file_seeded = 0;
2109 sanitise_line_reset();
2111 foreach my $rawline (@rawlines) {
2115 push(@fixed, $rawline) if ($fix);
2117 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2119 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2124 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2133 # Guestimate if this is a continuing comment. Run
2134 # the context looking for a comment "edge". If this
2135 # edge is a close comment then we must be in a comment
2139 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2140 next if (defined $rawlines[$ln - 1] &&
2141 $rawlines[$ln - 1] =~ /^-/);
2143 #print "RAW<$rawlines[$ln - 1]>\n";
2144 last if (!defined $rawlines[$ln - 1]);
2145 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2146 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2151 if (defined $edge && $edge eq '*/') {
2155 # Guestimate if this is a continuing comment. If this
2156 # is the start of a diff block and this line starts
2157 # ' *' then it is very likely a comment.
2158 if (!defined $edge &&
2159 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2164 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2165 sanitise_line_reset($in_comment);
2167 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2168 # Standardise the strings and chars within the input to
2169 # simplify matching -- only bother with positive lines.
2170 $line = sanitise_line($rawline);
2172 push(@lines, $line);
2175 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2180 #print "==>$rawline\n";
2181 #print "-->$line\n";
2183 if ($setup_docs && $line =~ /^\+/) {
2184 push(@setup_docs, $line);
2193 foreach my $line (@lines) {
2196 my $sline = $line; #copy of $line
2197 $sline =~ s/$;/ /g; #with comments as spaces
2199 my $rawline = $rawlines[$linenr - 1];
2201 #extract the line range in the file after the patch is applied
2202 if (!$in_commit_log &&
2203 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2205 $first_line = $linenr + 1;
2215 %suppress_ifbraces = ();
2216 %suppress_whiletrailers = ();
2217 %suppress_export = ();
2218 $suppress_statement = 0;
2221 # track the line number as we move through the hunk, note that
2222 # new versions of GNU diff omit the leading space on completely
2223 # blank context lines so we need to count that too.
2224 } elsif ($line =~ /^( |\+|$)/) {
2226 $realcnt-- if ($realcnt != 0);
2228 # Measure the line length and indent.
2229 ($length, $indent) = line_stats($rawline);
2231 # Track the previous line.
2232 ($prevline, $stashline) = ($stashline, $line);
2233 ($previndent, $stashindent) = ($stashindent, $indent);
2234 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2236 #warn "line<$line>\n";
2238 } elsif ($realcnt == 1) {
2242 my $hunk_line = ($realcnt != 0);
2244 $here = "#$linenr: " if (!$file);
2245 $here = "#$realline: " if ($file);
2248 # extract the filename as it passes
2249 if ($line =~ /^diff --git.*?(\S+)$/) {
2251 $realfile =~ s@^([^/]*)/@@ if (!$file);
2254 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2256 $realfile =~ s@^([^/]*)/@@ if (!$file);
2260 if (!$file && $tree && $p1_prefix ne '' &&
2261 -e "$root/$p1_prefix") {
2262 WARN("PATCH_PREFIX",
2263 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2266 if ($realfile =~ m@^include/asm/@) {
2267 ERROR("MODIFIED_INCLUDE_ASM",
2268 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2273 #make up the handle for any error we report on this line
2275 $prefix = "$realfile:$realline: "
2278 $prefix = "$filename:$realline: ";
2280 $prefix = "$filename:$linenr: ";
2285 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2288 $check = $check_orig;
2293 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2295 my $hereline = "$here\n$rawline\n";
2296 my $herecurr = "$here\n$rawline\n";
2297 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2299 $cnt_lines++ if ($realcnt != 0);
2301 # Check if the commit log has what seems like a diff which can confuse patch
2302 if ($in_commit_log && !$commit_log_has_diff &&
2303 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2304 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2305 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2306 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2307 ERROR("DIFF_IN_COMMIT_MSG",
2308 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2309 $commit_log_has_diff = 1;
2312 # Check for incorrect file permissions
2313 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2314 my $permhere = $here . "FILE: $realfile\n";
2315 if ($realfile !~ m@scripts/@ &&
2316 $realfile !~ /\.(py|pl|awk|sh)$/) {
2317 ERROR("EXECUTE_PERMISSIONS",
2318 "do not set execute permissions for source files\n" . $permhere);
2322 # Check the patch for a signoff:
2323 if ($line =~ /^\s*signed-off-by:/i) {
2328 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2329 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2330 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2331 $reported_maintainer_file = 1;
2334 # Check signature styles
2335 if (!$in_header_lines &&
2336 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2337 my $space_before = $1;
2339 my $space_after = $3;
2341 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2343 if ($sign_off !~ /$signature_tags/) {
2344 WARN("BAD_SIGN_OFF",
2345 "Non-standard signature: $sign_off\n" . $herecurr);
2347 if (defined $space_before && $space_before ne "") {
2348 if (WARN("BAD_SIGN_OFF",
2349 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2351 $fixed[$fixlinenr] =
2352 "$ucfirst_sign_off $email";
2355 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2356 if (WARN("BAD_SIGN_OFF",
2357 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2359 $fixed[$fixlinenr] =
2360 "$ucfirst_sign_off $email";
2364 if (!defined $space_after || $space_after ne " ") {
2365 if (WARN("BAD_SIGN_OFF",
2366 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2368 $fixed[$fixlinenr] =
2369 "$ucfirst_sign_off $email";
2373 my ($email_name, $email_address, $comment) = parse_email($email);
2374 my $suggested_email = format_email(($email_name, $email_address));
2375 if ($suggested_email eq "") {
2376 ERROR("BAD_SIGN_OFF",
2377 "Unrecognized email address: '$email'\n" . $herecurr);
2379 my $dequoted = $suggested_email;
2380 $dequoted =~ s/^"//;
2381 $dequoted =~ s/" </ </;
2382 # Don't force email to have quotes
2383 # Allow just an angle bracketed address
2384 if ("$dequoted$comment" ne $email &&
2385 "<$email_address>$comment" ne $email &&
2386 "$suggested_email$comment" ne $email) {
2387 WARN("BAD_SIGN_OFF",
2388 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2392 # Check for duplicate signatures
2393 my $sig_nospace = $line;
2394 $sig_nospace =~ s/\s//g;
2395 $sig_nospace = lc($sig_nospace);
2396 if (defined $signatures{$sig_nospace}) {
2397 WARN("BAD_SIGN_OFF",
2398 "Duplicate signature\n" . $herecurr);
2400 $signatures{$sig_nospace} = 1;
2404 # Check email subject for common tools that don't need to be mentioned
2405 if ($in_header_lines &&
2406 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2407 WARN("EMAIL_SUBJECT",
2408 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2411 # Check for old stable address
2412 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2413 ERROR("STABLE_ADDRESS",
2414 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2417 # Check for unwanted Gerrit info
2418 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2419 ERROR("GERRIT_CHANGE_ID",
2420 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2423 # Check if the commit log is in a possible stack dump
2424 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2425 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2426 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2428 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2429 # stack dump address
2430 $commit_log_possible_stack_dump = 1;
2433 # Check for line lengths > 75 in commit log, warn once
2434 if ($in_commit_log && !$commit_log_long_line &&
2435 length($line) > 75 &&
2436 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2437 # file delta changes
2438 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2440 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2441 # A Fixes: or Link: line
2442 $commit_log_possible_stack_dump)) {
2443 WARN("COMMIT_LOG_LONG_LINE",
2444 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2445 $commit_log_long_line = 1;
2448 # Reset possible stack dump if a blank line is found
2449 if ($in_commit_log && $commit_log_possible_stack_dump &&
2451 $commit_log_possible_stack_dump = 0;
2454 # Check for git id commit length and improperly formed commit descriptions
2455 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2456 $line !~ /^\s*(?:Link|Patchwork|http|BugLink):/i &&
2457 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2458 ($line =~ /\b[0-9a-f]{12,40}\b/i &&
2459 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2460 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2461 my $init_char = "c";
2462 my $orig_commit = "";
2469 my $id = '0123456789ab';
2470 my $orig_desc = "commit description";
2471 my $description = "";
2473 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2475 $orig_commit = lc($2);
2476 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2477 $orig_commit = lc($1);
2480 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2481 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2482 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2483 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2484 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2487 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2488 defined $rawlines[$linenr] &&
2489 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2492 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2493 defined $rawlines[$linenr] &&
2494 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2495 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2497 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2498 $orig_desc .= " " . $1;
2502 ($id, $description) = git_commit_info($orig_commit,
2505 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
2506 ERROR("GIT_COMMIT_ID",
2507 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2511 # Check for added, moved or deleted files
2512 if (!$reported_maintainer_file && !$in_commit_log &&
2513 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2514 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2515 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2516 (defined($1) || defined($2))))) {
2517 $reported_maintainer_file = 1;
2518 WARN("FILE_PATH_CHANGES",
2519 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2522 # Check for wrappage within a valid hunk of the file
2523 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2524 ERROR("CORRUPTED_PATCH",
2525 "patch seems to be corrupt (line wrapped?)\n" .
2526 $herecurr) if (!$emitted_corrupt++);
2529 # Check for absolute kernel paths.
2531 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2534 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2535 check_absolute_file($1, $herecurr)) {
2538 check_absolute_file($file, $herecurr);
2543 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2544 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2545 $rawline !~ m/^$UTF8*$/) {
2546 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2548 my $blank = copy_spacing($rawline);
2549 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2550 my $hereptr = "$hereline$ptr\n";
2553 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2556 # Check if it's the start of a commit log
2557 # (not a header line and we haven't seen the patch filename)
2558 if ($in_header_lines && $realfile =~ /^$/ &&
2559 !($rawline =~ /^\s+\S/ ||
2560 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2561 $in_header_lines = 0;
2565 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2566 # declined it, i.e defined some charset where it is missing.
2567 if ($in_header_lines &&
2568 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2570 $non_utf8_charset = 1;
2573 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2574 $rawline =~ /$NON_ASCII_UTF8/) {
2575 WARN("UTF8_BEFORE_PATCH",
2576 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2579 # Check for various typo / spelling mistakes
2580 if (defined($misspellings) &&
2581 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2582 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2584 my $typo_fix = $spelling_fix{lc($typo)};
2585 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2586 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2587 my $msg_type = \&WARN;
2588 $msg_type = \&CHK if ($file);
2589 if (&{$msg_type}("TYPO_SPELLING",
2590 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2592 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2597 # ignore non-hunk lines and lines being removed
2598 next if (!$hunk_line || $line =~ /^-/);
2600 #trailing whitespace
2601 if ($line =~ /^\+.*\015/) {
2602 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2603 if (ERROR("DOS_LINE_ENDINGS",
2604 "DOS line endings\n" . $herevet) &&
2606 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2608 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2609 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2610 if (ERROR("TRAILING_WHITESPACE",
2611 "trailing whitespace\n" . $herevet) &&
2613 $fixed[$fixlinenr] =~ s/\s+$//;
2619 # Check for FSF mailing addresses.
2620 if ($rawline =~ /\bwrite to the Free/i ||
2621 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2622 $rawline =~ /\b51\s+Franklin\s+St/i) {
2623 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2624 my $msg_type = \&ERROR;
2625 $msg_type = \&CHK if ($file);
2626 &{$msg_type}("FSF_MAILING_ADDRESS",
2627 "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)
2630 # check for Kconfig help text having a real description
2631 # Only applies when adding the entry originally, after that we do not have
2632 # sufficient context to determine whether it is indeed long enough.
2633 if ($realfile =~ /Kconfig/ &&
2634 $line =~ /^\+\s*config\s+/) {
2637 my $ln = $linenr + 1;
2641 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2642 $f = $lines[$ln - 1];
2643 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2644 $is_end = $lines[$ln - 1] =~ /^\+/;
2646 next if ($f =~ /^-/);
2647 last if (!$file && $f =~ /^\@\@/);
2649 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2651 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2658 next if ($f =~ /^$/);
2659 if ($f =~ /^\s*config\s/) {
2665 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2666 WARN("CONFIG_DESCRIPTION",
2667 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2669 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2672 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2673 if ($realfile =~ /Kconfig/ &&
2674 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2675 WARN("CONFIG_EXPERIMENTAL",
2676 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2679 # discourage the use of boolean for type definition attributes of Kconfig options
2680 if ($realfile =~ /Kconfig/ &&
2681 $line =~ /^\+\s*\bboolean\b/) {
2682 WARN("CONFIG_TYPE_BOOLEAN",
2683 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2686 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2687 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2690 'EXTRA_AFLAGS' => 'asflags-y',
2691 'EXTRA_CFLAGS' => 'ccflags-y',
2692 'EXTRA_CPPFLAGS' => 'cppflags-y',
2693 'EXTRA_LDFLAGS' => 'ldflags-y',
2696 WARN("DEPRECATED_VARIABLE",
2697 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead
.\n" . $herecurr) if ($replacement->{$flag});
2700 # check for DT compatible documentation
2701 if (defined $root &&
2702 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2703 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2705 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2707 my $dt_path = $root . "/Documentation/devicetree
/bindings/";
2708 my $vp_file = $dt_path . "vendor-prefixes
.txt
";
2710 foreach my $compat (@compats) {
2711 my $compat2 = $compat;
2712 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2713 my $compat3 = $compat;
2714 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2715 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2717 WARN("UNDOCUMENTED_DT_STRING
",
2718 "DT compatible string
\"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2721 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2723 `grep -Eq "^$vendor\\b" $vp_file`;
2725 WARN("UNDOCUMENTED_DT_STRING",
2726 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2731 # check we are in a valid source file if not then ignore this hunk
2732 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
2734 # line length limit (with some exclusions)
2736 # There are a few types of lines that may extend beyond $max_line_length:
2737 # logging functions like pr_info that end in a string
2738 # lines with a single string
2739 # #defines that are a single string
2741 # There are 3 different line length message types:
2742 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2743 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2744 # LONG_LINE all other lines longer than $max_line_length
2746 # if LONG_LINE is ignored, the other 2 types are also ignored
2749 if ($line =~ /^\+/ && $length > $max_line_length) {
2750 my $msg_type = "LONG_LINE";
2752 # Check the allowed long line types first
2754 # logging functions that end in a string that starts
2755 # before $max_line_length
2756 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2757 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2760 # lines with only strings (w/ possible termination)
2761 # #defines with only strings
2762 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2763 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2766 # EFI_GUID is another special case
2767 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/) {
2770 # Otherwise set the alternate message types
2772 # a comment starts before $max_line_length
2773 } elsif ($line =~ /($;[\s$;]*)$/ &&
2774 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2775 $msg_type = "LONG_LINE_COMMENT"
2777 # a quoted string starts before $max_line_length
2778 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2779 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2780 $msg_type = "LONG_LINE_STRING"
2783 if ($msg_type ne "" &&
2784 (show_type("LONG_LINE") || show_type($msg_type))) {
2786 "line over $max_line_length characters\n" . $herecurr);
2790 # check for adding lines without a newline.
2791 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2792 WARN("MISSING_EOF_NEWLINE",
2793 "adding a line without newline at end of file\n" . $herecurr);
2796 # Blackfin: use hi/lo macros
2797 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2798 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2799 my $herevet = "$here\n" . cat_vet($line) . "\n";
2801 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2803 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2804 my $herevet = "$here\n" . cat_vet($line) . "\n";
2806 "use the HI() macro, not (... >> 16)\n" . $herevet);
2810 # check we are in a valid source file C or perl if not then ignore this hunk
2811 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2813 # at the beginning of a line any tabs must come first and anything
2814 # more than 8 must use tabs.
2815 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2816 $rawline =~ /^\+\s* \s*/) {
2817 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2819 if (ERROR("CODE_INDENT",
2820 "code indent should use tabs where possible\n" . $herevet) &&
2822 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2826 # check for space before tabs.
2827 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2828 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2829 if (WARN("SPACE_BEFORE_TAB",
2830 "please, no space before tabs\n" . $herevet) &&
2832 while ($fixed[$fixlinenr] =~
2833 s/(^\+.*) {8,8}\t/$1\t\t/) {}
2834 while ($fixed[$fixlinenr] =~
2835 s/(^\+.*) +\t/$1\t/) {}
2839 # check for && or || at the start of a line
2840 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2841 CHK("LOGICAL_CONTINUATIONS",
2842 "Logical continuations should be on the previous line\n" . $hereprev);
2845 # check indentation starts on a tab stop
2846 if ($^V && $^V ge 5.10.0 &&
2847 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2848 my $indent = length($1);
2851 "Statements should start on a tabstop\n" . $herecurr) &&
2853 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2858 # check multi-line statement indentation matches previous line
2859 if ($^V && $^V ge 5.10.0 &&
2860 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2861 $prevline =~ /^\+(\t*)(.*)$/;
2865 my $pos = pos_last_openparen($rest);
2867 $line =~ /^(\+| )([ \t]*)/;
2870 my $goodtabindent = $oldindent .
2873 my $goodspaceindent = $oldindent . " " x $pos;
2875 if ($newindent ne $goodtabindent &&
2876 $newindent ne $goodspaceindent) {
2878 if (CHK("PARENTHESIS_ALIGNMENT",
2879 "Alignment should match open parenthesis\n" . $hereprev) &&
2880 $fix && $line =~ /^\+/) {
2881 $fixed[$fixlinenr] =~
2882 s/^\+[ \t]*/\+$goodtabindent/;
2888 # check for space after cast like "(int) foo" or "(struct foo) bar"
2889 # avoid checking a few false positives:
2890 # "sizeof(<type>)" or "__alignof__(<type>)"
2891 # function pointer declarations like "(*foo)(int) = bar;"
2892 # structure definitions like "(struct foo) { 0 };"
2893 # multiline macros that define functions
2894 # known attributes or the __attribute__ keyword
2895 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2896 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2898 "No space is necessary after a cast\n" . $herecurr) &&
2900 $fixed[$fixlinenr] =~
2901 s/(\(\s*$Type\s*\))[ \t]+/$1/;
2905 # Block comment styles
2906 # Networking with an initial /*
2907 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2908 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2909 $rawline =~ /^\+[ \t]*\*/ &&
2911 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2912 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2915 # Block comments use * on subsequent lines
2916 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
2917 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
2918 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
2919 $rawline =~ /^\+/ && #line is new
2920 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2921 WARN("BLOCK_COMMENT_STYLE",
2922 "Block comments use * on subsequent lines\n" . $hereprev);
2925 # Block comments use */ on trailing lines
2926 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2927 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2928 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2929 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
2930 WARN("BLOCK_COMMENT_STYLE",
2931 "Block comments use a trailing */ on a separate line\n" . $herecurr);
2934 # check for missing blank lines after struct/union declarations
2935 # with exceptions for various attributes and macros
2936 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2938 !($line =~ /^\+\s*$/ ||
2939 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2940 $line =~ /^\+\s*MODULE_/i ||
2941 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2942 $line =~ /^\+[a-z_]*init/ ||
2943 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2944 $line =~ /^\+\s*DECLARE/ ||
2945 $line =~ /^\+\s*__setup/)) {
2946 if (CHK("LINE_SPACING",
2947 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2949 fix_insert_line($fixlinenr, "\+");
2953 # check for multiple consecutive blank lines
2954 if ($prevline =~ /^[\+ ]\s*$/ &&
2955 $line =~ /^\+\s*$/ &&
2956 $last_blank_line != ($linenr - 1)) {
2957 if (CHK("LINE_SPACING",
2958 "Please don't use multiple blank lines\n" . $hereprev) &&
2960 fix_delete_line($fixlinenr, $rawline);
2963 $last_blank_line = $linenr;
2966 # check for missing blank lines after declarations
2967 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2968 # actual declarations
2969 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2970 # function pointer declarations
2971 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2972 # foo bar; where foo is some local typedef or #define
2973 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2974 # known declaration macros
2975 $prevline =~ /^\+\s+$declaration_macros/) &&
2976 # for "else if" which can look like "$Ident $Ident"
2977 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2978 # other possible extensions of declaration lines
2979 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2980 # not starting a section or a macro "\" extended line
2981 $prevline =~ /(?:\{\s*|\\)$/) &&
2982 # looks like a declaration
2983 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2984 # function pointer declarations
2985 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2986 # foo bar; where foo is some local typedef or #define
2987 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2988 # known declaration macros
2989 $sline =~ /^\+\s+$declaration_macros/ ||
2990 # start of struct or union or enum
2991 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2992 # start or end of block or continuation of declaration
2993 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2994 # bitfield continuation
2995 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2996 # other possible extensions of declaration lines
2997 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2998 # indentation of previous and current line are the same
2999 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3000 if (WARN("LINE_SPACING",
3001 "Missing a blank line after declarations\n" . $hereprev) &&
3003 fix_insert_line($fixlinenr, "\+");
3007 # check for spaces at the beginning of a line.
3009 # 1) within comments
3010 # 2) indented preprocessor commands
3012 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3013 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3014 if (WARN("LEADING_SPACE",
3015 "please, no spaces at the start of a line\n" . $herevet) &&
3017 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3021 # check we are in a valid C source file if not then ignore this hunk
3022 next if ($realfile !~ /\.(h|c)$/);
3024 # check indentation of any line with a bare else
3025 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3026 # if the previous line is a break or return and is indented 1 tab more...
3027 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3028 my $tabs = length($1) + 1;
3029 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3030 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3031 defined $lines[$linenr] &&
3032 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3033 WARN("UNNECESSARY_ELSE",
3034 "else is not generally useful after a break or return\n" . $hereprev);
3038 # check indentation of a line with a break;
3039 # if the previous line is a goto or return and is indented the same # of tabs
3040 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3042 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3043 WARN("UNNECESSARY_BREAK",
3044 "break is not useful after a goto or return\n" . $hereprev);
3048 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
3049 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
3050 WARN("CONFIG_EXPERIMENTAL",
3051 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
3054 # check for RCS/CVS revision markers
3055 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3057 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3060 # Blackfin: don't use __builtin_bfin_[cs]sync
3061 if ($line =~ /__builtin_bfin_csync/) {
3062 my $herevet = "$here\n" . cat_vet($line) . "\n";
3064 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3066 if ($line =~ /__builtin_bfin_ssync/) {
3067 my $herevet = "$here\n" . cat_vet($line) . "\n";
3069 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3072 # check for old HOTPLUG __dev<foo> section markings
3073 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3074 WARN("HOTPLUG_SECTION",
3075 "Using $1 is unnecessary\n" . $herecurr);
3078 # Check for potential 'bare' types
3079 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3081 #print "LINE<$line>\n";
3082 if ($linenr >= $suppress_statement &&
3083 $realcnt && $sline =~ /.\s*\S/) {
3084 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3085 ctx_statement_block($linenr, $realcnt, 0);
3086 $stat =~ s/\n./\n /g;
3087 $cond =~ s/\n./\n /g;
3089 #print "linenr<$linenr> <$stat>\n";
3090 # If this statement has no statement boundaries within
3091 # it there is no point in retrying a statement scan
3092 # until we hit end of it.
3093 my $frag = $stat; $frag =~ s/;+\s*$//;
3094 if ($frag !~ /(?:{|;)/) {
3095 #print "skip<$line_nr_next>\n";
3096 $suppress_statement = $line_nr_next;
3099 # Find the real next line.
3100 $realline_next = $line_nr_next;
3101 if (defined $realline_next &&
3102 (!defined $lines[$realline_next - 1] ||
3103 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3110 # Ignore goto labels.
3111 if ($s =~ /$Ident:\*$/s) {
3113 # Ignore functions being called
3114 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3116 } elsif ($s =~ /^.\s*else\b/s) {
3118 # declarations always start with types
3119 } 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) {
3122 possible($type, "A:" . $s);
3124 # definitions in global scope can only start with types
3125 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3126 possible($1, "B:" . $s);
3129 # any (foo ... *) is a pointer cast, and foo is a type
3130 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3131 possible($1, "C:" . $s);
3134 # Check for any sort of function declaration.
3135 # int foo(something bar, other baz);
3136 # void (*store_gdt)(x86_descr_ptr *);
3137 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3138 my ($name_len) = length($1);
3141 substr($ctx, 0, $name_len + 1, '');
3142 $ctx =~ s/\)[^\)]*$//;
3144 for my $arg (split(/\s*,\s*/, $ctx)) {
3145 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3147 possible($1, "D:" . $s);
3155 # Checks which may be anchored in the context.
3158 # Check for switch () and associated case and default
3159 # statements should be at the same indent.
3160 if ($line=~/\bswitch\s*\(.*\)/) {
3163 my @ctx = ctx_block_outer($linenr, $realcnt);
3165 for my $ctx (@ctx) {
3166 my ($clen, $cindent) = line_stats($ctx);
3167 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3168 $indent != $cindent) {
3169 $err .= "$sep$ctx\n";
3176 ERROR("SWITCH_CASE_INDENT_LEVEL",
3177 "switch and case should be at the same indent\n$hereline$err");
3181 # if/while/etc brace do not go on next line, unless defining a do while loop,
3182 # or if that brace on the next line is for something else
3183 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3184 my $pre_ctx = "$1$2";
3186 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3188 if ($line =~ /^\+\t{6,}/) {
3189 WARN("DEEP_INDENTATION",
3190 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3193 my $ctx_cnt = $realcnt - $#ctx - 1;
3194 my $ctx = join("\n", @ctx);
3196 my $ctx_ln = $linenr;
3197 my $ctx_skip = $realcnt;
3199 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3200 defined $lines[$ctx_ln - 1] &&
3201 $lines[$ctx_ln - 1] =~ /^-/)) {
3202 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3203 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3207 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3208 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3210 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3212 "that open brace { should be on the previous line\n" .
3213 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3215 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3216 $ctx =~ /\)\s*\;\s*$/ &&
3217 defined $lines[$ctx_ln - 1])
3219 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3220 if ($nindent > $indent) {
3221 WARN("TRAILING_SEMICOLON",
3222 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3223 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3228 # Check relative indent for conditionals and blocks.
3229 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3230 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3231 ctx_statement_block($linenr, $realcnt, 0)
3232 if (!defined $stat);
3233 my ($s, $c) = ($stat, $cond);
3235 substr($s, 0, length($c), '');
3237 # remove inline comments
3241 # Find out how long the conditional actually is.
3242 my @newlines = ($c =~ /\n/gs);
3243 my $cond_lines = 1 + $#newlines;
3245 # Make sure we remove the line prefixes as we have
3246 # none on the first line, and are going to readd them
3249 while ($s =~ /\n\s+\\\n/) {
3250 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3253 # We want to check the first line inside the block
3254 # starting at the end of the conditional, so remove:
3255 # 1) any blank line termination
3256 # 2) any opening brace { on end of the line
3258 my $continuation = 0;
3260 $s =~ s/^.*\bdo\b//;
3262 if ($s =~ s/^\s*\\//) {
3265 if ($s =~ s/^\s*?\n//) {
3270 # Also ignore a loop construct at the end of a
3271 # preprocessor statement.
3272 if (($prevline =~ /^.\s*#\s*define\s/ ||
3273 $prevline =~ /\\\s*$/) && $continuation == 0) {
3279 while ($cond_ptr != $cond_lines) {
3280 $cond_ptr = $cond_lines;
3282 # If we see an #else/#elif then the code
3284 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3289 # 1) blank lines, they should be at 0,
3290 # 2) preprocessor lines, and
3292 if ($continuation ||
3294 $s =~ /^\s*#\s*?/ ||
3295 $s =~ /^\s*$Ident\s*:/) {
3296 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3297 if ($s =~ s/^.*?\n//) {
3303 my (undef, $sindent) = line_stats("+" . $s);
3304 my $stat_real = raw_line($linenr, $cond_lines);
3306 # Check if either of these lines are modified, else
3307 # this is not this patch's fault.
3308 if (!defined($stat_real) ||
3309 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3312 if (defined($stat_real) && $cond_lines > 1) {
3313 $stat_real = "[...]\n$stat_real";
3316 #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";
3318 if ($check && $s ne '' &&
3319 (($sindent % 8) != 0 ||
3320 ($sindent < $indent) ||
3321 ($sindent > $indent + 8))) {
3322 WARN("SUSPECT_CODE_INDENT",
3323 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3327 # Track the 'values' across context and added lines.
3328 my $opline = $line; $opline =~ s/^./ /;
3329 my ($curr_values, $curr_vars) =
3330 annotate_values($opline . "\n", $prev_values);
3331 $curr_values = $prev_values . $curr_values;
3333 my $outline = $opline; $outline =~ s/\t/ /g;
3334 print "$linenr > .$outline\n";
3335 print "$linenr > $curr_values\n";
3336 print "$linenr > $curr_vars\n";
3338 $prev_values = substr($curr_values, -1);
3340 #ignore lines not being added
3341 next if ($line =~ /^[^\+]/);
3343 # check for declarations of signed or unsigned without int
3344 while ($line =~ m{($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3347 $var = "" if (!defined $var);
3348 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3352 $pointer = "" if (!defined $pointer);
3354 if (WARN("UNSPECIFIED_INT",
3355 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3357 my $decl = trim($sign) . " int ";
3358 my $comp_pointer = $pointer;
3359 $comp_pointer =~ s/\s//g;
3360 $decl .= $comp_pointer;
3361 $decl = rtrim($decl) if ($var eq "");
3362 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3367 # TEST: allow direct testing of the type matcher.
3369 if ($line =~ /^.\s*$Declare\s*$/) {
3371 "TEST: is type\n" . $herecurr);
3372 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3373 ERROR("TEST_NOT_TYPE",
3374 "TEST: is not type ($1 is)\n". $herecurr);
3378 # TEST: allow direct testing of the attribute matcher.
3380 if ($line =~ /^.\s*$Modifier\s*$/) {
3382 "TEST: is attr\n" . $herecurr);
3383 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3384 ERROR("TEST_NOT_ATTR",
3385 "TEST: is not attr ($1 is)\n". $herecurr);
3390 # check for initialisation to aggregates open brace on the next line
3391 if ($line =~ /^.\s*{/ &&
3392 $prevline =~ /(?:^|[^=])=\s*$/) {
3393 if (ERROR("OPEN_BRACE",
3394 "that open brace { should be on the previous line\n" . $hereprev) &&
3395 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3396 fix_delete_line($fixlinenr - 1, $prevrawline);
3397 fix_delete_line($fixlinenr, $rawline);
3398 my $fixedline = $prevrawline;
3399 $fixedline =~ s/\s*=\s*$/ = {/;
3400 fix_insert_line($fixlinenr, $fixedline);
3402 $fixedline =~ s/^(.\s*){\s*/$1/;
3403 fix_insert_line($fixlinenr, $fixedline);
3408 # Checks which are anchored on the added line.
3411 # check for malformed paths in #include statements (uses RAW line)
3412 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3414 if ($path =~ m{//}) {
3415 ERROR("MALFORMED_INCLUDE",
3416 "malformed #include filename\n" . $herecurr);
3418 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3419 ERROR("UAPI_INCLUDE",
3420 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3424 # no C99 // comments
3425 if ($line =~ m{//}) {
3426 if (ERROR("C99_COMMENTS",
3427 "do not use C99 // comments\n" . $herecurr) &&
3429 my $line = $fixed[$fixlinenr];
3430 if ($line =~ /\/\/(.*)$/) {
3431 my $comment = trim($1);
3432 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3436 # Remove C99 comments.
3438 $opline =~ s@//.*@@;
3440 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3441 # the whole statement.
3442 #print "APW <$lines[$realline_next - 1]>\n";
3443 if (defined $realline_next &&
3444 exists $lines[$realline_next - 1] &&
3445 !defined $suppress_export{$realline_next} &&
3446 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3447 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3448 # Handle definitions which produce identifiers with
3451 # EXPORT_SYMBOL(something_foo);
3453 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3454 $name =~ /^${Ident}_$2/) {
3455 #print "FOO C name<$name>\n";
3456 $suppress_export{$realline_next} = 1;
3458 } elsif ($stat !~ /(?:
3460 ^.DEFINE_$Ident\(\Q$name\E\)|
3461 ^.DECLARE_$Ident\(\Q$name\E\)|
3462 ^.LIST_HEAD\(\Q$name\E\)|
3463 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3464 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3466 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3467 $suppress_export{$realline_next} = 2;
3469 $suppress_export{$realline_next} = 1;
3472 if (!defined $suppress_export{$linenr} &&
3473 $prevline =~ /^.\s*$/ &&
3474 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3475 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3476 #print "FOO B <$lines[$linenr - 1]>\n";
3477 $suppress_export{$linenr} = 2;
3479 if (defined $suppress_export{$linenr} &&
3480 $suppress_export{$linenr} == 2) {
3481 WARN("EXPORT_SYMBOL",
3482 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3485 # check for global initialisers.
3486 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3487 if (ERROR("GLOBAL_INITIALISERS",
3488 "do not initialise globals to $1\n" . $herecurr) &&
3490 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3493 # check for static initialisers.
3494 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3495 if (ERROR("INITIALISED_STATIC",
3496 "do not initialise statics to $1\n" .
3499 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3503 # check for misordered declarations of char/short/int/long with signed/unsigned
3504 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3506 WARN("MISORDERED_TYPE",
3507 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3510 # check for static const char * arrays.
3511 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3512 WARN("STATIC_CONST_CHAR_ARRAY",
3513 "static const char * array should probably be static const char * const\n" .
3517 # check for static char foo[] = "bar" declarations.
3518 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3519 WARN("STATIC_CONST_CHAR_ARRAY",
3520 "static char array declaration should probably be static const char\n" .
3524 # check for const <foo> const where <foo> is not a pointer or array type
3525 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3527 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3529 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3530 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3532 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3536 # check for non-global char *foo[] = {"bar", ...} declarations.
3537 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3538 WARN("STATIC_CONST_CHAR_ARRAY",
3539 "char * array declaration might be better as static const\n" .
3543 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3544 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3546 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3548 if (WARN("ARRAY_SIZE",
3549 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3551 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3556 # check for function declarations without arguments like "int foo()"
3557 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3558 if (ERROR("FUNCTION_WITHOUT_ARGS",
3559 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3561 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3565 # check for uses of DEFINE_PCI_DEVICE_TABLE
3566 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3567 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3568 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3570 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3574 # check for new typedefs, only function parameters and sparse annotations
3576 if ($line =~ /\btypedef\s/ &&
3577 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3578 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3579 $line !~ /\b$typeTypedefs\b/ &&
3580 $line !~ /\b__bitwise(?:__|)\b/) {
3581 WARN("NEW_TYPEDEFS",
3582 "do not add new typedefs\n" . $herecurr);
3585 # * goes on variable not on type
3587 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3589 my ($ident, $from, $to) = ($1, $2, $2);
3591 # Should start with a space.
3592 $to =~ s/^(\S)/ $1/;
3593 # Should not end with a space.
3595 # '*'s should not have spaces between.
3596 while ($to =~ s/\*\s+\*/\*\*/) {
3599 ## print "1: from<$from> to<$to> ident<$ident>\n";
3601 if (ERROR("POINTER_LOCATION",
3602 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3604 my $sub_from = $ident;
3605 my $sub_to = $ident;
3606 $sub_to =~ s/\Q$from\E/$to/;
3607 $fixed[$fixlinenr] =~
3608 s@\Q$sub_from\E@$sub_to@;
3612 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3614 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3616 # Should start with a space.
3617 $to =~ s/^(\S)/ $1/;
3618 # Should not end with a space.
3620 # '*'s should not have spaces between.
3621 while ($to =~ s/\*\s+\*/\*\*/) {
3623 # Modifiers should have spaces.
3624 $to =~ s/(\b$Modifier$)/$1 /;
3626 ## print "2: from<$from> to<$to> ident<$ident>\n";
3627 if ($from ne $to && $ident !~ /^$Modifier$/) {
3628 if (ERROR("POINTER_LOCATION",
3629 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3632 my $sub_from = $match;
3633 my $sub_to = $match;
3634 $sub_to =~ s/\Q$from\E/$to/;
3635 $fixed[$fixlinenr] =~
3636 s@\Q$sub_from\E@$sub_to@;
3641 # avoid BUG() or BUG_ON()
3642 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3643 my $msg_type = \&WARN;
3644 $msg_type = \&CHK if ($file);
3645 &{$msg_type}("AVOID_BUG",
3646 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3649 # avoid LINUX_VERSION_CODE
3650 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3651 WARN("LINUX_VERSION_CODE",
3652 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3655 # check for uses of printk_ratelimit
3656 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3657 WARN("PRINTK_RATELIMITED",
3658 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3661 # printk should use KERN_* levels. Note that follow on printk's on the
3662 # same line do not need a level, so we use the current block context
3663 # to try and find and validate the current printk. In summary the current
3664 # printk includes all preceding printk's which have no newline on the end.
3665 # we assume the first bad printk is the one to report.
3666 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3668 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3669 #print "CHECK<$lines[$ln - 1]\n";
3670 # we have a preceding printk if it ends
3671 # with "\n" ignore it, else it is to blame
3672 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3673 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3680 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3681 "printk() should include KERN_ facility level\n" . $herecurr);
3685 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3687 my $level = lc($orig);
3688 $level = "warn" if ($level eq "warning");
3689 my $level2 = $level;
3690 $level2 = "dbg" if ($level eq "debug");
3691 WARN("PREFER_PR_LEVEL",
3692 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3695 if ($line =~ /\bpr_warning\s*\(/) {
3696 if (WARN("PREFER_PR_LEVEL",
3697 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3699 $fixed[$fixlinenr] =~
3700 s/\bpr_warning\b/pr_warn/;
3704 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3706 my $level = lc($orig);
3707 $level = "warn" if ($level eq "warning");
3708 $level = "dbg" if ($level eq "debug");
3709 WARN("PREFER_DEV_LEVEL",
3710 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3713 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
3714 # number of false positives, but assembly files are not checked, so at
3715 # least the arch entry code will not trigger this warning.
3716 if ($line =~ /\bENOSYS\b/) {
3718 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3721 # function brace can't be on same line, except for #defines of do while,
3722 # or if closed on same line
3723 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3724 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3725 if (ERROR("OPEN_BRACE",
3726 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3728 fix_delete_line($fixlinenr, $rawline);
3729 my $fixed_line = $rawline;
3730 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3733 fix_insert_line($fixlinenr, ltrim($line1));
3734 fix_insert_line($fixlinenr, "\+{");
3735 if ($line2 !~ /^\s*$/) {
3736 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3741 # open braces for enum, union and struct go on the same line.
3742 if ($line =~ /^.\s*{/ &&
3743 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3744 if (ERROR("OPEN_BRACE",
3745 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3746 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3747 fix_delete_line($fixlinenr - 1, $prevrawline);
3748 fix_delete_line($fixlinenr, $rawline);
3749 my $fixedline = rtrim($prevrawline) . " {";
3750 fix_insert_line($fixlinenr, $fixedline);
3751 $fixedline = $rawline;
3752 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3753 if ($fixedline !~ /^\+\s*$/) {
3754 fix_insert_line($fixlinenr, $fixedline);
3759 # missing space after union, struct or enum definition
3760 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3762 "missing space after $1 definition\n" . $herecurr) &&
3764 $fixed[$fixlinenr] =~
3765 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3769 # Function pointer declarations
3770 # check spacing between type, funcptr, and args
3771 # canonical declaration is "type (*funcptr)(args...)"
3772 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3774 my $pre_pointer_space = $2;
3775 my $post_pointer_space = $3;
3777 my $post_funcname_space = $5;
3778 my $pre_args_space = $6;
3780 # the $Declare variable will capture all spaces after the type
3781 # so check it for a missing trailing missing space but pointer return types
3782 # don't need a space so don't warn for those.
3783 my $post_declare_space = "";
3784 if ($declare =~ /(\s+)$/) {
3785 $post_declare_space = $1;
3786 $declare = rtrim($declare);
3788 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3790 "missing space after return type\n" . $herecurr);
3791 $post_declare_space = " ";
3794 # unnecessary space "type (*funcptr)(args...)"
3795 # This test is not currently implemented because these declarations are
3797 # int foo(int bar, ...)
3798 # and this is form shouldn't/doesn't generate a checkpatch warning.
3800 # elsif ($declare =~ /\s{2,}$/) {
3802 # "Multiple spaces after return type\n" . $herecurr);
3805 # unnecessary space "type ( *funcptr)(args...)"
3806 if (defined $pre_pointer_space &&
3807 $pre_pointer_space =~ /^\s/) {
3809 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3812 # unnecessary space "type (* funcptr)(args...)"
3813 if (defined $post_pointer_space &&
3814 $post_pointer_space =~ /^\s/) {
3816 "Unnecessary space before function pointer name\n" . $herecurr);
3819 # unnecessary space "type (*funcptr )(args...)"
3820 if (defined $post_funcname_space &&
3821 $post_funcname_space =~ /^\s/) {
3823 "Unnecessary space after function pointer name\n" . $herecurr);
3826 # unnecessary space "type (*funcptr) (args...)"
3827 if (defined $pre_args_space &&
3828 $pre_args_space =~ /^\s/) {
3830 "Unnecessary space before function pointer arguments\n" . $herecurr);
3833 if (show_type("SPACING") && $fix) {
3834 $fixed[$fixlinenr] =~
3835 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3839 # check for spacing round square brackets; allowed:
3840 # 1. with a type on the left -- int [] a;
3841 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3842 # 3. inside a curly brace -- = { [0...10] = 5 }
3843 while ($line =~ /(.*?\s)\[/g) {
3844 my ($where, $prefix) = ($-[1], $1);
3845 if ($prefix !~ /$Type\s+$/ &&
3846 ($where != 0 || $prefix !~ /^.\s+$/) &&
3847 $prefix !~ /[{,]\s+$/) {
3848 if (ERROR("BRACKET_SPACE",
3849 "space prohibited before open square bracket '['\n" . $herecurr) &&
3851 $fixed[$fixlinenr] =~
3852 s/^(\+.*?)\s+\[/$1\[/;
3857 # check for spaces between functions and their parentheses.
3858 while ($line =~ /($Ident)\s+\(/g) {
3860 my $ctx_before = substr($line, 0, $-[1]);
3861 my $ctx = "$ctx_before$name";
3863 # Ignore those directives where spaces _are_ permitted.
3865 if|for|while|switch|return|case|
3866 volatile|__volatile__|
3867 __attribute__|format|__extension__|
3870 # cpp #define statements have non-optional spaces, ie
3871 # if there is a space between the name and the open
3872 # parenthesis it is simply not a parameter group.
3873 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3875 # cpp #elif statement condition may start with a (
3876 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3878 # If this whole things ends with a type its most
3879 # likely a typedef for a function.
3880 } elsif ($ctx =~ /$Type$/) {
3884 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3886 $fixed[$fixlinenr] =~
3887 s/\b$name\s+\(/$name\(/;
3892 # Check operator spacing.
3893 if (!($line=~/\#\s*include/)) {
3894 my $fixed_line = "";
3898 <<=|>>=|<=|>=|==|!=|
3899 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3900 =>|->|<<|>>|<|>|=|!|~|
3901 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3904 my @elements = split(/($ops|;)/, $opline);
3906 ## print("element count: <" . $#elements . ">\n");
3907 ## foreach my $el (@elements) {
3908 ## print("el: <$el>\n");
3911 my @fix_elements = ();
3914 foreach my $el (@elements) {
3915 push(@fix_elements, substr($rawline, $off, length($el)));
3916 $off += length($el);
3921 my $blank = copy_spacing($opline);
3922 my $last_after = -1;
3924 for (my $n = 0; $n < $#elements; $n += 2) {
3926 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3928 ## print("n: <$n> good: <$good>\n");
3930 $off += length($elements[$n]);
3932 # Pick up the preceding and succeeding characters.
3933 my $ca = substr($opline, 0, $off);
3935 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3936 $cc = substr($opline, $off + length($elements[$n + 1]));
3938 my $cb = "$ca$;$cc";
3941 $a = 'V' if ($elements[$n] ne '');
3942 $a = 'W' if ($elements[$n] =~ /\s$/);
3943 $a = 'C' if ($elements[$n] =~ /$;$/);
3944 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3945 $a = 'O' if ($elements[$n] eq '');
3946 $a = 'E' if ($ca =~ /^\s*$/);
3948 my $op = $elements[$n + 1];
3951 if (defined $elements[$n + 2]) {
3952 $c = 'V' if ($elements[$n + 2] ne '');
3953 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3954 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3955 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3956 $c = 'O' if ($elements[$n + 2] eq '');
3957 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3962 my $ctx = "${a}x${c}";
3964 my $at = "(ctx:$ctx)";
3966 my $ptr = substr($blank, 0, $off) . "^";
3967 my $hereptr = "$hereline$ptr\n";
3969 # Pull out the value of this operator.
3970 my $op_type = substr($curr_values, $off + 1, 1);
3972 # Get the full operator variant.
3973 my $opv = $op . substr($curr_vars, $off, 1);
3975 # Ignore operators passed as parameters.
3976 if ($op_type ne 'V' &&
3977 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
3980 # } elsif ($op =~ /^$;+$/) {
3982 # ; should have either the end of line or a space or \ after it
3983 } elsif ($op eq ';') {
3984 if ($ctx !~ /.x[WEBC]/ &&
3985 $cc !~ /^\\/ && $cc !~ /^;/) {
3986 if (ERROR("SPACING",
3987 "space required after that '$op' $at\n" . $hereptr)) {
3988 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3994 } elsif ($op eq '//') {
3996 # : when part of a bitfield
3997 } elsif ($opv eq ':B') {
3998 # skip the bitfield test for now
4002 } elsif ($op eq '->') {
4003 if ($ctx =~ /Wx.|.xW/) {
4004 if (ERROR("SPACING",
4005 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4006 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4007 if (defined $fix_elements[$n + 2]) {
4008 $fix_elements[$n + 2] =~ s/^\s+//;
4014 # , must not have a space before and must have a space on the right.
4015 } elsif ($op eq ',') {
4016 my $rtrim_before = 0;
4017 my $space_after = 0;
4018 if ($ctx =~ /Wx./) {
4019 if (ERROR("SPACING",
4020 "space prohibited before that '$op' $at\n" . $hereptr)) {
4025 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4026 if (ERROR("SPACING",
4027 "space required after that '$op' $at\n" . $hereptr)) {
4033 if ($rtrim_before || $space_after) {
4034 if ($rtrim_before) {
4035 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4037 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4044 # '*' as part of a type definition -- reported already.
4045 } elsif ($opv eq '*_') {
4046 #warn "'*' is part of type\n";
4048 # unary operators should have a space before and
4049 # none after. May be left adjacent to another
4050 # unary operator, or a cast
4051 } elsif ($op eq '!' || $op eq '~' ||
4052 $opv eq '*U' || $opv eq '-U' ||
4053 $opv eq '&U' || $opv eq '&&U') {
4054 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4055 if (ERROR("SPACING",
4056 "space required before that '$op' $at\n" . $hereptr)) {
4057 if ($n != $last_after + 2) {
4058 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4063 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4064 # A unary '*' may be const
4066 } elsif ($ctx =~ /.xW/) {
4067 if (ERROR("SPACING",
4068 "space prohibited after that '$op' $at\n" . $hereptr)) {
4069 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4070 if (defined $fix_elements[$n + 2]) {
4071 $fix_elements[$n + 2] =~ s/^\s+//;
4077 # unary ++ and unary -- are allowed no space on one side.
4078 } elsif ($op eq '++' or $op eq '--') {
4079 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4080 if (ERROR("SPACING",
4081 "space required one side of that '$op' $at\n" . $hereptr)) {
4082 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4086 if ($ctx =~ /Wx[BE]/ ||
4087 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4088 if (ERROR("SPACING",
4089 "space prohibited before that '$op' $at\n" . $hereptr)) {
4090 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4094 if ($ctx =~ /ExW/) {
4095 if (ERROR("SPACING",
4096 "space prohibited after that '$op' $at\n" . $hereptr)) {
4097 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4098 if (defined $fix_elements[$n + 2]) {
4099 $fix_elements[$n + 2] =~ s/^\s+//;
4105 # << and >> may either have or not have spaces both sides
4106 } elsif ($op eq '<<' or $op eq '>>' or
4107 $op eq '&' or $op eq '^' or $op eq '|' or
4108 $op eq '+' or $op eq '-' or
4109 $op eq '*' or $op eq '/' or
4113 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4115 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4116 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4117 $fix_elements[$n + 2] =~ s/^\s+//;
4120 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4122 "space preferred before that '$op' $at\n" . $hereptr)) {
4123 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4127 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4128 if (ERROR("SPACING",
4129 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4130 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4131 if (defined $fix_elements[$n + 2]) {
4132 $fix_elements[$n + 2] =~ s/^\s+//;
4138 # A colon needs no spaces before when it is
4139 # terminating a case value or a label.
4140 } elsif ($opv eq ':C' || $opv eq ':L') {
4141 if ($ctx =~ /Wx./) {
4142 if (ERROR("SPACING",
4143 "space prohibited before that '$op' $at\n" . $hereptr)) {
4144 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4149 # All the others need spaces both sides.
4150 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4153 # Ignore email addresses <foo@bar>
4155 $cc =~ /^\S+\@\S+>/) ||
4157 $ca =~ /<\S+\@\S+$/))
4162 # for asm volatile statements
4163 # ignore a colon with another
4164 # colon immediately before or after
4166 ($ca =~ /:$/ || $cc =~ /^:/)) {
4170 # messages are ERROR, but ?: are CHK
4172 my $msg_type = \&ERROR;
4173 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4175 if (&{$msg_type}("SPACING",
4176 "spaces required around that '$op' $at\n" . $hereptr)) {
4177 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4178 if (defined $fix_elements[$n + 2]) {
4179 $fix_elements[$n + 2] =~ s/^\s+//;
4185 $off += length($elements[$n + 1]);
4187 ## print("n: <$n> GOOD: <$good>\n");
4189 $fixed_line = $fixed_line . $good;
4192 if (($#elements % 2) == 0) {
4193 $fixed_line = $fixed_line . $fix_elements[$#elements];
4196 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4197 $fixed[$fixlinenr] = $fixed_line;
4203 # check for whitespace before a non-naked semicolon
4204 if ($line =~ /^\+.*\S\s+;\s*$/) {
4206 "space prohibited before semicolon\n" . $herecurr) &&
4208 1 while $fixed[$fixlinenr] =~
4209 s/^(\+.*\S)\s+;/$1;/;
4213 # check for multiple assignments
4214 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4215 CHK("MULTIPLE_ASSIGNMENTS",
4216 "multiple assignments should be avoided\n" . $herecurr);
4219 ## # check for multiple declarations, allowing for a function declaration
4221 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4222 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4224 ## # Remove any bracketed sections to ensure we do not
4225 ## # falsly report the parameters of functions.
4227 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4229 ## if ($ln =~ /,/) {
4230 ## WARN("MULTIPLE_DECLARATION",
4231 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4235 #need space before brace following if, while, etc
4236 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4238 if (ERROR("SPACING",
4239 "space required before the open brace '{'\n" . $herecurr) &&
4241 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
4245 ## # check for blank lines before declarations
4246 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4247 ## $prevrawline =~ /^.\s*$/) {
4249 ## "No blank lines before declarations\n" . $hereprev);
4253 # closing brace should have a space following it when it has anything
4255 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4256 if (ERROR("SPACING",
4257 "space required after that close brace '}'\n" . $herecurr) &&
4259 $fixed[$fixlinenr] =~
4260 s/}((?!(?:,|;|\)))\S)/} $1/;
4264 # check spacing on square brackets
4265 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4266 if (ERROR("SPACING",
4267 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4269 $fixed[$fixlinenr] =~
4273 if ($line =~ /\s\]/) {
4274 if (ERROR("SPACING",
4275 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4277 $fixed[$fixlinenr] =~
4282 # check spacing on parentheses
4283 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4284 $line !~ /for\s*\(\s+;/) {
4285 if (ERROR("SPACING",
4286 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4288 $fixed[$fixlinenr] =~
4292 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4293 $line !~ /for\s*\(.*;\s+\)/ &&
4294 $line !~ /:\s+\)/) {
4295 if (ERROR("SPACING",
4296 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4298 $fixed[$fixlinenr] =~
4303 # check unnecessary parentheses around addressof/dereference single $Lvals
4304 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4306 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4308 if (CHK("UNNECESSARY_PARENTHESES",
4309 "Unnecessary parentheses around $var\n" . $herecurr) &&
4311 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4315 # check for unnecessary parentheses around function pointer uses
4316 # ie: (foo->bar)(); should be foo->bar();
4317 # but not "if (foo->bar) (" to avoid some false positives
4318 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4320 if (CHK("UNNECESSARY_PARENTHESES",
4321 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4323 my $var2 = deparenthesize($var);
4325 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4329 #goto labels aren't indented, allow a single space however
4330 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4331 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4332 if (WARN("INDENTED_LABEL",
4333 "labels should not be indented\n" . $herecurr) &&
4335 $fixed[$fixlinenr] =~
4340 # return is not a function
4341 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4343 if ($^V && $^V ge 5.10.0 &&
4344 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4346 $value = deparenthesize($value);
4347 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4348 ERROR("RETURN_PARENTHESES",
4349 "return is not a function, parentheses are not required\n" . $herecurr);
4351 } elsif ($spacing !~ /\s+/) {
4353 "space required before the open parenthesis '('\n" . $herecurr);
4357 # unnecessary return in a void function
4358 # at end-of-function, with the previous line a single leading tab, then return;
4359 # and the line before that not a goto label target like "out:"
4360 if ($sline =~ /^[ \+]}\s*$/ &&
4361 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4363 $lines[$linenr - 3] =~ /^[ +]/ &&
4364 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4366 "void function return statements are not generally useful\n" . $hereprev);
4369 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4370 if ($^V && $^V ge 5.10.0 &&
4371 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4372 my $openparens = $1;
4373 my $count = $openparens =~ tr@\(@\(@;
4375 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4376 my $comp = $4; #Not $1 because of $LvalOrFunc
4377 $msg = " - maybe == should be = ?" if ($comp eq "==");
4378 WARN("UNNECESSARY_PARENTHESES",
4379 "Unnecessary parentheses$msg\n" . $herecurr);
4383 # comparisons with a constant or upper case identifier on the left
4384 # avoid cases like "foo + BAR < baz"
4385 # only fix matches surrounded by parentheses to avoid incorrect
4386 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4387 if ($^V && $^V ge 5.10.0 &&
4388 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4393 my $newcomp = $comp;
4394 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4395 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4396 WARN("CONSTANT_COMPARISON",
4397 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4401 } elsif ($comp eq "<=") {
4403 } elsif ($comp eq ">") {
4405 } elsif ($comp eq ">=") {
4408 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4412 # Return of what appears to be an errno should normally be negative
4413 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4415 if ($name ne 'EOF' && $name ne 'ERROR') {
4416 WARN("USE_NEGATIVE_ERRNO",
4417 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4421 # Need a space before open parenthesis after if, while etc
4422 if ($line =~ /\b(if|while|for|switch)\(/) {
4423 if (ERROR("SPACING",
4424 "space required before the open parenthesis '('\n" . $herecurr) &&
4426 $fixed[$fixlinenr] =~
4427 s/\b(if|while|for|switch)\(/$1 \(/;
4431 # Check for illegal assignment in if conditional -- and check for trailing
4432 # statements after the conditional.
4433 if ($line =~ /do\s*(?!{)/) {
4434 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4435 ctx_statement_block($linenr, $realcnt, 0)
4436 if (!defined $stat);
4437 my ($stat_next) = ctx_statement_block($line_nr_next,
4438 $remain_next, $off_next);
4439 $stat_next =~ s/\n./\n /g;
4440 ##print "stat<$stat> stat_next<$stat_next>\n";
4442 if ($stat_next =~ /^\s*while\b/) {
4443 # If the statement carries leading newlines,
4444 # then count those as offsets.
4446 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4448 statement_rawlines($whitespace) - 1;
4450 $suppress_whiletrailers{$line_nr_next +
4454 if (!defined $suppress_whiletrailers{$linenr} &&
4455 defined($stat) && defined($cond) &&
4456 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4457 my ($s, $c) = ($stat, $cond);
4459 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4460 ERROR("ASSIGN_IN_IF",
4461 "do not use assignment in if condition\n" . $herecurr);
4464 # Find out what is on the end of the line after the
4466 substr($s, 0, length($c), '');
4468 $s =~ s/$;//g; # Remove any comments
4469 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4470 $c !~ /}\s*while\s*/)
4472 # Find out how long the conditional actually is.
4473 my @newlines = ($c =~ /\n/gs);
4474 my $cond_lines = 1 + $#newlines;
4477 $stat_real = raw_line($linenr, $cond_lines)
4478 . "\n" if ($cond_lines);
4479 if (defined($stat_real) && $cond_lines > 1) {
4480 $stat_real = "[...]\n$stat_real";
4483 ERROR("TRAILING_STATEMENTS",
4484 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4488 # Check for bitwise tests written as boolean
4500 WARN("HEXADECIMAL_BOOLEAN_TEST",
4501 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4504 # if and else should not have general statements after it
4505 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4507 $s =~ s/$;//g; # Remove any comments
4508 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4509 ERROR("TRAILING_STATEMENTS",
4510 "trailing statements should be on next line\n" . $herecurr);
4513 # if should not continue a brace
4514 if ($line =~ /}\s*if\b/) {
4515 ERROR("TRAILING_STATEMENTS",
4516 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4519 # case and default should not have general statements after them
4520 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4522 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4526 ERROR("TRAILING_STATEMENTS",
4527 "trailing statements should be on next line\n" . $herecurr);
4530 # Check for }<nl>else {, these must be at the same
4531 # indent level to be relevant to each other.
4532 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4533 $previndent == $indent) {
4534 if (ERROR("ELSE_AFTER_BRACE",
4535 "else should follow close brace '}'\n" . $hereprev) &&
4536 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4537 fix_delete_line($fixlinenr - 1, $prevrawline);
4538 fix_delete_line($fixlinenr, $rawline);
4539 my $fixedline = $prevrawline;
4540 $fixedline =~ s/}\s*$//;
4541 if ($fixedline !~ /^\+\s*$/) {
4542 fix_insert_line($fixlinenr, $fixedline);
4544 $fixedline = $rawline;
4545 $fixedline =~ s/^(.\s*)else/$1} else/;
4546 fix_insert_line($fixlinenr, $fixedline);
4550 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4551 $previndent == $indent) {
4552 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4554 # Find out what is on the end of the line after the
4556 substr($s, 0, length($c), '');
4559 if ($s =~ /^\s*;/) {
4560 if (ERROR("WHILE_AFTER_BRACE",
4561 "while should follow close brace '}'\n" . $hereprev) &&
4562 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4563 fix_delete_line($fixlinenr - 1, $prevrawline);
4564 fix_delete_line($fixlinenr, $rawline);
4565 my $fixedline = $prevrawline;
4566 my $trailing = $rawline;
4567 $trailing =~ s/^\+//;
4568 $trailing = trim($trailing);
4569 $fixedline =~ s/}\s*$/} $trailing/;
4570 fix_insert_line($fixlinenr, $fixedline);
4575 #Specific variable tests
4576 while ($line =~ m{($Constant|$Lval)}g) {
4579 #gcc binary extension
4580 if ($var =~ /^$Binary$/) {
4581 if (WARN("GCC_BINARY_CONSTANT",
4582 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4584 my $hexval = sprintf("0x%x", oct($var));
4585 $fixed[$fixlinenr] =~
4586 s/\b$var\b/$hexval/;
4591 if ($var !~ /^$Constant$/ &&
4592 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4593 #Ignore Page<foo> variants
4594 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4595 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4596 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4597 #Ignore some three character SI units explicitly, like MiB and KHz
4598 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4599 while ($var =~ m{($Ident)}g) {
4601 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4603 seed_camelcase_includes();
4604 if (!$file && !$camelcase_file_seeded) {
4605 seed_camelcase_file($realfile);
4606 $camelcase_file_seeded = 1;
4609 if (!defined $camelcase{$word}) {
4610 $camelcase{$word} = 1;
4612 "Avoid CamelCase: <$word>\n" . $herecurr);
4618 #no spaces allowed after \ in define
4619 if ($line =~ /\#\s*define.*\\\s+$/) {
4620 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4621 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4623 $fixed[$fixlinenr] =~ s/\s+$//;
4627 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4628 # itself <asm/foo.h> (uses RAW line)
4629 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4631 my $checkfile = "include/linux/$file";
4632 if (-f "$root/$checkfile" &&
4633 $realfile ne $checkfile &&
4634 $1 !~ /$allowed_asm_includes/)
4636 my $asminclude = `grep -Ec
"#include\\s+<asm/$file>" $root/$checkfile`;
4637 if ($asminclude > 0) {
4638 if ($realfile =~ m{^arch/}) {
4639 CHK
("ARCH_INCLUDE_LINUX",
4640 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4642 WARN
("INCLUDE_LINUX",
4643 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4649 # multi-statement macros should be enclosed in a do while loop, grab the
4650 # first statement and ensure its the whole macro if its not enclosed
4651 # in a known good container
4652 if ($realfile !~ m
@/vmlinux.lds
.h
$@ &&
4653 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4656 my ($off, $dstat, $dcond, $rest);
4658 my $has_flow_statement = 0;
4659 my $has_arg_concat = 0;
4660 ($dstat, $dcond, $ln, $cnt, $off) =
4661 ctx_statement_block
($linenr, $realcnt, 0);
4663 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4664 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4666 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4667 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4669 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4671 $dstat =~ s/\\\n.//g;
4672 $dstat =~ s/^\s*//s;
4673 $dstat =~ s/\s*$//s;
4675 # Flatten any parentheses and braces
4676 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4677 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4678 $dstat =~ s/.\[[^\[\]]*\]/1/)
4682 # Flatten any obvious string concatentation.
4683 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4684 $dstat =~ s/$Ident\s*($String)/$1/)
4688 # Make asm volatile uses seem like a generic function
4689 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4691 my $exceptions = qr{
4704 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4706 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4707 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4708 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4709 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4710 $dstat !~ /$exceptions/ &&
4711 $dstat !~ /^\.$Ident\s*=/ && # .foo =
4712 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4713 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4714 $dstat !~ /^for\s*$Constant$/ && # for (...)
4715 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4716 $dstat !~ /^do\s*{/ && # do {...
4717 $dstat !~ /^\(\{/ && # ({...
4718 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4721 my $herectx = $here . "\n";
4722 my $cnt = statement_rawlines
($ctx);
4724 for (my $n = 0; $n < $cnt; $n++) {
4725 $herectx .= raw_line
($linenr, $n) . "\n";
4728 if ($dstat =~ /;/) {
4729 ERROR
("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4730 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4732 ERROR
("COMPLEX_MACRO",
4733 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4737 # check for macros with flow control, but without ## concatenation
4738 # ## concatenation is commonly a macro that defines a function so ignore those
4739 if ($has_flow_statement && !$has_arg_concat) {
4740 my $herectx = $here . "\n";
4741 my $cnt = statement_rawlines
($ctx);
4743 for (my $n = 0; $n < $cnt; $n++) {
4744 $herectx .= raw_line
($linenr, $n) . "\n";
4746 WARN
("MACRO_WITH_FLOW_CONTROL",
4747 "Macros with flow control statements should be avoided\n" . "$herectx");
4750 # check for line continuations outside of #defines, preprocessor #, and asm
4753 if ($prevline !~ /^..*\\$/ &&
4754 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4755 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
4756 $line =~ /^\+.*\\$/) {
4757 WARN
("LINE_CONTINUATIONS",
4758 "Avoid unnecessary line continuations\n" . $herecurr);
4762 # do {} while (0) macro tests:
4763 # single-statement macros do not need to be enclosed in do while (0) loop,
4764 # macro should not end with a semicolon
4765 if ($^V && $^V ge 5.10.0 &&
4766 $realfile !~ m
@/vmlinux.lds
.h
$@ &&
4767 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4770 my ($off, $dstat, $dcond, $rest);
4772 ($dstat, $dcond, $ln, $cnt, $off) =
4773 ctx_statement_block
($linenr, $realcnt, 0);
4776 $dstat =~ s/\\\n.//g;
4779 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4784 my $cnt = statement_rawlines
($ctx);
4785 my $herectx = $here . "\n";
4787 for (my $n = 0; $n < $cnt; $n++) {
4788 $herectx .= raw_line
($linenr, $n) . "\n";
4791 if (($stmts =~ tr/;/;/) == 1 &&
4792 $stmts !~ /^\s*(if|while|for|switch)\b/) {
4793 WARN
("SINGLE_STATEMENT_DO_WHILE_MACRO",
4794 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4796 if (defined $semis && $semis ne "") {
4797 WARN
("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4798 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4800 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4802 my $cnt = statement_rawlines
($ctx);
4803 my $herectx = $here . "\n";
4805 for (my $n = 0; $n < $cnt; $n++) {
4806 $herectx .= raw_line
($linenr, $n) . "\n";
4809 WARN
("TRAILING_SEMICOLON",
4810 "macros should not use a trailing semicolon\n" . "$herectx");
4814 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4815 # all assignments may have only one of the following with an assignment:
4818 # VMLINUX_SYMBOL(...)
4819 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4820 WARN
("MISSING_VMLINUX_SYMBOL",
4821 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4824 # check for redundant bracing round if etc
4825 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4826 my ($level, $endln, @chunks) =
4827 ctx_statement_full
($linenr, $realcnt, 1);
4828 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4829 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4830 if ($#chunks > 0 && $level == 0) {
4834 my $herectx = $here . "\n";
4835 my $ln = $linenr - 1;
4836 for my $chunk (@chunks) {
4837 my ($cond, $block) = @{$chunk};
4839 # If the condition carries leading newlines, then count those as offsets.
4840 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4841 my $offset = statement_rawlines
($whitespace) - 1;
4843 $allowed[$allow] = 0;
4844 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4846 # We have looked at and allowed this specific line.
4847 $suppress_ifbraces{$ln + $offset} = 1;
4849 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4850 $ln += statement_rawlines
($block) - 1;
4852 substr($block, 0, length($cond), '');
4854 $seen++ if ($block =~ /^\s*{/);
4856 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4857 if (statement_lines
($cond) > 1) {
4858 #print "APW: ALLOWED: cond<$cond>\n";
4859 $allowed[$allow] = 1;
4861 if ($block =~/\b(?:if|for|while)\b/) {
4862 #print "APW: ALLOWED: block<$block>\n";
4863 $allowed[$allow] = 1;
4865 if (statement_block_size
($block) > 1) {
4866 #print "APW: ALLOWED: lines block<$block>\n";
4867 $allowed[$allow] = 1;
4872 my $sum_allowed = 0;
4873 foreach (@allowed) {
4876 if ($sum_allowed == 0) {
4878 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4879 } elsif ($sum_allowed != $allow &&
4882 "braces {} should be used on all arms of this statement\n" . $herectx);
4887 if (!defined $suppress_ifbraces{$linenr - 1} &&
4888 $line =~ /\b(if|while|for|else)\b/) {
4891 # Check the pre-context.
4892 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4893 #print "APW: ALLOWED: pre<$1>\n";
4897 my ($level, $endln, @chunks) =
4898 ctx_statement_full
($linenr, $realcnt, $-[0]);
4900 # Check the condition.
4901 my ($cond, $block) = @{$chunks[0]};
4902 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4903 if (defined $cond) {
4904 substr($block, 0, length($cond), '');
4906 if (statement_lines
($cond) > 1) {
4907 #print "APW: ALLOWED: cond<$cond>\n";
4910 if ($block =~/\b(?:if|for|while)\b/) {
4911 #print "APW: ALLOWED: block<$block>\n";
4914 if (statement_block_size
($block) > 1) {
4915 #print "APW: ALLOWED: lines block<$block>\n";
4918 # Check the post-context.
4919 if (defined $chunks[1]) {
4920 my ($cond, $block) = @{$chunks[1]};
4921 if (defined $cond) {
4922 substr($block, 0, length($cond), '');
4924 if ($block =~ /^\s*\{/) {
4925 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4929 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4930 my $herectx = $here . "\n";
4931 my $cnt = statement_rawlines
($block);
4933 for (my $n = 0; $n < $cnt; $n++) {
4934 $herectx .= raw_line
($linenr, $n) . "\n";
4938 "braces {} are not necessary for single statement blocks\n" . $herectx);
4942 # check for unnecessary blank lines around braces
4943 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4945 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4946 $fix && $prevrawline =~ /^\+/) {
4947 fix_delete_line
($fixlinenr - 1, $prevrawline);
4950 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4952 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4954 fix_delete_line
($fixlinenr, $rawline);
4958 # no volatiles please
4959 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4960 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4962 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4965 # Check for user-visible strings broken across lines, which breaks the ability
4966 # to grep for the string. Make exceptions when the previous string ends in a
4967 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4968 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
4969 if ($line =~ /^\+\s*$String/ &&
4970 $prevline =~ /"\s*$/ &&
4971 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4972 if (WARN
("SPLIT_STRING",
4973 "quoted string split across lines\n" . $hereprev) &&
4975 $prevrawline =~ /^\+.*"\s*$/ &&
4976 $last_coalesced_string_linenr != $linenr - 1) {
4977 my $extracted_string = get_quoted_string
($line, $rawline);
4978 my $comma_close = "";
4979 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4983 fix_delete_line
($fixlinenr - 1, $prevrawline);
4984 fix_delete_line
($fixlinenr, $rawline);
4985 my $fixedline = $prevrawline;
4986 $fixedline =~ s/"\s*$//;
4987 $fixedline .= substr($extracted_string, 1) . trim
($comma_close);
4988 fix_insert_line
($fixlinenr - 1, $fixedline);
4989 $fixedline = $rawline;
4990 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4991 if ($fixedline !~ /\+\s*$/) {
4992 fix_insert_line
($fixlinenr, $fixedline);
4994 $last_coalesced_string_linenr = $linenr;
4998 # check for missing a space in a string concatenation
4999 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5000 WARN
('MISSING_SPACE',
5001 "break quoted strings at a space character\n" . $hereprev);
5004 # check for spaces before a quoted newline
5005 if ($rawline =~ /^.*\".*\s\\n/) {
5006 if (WARN
("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5007 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5009 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5014 # concatenated string without spaces between elements
5015 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5016 CHK
("CONCATENATED_STRING",
5017 "Concatenated strings should use spaces between elements\n" . $herecurr);
5020 # uncoalesced string fragments
5021 if ($line =~ /$String\s*"/) {
5022 WARN
("STRING_FRAGMENTS",
5023 "Consecutive strings are generally better as a single string\n" . $herecurr);
5026 # check for %L{u,d,i} and 0x%[udi] in strings
5028 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5029 $string = substr($rawline, $-[1], $+[1] - $-[1]);
5030 $string =~ s/%%/__/g;
5031 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
5033 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
5036 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
5037 ERROR
("PRINTF_0xDECIMAL",
5038 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5042 # check for line continuations in quoted strings with odd counts of "
5043 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5044 WARN
("LINE_CONTINUATIONS",
5045 "Avoid line continuations in quoted strings\n" . $herecurr);
5049 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5050 CHK
("REDUNDANT_CODE",
5051 "if this code is redundant consider removing it\n" .
5055 # check for needless "if (<foo>) fn(<foo>)" uses
5056 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5057 my $tested = quotemeta($1);
5058 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5059 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5061 if (WARN
('NEEDLESS_IF',
5062 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5065 my $leading_tabs = "";
5066 my $new_leading_tabs = "";
5067 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5072 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5073 $new_leading_tabs = $1;
5074 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5081 fix_delete_line
($fixlinenr - 1, $prevrawline);
5082 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5088 # check for unnecessary "Out of Memory" messages
5089 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5090 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5091 (defined $1 || defined $3) &&
5094 my $testline = $lines[$linenr - 3];
5096 my ($s, $c) = ctx_statement_block
($linenr - 3, $realcnt, 0);
5097 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5099 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
5101 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5105 # check for logging functions with KERN_<LEVEL>
5106 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5107 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5109 if (WARN
("UNNECESSARY_KERN_LEVEL",
5110 "Possible unnecessary $level\n" . $herecurr) &&
5112 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5116 # check for mask then right shift without a parentheses
5117 if ($^V && $^V ge 5.10.0 &&
5118 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5119 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5120 WARN
("MASK_THEN_SHIFT",
5121 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5124 # check for pointer comparisons to NULL
5125 if ($^V && $^V ge 5.10.0) {
5126 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5129 $equal = "" if ($4 eq "!=");
5130 if (CHK
("COMPARISON_TO_NULL",
5131 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5133 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5138 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5139 if ($line =~ /(\b$InitAttribute\b)/) {
5141 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5144 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5145 ERROR
("MISPLACED_INIT",
5146 "$attr should be placed after $var\n" . $herecurr)) ||
5147 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5148 WARN
("MISPLACED_INIT",
5149 "$attr should be placed after $var\n" . $herecurr))) &&
5151 $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;
5156 # check for $InitAttributeData (ie: __initdata) with const
5157 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5159 $attr =~ /($InitAttributePrefix)(.*)/;
5160 my $attr_prefix = $1;
5162 if (ERROR
("INIT_ATTRIBUTE",
5163 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5165 $fixed[$fixlinenr] =~
5166 s/$InitAttributeData/${attr_prefix}initconst/;
5170 # check for $InitAttributeConst (ie: __initconst) without const
5171 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5173 if (ERROR
("INIT_ATTRIBUTE",
5174 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5176 my $lead = $fixed[$fixlinenr] =~
5177 /(^\+\s*(?:static\s+))/;
5179 $lead = "$lead " if ($lead !~ /^\+$/);
5180 $lead = "${lead}const ";
5181 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5185 # check for __read_mostly with const non-pointer (should just be const)
5186 if ($line =~ /\b__read_mostly\b/ &&
5187 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5188 if (ERROR
("CONST_READ_MOSTLY",
5189 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5191 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5195 # don't use __constant_<foo> functions outside of include/uapi/
5196 if ($realfile !~ m
@^include/uapi/@ &&
5197 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5198 my $constant_func = $1;
5199 my $func = $constant_func;
5200 $func =~ s/^__constant_//;
5201 if (WARN
("CONSTANT_CONVERSION",
5202 "$constant_func should be $func\n" . $herecurr) &&
5204 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5208 # prefer usleep_range over udelay
5209 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5211 # ignore udelay's < 10, however
5212 if (! ($delay < 10) ) {
5214 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5216 if ($delay > 2000) {
5218 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5222 # warn about unexpectedly long msleep's
5223 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5226 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5230 # check for comparisons of jiffies
5231 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5232 WARN
("JIFFIES_COMPARISON",
5233 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5236 # check for comparisons of get_jiffies_64()
5237 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5238 WARN
("JIFFIES_COMPARISON",
5239 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5242 # warn about #ifdefs in C files
5243 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5244 # print "#ifdef in C files should be avoided\n";
5245 # print "$herecurr";
5249 # warn about spacing in #ifdefs
5250 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5251 if (ERROR
("SPACING",
5252 "exactly one space required after that #$1\n" . $herecurr) &&
5254 $fixed[$fixlinenr] =~
5255 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5260 # check for spinlock_t definitions without a comment.
5261 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5262 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5264 if (!ctx_has_comment
($first_line, $linenr)) {
5265 CHK
("UNCOMMENTED_DEFINITION",
5266 "$1 definition without comment\n" . $herecurr);
5269 # check for memory barriers without a comment.
5275 read_barrier_depends
5277 my $barrier_stems = qr{
5285 my $all_barriers = qr{
5287 smp_
(?
:$barrier_stems)|
5288 virt_
(?
:$barrier_stems)
5291 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5292 if (!ctx_has_comment
($first_line, $linenr)) {
5293 WARN
("MEMORY_BARRIER",
5294 "memory barrier without comment\n" . $herecurr);
5298 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5300 if ($realfile !~ m
@^include/asm-generic
/@ &&
5301 $realfile !~ m
@/barrier\.h
$@ &&
5302 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5303 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5304 WARN
("MEMORY_BARRIER",
5305 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5308 # check for waitqueue_active without a comment.
5309 if ($line =~ /\bwaitqueue_active\s*\(/) {
5310 if (!ctx_has_comment
($first_line, $linenr)) {
5311 WARN
("WAITQUEUE_ACTIVE",
5312 "waitqueue_active without comment\n" . $herecurr);
5316 # Check for expedited grace periods that interrupt non-idle non-nohz
5317 # online CPUs. These expedited can therefore degrade real-time response
5318 # if used carelessly, and should be avoided where not absolutely
5319 # needed. It is always OK to use synchronize_rcu_expedited() and
5320 # synchronize_sched_expedited() at boot time (before real-time applications
5321 # start) and in error situations where real-time response is compromised in
5322 # any case. Note that synchronize_srcu_expedited() does -not- interrupt
5323 # other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5324 # Of course, nothing comes for free, and srcu_read_lock() and
5325 # srcu_read_unlock() do contain full memory barriers in payment for
5326 # synchronize_srcu_expedited() non-interruption properties.
5327 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5328 WARN
("EXPEDITED_RCU_GRACE_PERIOD",
5329 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5333 # check of hardware specific defines
5334 if ($line =~ m
@^.\s
*\#\s
*if.*\b(__i386__
|__powerpc64__
|__sun__
|__s390x__
)\b@ && $realfile !~ m
@include/asm-@) {
5336 "architecture specific defines should be avoided\n" . $herecurr);
5339 # Check that the storage class is at the beginning of a declaration
5340 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
5341 WARN
("STORAGE_CLASS",
5342 "storage class should be at the beginning of the declaration\n" . $herecurr)
5345 # check the location of the inline attribute, that it is between
5346 # storage class and type.
5347 if ($line =~ /\b$Type\s+$Inline\b/ ||
5348 $line =~ /\b$Inline\s+$Storage\b/) {
5349 ERROR
("INLINE_LOCATION",
5350 "inline keyword should sit between storage class and type\n" . $herecurr);
5353 # Check for __inline__ and __inline, prefer inline
5354 if ($realfile !~ m
@\binclude/uapi/@ &&
5355 $line =~ /\b(__inline__|__inline)\b/) {
5357 "plain inline is preferred over $1\n" . $herecurr) &&
5359 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5364 # Check for __attribute__ packed, prefer __packed
5365 if ($realfile !~ m
@\binclude/uapi/@ &&
5366 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5367 WARN
("PREFER_PACKED",
5368 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5371 # Check for __attribute__ aligned, prefer __aligned
5372 if ($realfile !~ m
@\binclude/uapi/@ &&
5373 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5374 WARN
("PREFER_ALIGNED",
5375 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5378 # Check for __attribute__ format(printf, prefer __printf
5379 if ($realfile !~ m
@\binclude/uapi/@ &&
5380 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5381 if (WARN
("PREFER_PRINTF",
5382 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5384 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5389 # Check for __attribute__ format(scanf, prefer __scanf
5390 if ($realfile !~ m
@\binclude/uapi/@ &&
5391 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5392 if (WARN
("PREFER_SCANF",
5393 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5395 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5399 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5400 if ($^V && $^V ge 5.10.0 &&
5401 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5402 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5403 $line =~ /\b__weak\b/)) {
5404 ERROR
("WEAK_DECLARATION",
5405 "Using weak declarations can have unintended link defects\n" . $herecurr);
5408 # check for c99 types like uint8_t used outside of uapi/
5409 if ($realfile !~ m
@\binclude/uapi/@ &&
5410 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5412 if ($type =~ /\b($typeC99Typedefs)\b/) {
5414 my $kernel_type = 'u';
5415 $kernel_type = 's' if ($type =~ /^_*[si]/);
5418 if (CHK
("PREFER_KERNEL_TYPES",
5419 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5421 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5426 # check for cast of C90 native int or longer types constants
5427 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5430 if (WARN
("TYPECAST_INT_CONSTANT",
5431 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5434 my $newconst = $const;
5435 $newconst =~ s/${Int_type}$//;
5436 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5437 if ($cast =~ /\blong\s+long\b/) {
5439 } elsif ($cast =~ /\blong\b/) {
5442 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5446 # check for sizeof(&)
5447 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5448 WARN
("SIZEOF_ADDRESS",
5449 "sizeof(& should be avoided\n" . $herecurr);
5452 # check for sizeof without parenthesis
5453 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5454 if (WARN
("SIZEOF_PARENTHESIS",
5455 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5457 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5461 # check for struct spinlock declarations
5462 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5463 WARN
("USE_SPINLOCK_T",
5464 "struct spinlock should be spinlock_t\n" . $herecurr);
5467 # check for seq_printf uses that could be seq_puts
5468 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5469 my $fmt = get_quoted_string
($line, $rawline);
5472 if (WARN
("PREFER_SEQ_PUTS",
5473 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5475 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5480 # Check for misused memsets
5481 if ($^V && $^V ge 5.10.0 &&
5483 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5489 if ($ms_size =~ /^(0x|)0$/i) {
5491 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5492 } elsif ($ms_size =~ /^(0x|)1$/i) {
5494 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5498 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5499 if ($^V && $^V ge 5.10.0 &&
5501 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5502 if (WARN
("PREFER_ETHER_ADDR_COPY",
5503 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5505 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5509 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5510 if ($^V && $^V ge 5.10.0 &&
5512 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5513 WARN
("PREFER_ETHER_ADDR_EQUAL",
5514 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5517 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5518 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5519 if ($^V && $^V ge 5.10.0 &&
5521 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5525 if ($ms_val =~ /^(?:0x|)0+$/i) {
5526 if (WARN
("PREFER_ETH_ZERO_ADDR",
5527 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5529 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5531 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5532 if (WARN
("PREFER_ETH_BROADCAST_ADDR",
5533 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5535 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5540 # typecasts on min/max could be min_t/max_t
5541 if ($^V && $^V ge 5.10.0 &&
5543 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5544 if (defined $2 || defined $7) {
5546 my $cast1 = deparenthesize
($2);
5548 my $cast2 = deparenthesize
($7);
5552 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5553 $cast = "$cast1 or $cast2";
5554 } elsif ($cast1 ne "") {
5560 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5564 # check usleep_range arguments
5565 if ($^V && $^V ge 5.10.0 &&
5567 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5571 WARN
("USLEEP_RANGE",
5572 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5573 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5575 WARN
("USLEEP_RANGE",
5576 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5580 # check for naked sscanf
5581 if ($^V && $^V ge 5.10.0 &&
5583 $line =~ /\bsscanf\b/ &&
5584 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5585 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5586 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5587 my $lc = $stat =~ tr
@\n@@;
5588 $lc = $lc + $linenr;
5589 my $stat_real = raw_line
($linenr, 0);
5590 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5591 $stat_real = $stat_real . "\n" . raw_line
($count, 0);
5593 WARN
("NAKED_SSCANF",
5594 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5597 # check for simple sscanf that should be kstrto<foo>
5598 if ($^V && $^V ge 5.10.0 &&
5600 $line =~ /\bsscanf\b/) {
5601 my $lc = $stat =~ tr
@\n@@;
5602 $lc = $lc + $linenr;
5603 my $stat_real = raw_line
($linenr, 0);
5604 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5605 $stat_real = $stat_real . "\n" . raw_line
($count, 0);
5607 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5609 my $count = $format =~ tr
@%@%@;
5611 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5612 WARN
("SSCANF_TO_KSTRTO",
5613 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5618 # check for new externs in .h files.
5619 if ($realfile =~ /\.h$/ &&
5620 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5621 if (CHK
("AVOID_EXTERNS",
5622 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5624 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5628 # check for new externs in .c files.
5629 if ($realfile =~ /\.c$/ && defined $stat &&
5630 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5632 my $function_name = $1;
5633 my $paren_space = $2;
5636 if (defined $cond) {
5637 substr($s, 0, length($cond), '');
5639 if ($s =~ /^\s*;/ &&
5640 $function_name ne 'uninitialized_var')
5642 WARN
("AVOID_EXTERNS",
5643 "externs should be avoided in .c files\n" . $herecurr);
5646 if ($paren_space =~ /\n/) {
5647 WARN
("FUNCTION_ARGUMENTS",
5648 "arguments for function declarations should follow identifier\n" . $herecurr);
5651 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5652 $stat =~ /^.\s*extern\s+/)
5654 WARN
("AVOID_EXTERNS",
5655 "externs should be avoided in .c files\n" . $herecurr);
5658 # checks for new __setup's
5659 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5662 if (!grep(/$name/, @setup_docs)) {
5663 CHK
("UNDOCUMENTED_SETUP",
5664 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
5668 # check for pointless casting of kmalloc return
5669 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5670 WARN
("UNNECESSARY_CASTS",
5671 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5675 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5676 if ($^V && $^V ge 5.10.0 &&
5677 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5678 CHK
("ALLOC_SIZEOF_STRUCT",
5679 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5682 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5683 if ($^V && $^V ge 5.10.0 &&
5684 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5688 my $newfunc = "kmalloc_array";
5689 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5692 if ($a1 =~ /^sizeof\s*\S/) {
5696 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5697 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5698 if (WARN
("ALLOC_WITH_MULTIPLY",
5699 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5701 $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;
5707 # check for krealloc arg reuse
5708 if ($^V && $^V ge 5.10.0 &&
5709 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5710 WARN
("KREALLOC_ARG_REUSE",
5711 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5714 # check for alloc argument mismatch
5715 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5716 WARN
("ALLOC_ARRAY_ARGS",
5717 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5720 # check for multiple semicolons
5721 if ($line =~ /;\s*;\s*$/) {
5722 if (WARN
("ONE_SEMICOLON",
5723 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5725 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5729 # check for #defines like: 1 << <digit> that could be BIT(digit)
5730 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5732 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5733 if (CHK
("BIT_MACRO",
5734 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5736 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5740 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
5741 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
5743 if (WARN
("PREFER_IS_ENABLED",
5744 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
5746 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
5750 # check for case / default statements not preceded by break/fallthrough/switch
5751 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5753 my $has_statement = 0;
5755 my $prevline = $linenr;
5756 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5758 my $rline = $rawlines[$prevline - 1];
5759 my $fline = $lines[$prevline - 1];
5760 last if ($fline =~ /^\@\@/);
5761 next if ($fline =~ /^\-/);
5762 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5763 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5764 next if ($fline =~ /^.[\s$;]*$/);
5767 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5769 if (!$has_break && $has_statement) {
5770 WARN
("MISSING_BREAK",
5771 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5775 # check for switch/default statements without a break;
5776 if ($^V && $^V ge 5.10.0 &&
5778 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5780 my $herectx = $here . "\n";
5781 my $cnt = statement_rawlines
($stat);
5782 for (my $n = 0; $n < $cnt; $n++) {
5783 $herectx .= raw_line
($linenr, $n) . "\n";
5785 WARN
("DEFAULT_NO_BREAK",
5786 "switch default: should use break\n" . $herectx);
5789 # check for gcc specific __FUNCTION__
5790 if ($line =~ /\b__FUNCTION__\b/) {
5791 if (WARN
("USE_FUNC",
5792 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5794 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5798 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
5799 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5801 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5804 # check for use of yield()
5805 if ($line =~ /\byield\s*\(\s*\)/) {
5807 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5810 # check for comparisons against true and false
5811 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5819 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5821 my $type = lc($otype);
5822 if ($type =~ /^(?:true|false)$/) {
5823 if (("$test" eq "==" && "$type" eq "true") ||
5824 ("$test" eq "!=" && "$type" eq "false")) {
5828 CHK
("BOOL_COMPARISON",
5829 "Using comparison to $otype is error prone\n" . $herecurr);
5831 ## maybe suggesting a correct construct would better
5832 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5837 # check for semaphores initialized locked
5838 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
5839 WARN
("CONSIDER_COMPLETION",
5840 "consider using a completion\n" . $herecurr);
5843 # recommend kstrto* over simple_strto* and strict_strto*
5844 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5845 WARN
("CONSIDER_KSTRTO",
5846 "$1 is obsolete, use k$3 instead\n" . $herecurr);
5849 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
5850 if ($line =~ /^.\s*__initcall\s*\(/) {
5851 WARN
("USE_DEVICE_INITCALL",
5852 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5855 # check for various structs that are normally const (ops, kgdb, device_tree)
5856 my $const_structs = qr{
5858 address_space_operations
|
5860 block_device_operations
|
5865 file_lock_operations
|
5875 lock_manager_operations
|
5882 pipe_buf_operations
|
5883 platform_hibernation_ops
|
5884 platform_suspend_ops
|
5889 soc_pcmcia_socket_ops
|
5896 if ($line !~ /\bconst\b/ &&
5897 $line =~ /\bstruct\s+($const_structs)\b/) {
5898 WARN
("CONST_STRUCT",
5899 "struct $1 should normally be const\n" .
5903 # use of NR_CPUS is usually wrong
5904 # ignore definitions of NR_CPUS and usage to define arrays as likely right
5905 if ($line =~ /\bNR_CPUS\b/ &&
5906 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5907 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
5908 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5909 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5910 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
5913 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
5916 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5917 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5918 ERROR
("DEFINE_ARCH_HAS",
5919 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5922 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
5923 if ($^V && $^V ge 5.10.0 &&
5924 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5925 WARN
("LIKELY_MISUSE",
5926 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5929 # whine mightly about in_atomic
5930 if ($line =~ /\bin_atomic\s*\(/) {
5931 if ($realfile =~ m
@^drivers/@) {
5933 "do not use in_atomic in drivers\n" . $herecurr);
5934 } elsif ($realfile !~ m
@^kernel/@) {
5936 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5940 # whine about ACCESS_ONCE
5941 if ($^V && $^V ge 5.10.0 &&
5942 $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
5946 $par =~ s/^\(\s*(.*)\s*\)$/$1/;
5948 if (WARN
("PREFER_WRITE_ONCE",
5949 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
5951 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
5954 if (WARN
("PREFER_READ_ONCE",
5955 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
5957 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
5962 # check for lockdep_set_novalidate_class
5963 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5964 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5965 if ($realfile !~ m
@^kernel/lockdep@ &&
5966 $realfile !~ m
@^include/linux/lockdep@ &&
5967 $realfile !~ m
@^drivers/base/core@) {
5969 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5973 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5974 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
5975 WARN
("EXPORTED_WORLD_WRITABLE",
5976 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5979 # Mode permission misuses where it seems decimal should be octal
5980 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5981 if ($^V && $^V ge 5.10.0 &&
5982 $line =~ /$mode_perms_search/) {
5983 foreach my $entry (@mode_permission_funcs) {
5984 my $func = $entry->[0];
5985 my $arg_pos = $entry->[1];
5990 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5992 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5993 if ($line =~ /$test/) {
5995 $val = $6 if ($skip_args ne "");
5997 if ($val !~ /^0$/ &&
5998 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5999 length($val) ne 4)) {
6000 ERROR
("NON_OCTAL_PERMISSIONS",
6001 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
6002 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6003 ERROR
("EXPORTED_WORLD_WRITABLE",
6004 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6010 # validate content of MODULE_LICENSE against list from include/linux/module.h
6011 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6012 my $extracted_string = get_quoted_string
($line, $rawline);
6013 my $valid_licenses = qr{
6016 GPL\
and\ additional\ rights
|
6022 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6023 WARN
("MODULE_LICENSE",
6024 "unknown module license " . $extracted_string . "\n" . $herecurr);
6029 # If we have no input at all, then there is nothing to report on
6030 # so just keep quiet.
6031 if ($#rawlines == -1) {
6035 # In mailback mode only produce a report in the negative, for
6036 # things that appear to be patches.
6037 if ($mailback && ($clean == 1 || !$is_patch)) {
6041 # This is not a patch, and we are are in 'no-patch' mode so
6043 if (!$chk_patch && !$is_patch) {
6047 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
6048 ERROR
("NOT_UNIFIED_DIFF",
6049 "Does not appear to be a unified-diff format patch\n");
6051 if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
6052 ERROR
("MISSING_SIGN_OFF",
6053 "Missing Signed-off-by: line(s)\n");
6056 print report_dump
();
6057 if ($summary && !($clean == 1 && $quiet == 1)) {
6058 print "$filename " if ($summary_file);
6059 print "total: $cnt_error errors, $cnt_warn warnings, " .
6060 (($check)?
"$cnt_chk checks, " : "") .
6061 "$cnt_lines lines checked\n";
6065 # If there were any defects found and not already fixing them
6066 if (!$clean and !$fix) {
6069 NOTE
: For some of the reported defects
, checkpatch may be able to
6070 mechanically convert to the typical style using
--fix
or --fix-inplace
.
6073 # If there were whitespace errors which cleanpatch can fix
6074 # then suggest that.
6075 if ($rpt_cleaners) {
6079 NOTE
: Whitespace errors detected
.
6080 You may wish to
use scripts
/cleanpatch or scripts/cleanfile
6085 if ($clean == 0 && $fix &&
6086 ("@rawlines" ne "@fixed" ||
6087 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6088 my $newfile = $filename;
6089 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6093 @fixed = fix_inserted_deleted_lines
(\
@fixed, \
@fixed_inserted, \
@fixed_deleted);
6095 open($f, '>', $newfile)
6096 or die "$P: Can't open $newfile for write\n";
6097 foreach my $fixed_line (@fixed) {
6100 if ($linecount > 3) {
6101 $fixed_line =~ s/^\+//;
6102 print $f $fixed_line . "\n";
6105 print $f $fixed_line . "\n";
6113 Wrote EXPERIMENTAL
--fix correction
(s
) to
'$newfile'
6115 Do _NOT_ trust the results written to this file
.
6116 Do _NOT_ submit these changes without inspecting them
for correctness
.
6118 This EXPERIMENTAL file
is simply a convenience to help rewrite patches
.
6119 No warranties
, expressed
or implied
...
6127 print "$vname has no obvious style problems and is ready for submission.\n";
6129 print "$vname has style problems, please review.\n";