2 # SPDX-License-Identifier: GPL-2.0
4 # (c) 2001, Dave Jones. (the file handling bit)
5 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
6 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
7 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
8 # (c) 2010-2018 Joe Perches <joe@perches.com>
15 use Term
::ANSIColor
qw(:constants);
18 my $D = dirname
(abs_path
($P));
22 use Getopt
::Long
qw(:config no_auto_abbrev);
52 my $configuration_file = ".checkpatch.conf";
53 my $max_line_length = 80;
54 my $ignore_perl_version = 0;
55 my $minimum_perl_version = 5.10.0;
56 my $min_conf_desc_length = 4;
57 my $spelling_file = "$D/spelling.txt";
59 my $codespellfile = "/usr/share/codespell/dictionary.txt";
60 my $conststructsfile = "$D/const_structs.checkpatch";
61 my $typedefsfile = "";
63 my $allow_c99_comments = 1;
69 Usage
: $P [OPTION
]... [FILE
]...
74 --no-tree run without a kernel tree
75 --no-signoff
do not check
for 'Signed-off-by' line
76 --patch treat FILE as patchfile
(default)
77 --emacs emacs compile window format
78 --terse one line per report
79 --showfile emit diffed file position
, not input file position
80 -g
, --git treat FILE as a single commit
or git revision range
81 single git commit with
:
85 multiple git commits with
:
89 git merges are ignored
90 -f
, --file treat FILE as regular source file
91 --subjective
, --strict enable more subjective tests
92 --list-types list the possible message types
93 --types TYPE
(,TYPE2
...) show only these comma separated message types
94 --ignore TYPE
(,TYPE2
...) ignore various comma separated message types
95 --show-types show the specific message type
in the output
96 --max-line-length
=n set the maximum line
length, if exceeded
, warn
97 --min-conf-desc-length
=n set the min description
length, if shorter
, warn
98 --root
=PATH PATH to the kernel tree root
99 --no-summary suppress the per-file summary
100 --mailback only produce a report
in case of warnings
/errors
101 --summary-file include the filename
in summary
102 --debug KEY
=[0|1] turn on
/off debugging of KEY
, where KEY
is one of
103 'values', 'possible', 'type', and 'attr' (default
105 --test-only
=WORD report only warnings
/errors containing WORD
107 --fix EXPERIMENTAL
- may create horrible results
108 If correctable single-line errors exist
, create
109 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
110 with potential errors corrected to the preferred
112 --fix-inplace EXPERIMENTAL
- may create horrible results
113 Is the same as
--fix
, but overwrites the input
114 file
. It
's your fault if there's
no backup
or git
115 --ignore-perl-version override checking of perl version
. expect
117 --codespell Use the codespell dictionary
for spelling
/typos
118 (default:/usr/share
/codespell/dictionary
.txt
)
119 --codespellfile Use this codespell dictionary
120 --typedefsfile Read additional types from this file
121 --color
[=WHEN
] Use colors
'always', 'never', or only
when output
122 is a terminal
('auto'). Default
is 'auto'.
123 -h
, --help
, --version display this help
and exit
125 When FILE
is - read standard input
.
133 return grep { !$seen{$_}++ } @_;
143 open(my $script, '<', abs_path
($P)) or
144 die "$P: Can't read '$P' $!\n";
146 my $text = <$script>;
150 # Also catch when type or level is passed through a variable
151 for ($text =~ /(?:(?:\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
154 @types = sort(uniq
(@types));
155 print("#\tMessage type\n\n");
156 foreach my $type (@types) {
157 print(++$count . "\t" . $type . "\n");
163 my $conf = which_conf
($configuration_file);
166 open(my $conffile, '<', "$conf")
167 or warn "$P: Can't find a readable $configuration_file file $!\n";
169 while (<$conffile>) {
172 $line =~ s/\s*\n?$//g;
176 next if ($line =~ m/^\s*#/);
177 next if ($line =~ m/^\s*$/);
179 my @words = split(" ", $line);
180 foreach my $word (@words) {
181 last if ($word =~ m/^#/);
182 push (@conf_args, $word);
186 unshift(@ARGV, @conf_args) if @conf_args;
189 # Perl's Getopt::Long allows options to take optional arguments after a space.
190 # Prevent --color by itself from consuming other arguments
192 if ($_ eq "--color" || $_ eq "-color") {
193 $_ = "--color=$color";
198 'q|quiet+' => \
$quiet,
200 'signoff!' => \
$chk_signoff,
201 'patch!' => \
$chk_patch,
204 'showfile!' => \
$showfile,
207 'subjective!' => \
$check,
208 'strict!' => \
$check,
209 'ignore=s' => \
@ignore,
211 'show-types!' => \
$show_types,
212 'list-types!' => \
$list_types,
213 'max-line-length=i' => \
$max_line_length,
214 'min-conf-desc-length=i' => \
$min_conf_desc_length,
216 'summary!' => \
$summary,
217 'mailback!' => \
$mailback,
218 'summary-file!' => \
$summary_file,
220 'fix-inplace!' => \
$fix_inplace,
221 'ignore-perl-version!' => \
$ignore_perl_version,
222 'debug=s' => \
%debug,
223 'test-only=s' => \
$tst_only,
224 'codespell!' => \
$codespell,
225 'codespellfile=s' => \
$codespellfile,
226 'typedefsfile=s' => \
$typedefsfile,
227 'color=s' => \
$color,
228 'no-color' => \
$color, #keep old behaviors of -nocolor
229 'nocolor' => \
$color, #keep old behaviors of -nocolor
236 list_types
(0) if ($list_types);
238 $fix = 1 if ($fix_inplace);
239 $check_orig = $check;
243 if ($^V && $^V lt $minimum_perl_version) {
244 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
245 if (!$ignore_perl_version) {
250 #if no filenames are given, push '-' to read patch from stdin
255 if ($color =~ /^[01]$/) {
257 } elsif ($color =~ /^always$/i) {
259 } elsif ($color =~ /^never$/i) {
261 } elsif ($color =~ /^auto$/i) {
262 $color = (-t STDOUT
);
264 die "Invalid color mode: $color\n";
267 sub hash_save_array_words
{
268 my ($hashRef, $arrayRef) = @_;
270 my @array = split(/,/, join(',', @$arrayRef));
271 foreach my $word (@array) {
272 $word =~ s/\s*\n?$//g;
275 $word =~ tr/[a-z]/[A-Z]/;
277 next if ($word =~ m/^\s*#/);
278 next if ($word =~ m/^\s*$/);
284 sub hash_show_words
{
285 my ($hashRef, $prefix) = @_;
287 if (keys %$hashRef) {
288 print "\nNOTE: $prefix message types:";
289 foreach my $word (sort keys %$hashRef) {
296 hash_save_array_words
(\
%ignore_type, \
@ignore);
297 hash_save_array_words
(\
%use_type, \
@use);
300 my $dbg_possible = 0;
303 for my $key (keys %debug) {
305 eval "\${dbg_$key} = '$debug{$key}';";
309 my $rpt_cleaners = 0;
318 if (!top_of_kernel_tree
($root)) {
319 die "$P: $root: --root does not point at a valid tree\n";
322 if (top_of_kernel_tree
('.')) {
324 } elsif ($0 =~ m
@(.*)/scripts/[^/]*$@ &&
325 top_of_kernel_tree
($1)) {
330 if (!defined $root) {
331 print "Must be run from the top-level dir. of a kernel tree\n";
336 my $emitted_corrupt = 0;
339 [A-Za-z_
][A-Za-z\d_
]*
340 (?
:\s
*\#\#\s
*[A-Za-z_
][A-Za-z\d_
]*)*
342 our $Storage = qr{extern|static|asmlinkage};
355 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
356 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
357 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
358 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
359 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
361 # Notes to $Attribute:
362 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
383 ____cacheline_aligned
|
384 ____cacheline_aligned_in_smp
|
385 ____cacheline_internodealigned_in_smp
|
389 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
390 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
391 our $Lval = qr{$Ident(?:$Member)*};
393 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
394 our $Binary = qr{(?i)0b[01]+$Int_type?};
395 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
396 our $Int = qr{[0-9]+$Int_type?};
397 our $Octal = qr{0[0-7]+$Int_type?};
398 our $String = qr{"[X\t]*"};
399 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
400 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
401 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
402 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
403 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
404 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
405 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
406 our $Arithmetic = qr{\+|-|\*|\/|%};
410 &&|\
|\
||,|\
^|\
+\
+|--|&|\
||$Arithmetic
413 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
417 our $NonptrTypeMisordered;
418 our $NonptrTypeWithAttr;
422 our $DeclareMisordered;
424 our $NON_ASCII_UTF8 = qr{
425 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
426 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
427 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
428 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
429 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
430 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
431 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
435 [\x09\x0A\x0D\x20-\x7E] # ASCII
439 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
440 our $typeOtherOSTypedefs = qr{(?x
:
441 u_
(?
:char
|short
|int|long
) | # bsd
442 u
(?
:nchar
|short
|int|long
) # sysv
444 our $typeKernelTypedefs = qr{(?x
:
445 (?
:__
)?
(?
:u
|s
|be
|le)(?
:8|16|32|64)|
448 our $typeTypedefs = qr{(?x
:
450 $typeOtherOSTypedefs\b|
451 $typeKernelTypedefs\b
454 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
456 our $logFunctions = qr{(?x
:
457 printk
(?
:_ratelimited
|_once
|_deferred_once
|_deferred
|)|
458 (?
:[a-z0-9
]+_
){1,2}(?
:printk
|emerg
|alert
|crit
|err
|warning
|warn|notice
|info
|debug
|dbg
|vdbg
|devel
|cont
|WARN
)(?
:_ratelimited
|_once
|)|
460 WARN
(?
:_RATELIMIT
|_ONCE
|)|
463 seq_vprintf
|seq_printf
|seq_puts
466 our $signature_tags = qr{(?xi
:
477 our @typeListMisordered = (
478 qr{char\s+(?:un)?signed},
479 qr{int\s+(?:(?:un)?signed\s+)?short\s},
480 qr{int\s+short(?:\s+(?:un)?signed)},
481 qr{short\s+int(?:\s+(?:un)?signed)},
482 qr{(?:un)?signed\s+int\s+short},
483 qr{short\s+(?:un)?signed},
484 qr{long\s+int\s+(?:un)?signed},
485 qr{int\s+long\s+(?:un)?signed},
486 qr{long\s+(?:un)?signed\s+int},
487 qr{int\s+(?:un)?signed\s+long},
488 qr{int\s+(?:un)?signed},
489 qr{int\s+long\s+long\s+(?:un)?signed},
490 qr{long\s+long\s+int\s+(?:un)?signed},
491 qr{long\s+long\s+(?:un)?signed\s+int},
492 qr{long\s+long\s+(?:un)?signed},
493 qr{long\s+(?:un)?signed},
498 qr{(?:(?:un)?signed\s+)?char},
499 qr{(?:(?:un)?signed\s+)?short\s+int},
500 qr{(?:(?:un)?signed\s+)?short},
501 qr{(?:(?:un)?signed\s+)?int},
502 qr{(?:(?:un)?signed\s+)?long\s+int},
503 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
504 qr{(?:(?:un)?signed\s+)?long\s+long},
505 qr{(?:(?:un)?signed\s+)?long},
514 qr{${Ident}_handler
},
515 qr{${Ident}_handler_fn
},
519 our $C90_int_types = qr{(?x
:
520 long\s
+long\s
+int\s
+(?
:un
)?signed
|
521 long\s
+long\s
+(?
:un
)?signed\s
+int|
522 long\s
+long\s
+(?
:un
)?signed
|
523 (?
:(?
:un
)?signed\s
+)?long\s
+long\s
+int|
524 (?
:(?
:un
)?signed\s
+)?long\s
+long
|
525 int\s
+long\s
+long\s
+(?
:un
)?signed
|
526 int\s
+(?
:(?
:un
)?signed\s
+)?long\s
+long
|
528 long\s
+int\s
+(?
:un
)?signed
|
529 long\s
+(?
:un
)?signed\s
+int|
530 long\s
+(?
:un
)?signed
|
531 (?
:(?
:un
)?signed\s
+)?long\s
+int|
532 (?
:(?
:un
)?signed\s
+)?long
|
533 int\s
+long\s
+(?
:un
)?signed
|
534 int\s
+(?
:(?
:un
)?signed\s
+)?long
|
537 (?
:(?
:un
)?signed\s
+)?
int
540 our @typeListFile = ();
541 our @typeListWithAttr = (
543 qr{struct\s+$InitAttribute\s+$Ident},
544 qr{union\s+$InitAttribute\s+$Ident},
547 our @modifierList = (
550 our @modifierListFile = ();
552 our @mode_permission_funcs = (
554 ["module_param_(?:array|named|string)", 4],
555 ["module_param_array_named", 5],
556 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
557 ["proc_create(?:_data|)", 2],
558 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
559 ["IIO_DEV_ATTR_[A-Z_]+", 1],
560 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
561 ["SENSOR_TEMPLATE(?:_2|)", 3],
565 #Create a search pattern for all these functions to speed up a loop below
566 our $mode_perms_search = "";
567 foreach my $entry (@mode_permission_funcs) {
568 $mode_perms_search .= '|' if ($mode_perms_search ne "");
569 $mode_perms_search .= $entry->[0];
571 $mode_perms_search = "(?:${mode_perms_search})";
573 our $mode_perms_world_writable = qr{
581 our %mode_permission_string_types = (
600 #Create a search pattern for all these strings to speed up a loop below
601 our $mode_perms_string_search = "";
602 foreach my $entry (keys %mode_permission_string_types) {
603 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
604 $mode_perms_string_search .= $entry;
606 our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
607 our $multi_mode_perms_string_search = qr{
608 ${single_mode_perms_string_search
}
609 (?
:\s
*\
|\s
*${single_mode_perms_string_search
})*
615 return trim
($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
622 while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
623 $curpos = pos($string);
626 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
628 $to |= $mode_permission_string_types{$match};
629 $val .= '\s*\|\s*' if ($val ne "");
633 $oval =~ s/^\s*\|\s*//;
634 $oval =~ s/\s*\|\s*$//;
635 return sprintf("%04o", $to);
638 our $allowed_asm_includes = qr{(?x
:
644 # memory.h: ARM has a custom one
646 # Load common spelling mistakes and build regular expression list.
650 if (open(my $spelling, '<', $spelling_file)) {
651 while (<$spelling>) {
654 $line =~ s/\s*\n?$//g;
657 next if ($line =~ m/^\s*#/);
658 next if ($line =~ m/^\s*$/);
660 my ($suspect, $fix) = split(/\|\|/, $line);
662 $spelling_fix{$suspect} = $fix;
666 warn "No typos will be found - file '$spelling_file': $!\n";
670 if (open(my $spelling, '<', $codespellfile)) {
671 while (<$spelling>) {
674 $line =~ s/\s*\n?$//g;
677 next if ($line =~ m/^\s*#/);
678 next if ($line =~ m/^\s*$/);
679 next if ($line =~ m/, disabled/i);
683 my ($suspect, $fix) = split(/->/, $line);
685 $spelling_fix{$suspect} = $fix;
689 warn "No codespell typos will be found - file '$codespellfile': $!\n";
693 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
696 my ($wordsRef, $file) = @_;
698 if (open(my $words, '<', $file)) {
702 $line =~ s/\s*\n?$//g;
705 next if ($line =~ m/^\s*#/);
706 next if ($line =~ m/^\s*$/);
708 print("$file: '$line' invalid - ignored\n");
712 $$wordsRef .= '|' if ($$wordsRef ne "");
722 my $const_structs = "";
723 read_words
(\
$const_structs, $conststructsfile)
724 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
726 my $typeOtherTypedefs = "";
727 if (length($typedefsfile)) {
728 read_words
(\
$typeOtherTypedefs, $typedefsfile)
729 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
731 $typeTypedefs .= '|' . $typeOtherTypedefs if ($typeOtherTypedefs ne "");
734 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
735 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
736 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
737 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
738 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
744 (?
:$Modifier\s+|const\s
+)*
746 (?
:typeof
|__typeof__
)\s
*\
([^\
)]*\
)|
750 (?
:\s
+$Modifier|\s
+const
)*
752 $NonptrTypeMisordered = qr{
753 (?
:$Modifier\s+|const\s
+)*
757 (?
:\s
+$Modifier|\s
+const
)*
759 $NonptrTypeWithAttr = qr{
760 (?
:$Modifier\s+|const\s
+)*
762 (?
:typeof
|__typeof__
)\s
*\
([^\
)]*\
)|
766 (?
:\s
+$Modifier|\s
+const
)*
770 (?
:(?
:\s
|\
*|\
[\
])+\s
*const
|(?
:\s
|\
*\s
*(?
:const\s
*)?
|\
[\
])+|(?
:\s
*\
[\s
*\
])+)?
771 (?
:\s
+$Inline|\s
+$Modifier)*
773 $TypeMisordered = qr{
774 $NonptrTypeMisordered
775 (?
:(?
:\s
|\
*|\
[\
])+\s
*const
|(?
:\s
|\
*\s
*(?
:const\s
*)?
|\
[\
])+|(?
:\s
*\
[\s
*\
])+)?
776 (?
:\s
+$Inline|\s
+$Modifier)*
778 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
779 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
783 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s
*};
785 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
786 # requires at least perl version v5.10.0
787 # Any use must be runtime checked with $^V
789 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
790 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s
*};
791 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
793 our $declaration_macros = qr{(?x
:
794 (?
:$Storage\s+)?
(?
:[A-Z_
][A-Z0-9
]*_
){0,2}(?
:DEFINE
|DECLARE
)(?
:_
[A-Z0-9
]+){1,6}\s
*\
(|
795 (?
:$Storage\s+)?
[HLP
]?LIST_HEAD\s
*\
(|
796 (?
:$Storage\s+)?
${Type
}\s
+uninitialized_var\s
*\
(|
797 (?
:SKCIPHER_REQUEST
|SHASH_DESC
|AHASH_REQUEST
)_ON_STACK\s
*\
(
802 return "" if (!defined($string));
804 while ($string =~ /^\s*\(.*\)\s*$/) {
805 $string =~ s
@^\s*\(\s
*@@;
806 $string =~ s
@\s*\)\s
*$@@;
809 $string =~ s
@\s+@ @g;
814 sub seed_camelcase_file
{
817 return if (!(-f
$file));
821 open(my $include_file, '<', "$file")
822 or warn "$P: Can't read '$file' $!\n";
823 my $text = <$include_file>;
824 close($include_file);
826 my @lines = split('\n', $text);
828 foreach my $line (@lines) {
829 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
830 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
832 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
834 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
840 sub is_maintained_obsolete
{
843 return 0 if (!$tree || !(-e
"$root/scripts/get_maintainer.pl"));
845 my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
847 return $status =~ /obsolete/i;
850 my $camelcase_seeded = 0;
851 sub seed_camelcase_includes
{
852 return if ($camelcase_seeded);
855 my $camelcase_cache = "";
856 my @include_files = ();
858 $camelcase_seeded = 1;
861 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
862 chomp $git_last_include_commit;
863 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
865 my $last_mod_date = 0;
866 $files = `find $root/include -name "*.h"`;
867 @include_files = split('\n', $files);
868 foreach my $file (@include_files) {
869 my $date = POSIX
::strftime
("%Y%m%d%H%M",
870 localtime((stat $file)[9]));
871 $last_mod_date = $date if ($last_mod_date < $date);
873 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
876 if ($camelcase_cache ne "" && -f
$camelcase_cache) {
877 open(my $camelcase_file, '<', "$camelcase_cache")
878 or warn "$P: Can't read '$camelcase_cache' $!\n";
879 while (<$camelcase_file>) {
883 close($camelcase_file);
889 $files = `git ls-files "include/*.h"`;
890 @include_files = split('\n', $files);
893 foreach my $file (@include_files) {
894 seed_camelcase_file
($file);
897 if ($camelcase_cache ne "") {
898 unlink glob ".checkpatch-camelcase.*";
899 open(my $camelcase_file, '>', "$camelcase_cache")
900 or warn "$P: Can't write '$camelcase_cache' $!\n";
901 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
902 print $camelcase_file ("$_\n");
904 close($camelcase_file);
908 sub git_commit_info
{
909 my ($commit, $id, $desc) = @_;
911 return ($id, $desc) if ((which
("git") eq "") || !(-e
".git"));
913 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
914 $output =~ s/^\s*//gm;
915 my @lines = split("\n", $output);
917 return ($id, $desc) if ($#lines < 0);
919 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
920 # Maybe one day convert this block of bash into something that returns
921 # all matching commit ids, but it's very slow...
923 # echo "checking commits $1..."
924 # git rev-list --remotes | grep -i "^$1" |
925 # while read line ; do
926 # git log --format='%H %s' -1 $line |
927 # echo "commit $(cut -c 1-12,41-)"
929 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
932 $id = substr($lines[0], 0, 12);
933 $desc = substr($lines[0], 41);
939 $chk_signoff = 0 if ($file);
944 my @fixed_inserted = ();
945 my @fixed_deleted = ();
948 # If input is git commits, extract all commits from the commit expressions.
949 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
950 die "$P: No git repository found\n" if ($git && !-e
".git");
954 foreach my $commit_expr (@ARGV) {
956 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
957 $git_range = "-$2 $1";
958 } elsif ($commit_expr =~ m/\.\./) {
959 $git_range = "$commit_expr";
961 $git_range = "-1 $commit_expr";
963 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
964 foreach my $line (split(/\n/, $lines)) {
965 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
966 next if (!defined($1) || !defined($2));
969 unshift(@commits, $sha1);
970 $git_commits{$sha1} = $subject;
973 die "$P: no git commits after extraction!\n" if (@commits == 0);
978 for my $filename (@ARGV) {
981 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
982 die "$P: $filename: git format-patch failed - $!\n";
984 open($FILE, '-|', "diff -u /dev/null $filename") ||
985 die "$P: $filename: diff failed - $!\n";
986 } elsif ($filename eq '-') {
987 open($FILE, '<&STDIN');
989 open($FILE, '<', "$filename") ||
990 die "$P: $filename: open failed - $!\n";
992 if ($filename eq '-') {
993 $vname = 'Your patch';
995 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1001 push(@rawlines, $_);
1005 if ($#ARGV > 0 && $quiet == 0) {
1006 print '-' x length($vname) . "\n";
1008 print '-' x length($vname) . "\n";
1011 if (!process($filename)) {
1017 @fixed_inserted = ();
1018 @fixed_deleted = ();
1020 @modifierListFile = ();
1026 hash_show_words(\%use_type, "Used");
1027 hash_show_words(\%ignore_type, "Ignored");
1029 if ($^V lt 5.10.0) {
1032 NOTE: perl $^V is not modern enough to detect all possible issues.
1033 An upgrade to at least perl v5.10.0 is suggested.
1039 NOTE: If any of the errors are false positives, please report
1040 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1047 sub top_of_kernel_tree {
1051 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1052 "README", "Documentation", "arch", "include", "drivers",
1053 "fs", "init", "ipc", "kernel", "lib", "scripts",
1056 foreach my $check (@tree_check) {
1057 if (! -e $root . '/' . $check) {
1065 my ($formatted_email) = @_;
1071 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1074 $comment = $3 if defined $3;
1075 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1077 $comment = $2 if defined $2;
1078 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1080 $comment = $2 if defined $2;
1081 $formatted_email =~ s/\Q$address\E.*$//;
1082 $name = $formatted_email;
1083 $name = trim($name);
1084 $name =~ s/^\"|\"$//g;
1085 # If there's a name left after stripping spaces and
1086 # leading quotes, and the address doesn't have both
1087 # leading and trailing angle brackets, the address
1089 # "joe smith joe@smith.com" bad
1090 # "joe smith <joe@smith.com" bad
1091 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1098 $name = trim($name);
1099 $name =~ s/^\"|\"$//g;
1100 $address = trim($address);
1101 $address =~ s/^\<|\>$//g;
1103 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1104 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1105 $name = "\"$name\"";
1108 return ($name, $address, $comment);
1112 my ($name, $address) = @_;
1114 my $formatted_email;
1116 $name = trim($name);
1117 $name =~ s/^\"|\"$//g;
1118 $address = trim($address);
1120 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1121 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1122 $name = "\"$name\"";
1125 if ("$name" eq "") {
1126 $formatted_email = "$address";
1128 $formatted_email = "$name <$address>";
1131 return $formatted_email;
1137 foreach my $path (split(/:/, $ENV{PATH})) {
1138 if (-e "$path/$bin") {
1139 return "$path/$bin";
1149 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1150 if (-e "$path/$conf") {
1151 return "$path/$conf";
1163 for my $c (split(//, $str)) {
1167 for (; ($n % 8) != 0; $n++) {
1179 (my $res = shift) =~ tr/\t/ /c;
1186 # Drop the diff line leader and expand tabs
1188 $line = expand_tabs($line);
1190 # Pick the indent from the front of the line.
1191 my ($white) = ($line =~ /^(\s*)/);
1193 return (length($line), length($white));
1196 my $sanitise_quote = '';
1198 sub sanitise_line_reset {
1199 my ($in_comment) = @_;
1202 $sanitise_quote = '*/';
1204 $sanitise_quote = '';
1217 # Always copy over the diff marker.
1218 $res = substr($line, 0, 1);
1220 for ($off = 1; $off < length($line); $off++) {
1221 $c = substr($line, $off, 1);
1223 # Comments we are whacking completely including the begin
1224 # and end, all to $;.
1225 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1226 $sanitise_quote = '*/';
1228 substr($res, $off, 2, "$;$;");
1232 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1233 $sanitise_quote = '';
1234 substr($res, $off, 2, "$;$;");
1238 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1239 $sanitise_quote = '//';
1241 substr($res, $off, 2, $sanitise_quote);
1246 # A \ in a string means ignore the next character.
1247 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1249 substr($res, $off, 2, 'XX');
1254 if ($c eq "'" || $c eq '"') {
1255 if ($sanitise_quote eq '') {
1256 $sanitise_quote = $c;
1258 substr($res, $off, 1, $c);
1260 } elsif ($sanitise_quote eq $c) {
1261 $sanitise_quote = '';
1265 #print "c<$c> SQ<$sanitise_quote>\n";
1266 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1267 substr($res, $off, 1, $;);
1268 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1269 substr($res, $off, 1, $;);
1270 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1271 substr($res, $off, 1, 'X');
1273 substr($res, $off, 1, $c);
1277 if ($sanitise_quote eq '//') {
1278 $sanitise_quote = '';
1281 # The pathname on a #include may be surrounded by '<' and '>'.
1282 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1283 my $clean = 'X' x length($1);
1284 $res =~ s@\<.*\>@<$clean>@;
1286 # The whole of a #error is a string.
1287 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1288 my $clean = 'X' x length($1);
1289 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1292 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1294 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1300 sub get_quoted_string {
1301 my ($line, $rawline) = @_;
1303 return "" if (!defined($line) || !defined($rawline));
1304 return "" if ($line !~ m/($String)/g);
1305 return substr($rawline, $-[0], $+[0] - $-[0]);
1308 sub ctx_statement_block {
1309 my ($linenr, $remain, $off) = @_;
1310 my $line = $linenr - 1;
1313 my $coff = $off - 1;
1327 @stack = (['', 0]) if ($#stack == -1);
1329 #warn "CSB: blk<$blk> remain<$remain>\n";
1330 # If we are about to drop off the end, pull in more
1333 for (; $remain > 0; $line++) {
1334 last if (!defined $lines[$line]);
1335 next if ($lines[$line] =~ /^-/);
1338 $blk .= $lines[$line] . "\n";
1339 $len = length($blk);
1343 # Bail if there is no further context.
1344 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1348 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1354 $c = substr($blk, $off, 1);
1355 $remainder = substr($blk, $off);
1357 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1359 # Handle nested #if/#else.
1360 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1361 push(@stack, [ $type, $level ]);
1362 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1363 ($type, $level) = @{$stack[$#stack - 1]};
1364 } elsif ($remainder =~ /^#\s*endif\b/) {
1365 ($type, $level) = @{pop(@stack)};
1368 # Statement ends at the ';' or a close '}' at the
1370 if ($level == 0 && $c eq ';') {
1374 # An else is really a conditional as long as its not else if
1375 if ($level == 0 && $coff_set == 0 &&
1376 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1377 $remainder =~ /^(else)(?:\s|{)/ &&
1378 $remainder !~ /^else\s+if\b/) {
1379 $coff = $off + length($1) - 1;
1381 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1382 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1385 if (($type eq '' || $type eq '(') && $c eq '(') {
1389 if ($type eq '(' && $c eq ')') {
1391 $type = ($level != 0)? '(' : '';
1393 if ($level == 0 && $coff < $soff) {
1396 #warn "CSB: mark coff<$coff>\n";
1399 if (($type eq '' || $type eq '{') && $c eq '{') {
1403 if ($type eq '{' && $c eq '}') {
1405 $type = ($level != 0)? '{' : '';
1408 if (substr($blk, $off + 1, 1) eq ';') {
1414 # Preprocessor commands end at the newline unless escaped.
1415 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1423 # We are truly at the end, so shuffle to the next line.
1430 my $statement = substr($blk, $soff, $off - $soff + 1);
1431 my $condition = substr($blk, $soff, $coff - $soff + 1);
1433 #warn "STATEMENT<$statement>\n";
1434 #warn "CONDITION<$condition>\n";
1436 #print "coff<$coff> soff<$off> loff<$loff>\n";
1438 return ($statement, $condition,
1439 $line, $remain + 1, $off - $loff + 1, $level);
1442 sub statement_lines {
1445 # Strip the diff line prefixes and rip blank lines at start and end.
1446 $stmt =~ s/(^|\n)./$1/g;
1450 my @stmt_lines = ($stmt =~ /\n/g);
1452 return $#stmt_lines + 2;
1455 sub statement_rawlines {
1458 my @stmt_lines = ($stmt =~ /\n/g);
1460 return $#stmt_lines + 2;
1463 sub statement_block_size {
1466 $stmt =~ s/(^|\n)./$1/g;
1472 my @stmt_lines = ($stmt =~ /\n/g);
1473 my @stmt_statements = ($stmt =~ /;/g);
1475 my $stmt_lines = $#stmt_lines + 2;
1476 my $stmt_statements = $#stmt_statements + 1;
1478 if ($stmt_lines > $stmt_statements) {
1481 return $stmt_statements;
1485 sub ctx_statement_full {
1486 my ($linenr, $remain, $off) = @_;
1487 my ($statement, $condition, $level);
1491 # Grab the first conditional/block pair.
1492 ($statement, $condition, $linenr, $remain, $off, $level) =
1493 ctx_statement_block($linenr, $remain, $off);
1494 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1495 push(@chunks, [ $condition, $statement ]);
1496 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1497 return ($level, $linenr, @chunks);
1500 # Pull in the following conditional/block pairs and see if they
1501 # could continue the statement.
1503 ($statement, $condition, $linenr, $remain, $off, $level) =
1504 ctx_statement_block($linenr, $remain, $off);
1505 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1506 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1508 push(@chunks, [ $condition, $statement ]);
1511 return ($level, $linenr, @chunks);
1515 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1517 my $start = $linenr - 1;
1524 my @stack = ($level);
1525 for ($line = $start; $remain > 0; $line++) {
1526 next if ($rawlines[$line] =~ /^-/);
1529 $blk .= $rawlines[$line];
1531 # Handle nested #if/#else.
1532 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1533 push(@stack, $level);
1534 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1535 $level = $stack[$#stack - 1];
1536 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1537 $level = pop(@stack);
1540 foreach my $c (split(//, $lines[$line])) {
1541 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1547 if ($c eq $close && $level > 0) {
1549 last if ($level == 0);
1550 } elsif ($c eq $open) {
1555 if (!$outer || $level <= 1) {
1556 push(@res, $rawlines[$line]);
1559 last if ($level == 0);
1562 return ($level, @res);
1564 sub ctx_block_outer {
1565 my ($linenr, $remain) = @_;
1567 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1571 my ($linenr, $remain) = @_;
1573 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1577 my ($linenr, $remain, $off) = @_;
1579 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1582 sub ctx_block_level {
1583 my ($linenr, $remain) = @_;
1585 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1587 sub ctx_statement_level {
1588 my ($linenr, $remain, $off) = @_;
1590 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1593 sub ctx_locate_comment {
1594 my ($first_line, $end_line) = @_;
1596 # Catch a comment on the end of the line itself.
1597 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1598 return $current_comment if (defined $current_comment);
1600 # Look through the context and try and figure out if there is a
1603 $current_comment = '';
1604 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1605 my $line = $rawlines[$linenr - 1];
1607 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1610 if ($line =~ m@/\*@) {
1613 if (!$in_comment && $current_comment ne '') {
1614 $current_comment = '';
1616 $current_comment .= $line . "\n" if ($in_comment);
1617 if ($line =~ m@\*/@) {
1622 chomp($current_comment);
1623 return($current_comment);
1625 sub ctx_has_comment {
1626 my ($first_line, $end_line) = @_;
1627 my $cmt = ctx_locate_comment($first_line, $end_line);
1629 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1630 ##print "CMMT: $cmt\n";
1632 return ($cmt ne '');
1636 my ($linenr, $cnt) = @_;
1638 my $offset = $linenr - 1;
1643 $line = $rawlines[$offset++];
1644 next if (defined($line) && $line =~ /^-/);
1652 my ($linenr, $lc) = @_;
1654 my $stat_real = raw_line($linenr, 0);
1655 for (my $count = $linenr + 1; $count <= $lc; $count++) {
1656 $stat_real = $stat_real . "\n" . raw_line($count, 0);
1663 my ($linenr, $cnt, $here) = @_;
1665 my $herectx = $here . "\n";
1666 for (my $n = 0; $n < $cnt; $n++) {
1667 $herectx .= raw_line($linenr, $n) . "\n";
1678 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1681 $coded = sprintf("^%c", unpack('C', $2) + 64);
1690 my $av_preprocessor = 0;
1695 sub annotate_reset {
1696 $av_preprocessor = 0;
1698 @av_paren_type = ('E');
1699 $av_pend_colon = 'O';
1702 sub annotate_values {
1703 my ($stream, $type) = @_;
1706 my $var = '_' x length($stream);
1709 print "$stream\n" if ($dbg_values > 1);
1711 while (length($cur)) {
1712 @av_paren_type = ('E') if ($#av_paren_type < 0);
1713 print " <" . join('', @av_paren_type) .
1714 "> <$type> <$av_pending>" if ($dbg_values > 1);
1715 if ($cur =~ /^(\s+)/o) {
1716 print "WS($1)\n" if ($dbg_values > 1);
1717 if ($1 =~ /\n/ && $av_preprocessor) {
1718 $type = pop(@av_paren_type);
1719 $av_preprocessor = 0;
1722 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1723 print "CAST($1)\n" if ($dbg_values > 1);
1724 push(@av_paren_type, $type);
1727 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1728 print "DECLARE($1)\n" if ($dbg_values > 1);
1731 } elsif ($cur =~ /^($Modifier)\s*/) {
1732 print "MODIFIER($1)\n" if ($dbg_values > 1);
1735 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1736 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1737 $av_preprocessor = 1;
1738 push(@av_paren_type, $type);
1744 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1745 print "UNDEF($1)\n" if ($dbg_values > 1);
1746 $av_preprocessor = 1;
1747 push(@av_paren_type, $type);
1749 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1750 print "PRE_START($1)\n" if ($dbg_values > 1);
1751 $av_preprocessor = 1;
1753 push(@av_paren_type, $type);
1754 push(@av_paren_type, $type);
1757 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1758 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1759 $av_preprocessor = 1;
1761 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1765 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1766 print "PRE_END($1)\n" if ($dbg_values > 1);
1768 $av_preprocessor = 1;
1770 # Assume all arms of the conditional end as this
1771 # one does, and continue as if the #endif was not here.
1772 pop(@av_paren_type);
1773 push(@av_paren_type, $type);
1776 } elsif ($cur =~ /^(\\\n)/o) {
1777 print "PRECONT($1)\n" if ($dbg_values > 1);
1779 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1780 print "ATTR($1)\n" if ($dbg_values > 1);
1781 $av_pending = $type;
1784 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1785 print "SIZEOF($1)\n" if ($dbg_values > 1);
1791 } elsif ($cur =~ /^(if|while|for)\b/o) {
1792 print "COND($1)\n" if ($dbg_values > 1);
1796 } elsif ($cur =~/^(case)/o) {
1797 print "CASE($1)\n" if ($dbg_values > 1);
1798 $av_pend_colon = 'C';
1801 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1802 print "KEYWORD($1)\n" if ($dbg_values > 1);
1805 } elsif ($cur =~ /^(\()/o) {
1806 print "PAREN('$1')\n" if ($dbg_values > 1);
1807 push(@av_paren_type, $av_pending);
1811 } elsif ($cur =~ /^(\))/o) {
1812 my $new_type = pop(@av_paren_type);
1813 if ($new_type ne '_') {
1815 print "PAREN('$1') -> $type\n"
1816 if ($dbg_values > 1);
1818 print "PAREN('$1')\n" if ($dbg_values > 1);
1821 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1822 print "FUNC($1)\n" if ($dbg_values > 1);
1826 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1827 if (defined $2 && $type eq 'C' || $type eq 'T') {
1828 $av_pend_colon = 'B';
1829 } elsif ($type eq 'E') {
1830 $av_pend_colon = 'L';
1832 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1835 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1836 print "IDENT($1)\n" if ($dbg_values > 1);
1839 } elsif ($cur =~ /^($Assignment)/o) {
1840 print "ASSIGN($1)\n" if ($dbg_values > 1);
1843 } elsif ($cur =~/^(;|{|})/) {
1844 print "END($1)\n" if ($dbg_values > 1);
1846 $av_pend_colon = 'O';
1848 } elsif ($cur =~/^(,)/) {
1849 print "COMMA($1)\n" if ($dbg_values > 1);
1852 } elsif ($cur =~ /^(\?)/o) {
1853 print "QUESTION($1)\n" if ($dbg_values > 1);
1856 } elsif ($cur =~ /^(:)/o) {
1857 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1859 substr($var, length($res), 1, $av_pend_colon);
1860 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1865 $av_pend_colon = 'O';
1867 } elsif ($cur =~ /^(\[)/o) {
1868 print "CLOSE($1)\n" if ($dbg_values > 1);
1871 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1874 print "OPV($1)\n" if ($dbg_values > 1);
1881 substr($var, length($res), 1, $variant);
1884 } elsif ($cur =~ /^($Operators)/o) {
1885 print "OP($1)\n" if ($dbg_values > 1);
1886 if ($1 ne '++' && $1 ne '--') {
1890 } elsif ($cur =~ /(^.)/o) {
1891 print "C($1)\n" if ($dbg_values > 1);
1894 $cur = substr($cur, length($1));
1895 $res .= $type x length($1);
1899 return ($res, $var);
1903 my ($possible, $line) = @_;
1904 my $notPermitted = qr{(?:
1921 ^(?:typedef|struct|enum)\b
1923 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1924 if ($possible !~ $notPermitted) {
1925 # Check for modifiers.
1926 $possible =~ s/\s*$Storage\s*//g;
1927 $possible =~ s/\s*$Sparse\s*//g;
1928 if ($possible =~ /^\s*$/) {
1930 } elsif ($possible =~ /\s/) {
1931 $possible =~ s/\s*$Type\s*//g;
1932 for my $modifier (split(' ', $possible)) {
1933 if ($modifier !~ $notPermitted) {
1934 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1935 push(@modifierListFile, $modifier);
1940 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1941 push(@typeListFile, $possible);
1945 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1954 $type =~ tr/[a-z]/[A-Z]/;
1956 return defined $use_type{$type} if (scalar keys %use_type > 0);
1958 return !defined $ignore_type{$type};
1962 my ($level, $type, $msg) = @_;
1964 if (!show_type($type) ||
1965 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1970 if ($level eq 'ERROR') {
1972 } elsif ($level eq 'WARNING') {
1978 $output .= $prefix . $level . ':';
1980 $output .= BLUE if ($color);
1981 $output .= "$type:";
1983 $output .= RESET if ($color);
1984 $output .= ' ' . $msg . "\n";
1987 my @lines = split("\n", $output, -1);
1988 splice(@lines, 1, 1);
1989 $output = join("\n", @lines);
1991 $output = (split('\n', $output))[0] . "\n" if ($terse);
1993 push(our @report, $output);
2002 sub fixup_current_range {
2003 my ($lineRef, $offset, $length) = @_;
2005 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2008 my $no = $o + $offset;
2009 my $nl = $l + $length;
2010 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2014 sub fix_inserted_deleted_lines {
2015 my ($linesRef, $insertedRef, $deletedRef) = @_;
2017 my $range_last_linenr = 0;
2018 my $delta_offset = 0;
2023 my $next_insert = 0;
2024 my $next_delete = 0;
2028 my $inserted = @{$insertedRef}[$next_insert++];
2029 my $deleted = @{$deletedRef}[$next_delete++];
2031 foreach my $old_line (@{$linesRef}) {
2033 my $line = $old_line; #don't modify the array
2034 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
2036 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2037 $range_last_linenr = $new_linenr;
2038 fixup_current_range(\$line, $delta_offset, 0);
2041 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2042 $deleted = @{$deletedRef}[$next_delete++];
2044 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2047 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2048 push(@lines, ${$inserted}{'LINE'});
2049 $inserted = @{$insertedRef}[$next_insert++];
2051 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2055 push(@lines, $line);
2065 sub fix_insert_line {
2066 my ($linenr, $line) = @_;
2072 push(@fixed_inserted, $inserted);
2075 sub fix_delete_line {
2076 my ($linenr, $line) = @_;
2083 push(@fixed_deleted, $deleted);
2087 my ($type, $msg) = @_;
2089 if (report("ERROR", $type, $msg)) {
2097 my ($type, $msg) = @_;
2099 if (report("WARNING", $type, $msg)) {
2107 my ($type, $msg) = @_;
2109 if ($check && report("CHECK", $type, $msg)) {
2117 sub check_absolute_file {
2118 my ($absolute, $herecurr) = @_;
2119 my $file = $absolute;
2121 ##print "absolute<$absolute>\n";
2123 # See if any suffix of this path is a path within the tree.
2124 while ($file =~ s@^[^/]*/@@) {
2125 if (-f "$root/$file") {
2126 ##print "file<$file>\n";
2134 # It is, so see if the prefix is acceptable.
2135 my $prefix = $absolute;
2136 substr($prefix, -length($file)) = '';
2138 ##print "prefix<$prefix>\n";
2139 if ($prefix ne ".../") {
2140 WARN("USE_RELATIVE_PATH",
2141 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2148 $string =~ s/^\s+|\s+$//g;
2156 $string =~ s/^\s+//;
2164 $string =~ s/\s+$//;
2169 sub string_find_replace {
2170 my ($string, $find, $replace) = @_;
2172 $string =~ s/$find/$replace/g;
2180 my $source_indent = 8;
2181 my $max_spaces_before_tab = $source_indent - 1;
2182 my $spaces_to_tab = " " x $source_indent;
2184 #convert leading spaces to tabs
2185 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2186 #Remove spaces before a tab
2187 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2192 sub pos_last_openparen {
2197 my $opens = $line =~ tr/\(/\(/;
2198 my $closes = $line =~ tr/\)/\)/;
2200 my $last_openparen = 0;
2202 if (($opens == 0) || ($closes >= $opens)) {
2206 my $len = length($line);
2208 for ($pos = 0; $pos < $len; $pos++) {
2209 my $string = substr($line, $pos);
2210 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2211 $pos += length($1) - 1;
2212 } elsif (substr($line, $pos, 1) eq '(') {
2213 $last_openparen = $pos;
2214 } elsif (index($string, '(') == -1) {
2219 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2223 my $filename = shift;
2229 my $stashrawline="";
2239 my $in_header_lines = $file ? 0 : 1;
2240 my $in_commit_log = 0; #Scanning lines before patch
2241 my $has_commit_log = 0; #Encountered lines before patch
2242 my $commit_log_possible_stack_dump = 0;
2243 my $commit_log_long_line = 0;
2244 my $commit_log_has_diff = 0;
2245 my $reported_maintainer_file = 0;
2246 my $non_utf8_charset = 0;
2248 my $last_blank_line = 0;
2249 my $last_coalesced_string_linenr = -1;
2257 # Trace the real file/line as we go.
2262 my $context_function; #undef'd unless there's a known function
2264 my $comment_edge = 0;
2268 my $prev_values = 'E';
2271 my %suppress_ifbraces;
2272 my %suppress_whiletrailers;
2273 my %suppress_export;
2274 my $suppress_statement = 0;
2276 my %signatures = ();
2278 # Pre-scan the patch sanitizing the lines.
2279 # Pre-scan the patch looking for any __setup documentation.
2281 my @setup_docs = ();
2284 my $camelcase_file_seeded = 0;
2286 my $checklicenseline = 1;
2288 sanitise_line_reset();
2290 foreach my $rawline (@rawlines) {
2294 push(@fixed, $rawline) if ($fix);
2296 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2298 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
2303 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2312 # Guestimate if this is a continuing comment. Run
2313 # the context looking for a comment "edge". If this
2314 # edge is a close comment then we must be in a comment
2318 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2319 next if (defined $rawlines[$ln - 1] &&
2320 $rawlines[$ln - 1] =~ /^-/);
2322 #print "RAW<$rawlines[$ln - 1]>\n";
2323 last if (!defined $rawlines[$ln - 1]);
2324 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2325 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2330 if (defined $edge && $edge eq '*/') {
2334 # Guestimate if this is a continuing comment. If this
2335 # is the start of a diff block and this line starts
2336 # ' *' then it is very likely a comment.
2337 if (!defined $edge &&
2338 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2343 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2344 sanitise_line_reset($in_comment);
2346 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2347 # Standardise the strings and chars within the input to
2348 # simplify matching -- only bother with positive lines.
2349 $line = sanitise_line($rawline);
2351 push(@lines, $line);
2354 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2359 #print "==>$rawline\n";
2360 #print "-->$line\n";
2362 if ($setup_docs && $line =~ /^\+/) {
2363 push(@setup_docs, $line);
2372 foreach my $line (@lines) {
2375 my $sline = $line; #copy of $line
2376 $sline =~ s/$;/ /g; #with comments as spaces
2378 my $rawline = $rawlines[$linenr - 1];
2380 # check if it's a mode change, rename or start of a patch
2381 if (!$in_commit_log &&
2382 ($line =~ /^ mode change [0-7]+ => [0-7]+ \S+\s*$/ ||
2383 ($line =~ /^rename (?:from|to) \S+\s*$/ ||
2384 $line =~ /^diff --git a\/[\w\/\.\_\-]+ b\/\S+\s*$/))) {
2388 #extract the line range in the file after the patch is applied
2389 if (!$in_commit_log &&
2390 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2393 $first_line = $linenr + 1;
2403 %suppress_ifbraces = ();
2404 %suppress_whiletrailers = ();
2405 %suppress_export = ();
2406 $suppress_statement = 0;
2407 if ($context =~ /\b(\w+)\s*\(/) {
2408 $context_function = $1;
2410 undef $context_function;
2414 # track the line number as we move through the hunk, note that
2415 # new versions of GNU diff omit the leading space on completely
2416 # blank context lines so we need to count that too.
2417 } elsif ($line =~ /^( |\+|$)/) {
2419 $realcnt-- if ($realcnt != 0);
2421 # Measure the line length and indent.
2422 ($length, $indent) = line_stats($rawline);
2424 # Track the previous line.
2425 ($prevline, $stashline) = ($stashline, $line);
2426 ($previndent, $stashindent) = ($stashindent, $indent);
2427 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2429 #warn "line<$line>\n";
2431 } elsif ($realcnt == 1) {
2435 my $hunk_line = ($realcnt != 0);
2437 $here = "#$linenr: " if (!$file);
2438 $here = "#$realline: " if ($file);
2441 # extract the filename as it passes
2442 if ($line =~ /^diff --git.*?(\S+)$/) {
2444 $realfile =~ s@^([^/]*)/@@ if (!$file);
2447 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2449 $realfile =~ s@^([^/]*)/@@ if (!$file);
2453 if (!$file && $tree && $p1_prefix ne '' &&
2454 -e "$root/$p1_prefix") {
2455 WARN("PATCH_PREFIX",
2456 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2459 if ($realfile =~ m@^include/asm/@) {
2460 ERROR("MODIFIED_INCLUDE_ASM",
2461 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2466 #make up the handle for any error we report on this line
2468 $prefix = "$realfile:$realline: "
2471 $prefix = "$filename:$realline: ";
2473 $prefix = "$filename:$linenr: ";
2478 if (is_maintained_obsolete($realfile)) {
2480 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2482 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2485 $check = $check_orig;
2487 $checklicenseline = 1;
2491 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2493 my $hereline = "$here\n$rawline\n";
2494 my $herecurr = "$here\n$rawline\n";
2495 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2497 $cnt_lines++ if ($realcnt != 0);
2499 # Check if the commit log has what seems like a diff which can confuse patch
2500 if ($in_commit_log && !$commit_log_has_diff &&
2501 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2502 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2503 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2504 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2505 ERROR("DIFF_IN_COMMIT_MSG",
2506 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2507 $commit_log_has_diff = 1;
2510 # Check for incorrect file permissions
2511 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2512 my $permhere = $here . "FILE: $realfile\n";
2513 if ($realfile !~ m@scripts/@ &&
2514 $realfile !~ /\.(py|pl|awk|sh)$/) {
2515 ERROR("EXECUTE_PERMISSIONS",
2516 "do not set execute permissions for source files\n" . $permhere);
2520 # Check the patch for a signoff:
2521 if ($line =~ /^\s*signed-off-by:/i) {
2526 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2527 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2528 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2529 $reported_maintainer_file = 1;
2532 # Check signature styles
2533 if (!$in_header_lines &&
2534 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2535 my $space_before = $1;
2537 my $space_after = $3;
2539 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2541 if ($sign_off !~ /$signature_tags/) {
2542 WARN("BAD_SIGN_OFF",
2543 "Non-standard signature: $sign_off\n" . $herecurr);
2545 if (defined $space_before && $space_before ne "") {
2546 if (WARN("BAD_SIGN_OFF",
2547 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2549 $fixed[$fixlinenr] =
2550 "$ucfirst_sign_off $email";
2553 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2554 if (WARN("BAD_SIGN_OFF",
2555 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2557 $fixed[$fixlinenr] =
2558 "$ucfirst_sign_off $email";
2562 if (!defined $space_after || $space_after ne " ") {
2563 if (WARN("BAD_SIGN_OFF",
2564 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2566 $fixed[$fixlinenr] =
2567 "$ucfirst_sign_off $email";
2571 my ($email_name, $email_address, $comment) = parse_email($email);
2572 my $suggested_email = format_email(($email_name, $email_address));
2573 if ($suggested_email eq "") {
2574 ERROR("BAD_SIGN_OFF",
2575 "Unrecognized email address: '$email'\n" . $herecurr);
2577 my $dequoted = $suggested_email;
2578 $dequoted =~ s/^"//;
2579 $dequoted =~ s/" </ </;
2580 # Don't force email to have quotes
2581 # Allow just an angle bracketed address
2582 if ("$dequoted$comment" ne $email &&
2583 "<$email_address>$comment" ne $email &&
2584 "$suggested_email$comment" ne $email) {
2585 WARN("BAD_SIGN_OFF",
2586 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2590 # Check for duplicate signatures
2591 my $sig_nospace = $line;
2592 $sig_nospace =~ s/\s//g;
2593 $sig_nospace = lc($sig_nospace);
2594 if (defined $signatures{$sig_nospace}) {
2595 WARN("BAD_SIGN_OFF",
2596 "Duplicate signature\n" . $herecurr);
2598 $signatures{$sig_nospace} = 1;
2602 # Check email subject for common tools that don't need to be mentioned
2603 if ($in_header_lines &&
2604 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2605 WARN("EMAIL_SUBJECT",
2606 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2609 # Check for unwanted Gerrit info
2610 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2611 ERROR("GERRIT_CHANGE_ID",
2612 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2615 # Check if the commit log is in a possible stack dump
2616 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2617 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2618 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2620 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2621 # stack dump address
2622 $commit_log_possible_stack_dump = 1;
2625 # Check for line lengths > 75 in commit log, warn once
2626 if ($in_commit_log && !$commit_log_long_line &&
2627 length($line) > 75 &&
2628 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2629 # file delta changes
2630 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2632 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2633 # A Fixes: or Link: line
2634 $commit_log_possible_stack_dump)) {
2635 WARN("COMMIT_LOG_LONG_LINE",
2636 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2637 $commit_log_long_line = 1;
2640 # Reset possible stack dump if a blank line is found
2641 if ($in_commit_log && $commit_log_possible_stack_dump &&
2643 $commit_log_possible_stack_dump = 0;
2646 # Check for git id commit length and improperly formed commit descriptions
2647 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2648 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
2649 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
2650 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2651 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2652 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2653 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2654 my $init_char = "c";
2655 my $orig_commit = "";
2662 my $id = '0123456789ab';
2663 my $orig_desc = "commit description";
2664 my $description = "";
2666 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2668 $orig_commit = lc($2);
2669 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2670 $orig_commit = lc($1);
2673 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2674 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2675 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2676 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2677 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2680 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2681 defined $rawlines[$linenr] &&
2682 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2685 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2686 defined $rawlines[$linenr] &&
2687 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2688 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2690 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2691 $orig_desc .= " " . $1;
2695 ($id, $description) = git_commit_info($orig_commit,
2699 ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
2700 ERROR("GIT_COMMIT_ID",
2701 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2705 # Check for added, moved or deleted files
2706 if (!$reported_maintainer_file && !$in_commit_log &&
2707 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2708 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2709 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2710 (defined($1) || defined($2))))) {
2712 $reported_maintainer_file = 1;
2713 WARN("FILE_PATH_CHANGES",
2714 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2717 # Check for wrappage within a valid hunk of the file
2718 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2719 ERROR("CORRUPTED_PATCH",
2720 "patch seems to be corrupt (line wrapped?)\n" .
2721 $herecurr) if (!$emitted_corrupt++);
2724 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2725 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2726 $rawline !~ m/^$UTF8*$/) {
2727 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2729 my $blank = copy_spacing($rawline);
2730 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2731 my $hereptr = "$hereline$ptr\n";
2734 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2737 # Check if it's the start of a commit log
2738 # (not a header line and we haven't seen the patch filename)
2739 if ($in_header_lines && $realfile =~ /^$/ &&
2740 !($rawline =~ /^\s+(?:\S|$)/ ||
2741 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
2742 $in_header_lines = 0;
2744 $has_commit_log = 1;
2747 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2748 # declined it, i.e defined some charset where it is missing.
2749 if ($in_header_lines &&
2750 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2752 $non_utf8_charset = 1;
2755 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2756 $rawline =~ /$NON_ASCII_UTF8/) {
2757 WARN("UTF8_BEFORE_PATCH",
2758 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2761 # Check for absolute kernel paths in commit message
2762 if ($tree && $in_commit_log) {
2763 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2766 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2767 check_absolute_file($1, $herecurr)) {
2770 check_absolute_file($file, $herecurr);
2775 # Check for various typo / spelling mistakes
2776 if (defined($misspellings) &&
2777 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2778 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2780 my $typo_fix = $spelling_fix{lc($typo)};
2781 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2782 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2783 my $msg_level = \&WARN;
2784 $msg_level = \&CHK if ($file);
2785 if (&{$msg_level}("TYPO_SPELLING",
2786 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2788 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2793 # ignore non-hunk lines and lines being removed
2794 next if (!$hunk_line || $line =~ /^-/);
2796 #trailing whitespace
2797 if ($line =~ /^\+.*\015/) {
2798 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2799 if (ERROR("DOS_LINE_ENDINGS",
2800 "DOS line endings\n" . $herevet) &&
2802 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2804 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2805 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2806 if (ERROR("TRAILING_WHITESPACE",
2807 "trailing whitespace\n" . $herevet) &&
2809 $fixed[$fixlinenr] =~ s/\s+$//;
2815 # Check for FSF mailing addresses.
2816 if ($rawline =~ /\bwrite to the Free/i ||
2817 $rawline =~ /\b675\s+Mass\s+Ave/i ||
2818 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2819 $rawline =~ /\b51\s+Franklin\s+St/i) {
2820 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2821 my $msg_level = \&ERROR;
2822 $msg_level = \&CHK if ($file);
2823 &{$msg_level}("FSF_MAILING_ADDRESS",
2824 "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)
2827 # check for Kconfig help text having a real description
2828 # Only applies when adding the entry originally, after that we do not have
2829 # sufficient context to determine whether it is indeed long enough.
2830 if ($realfile =~ /Kconfig/ &&
2831 # 'choice' is usually the last thing on the line (though
2832 # Kconfig supports named choices), so use a word boundary
2833 # (\b) rather than a whitespace character (\s)
2834 $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
2837 my $ln = $linenr + 1;
2841 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2842 $f = $lines[$ln - 1];
2843 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2844 $is_end = $lines[$ln - 1] =~ /^\+/;
2846 next if ($f =~ /^-/);
2847 last if (!$file && $f =~ /^\@\@/);
2849 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
2851 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:help|---help---)\s*$/) {
2852 if ($lines[$ln - 1] =~ "---help---") {
2853 WARN("CONFIG_DESCRIPTION",
2854 "prefer 'help' over '---help---' for new help texts\n" . $herecurr);
2862 next if ($f =~ /^$/);
2864 # This only checks context lines in the patch
2865 # and so hopefully shouldn't trigger false
2866 # positives, even though some of these are
2867 # common words in help texts
2868 if ($f =~ /^\s*(?:config|menuconfig|choice|endchoice|
2869 if|endif|menu|endmenu|source)\b/x) {
2875 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2876 WARN("CONFIG_DESCRIPTION",
2877 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2879 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2882 # check for MAINTAINERS entries that don't have the right form
2883 if ($realfile =~ /^MAINTAINERS$/ &&
2884 $rawline =~ /^\+[A-Z]:/ &&
2885 $rawline !~ /^\+[A-Z]:\t\S/) {
2886 if (WARN("MAINTAINERS_STYLE",
2887 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
2889 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
2893 # discourage the use of boolean for type definition attributes of Kconfig options
2894 if ($realfile =~ /Kconfig/ &&
2895 $line =~ /^\+\s*\bboolean\b/) {
2896 WARN("CONFIG_TYPE_BOOLEAN",
2897 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2900 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2901 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2904 'EXTRA_AFLAGS' => 'asflags-y',
2905 'EXTRA_CFLAGS' => 'ccflags-y',
2906 'EXTRA_CPPFLAGS' => 'cppflags-y',
2907 'EXTRA_LDFLAGS' => 'ldflags-y',
2910 WARN("DEPRECATED_VARIABLE",
2911 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead
.\n" . $herecurr) if ($replacement->{$flag});
2914 # check for DT compatible documentation
2915 if (defined $root &&
2916 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2917 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2919 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2921 my $dt_path = $root . "/Documentation/devicetree
/bindings/";
2922 my $vp_file = $dt_path . "vendor-prefixes
.txt
";
2924 foreach my $compat (@compats) {
2925 my $compat2 = $compat;
2926 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2927 my $compat3 = $compat;
2928 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2929 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2931 WARN("UNDOCUMENTED_DT_STRING
",
2932 "DT compatible string
\"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2935 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2937 `grep -Eq "^$vendor\\b" $vp_file`;
2939 WARN("UNDOCUMENTED_DT_STRING",
2940 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2945 # check for using SPDX license tag at beginning of files
2946 if ($realline == $checklicenseline) {
2947 if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
2948 $checklicenseline = 2;
2949 } elsif ($rawline =~ /^\+/) {
2951 if ($realfile =~ /\.(h|s|S)$/) {
2953 } elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
2955 } elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc)$/) {
2957 } elsif ($realfile =~ /\.rst$/) {
2961 if ($comment !~ /^$/ &&
2962 $rawline !~ /^\+\Q$comment\E SPDX-License-Identifier: /) {
2963 WARN("SPDX_LICENSE_TAG",
2964 "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
2969 # check we are in a valid source file if not then ignore this hunk
2970 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
2972 # line length limit (with some exclusions)
2974 # There are a few types of lines that may extend beyond $max_line_length:
2975 # logging functions like pr_info that end in a string
2976 # lines with a single string
2977 # #defines that are a single string
2978 # lines with an RFC3986 like URL
2980 # There are 3 different line length message types:
2981 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
2982 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2983 # LONG_LINE all other lines longer than $max_line_length
2985 # if LONG_LINE is ignored, the other 2 types are also ignored
2988 if ($line =~ /^\+/ && $length > $max_line_length) {
2989 my $msg_type = "LONG_LINE";
2991 # Check the allowed long line types first
2993 # logging functions that end in a string that starts
2994 # before $max_line_length
2995 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2996 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2999 # lines with only strings (w/ possible termination)
3000 # #defines with only strings
3001 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
3002 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
3005 # More special cases
3006 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3007 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3010 # URL ($rawline is used in case the URL is in a comment)
3011 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
3014 # Otherwise set the alternate message types
3016 # a comment starts before $max_line_length
3017 } elsif ($line =~ /($;[\s$;]*)$/ &&
3018 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3019 $msg_type = "LONG_LINE_COMMENT"
3021 # a quoted string starts before $max_line_length
3022 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3023 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3024 $msg_type = "LONG_LINE_STRING"
3027 if ($msg_type ne "" &&
3028 (show_type("LONG_LINE") || show_type($msg_type))) {
3030 "line over $max_line_length characters\n" . $herecurr);
3034 # check for adding lines without a newline.
3035 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3036 WARN("MISSING_EOF_NEWLINE",
3037 "adding a line without newline at end of file\n" . $herecurr);
3040 # check we are in a valid source file C or perl if not then ignore this hunk
3041 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3043 # at the beginning of a line any tabs must come first and anything
3044 # more than 8 must use tabs.
3045 if ($rawline =~ /^\+\s* \t\s*\S/ ||
3046 $rawline =~ /^\+\s* \s*/) {
3047 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3049 if (ERROR("CODE_INDENT",
3050 "code indent should use tabs where possible\n" . $herevet) &&
3052 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3056 # check for space before tabs.
3057 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3058 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3059 if (WARN("SPACE_BEFORE_TAB",
3060 "please, no space before tabs\n" . $herevet) &&
3062 while ($fixed[$fixlinenr] =~
3063 s/(^\+.*) {8,8}\t/$1\t\t/) {}
3064 while ($fixed[$fixlinenr] =~
3065 s/(^\+.*) +\t/$1\t/) {}
3069 # check for assignments on the start of a line
3070 if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3071 CHK("ASSIGNMENT_CONTINUATIONS",
3072 "Assignment operator '$1' should be on the previous line\n" . $hereprev);
3075 # check for && or || at the start of a line
3076 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3077 CHK("LOGICAL_CONTINUATIONS",
3078 "Logical continuations should be on the previous line\n" . $hereprev);
3081 # check indentation starts on a tab stop
3082 if ($^V && $^V ge 5.10.0 &&
3083 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3084 my $indent = length($1);
3087 "Statements should start on a tabstop\n" . $herecurr) &&
3089 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
3094 # check multi-line statement indentation matches previous line
3095 if ($^V && $^V ge 5.10.0 &&
3096 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3097 $prevline =~ /^\+(\t*)(.*)$/;
3101 my $pos = pos_last_openparen($rest);
3103 $line =~ /^(\+| )([ \t]*)/;
3106 my $goodtabindent = $oldindent .
3109 my $goodspaceindent = $oldindent . " " x $pos;
3111 if ($newindent ne $goodtabindent &&
3112 $newindent ne $goodspaceindent) {
3114 if (CHK("PARENTHESIS_ALIGNMENT",
3115 "Alignment should match open parenthesis\n" . $hereprev) &&
3116 $fix && $line =~ /^\+/) {
3117 $fixed[$fixlinenr] =~
3118 s/^\+[ \t]*/\+$goodtabindent/;
3124 # check for space after cast like "(int) foo" or "(struct foo) bar"
3125 # avoid checking a few false positives:
3126 # "sizeof(<type>)" or "__alignof__(<type>)"
3127 # function pointer declarations like "(*foo)(int) = bar;"
3128 # structure definitions like "(struct foo) { 0 };"
3129 # multiline macros that define functions
3130 # known attributes or the __attribute__ keyword
3131 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3132 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3134 "No space is necessary after a cast\n" . $herecurr) &&
3136 $fixed[$fixlinenr] =~
3137 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3141 # Block comment styles
3142 # Networking with an initial /*
3143 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3144 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3145 $rawline =~ /^\+[ \t]*\*/ &&
3147 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3148 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3151 # Block comments use * on subsequent lines
3152 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3153 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
3154 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3155 $rawline =~ /^\+/ && #line is new
3156 $rawline !~ /^\+[ \t]*\*/) { #no leading *
3157 WARN("BLOCK_COMMENT_STYLE",
3158 "Block comments use * on subsequent lines\n" . $hereprev);
3161 # Block comments use */ on trailing lines
3162 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
3163 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3164 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3165 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
3166 WARN("BLOCK_COMMENT_STYLE",
3167 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3170 # Block comment * alignment
3171 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3172 $line =~ /^\+[ \t]*$;/ && #leading comment
3173 $rawline =~ /^\+[ \t]*\*/ && #leading *
3174 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
3175 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3176 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3178 $prevrawline =~ m@^\+([ \t]*/?)\*@;
3180 $oldindent = expand_tabs($1);
3182 $prevrawline =~ m@^\+(.*/?)\*@;
3183 $oldindent = expand_tabs($1);
3185 $rawline =~ m@^\+([ \t]*)\*@;
3187 $newindent = expand_tabs($newindent);
3188 if (length($oldindent) ne length($newindent)) {
3189 WARN("BLOCK_COMMENT_STYLE",
3190 "Block comments should align the * on each line\n" . $hereprev);
3194 # check for missing blank lines after struct/union declarations
3195 # with exceptions for various attributes and macros
3196 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3198 !($line =~ /^\+\s*$/ ||
3199 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3200 $line =~ /^\+\s*MODULE_/i ||
3201 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3202 $line =~ /^\+[a-z_]*init/ ||
3203 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3204 $line =~ /^\+\s*DECLARE/ ||
3205 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3206 $line =~ /^\+\s*__setup/)) {
3207 if (CHK("LINE_SPACING",
3208 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3210 fix_insert_line($fixlinenr, "\+");
3214 # check for multiple consecutive blank lines
3215 if ($prevline =~ /^[\+ ]\s*$/ &&
3216 $line =~ /^\+\s*$/ &&
3217 $last_blank_line != ($linenr - 1)) {
3218 if (CHK("LINE_SPACING",
3219 "Please don't use multiple blank lines\n" . $hereprev) &&
3221 fix_delete_line($fixlinenr, $rawline);
3224 $last_blank_line = $linenr;
3227 # check for missing blank lines after declarations
3228 if ($sline =~ /^\+\s+\S/ && #Not at char 1
3229 # actual declarations
3230 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3231 # function pointer declarations
3232 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3233 # foo bar; where foo is some local typedef or #define
3234 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3235 # known declaration macros
3236 $prevline =~ /^\+\s+$declaration_macros/) &&
3237 # for "else if" which can look like "$Ident $Ident"
3238 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3239 # other possible extensions of declaration lines
3240 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3241 # not starting a section or a macro "\" extended line
3242 $prevline =~ /(?:\{\s*|\\)$/) &&
3243 # looks like a declaration
3244 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3245 # function pointer declarations
3246 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3247 # foo bar; where foo is some local typedef or #define
3248 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3249 # known declaration macros
3250 $sline =~ /^\+\s+$declaration_macros/ ||
3251 # start of struct or union or enum
3252 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3253 # start or end of block or continuation of declaration
3254 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3255 # bitfield continuation
3256 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3257 # other possible extensions of declaration lines
3258 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3259 # indentation of previous and current line are the same
3260 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3261 if (WARN("LINE_SPACING",
3262 "Missing a blank line after declarations\n" . $hereprev) &&
3264 fix_insert_line($fixlinenr, "\+");
3268 # check for spaces at the beginning of a line.
3270 # 1) within comments
3271 # 2) indented preprocessor commands
3273 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3274 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3275 if (WARN("LEADING_SPACE",
3276 "please, no spaces at the start of a line\n" . $herevet) &&
3278 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3282 # check we are in a valid C source file if not then ignore this hunk
3283 next if ($realfile !~ /\.(h|c)$/);
3285 # check for unusual line ending [ or (
3286 if ($line =~ /^\+.*([\[\(])\s*$/) {
3287 CHK("OPEN_ENDED_LINE",
3288 "Lines should not end with a '$1'\n" . $herecurr);
3291 # check if this appears to be the start function declaration, save the name
3292 if ($sline =~ /^\+\{\s*$/ &&
3293 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3294 $context_function = $1;
3297 # check if this appears to be the end of function declaration
3298 if ($sline =~ /^\+\}\s*$/) {
3299 undef $context_function;
3302 # check indentation of any line with a bare else
3303 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3304 # if the previous line is a break or return and is indented 1 tab more...
3305 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3306 my $tabs = length($1) + 1;
3307 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3308 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3309 defined $lines[$linenr] &&
3310 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3311 WARN("UNNECESSARY_ELSE",
3312 "else is not generally useful after a break or return\n" . $hereprev);
3316 # check indentation of a line with a break;
3317 # if the previous line is a goto or return and is indented the same # of tabs
3318 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3320 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3321 WARN("UNNECESSARY_BREAK",
3322 "break is not useful after a goto or return\n" . $hereprev);
3326 # check for RCS/CVS revision markers
3327 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3329 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3332 # check for old HOTPLUG __dev<foo> section markings
3333 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3334 WARN("HOTPLUG_SECTION",
3335 "Using $1 is unnecessary\n" . $herecurr);
3338 # Check for potential 'bare' types
3339 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3341 #print "LINE<$line>\n";
3342 if ($linenr > $suppress_statement &&
3343 $realcnt && $sline =~ /.\s*\S/) {
3344 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3345 ctx_statement_block($linenr, $realcnt, 0);
3346 $stat =~ s/\n./\n /g;
3347 $cond =~ s/\n./\n /g;
3349 #print "linenr<$linenr> <$stat>\n";
3350 # If this statement has no statement boundaries within
3351 # it there is no point in retrying a statement scan
3352 # until we hit end of it.
3353 my $frag = $stat; $frag =~ s/;+\s*$//;
3354 if ($frag !~ /(?:{|;)/) {
3355 #print "skip<$line_nr_next>\n";
3356 $suppress_statement = $line_nr_next;
3359 # Find the real next line.
3360 $realline_next = $line_nr_next;
3361 if (defined $realline_next &&
3362 (!defined $lines[$realline_next - 1] ||
3363 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3370 # Ignore goto labels.
3371 if ($s =~ /$Ident:\*$/s) {
3373 # Ignore functions being called
3374 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3376 } elsif ($s =~ /^.\s*else\b/s) {
3378 # declarations always start with types
3379 } 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) {
3382 possible($type, "A:" . $s);
3384 # definitions in global scope can only start with types
3385 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3386 possible($1, "B:" . $s);
3389 # any (foo ... *) is a pointer cast, and foo is a type
3390 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3391 possible($1, "C:" . $s);
3394 # Check for any sort of function declaration.
3395 # int foo(something bar, other baz);
3396 # void (*store_gdt)(x86_descr_ptr *);
3397 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3398 my ($name_len) = length($1);
3401 substr($ctx, 0, $name_len + 1, '');
3402 $ctx =~ s/\)[^\)]*$//;
3404 for my $arg (split(/\s*,\s*/, $ctx)) {
3405 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3407 possible($1, "D:" . $s);
3415 # Checks which may be anchored in the context.
3418 # Check for switch () and associated case and default
3419 # statements should be at the same indent.
3420 if ($line=~/\bswitch\s*\(.*\)/) {
3423 my @ctx = ctx_block_outer($linenr, $realcnt);
3425 for my $ctx (@ctx) {
3426 my ($clen, $cindent) = line_stats($ctx);
3427 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3428 $indent != $cindent) {
3429 $err .= "$sep$ctx\n";
3436 ERROR("SWITCH_CASE_INDENT_LEVEL",
3437 "switch and case should be at the same indent\n$hereline$err");
3441 # if/while/etc brace do not go on next line, unless defining a do while loop,
3442 # or if that brace on the next line is for something else
3443 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3444 my $pre_ctx = "$1$2";
3446 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3448 if ($line =~ /^\+\t{6,}/) {
3449 WARN("DEEP_INDENTATION",
3450 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3453 my $ctx_cnt = $realcnt - $#ctx - 1;
3454 my $ctx = join("\n", @ctx);
3456 my $ctx_ln = $linenr;
3457 my $ctx_skip = $realcnt;
3459 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3460 defined $lines[$ctx_ln - 1] &&
3461 $lines[$ctx_ln - 1] =~ /^-/)) {
3462 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3463 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3467 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3468 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3470 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3472 "that open brace { should be on the previous line\n" .
3473 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3475 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3476 $ctx =~ /\)\s*\;\s*$/ &&
3477 defined $lines[$ctx_ln - 1])
3479 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3480 if ($nindent > $indent) {
3481 WARN("TRAILING_SEMICOLON",
3482 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3483 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3488 # Check relative indent for conditionals and blocks.
3489 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3490 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3491 ctx_statement_block($linenr, $realcnt, 0)
3492 if (!defined $stat);
3493 my ($s, $c) = ($stat, $cond);
3495 substr($s, 0, length($c), '');
3497 # remove inline comments
3501 # Find out how long the conditional actually is.
3502 my @newlines = ($c =~ /\n/gs);
3503 my $cond_lines = 1 + $#newlines;
3505 # Make sure we remove the line prefixes as we have
3506 # none on the first line, and are going to readd them
3509 while ($s =~ /\n\s+\\\n/) {
3510 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3513 # We want to check the first line inside the block
3514 # starting at the end of the conditional, so remove:
3515 # 1) any blank line termination
3516 # 2) any opening brace { on end of the line
3518 my $continuation = 0;
3520 $s =~ s/^.*\bdo\b//;
3522 if ($s =~ s/^\s*\\//) {
3525 if ($s =~ s/^\s*?\n//) {
3530 # Also ignore a loop construct at the end of a
3531 # preprocessor statement.
3532 if (($prevline =~ /^.\s*#\s*define\s/ ||
3533 $prevline =~ /\\\s*$/) && $continuation == 0) {
3539 while ($cond_ptr != $cond_lines) {
3540 $cond_ptr = $cond_lines;
3542 # If we see an #else/#elif then the code
3544 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3549 # 1) blank lines, they should be at 0,
3550 # 2) preprocessor lines, and
3552 if ($continuation ||
3554 $s =~ /^\s*#\s*?/ ||
3555 $s =~ /^\s*$Ident\s*:/) {
3556 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3557 if ($s =~ s/^.*?\n//) {
3563 my (undef, $sindent) = line_stats("+" . $s);
3564 my $stat_real = raw_line($linenr, $cond_lines);
3566 # Check if either of these lines are modified, else
3567 # this is not this patch's fault.
3568 if (!defined($stat_real) ||
3569 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3572 if (defined($stat_real) && $cond_lines > 1) {
3573 $stat_real = "[...]\n$stat_real";
3576 #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";
3578 if ($check && $s ne '' &&
3579 (($sindent % 8) != 0 ||
3580 ($sindent < $indent) ||
3581 ($sindent == $indent &&
3582 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
3583 ($sindent > $indent + 8))) {
3584 WARN("SUSPECT_CODE_INDENT",
3585 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3589 # Track the 'values' across context and added lines.
3590 my $opline = $line; $opline =~ s/^./ /;
3591 my ($curr_values, $curr_vars) =
3592 annotate_values($opline . "\n", $prev_values);
3593 $curr_values = $prev_values . $curr_values;
3595 my $outline = $opline; $outline =~ s/\t/ /g;
3596 print "$linenr > .$outline\n";
3597 print "$linenr > $curr_values\n";
3598 print "$linenr > $curr_vars\n";
3600 $prev_values = substr($curr_values, -1);
3602 #ignore lines not being added
3603 next if ($line =~ /^[^\+]/);
3605 # check for dereferences that span multiple lines
3606 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3607 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3608 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3610 $line =~ /^.\s*($Lval)/;
3613 WARN("MULTILINE_DEREFERENCE",
3614 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3617 # check for declarations of signed or unsigned without int
3618 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3621 $var = "" if (!defined $var);
3622 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3626 $pointer = "" if (!defined $pointer);
3628 if (WARN("UNSPECIFIED_INT",
3629 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3631 my $decl = trim($sign) . " int ";
3632 my $comp_pointer = $pointer;
3633 $comp_pointer =~ s/\s//g;
3634 $decl .= $comp_pointer;
3635 $decl = rtrim($decl) if ($var eq "");
3636 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3641 # TEST: allow direct testing of the type matcher.
3643 if ($line =~ /^.\s*$Declare\s*$/) {
3645 "TEST: is type\n" . $herecurr);
3646 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3647 ERROR("TEST_NOT_TYPE",
3648 "TEST: is not type ($1 is)\n". $herecurr);
3652 # TEST: allow direct testing of the attribute matcher.
3654 if ($line =~ /^.\s*$Modifier\s*$/) {
3656 "TEST: is attr\n" . $herecurr);
3657 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3658 ERROR("TEST_NOT_ATTR",
3659 "TEST: is not attr ($1 is)\n". $herecurr);
3664 # check for initialisation to aggregates open brace on the next line
3665 if ($line =~ /^.\s*{/ &&
3666 $prevline =~ /(?:^|[^=])=\s*$/) {
3667 if (ERROR("OPEN_BRACE",
3668 "that open brace { should be on the previous line\n" . $hereprev) &&
3669 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3670 fix_delete_line($fixlinenr - 1, $prevrawline);
3671 fix_delete_line($fixlinenr, $rawline);
3672 my $fixedline = $prevrawline;
3673 $fixedline =~ s/\s*=\s*$/ = {/;
3674 fix_insert_line($fixlinenr, $fixedline);
3676 $fixedline =~ s/^(.\s*)\{\s*/$1/;
3677 fix_insert_line($fixlinenr, $fixedline);
3682 # Checks which are anchored on the added line.
3685 # check for malformed paths in #include statements (uses RAW line)
3686 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3688 if ($path =~ m{//}) {
3689 ERROR("MALFORMED_INCLUDE",
3690 "malformed #include filename\n" . $herecurr);
3692 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3693 ERROR("UAPI_INCLUDE",
3694 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3698 # no C99 // comments
3699 if ($line =~ m{//}) {
3700 if (ERROR("C99_COMMENTS",
3701 "do not use C99 // comments\n" . $herecurr) &&
3703 my $line = $fixed[$fixlinenr];
3704 if ($line =~ /\/\/(.*)$/) {
3705 my $comment = trim($1);
3706 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3710 # Remove C99 comments.
3712 $opline =~ s@//.*@@;
3714 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3715 # the whole statement.
3716 #print "APW <$lines[$realline_next - 1]>\n";
3717 if (defined $realline_next &&
3718 exists $lines[$realline_next - 1] &&
3719 !defined $suppress_export{$realline_next} &&
3720 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3721 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3722 # Handle definitions which produce identifiers with
3725 # EXPORT_SYMBOL(something_foo);
3727 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3728 $name =~ /^${Ident}_$2/) {
3729 #print "FOO C name<$name>\n";
3730 $suppress_export{$realline_next} = 1;
3732 } elsif ($stat !~ /(?:
3734 ^.DEFINE_$Ident\(\Q$name\E\)|
3735 ^.DECLARE_$Ident\(\Q$name\E\)|
3736 ^.LIST_HEAD\(\Q$name\E\)|
3737 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3738 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3740 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3741 $suppress_export{$realline_next} = 2;
3743 $suppress_export{$realline_next} = 1;
3746 if (!defined $suppress_export{$linenr} &&
3747 $prevline =~ /^.\s*$/ &&
3748 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3749 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3750 #print "FOO B <$lines[$linenr - 1]>\n";
3751 $suppress_export{$linenr} = 2;
3753 if (defined $suppress_export{$linenr} &&
3754 $suppress_export{$linenr} == 2) {
3755 WARN("EXPORT_SYMBOL",
3756 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3759 # check for global initialisers.
3760 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3761 if (ERROR("GLOBAL_INITIALISERS",
3762 "do not initialise globals to $1\n" . $herecurr) &&
3764 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3767 # check for static initialisers.
3768 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3769 if (ERROR("INITIALISED_STATIC",
3770 "do not initialise statics to $1\n" .
3773 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3777 # check for misordered declarations of char/short/int/long with signed/unsigned
3778 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3780 WARN("MISORDERED_TYPE",
3781 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3784 # check for static const char * arrays.
3785 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3786 WARN("STATIC_CONST_CHAR_ARRAY",
3787 "static const char * array should probably be static const char * const\n" .
3791 # check for static char foo[] = "bar" declarations.
3792 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3793 WARN("STATIC_CONST_CHAR_ARRAY",
3794 "static char array declaration should probably be static const char\n" .
3798 # check for const <foo> const where <foo> is not a pointer or array type
3799 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3801 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3803 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3804 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3806 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3810 # check for non-global char *foo[] = {"bar", ...} declarations.
3811 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3812 WARN("STATIC_CONST_CHAR_ARRAY",
3813 "char * array declaration might be better as static const\n" .
3817 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3818 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3820 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3822 if (WARN("ARRAY_SIZE",
3823 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3825 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3830 # check for function declarations without arguments like "int foo()"
3831 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3832 if (ERROR("FUNCTION_WITHOUT_ARGS",
3833 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3835 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3839 # check for new typedefs, only function parameters and sparse annotations
3841 if ($line =~ /\btypedef\s/ &&
3842 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3843 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3844 $line !~ /\b$typeTypedefs\b/ &&
3845 $line !~ /\b__bitwise\b/) {
3846 WARN("NEW_TYPEDEFS",
3847 "do not add new typedefs\n" . $herecurr);
3850 # * goes on variable not on type
3852 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3854 my ($ident, $from, $to) = ($1, $2, $2);
3856 # Should start with a space.
3857 $to =~ s/^(\S)/ $1/;
3858 # Should not end with a space.
3860 # '*'s should not have spaces between.
3861 while ($to =~ s/\*\s+\*/\*\*/) {
3864 ## print "1: from<$from> to<$to> ident<$ident>\n";
3866 if (ERROR("POINTER_LOCATION",
3867 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3869 my $sub_from = $ident;
3870 my $sub_to = $ident;
3871 $sub_to =~ s/\Q$from\E/$to/;
3872 $fixed[$fixlinenr] =~
3873 s@\Q$sub_from\E@$sub_to@;
3877 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3879 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3881 # Should start with a space.
3882 $to =~ s/^(\S)/ $1/;
3883 # Should not end with a space.
3885 # '*'s should not have spaces between.
3886 while ($to =~ s/\*\s+\*/\*\*/) {
3888 # Modifiers should have spaces.
3889 $to =~ s/(\b$Modifier$)/$1 /;
3891 ## print "2: from<$from> to<$to> ident<$ident>\n";
3892 if ($from ne $to && $ident !~ /^$Modifier$/) {
3893 if (ERROR("POINTER_LOCATION",
3894 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3897 my $sub_from = $match;
3898 my $sub_to = $match;
3899 $sub_to =~ s/\Q$from\E/$to/;
3900 $fixed[$fixlinenr] =~
3901 s@\Q$sub_from\E@$sub_to@;
3906 # avoid BUG() or BUG_ON()
3907 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3908 my $msg_level = \&WARN;
3909 $msg_level = \&CHK if ($file);
3910 &{$msg_level}("AVOID_BUG",
3911 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3914 # avoid LINUX_VERSION_CODE
3915 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3916 WARN("LINUX_VERSION_CODE",
3917 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3920 # check for uses of printk_ratelimit
3921 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3922 WARN("PRINTK_RATELIMITED",
3923 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3926 # printk should use KERN_* levels
3927 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
3928 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3929 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
3932 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3934 my $level = lc($orig);
3935 $level = "warn" if ($level eq "warning");
3936 my $level2 = $level;
3937 $level2 = "dbg" if ($level eq "debug");
3938 WARN("PREFER_PR_LEVEL",
3939 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3942 if ($line =~ /\bpr_warning\s*\(/) {
3943 if (WARN("PREFER_PR_LEVEL",
3944 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3946 $fixed[$fixlinenr] =~
3947 s/\bpr_warning\b/pr_warn/;
3951 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3953 my $level = lc($orig);
3954 $level = "warn" if ($level eq "warning");
3955 $level = "dbg" if ($level eq "debug");
3956 WARN("PREFER_DEV_LEVEL",
3957 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3960 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
3961 # number of false positives, but assembly files are not checked, so at
3962 # least the arch entry code will not trigger this warning.
3963 if ($line =~ /\bENOSYS\b/) {
3965 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3968 # function brace can't be on same line, except for #defines of do while,
3969 # or if closed on same line
3970 if ($^V && $^V ge 5.10.0 &&
3971 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
3972 $sline !~ /\#\s*define\b.*do\s*\{/ &&
3974 if (ERROR("OPEN_BRACE",
3975 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
3977 fix_delete_line($fixlinenr, $rawline);
3978 my $fixed_line = $rawline;
3979 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3982 fix_insert_line($fixlinenr, ltrim($line1));
3983 fix_insert_line($fixlinenr, "\+{");
3984 if ($line2 !~ /^\s*$/) {
3985 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3990 # open braces for enum, union and struct go on the same line.
3991 if ($line =~ /^.\s*{/ &&
3992 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3993 if (ERROR("OPEN_BRACE",
3994 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3995 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3996 fix_delete_line($fixlinenr - 1, $prevrawline);
3997 fix_delete_line($fixlinenr, $rawline);
3998 my $fixedline = rtrim($prevrawline) . " {";
3999 fix_insert_line($fixlinenr, $fixedline);
4000 $fixedline = $rawline;
4001 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
4002 if ($fixedline !~ /^\+\s*$/) {
4003 fix_insert_line($fixlinenr, $fixedline);
4008 # missing space after union, struct or enum definition
4009 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4011 "missing space after $1 definition\n" . $herecurr) &&
4013 $fixed[$fixlinenr] =~
4014 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4018 # Function pointer declarations
4019 # check spacing between type, funcptr, and args
4020 # canonical declaration is "type (*funcptr)(args...)"
4021 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4023 my $pre_pointer_space = $2;
4024 my $post_pointer_space = $3;
4026 my $post_funcname_space = $5;
4027 my $pre_args_space = $6;
4029 # the $Declare variable will capture all spaces after the type
4030 # so check it for a missing trailing missing space but pointer return types
4031 # don't need a space so don't warn for those.
4032 my $post_declare_space = "";
4033 if ($declare =~ /(\s+)$/) {
4034 $post_declare_space = $1;
4035 $declare = rtrim($declare);
4037 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4039 "missing space after return type\n" . $herecurr);
4040 $post_declare_space = " ";
4043 # unnecessary space "type (*funcptr)(args...)"
4044 # This test is not currently implemented because these declarations are
4046 # int foo(int bar, ...)
4047 # and this is form shouldn't/doesn't generate a checkpatch warning.
4049 # elsif ($declare =~ /\s{2,}$/) {
4051 # "Multiple spaces after return type\n" . $herecurr);
4054 # unnecessary space "type ( *funcptr)(args...)"
4055 if (defined $pre_pointer_space &&
4056 $pre_pointer_space =~ /^\s/) {
4058 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4061 # unnecessary space "type (* funcptr)(args...)"
4062 if (defined $post_pointer_space &&
4063 $post_pointer_space =~ /^\s/) {
4065 "Unnecessary space before function pointer name\n" . $herecurr);
4068 # unnecessary space "type (*funcptr )(args...)"
4069 if (defined $post_funcname_space &&
4070 $post_funcname_space =~ /^\s/) {
4072 "Unnecessary space after function pointer name\n" . $herecurr);
4075 # unnecessary space "type (*funcptr) (args...)"
4076 if (defined $pre_args_space &&
4077 $pre_args_space =~ /^\s/) {
4079 "Unnecessary space before function pointer arguments\n" . $herecurr);
4082 if (show_type("SPACING") && $fix) {
4083 $fixed[$fixlinenr] =~
4084 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4088 # check for spacing round square brackets; allowed:
4089 # 1. with a type on the left -- int [] a;
4090 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4091 # 3. inside a curly brace -- = { [0...10] = 5 }
4092 while ($line =~ /(.*?\s)\[/g) {
4093 my ($where, $prefix) = ($-[1], $1);
4094 if ($prefix !~ /$Type\s+$/ &&
4095 ($where != 0 || $prefix !~ /^.\s+$/) &&
4096 $prefix !~ /[{,:]\s+$/) {
4097 if (ERROR("BRACKET_SPACE",
4098 "space prohibited before open square bracket '['\n" . $herecurr) &&
4100 $fixed[$fixlinenr] =~
4101 s/^(\+.*?)\s+\[/$1\[/;
4106 # check for spaces between functions and their parentheses.
4107 while ($line =~ /($Ident)\s+\(/g) {
4109 my $ctx_before = substr($line, 0, $-[1]);
4110 my $ctx = "$ctx_before$name";
4112 # Ignore those directives where spaces _are_ permitted.
4114 if|for|while|switch|return|case|
4115 volatile|__volatile__|
4116 __attribute__|format|__extension__|
4119 # cpp #define statements have non-optional spaces, ie
4120 # if there is a space between the name and the open
4121 # parenthesis it is simply not a parameter group.
4122 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4124 # cpp #elif statement condition may start with a (
4125 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4127 # If this whole things ends with a type its most
4128 # likely a typedef for a function.
4129 } elsif ($ctx =~ /$Type$/) {
4133 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4135 $fixed[$fixlinenr] =~
4136 s/\b$name\s+\(/$name\(/;
4141 # Check operator spacing.
4142 if (!($line=~/\#\s*include/)) {
4143 my $fixed_line = "";
4147 <<=|>>=|<=|>=|==|!=|
4148 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4149 =>|->|<<|>>|<|>|=|!|~|
4150 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4153 my @elements = split(/($ops|;)/, $opline);
4155 ## print("element count: <" . $#elements . ">\n");
4156 ## foreach my $el (@elements) {
4157 ## print("el: <$el>\n");
4160 my @fix_elements = ();
4163 foreach my $el (@elements) {
4164 push(@fix_elements, substr($rawline, $off, length($el)));
4165 $off += length($el);
4170 my $blank = copy_spacing($opline);
4171 my $last_after = -1;
4173 for (my $n = 0; $n < $#elements; $n += 2) {
4175 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4177 ## print("n: <$n> good: <$good>\n");
4179 $off += length($elements[$n]);
4181 # Pick up the preceding and succeeding characters.
4182 my $ca = substr($opline, 0, $off);
4184 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4185 $cc = substr($opline, $off + length($elements[$n + 1]));
4187 my $cb = "$ca$;$cc";
4190 $a = 'V' if ($elements[$n] ne '');
4191 $a = 'W' if ($elements[$n] =~ /\s$/);
4192 $a = 'C' if ($elements[$n] =~ /$;$/);
4193 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4194 $a = 'O' if ($elements[$n] eq '');
4195 $a = 'E' if ($ca =~ /^\s*$/);
4197 my $op = $elements[$n + 1];
4200 if (defined $elements[$n + 2]) {
4201 $c = 'V' if ($elements[$n + 2] ne '');
4202 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4203 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4204 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4205 $c = 'O' if ($elements[$n + 2] eq '');
4206 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4211 my $ctx = "${a}x${c}";
4213 my $at = "(ctx:$ctx)";
4215 my $ptr = substr($blank, 0, $off) . "^";
4216 my $hereptr = "$hereline$ptr\n";
4218 # Pull out the value of this operator.
4219 my $op_type = substr($curr_values, $off + 1, 1);
4221 # Get the full operator variant.
4222 my $opv = $op . substr($curr_vars, $off, 1);
4224 # Ignore operators passed as parameters.
4225 if ($op_type ne 'V' &&
4226 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4229 # } elsif ($op =~ /^$;+$/) {
4231 # ; should have either the end of line or a space or \ after it
4232 } elsif ($op eq ';') {
4233 if ($ctx !~ /.x[WEBC]/ &&
4234 $cc !~ /^\\/ && $cc !~ /^;/) {
4235 if (ERROR("SPACING",
4236 "space required after that '$op' $at\n" . $hereptr)) {
4237 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4243 } elsif ($op eq '//') {
4245 # : when part of a bitfield
4246 } elsif ($opv eq ':B') {
4247 # skip the bitfield test for now
4251 } elsif ($op eq '->') {
4252 if ($ctx =~ /Wx.|.xW/) {
4253 if (ERROR("SPACING",
4254 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4255 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4256 if (defined $fix_elements[$n + 2]) {
4257 $fix_elements[$n + 2] =~ s/^\s+//;
4263 # , must not have a space before and must have a space on the right.
4264 } elsif ($op eq ',') {
4265 my $rtrim_before = 0;
4266 my $space_after = 0;
4267 if ($ctx =~ /Wx./) {
4268 if (ERROR("SPACING",
4269 "space prohibited before that '$op' $at\n" . $hereptr)) {
4274 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4275 if (ERROR("SPACING",
4276 "space required after that '$op' $at\n" . $hereptr)) {
4282 if ($rtrim_before || $space_after) {
4283 if ($rtrim_before) {
4284 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4286 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4293 # '*' as part of a type definition -- reported already.
4294 } elsif ($opv eq '*_') {
4295 #warn "'*' is part of type\n";
4297 # unary operators should have a space before and
4298 # none after. May be left adjacent to another
4299 # unary operator, or a cast
4300 } elsif ($op eq '!' || $op eq '~' ||
4301 $opv eq '*U' || $opv eq '-U' ||
4302 $opv eq '&U' || $opv eq '&&U') {
4303 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4304 if (ERROR("SPACING",
4305 "space required before that '$op' $at\n" . $hereptr)) {
4306 if ($n != $last_after + 2) {
4307 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4312 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4313 # A unary '*' may be const
4315 } elsif ($ctx =~ /.xW/) {
4316 if (ERROR("SPACING",
4317 "space prohibited after that '$op' $at\n" . $hereptr)) {
4318 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4319 if (defined $fix_elements[$n + 2]) {
4320 $fix_elements[$n + 2] =~ s/^\s+//;
4326 # unary ++ and unary -- are allowed no space on one side.
4327 } elsif ($op eq '++' or $op eq '--') {
4328 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4329 if (ERROR("SPACING",
4330 "space required one side of that '$op' $at\n" . $hereptr)) {
4331 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4335 if ($ctx =~ /Wx[BE]/ ||
4336 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4337 if (ERROR("SPACING",
4338 "space prohibited before that '$op' $at\n" . $hereptr)) {
4339 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4343 if ($ctx =~ /ExW/) {
4344 if (ERROR("SPACING",
4345 "space prohibited after that '$op' $at\n" . $hereptr)) {
4346 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4347 if (defined $fix_elements[$n + 2]) {
4348 $fix_elements[$n + 2] =~ s/^\s+//;
4354 # << and >> may either have or not have spaces both sides
4355 } elsif ($op eq '<<' or $op eq '>>' or
4356 $op eq '&' or $op eq '^' or $op eq '|' or
4357 $op eq '+' or $op eq '-' or
4358 $op eq '*' or $op eq '/' or
4362 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4364 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4365 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4366 $fix_elements[$n + 2] =~ s/^\s+//;
4369 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4371 "space preferred before that '$op' $at\n" . $hereptr)) {
4372 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4376 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4377 if (ERROR("SPACING",
4378 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4379 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4380 if (defined $fix_elements[$n + 2]) {
4381 $fix_elements[$n + 2] =~ s/^\s+//;
4387 # A colon needs no spaces before when it is
4388 # terminating a case value or a label.
4389 } elsif ($opv eq ':C' || $opv eq ':L') {
4390 if ($ctx =~ /Wx./) {
4391 if (ERROR("SPACING",
4392 "space prohibited before that '$op' $at\n" . $hereptr)) {
4393 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4398 # All the others need spaces both sides.
4399 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4402 # Ignore email addresses <foo@bar>
4404 $cc =~ /^\S+\@\S+>/) ||
4406 $ca =~ /<\S+\@\S+$/))
4411 # for asm volatile statements
4412 # ignore a colon with another
4413 # colon immediately before or after
4415 ($ca =~ /:$/ || $cc =~ /^:/)) {
4419 # messages are ERROR, but ?: are CHK
4421 my $msg_level = \&ERROR;
4422 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4424 if (&{$msg_level}("SPACING",
4425 "spaces required around that '$op' $at\n" . $hereptr)) {
4426 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4427 if (defined $fix_elements[$n + 2]) {
4428 $fix_elements[$n + 2] =~ s/^\s+//;
4434 $off += length($elements[$n + 1]);
4436 ## print("n: <$n> GOOD: <$good>\n");
4438 $fixed_line = $fixed_line . $good;
4441 if (($#elements % 2) == 0) {
4442 $fixed_line = $fixed_line . $fix_elements[$#elements];
4445 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4446 $fixed[$fixlinenr] = $fixed_line;
4452 # check for whitespace before a non-naked semicolon
4453 if ($line =~ /^\+.*\S\s+;\s*$/) {
4455 "space prohibited before semicolon\n" . $herecurr) &&
4457 1 while $fixed[$fixlinenr] =~
4458 s/^(\+.*\S)\s+;/$1;/;
4462 # check for multiple assignments
4463 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4464 CHK("MULTIPLE_ASSIGNMENTS",
4465 "multiple assignments should be avoided\n" . $herecurr);
4468 ## # check for multiple declarations, allowing for a function declaration
4470 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4471 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4473 ## # Remove any bracketed sections to ensure we do not
4474 ## # falsly report the parameters of functions.
4476 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4478 ## if ($ln =~ /,/) {
4479 ## WARN("MULTIPLE_DECLARATION",
4480 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4484 #need space before brace following if, while, etc
4485 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4487 if (ERROR("SPACING",
4488 "space required before the open brace '{'\n" . $herecurr) &&
4490 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
4494 ## # check for blank lines before declarations
4495 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4496 ## $prevrawline =~ /^.\s*$/) {
4498 ## "No blank lines before declarations\n" . $hereprev);
4502 # closing brace should have a space following it when it has anything
4504 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4505 if (ERROR("SPACING",
4506 "space required after that close brace '}'\n" . $herecurr) &&
4508 $fixed[$fixlinenr] =~
4509 s/}((?!(?:,|;|\)))\S)/} $1/;
4513 # check spacing on square brackets
4514 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4515 if (ERROR("SPACING",
4516 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4518 $fixed[$fixlinenr] =~
4522 if ($line =~ /\s\]/) {
4523 if (ERROR("SPACING",
4524 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4526 $fixed[$fixlinenr] =~
4531 # check spacing on parentheses
4532 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4533 $line !~ /for\s*\(\s+;/) {
4534 if (ERROR("SPACING",
4535 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4537 $fixed[$fixlinenr] =~
4541 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4542 $line !~ /for\s*\(.*;\s+\)/ &&
4543 $line !~ /:\s+\)/) {
4544 if (ERROR("SPACING",
4545 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4547 $fixed[$fixlinenr] =~
4552 # check unnecessary parentheses around addressof/dereference single $Lvals
4553 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4555 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4557 if (CHK("UNNECESSARY_PARENTHESES",
4558 "Unnecessary parentheses around $var\n" . $herecurr) &&
4560 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4564 # check for unnecessary parentheses around function pointer uses
4565 # ie: (foo->bar)(); should be foo->bar();
4566 # but not "if (foo->bar) (" to avoid some false positives
4567 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4569 if (CHK("UNNECESSARY_PARENTHESES",
4570 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4572 my $var2 = deparenthesize($var);
4574 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4578 # check for unnecessary parentheses around comparisons in if uses
4579 # when !drivers/staging or command-line uses --strict
4580 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
4581 $^V && $^V ge 5.10.0 && defined($stat) &&
4582 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
4584 my $test = substr($2, 1, -1);
4586 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
4588 # avoid parentheses around potential macro args
4589 next if ($match =~ /^\s*\w+\s*$/);
4590 if (!defined($herectx)) {
4591 $herectx = $here . "\n";
4592 my $cnt = statement_rawlines($if_stat);
4593 for (my $n = 0; $n < $cnt; $n++) {
4594 my $rl = raw_line($linenr, $n);
4595 $herectx .= $rl . "\n";
4596 last if $rl =~ /^[ \+].*\{/;
4599 CHK("UNNECESSARY_PARENTHESES",
4600 "Unnecessary parentheses around '$match'\n" . $herectx);
4604 #goto labels aren't indented, allow a single space however
4605 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4606 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4607 if (WARN("INDENTED_LABEL",
4608 "labels should not be indented\n" . $herecurr) &&
4610 $fixed[$fixlinenr] =~
4615 # return is not a function
4616 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4618 if ($^V && $^V ge 5.10.0 &&
4619 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4621 $value = deparenthesize($value);
4622 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4623 ERROR("RETURN_PARENTHESES",
4624 "return is not a function, parentheses are not required\n" . $herecurr);
4626 } elsif ($spacing !~ /\s+/) {
4628 "space required before the open parenthesis '('\n" . $herecurr);
4632 # unnecessary return in a void function
4633 # at end-of-function, with the previous line a single leading tab, then return;
4634 # and the line before that not a goto label target like "out:"
4635 if ($sline =~ /^[ \+]}\s*$/ &&
4636 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4638 $lines[$linenr - 3] =~ /^[ +]/ &&
4639 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4641 "void function return statements are not generally useful\n" . $hereprev);
4644 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4645 if ($^V && $^V ge 5.10.0 &&
4646 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4647 my $openparens = $1;
4648 my $count = $openparens =~ tr@\(@\(@;
4650 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4651 my $comp = $4; #Not $1 because of $LvalOrFunc
4652 $msg = " - maybe == should be = ?" if ($comp eq "==");
4653 WARN("UNNECESSARY_PARENTHESES",
4654 "Unnecessary parentheses$msg\n" . $herecurr);
4658 # comparisons with a constant or upper case identifier on the left
4659 # avoid cases like "foo + BAR < baz"
4660 # only fix matches surrounded by parentheses to avoid incorrect
4661 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4662 if ($^V && $^V ge 5.10.0 &&
4663 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4668 my $newcomp = $comp;
4669 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4670 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4671 WARN("CONSTANT_COMPARISON",
4672 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4676 } elsif ($comp eq "<=") {
4678 } elsif ($comp eq ">") {
4680 } elsif ($comp eq ">=") {
4683 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4687 # Return of what appears to be an errno should normally be negative
4688 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4690 if ($name ne 'EOF' && $name ne 'ERROR') {
4691 WARN("USE_NEGATIVE_ERRNO",
4692 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4696 # Need a space before open parenthesis after if, while etc
4697 if ($line =~ /\b(if|while|for|switch)\(/) {
4698 if (ERROR("SPACING",
4699 "space required before the open parenthesis '('\n" . $herecurr) &&
4701 $fixed[$fixlinenr] =~
4702 s/\b(if|while|for|switch)\(/$1 \(/;
4706 # Check for illegal assignment in if conditional -- and check for trailing
4707 # statements after the conditional.
4708 if ($line =~ /do\s*(?!{)/) {
4709 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4710 ctx_statement_block($linenr, $realcnt, 0)
4711 if (!defined $stat);
4712 my ($stat_next) = ctx_statement_block($line_nr_next,
4713 $remain_next, $off_next);
4714 $stat_next =~ s/\n./\n /g;
4715 ##print "stat<$stat> stat_next<$stat_next>\n";
4717 if ($stat_next =~ /^\s*while\b/) {
4718 # If the statement carries leading newlines,
4719 # then count those as offsets.
4721 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4723 statement_rawlines($whitespace) - 1;
4725 $suppress_whiletrailers{$line_nr_next +
4729 if (!defined $suppress_whiletrailers{$linenr} &&
4730 defined($stat) && defined($cond) &&
4731 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4732 my ($s, $c) = ($stat, $cond);
4734 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4735 ERROR("ASSIGN_IN_IF",
4736 "do not use assignment in if condition\n" . $herecurr);
4739 # Find out what is on the end of the line after the
4741 substr($s, 0, length($c), '');
4743 $s =~ s/$;//g; # Remove any comments
4744 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4745 $c !~ /}\s*while\s*/)
4747 # Find out how long the conditional actually is.
4748 my @newlines = ($c =~ /\n/gs);
4749 my $cond_lines = 1 + $#newlines;
4752 $stat_real = raw_line($linenr, $cond_lines)
4753 . "\n" if ($cond_lines);
4754 if (defined($stat_real) && $cond_lines > 1) {
4755 $stat_real = "[...]\n$stat_real";
4758 ERROR("TRAILING_STATEMENTS",
4759 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4763 # Check for bitwise tests written as boolean
4775 WARN("HEXADECIMAL_BOOLEAN_TEST",
4776 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4779 # if and else should not have general statements after it
4780 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4782 $s =~ s/$;//g; # Remove any comments
4783 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4784 ERROR("TRAILING_STATEMENTS",
4785 "trailing statements should be on next line\n" . $herecurr);
4788 # if should not continue a brace
4789 if ($line =~ /}\s*if\b/) {
4790 ERROR("TRAILING_STATEMENTS",
4791 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4794 # case and default should not have general statements after them
4795 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4797 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4801 ERROR("TRAILING_STATEMENTS",
4802 "trailing statements should be on next line\n" . $herecurr);
4805 # Check for }<nl>else {, these must be at the same
4806 # indent level to be relevant to each other.
4807 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4808 $previndent == $indent) {
4809 if (ERROR("ELSE_AFTER_BRACE",
4810 "else should follow close brace '}'\n" . $hereprev) &&
4811 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4812 fix_delete_line($fixlinenr - 1, $prevrawline);
4813 fix_delete_line($fixlinenr, $rawline);
4814 my $fixedline = $prevrawline;
4815 $fixedline =~ s/}\s*$//;
4816 if ($fixedline !~ /^\+\s*$/) {
4817 fix_insert_line($fixlinenr, $fixedline);
4819 $fixedline = $rawline;
4820 $fixedline =~ s/^(.\s*)else/$1} else/;
4821 fix_insert_line($fixlinenr, $fixedline);
4825 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4826 $previndent == $indent) {
4827 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4829 # Find out what is on the end of the line after the
4831 substr($s, 0, length($c), '');
4834 if ($s =~ /^\s*;/) {
4835 if (ERROR("WHILE_AFTER_BRACE",
4836 "while should follow close brace '}'\n" . $hereprev) &&
4837 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4838 fix_delete_line($fixlinenr - 1, $prevrawline);
4839 fix_delete_line($fixlinenr, $rawline);
4840 my $fixedline = $prevrawline;
4841 my $trailing = $rawline;
4842 $trailing =~ s/^\+//;
4843 $trailing = trim($trailing);
4844 $fixedline =~ s/}\s*$/} $trailing/;
4845 fix_insert_line($fixlinenr, $fixedline);
4850 #Specific variable tests
4851 while ($line =~ m{($Constant|$Lval)}g) {
4854 #gcc binary extension
4855 if ($var =~ /^$Binary$/) {
4856 if (WARN("GCC_BINARY_CONSTANT",
4857 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4859 my $hexval = sprintf("0x%x", oct($var));
4860 $fixed[$fixlinenr] =~
4861 s/\b$var\b/$hexval/;
4866 if ($var !~ /^$Constant$/ &&
4867 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4868 #Ignore Page<foo> variants
4869 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4870 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4871 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4872 #Ignore some three character SI units explicitly, like MiB and KHz
4873 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4874 while ($var =~ m{($Ident)}g) {
4876 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4878 seed_camelcase_includes();
4879 if (!$file && !$camelcase_file_seeded) {
4880 seed_camelcase_file($realfile);
4881 $camelcase_file_seeded = 1;
4884 if (!defined $camelcase{$word}) {
4885 $camelcase{$word} = 1;
4887 "Avoid CamelCase: <$word>\n" . $herecurr);
4893 #no spaces allowed after \ in define
4894 if ($line =~ /\#\s*define.*\\\s+$/) {
4895 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4896 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4898 $fixed[$fixlinenr] =~ s/\s+$//;
4902 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4903 # itself <asm/foo.h> (uses RAW line)
4904 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4906 my $checkfile = "include/linux/$file";
4907 if (-f "$root/$checkfile" &&
4908 $realfile ne $checkfile &&
4909 $1 !~ /$allowed_asm_includes/)
4911 my $asminclude = `grep -Ec
"#include\\s+<asm/$file>" $root/$checkfile`;
4912 if ($asminclude > 0) {
4913 if ($realfile =~ m{^arch/}) {
4914 CHK
("ARCH_INCLUDE_LINUX",
4915 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4917 WARN
("INCLUDE_LINUX",
4918 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4924 # multi-statement macros should be enclosed in a do while loop, grab the
4925 # first statement and ensure its the whole macro if its not enclosed
4926 # in a known good container
4927 if ($realfile !~ m
@/vmlinux.lds
.h
$@ &&
4928 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4931 my ($off, $dstat, $dcond, $rest);
4933 my $has_flow_statement = 0;
4934 my $has_arg_concat = 0;
4935 ($dstat, $dcond, $ln, $cnt, $off) =
4936 ctx_statement_block
($linenr, $realcnt, 0);
4938 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4939 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4941 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4942 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4944 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4945 my $define_args = $1;
4946 my $define_stmt = $dstat;
4949 if (defined $define_args && $define_args ne "") {
4950 $define_args = substr($define_args, 1, length($define_args) - 2);
4951 $define_args =~ s/\s*//g;
4952 @def_args = split(",", $define_args);
4956 $dstat =~ s/\\\n.//g;
4957 $dstat =~ s/^\s*//s;
4958 $dstat =~ s/\s*$//s;
4960 # Flatten any parentheses and braces
4961 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4962 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4963 $dstat =~ s/.\[[^\[\]]*\]/1/)
4967 # Flatten any obvious string concatentation.
4968 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4969 $dstat =~ s/$Ident\s*($String)/$1/)
4973 # Make asm volatile uses seem like a generic function
4974 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4976 my $exceptions = qr{
4989 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4992 my $stmt_cnt = statement_rawlines
($ctx);
4993 my $herectx = get_stat_here
($linenr, $stmt_cnt, $here);
4996 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4997 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4998 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4999 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
5000 $dstat !~ /$exceptions/ &&
5001 $dstat !~ /^\.$Ident\s*=/ && # .foo =
5002 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
5003 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
5004 $dstat !~ /^for\s*$Constant$/ && # for (...)
5005 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
5006 $dstat !~ /^do\s*{/ && # do {...
5007 $dstat !~ /^\(\{/ && # ({...
5008 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
5010 if ($dstat =~ /^\s*if\b/) {
5011 ERROR
("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5012 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5013 } elsif ($dstat =~ /;/) {
5014 ERROR
("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5015 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5017 ERROR
("COMPLEX_MACRO",
5018 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5023 # Make $define_stmt single line, comment-free, etc
5024 my @stmt_array = split('\n', $define_stmt);
5027 foreach my $l (@stmt_array) {
5032 } elsif ($l =~ /^[\+ ]/) {
5033 $define_stmt .= substr($l, 1);
5036 $define_stmt =~ s/$;//g;
5037 $define_stmt =~ s/\s+/ /g;
5038 $define_stmt = trim
($define_stmt);
5040 # check if any macro arguments are reused (ignore '...' and 'type')
5041 foreach my $arg (@def_args) {
5042 next if ($arg =~ /\.\.\./);
5043 next if ($arg =~ /^type$/i);
5044 my $tmp_stmt = $define_stmt;
5045 $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
5046 $tmp_stmt =~ s/\#+\s*$arg\b//g;
5047 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
5048 my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
5050 CHK
("MACRO_ARG_REUSE",
5051 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
5053 # check if any macro arguments may have other precedence issues
5054 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
5055 ((defined($1) && $1 ne ',') ||
5056 (defined($2) && $2 ne ','))) {
5057 CHK
("MACRO_ARG_PRECEDENCE",
5058 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
5062 # check for macros with flow control, but without ## concatenation
5063 # ## concatenation is commonly a macro that defines a function so ignore those
5064 if ($has_flow_statement && !$has_arg_concat) {
5065 my $cnt = statement_rawlines
($ctx);
5066 my $herectx = get_stat_here
($linenr, $cnt, $here);
5068 WARN
("MACRO_WITH_FLOW_CONTROL",
5069 "Macros with flow control statements should be avoided\n" . "$herectx");
5072 # check for line continuations outside of #defines, preprocessor #, and asm
5075 if ($prevline !~ /^..*\\$/ &&
5076 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
5077 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
5078 $line =~ /^\+.*\\$/) {
5079 WARN
("LINE_CONTINUATIONS",
5080 "Avoid unnecessary line continuations\n" . $herecurr);
5084 # do {} while (0) macro tests:
5085 # single-statement macros do not need to be enclosed in do while (0) loop,
5086 # macro should not end with a semicolon
5087 if ($^V && $^V ge 5.10.0 &&
5088 $realfile !~ m
@/vmlinux.lds
.h
$@ &&
5089 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5092 my ($off, $dstat, $dcond, $rest);
5094 ($dstat, $dcond, $ln, $cnt, $off) =
5095 ctx_statement_block
($linenr, $realcnt, 0);
5098 $dstat =~ s/\\\n.//g;
5101 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5106 my $cnt = statement_rawlines
($ctx);
5107 my $herectx = get_stat_here
($linenr, $cnt, $here);
5109 if (($stmts =~ tr/;/;/) == 1 &&
5110 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5111 WARN
("SINGLE_STATEMENT_DO_WHILE_MACRO",
5112 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5114 if (defined $semis && $semis ne "") {
5115 WARN
("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5116 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5118 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5120 my $cnt = statement_rawlines
($ctx);
5121 my $herectx = get_stat_here
($linenr, $cnt, $here);
5123 WARN
("TRAILING_SEMICOLON",
5124 "macros should not use a trailing semicolon\n" . "$herectx");
5128 # check for redundant bracing round if etc
5129 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5130 my ($level, $endln, @chunks) =
5131 ctx_statement_full
($linenr, $realcnt, 1);
5132 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5133 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5134 if ($#chunks > 0 && $level == 0) {
5138 my $herectx = $here . "\n";
5139 my $ln = $linenr - 1;
5140 for my $chunk (@chunks) {
5141 my ($cond, $block) = @{$chunk};
5143 # If the condition carries leading newlines, then count those as offsets.
5144 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5145 my $offset = statement_rawlines
($whitespace) - 1;
5147 $allowed[$allow] = 0;
5148 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5150 # We have looked at and allowed this specific line.
5151 $suppress_ifbraces{$ln + $offset} = 1;
5153 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5154 $ln += statement_rawlines
($block) - 1;
5156 substr($block, 0, length($cond), '');
5158 $seen++ if ($block =~ /^\s*{/);
5160 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5161 if (statement_lines
($cond) > 1) {
5162 #print "APW: ALLOWED: cond<$cond>\n";
5163 $allowed[$allow] = 1;
5165 if ($block =~/\b(?:if|for|while)\b/) {
5166 #print "APW: ALLOWED: block<$block>\n";
5167 $allowed[$allow] = 1;
5169 if (statement_block_size
($block) > 1) {
5170 #print "APW: ALLOWED: lines block<$block>\n";
5171 $allowed[$allow] = 1;
5176 my $sum_allowed = 0;
5177 foreach (@allowed) {
5180 if ($sum_allowed == 0) {
5182 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5183 } elsif ($sum_allowed != $allow &&
5186 "braces {} should be used on all arms of this statement\n" . $herectx);
5191 if (!defined $suppress_ifbraces{$linenr - 1} &&
5192 $line =~ /\b(if|while|for|else)\b/) {
5195 # Check the pre-context.
5196 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5197 #print "APW: ALLOWED: pre<$1>\n";
5201 my ($level, $endln, @chunks) =
5202 ctx_statement_full
($linenr, $realcnt, $-[0]);
5204 # Check the condition.
5205 my ($cond, $block) = @{$chunks[0]};
5206 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5207 if (defined $cond) {
5208 substr($block, 0, length($cond), '');
5210 if (statement_lines
($cond) > 1) {
5211 #print "APW: ALLOWED: cond<$cond>\n";
5214 if ($block =~/\b(?:if|for|while)\b/) {
5215 #print "APW: ALLOWED: block<$block>\n";
5218 if (statement_block_size
($block) > 1) {
5219 #print "APW: ALLOWED: lines block<$block>\n";
5222 # Check the post-context.
5223 if (defined $chunks[1]) {
5224 my ($cond, $block) = @{$chunks[1]};
5225 if (defined $cond) {
5226 substr($block, 0, length($cond), '');
5228 if ($block =~ /^\s*\{/) {
5229 #print "APW: ALLOWED: chunk-1 block<$block>\n";
5233 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5234 my $cnt = statement_rawlines
($block);
5235 my $herectx = get_stat_here
($linenr, $cnt, $here);
5238 "braces {} are not necessary for single statement blocks\n" . $herectx);
5242 # check for single line unbalanced braces
5243 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5244 $sline =~ /^.\s*else\s*\{\s*$/) {
5245 CHK
("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5248 # check for unnecessary blank lines around braces
5249 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5251 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5252 $fix && $prevrawline =~ /^\+/) {
5253 fix_delete_line
($fixlinenr - 1, $prevrawline);
5256 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5258 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5260 fix_delete_line
($fixlinenr, $rawline);
5264 # no volatiles please
5265 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5266 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5268 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5271 # Check for user-visible strings broken across lines, which breaks the ability
5272 # to grep for the string. Make exceptions when the previous string ends in a
5273 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5274 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5275 if ($line =~ /^\+\s*$String/ &&
5276 $prevline =~ /"\s*$/ &&
5277 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5278 if (WARN
("SPLIT_STRING",
5279 "quoted string split across lines\n" . $hereprev) &&
5281 $prevrawline =~ /^\+.*"\s*$/ &&
5282 $last_coalesced_string_linenr != $linenr - 1) {
5283 my $extracted_string = get_quoted_string
($line, $rawline);
5284 my $comma_close = "";
5285 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5289 fix_delete_line
($fixlinenr - 1, $prevrawline);
5290 fix_delete_line
($fixlinenr, $rawline);
5291 my $fixedline = $prevrawline;
5292 $fixedline =~ s/"\s*$//;
5293 $fixedline .= substr($extracted_string, 1) . trim
($comma_close);
5294 fix_insert_line
($fixlinenr - 1, $fixedline);
5295 $fixedline = $rawline;
5296 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5297 if ($fixedline !~ /\+\s*$/) {
5298 fix_insert_line
($fixlinenr, $fixedline);
5300 $last_coalesced_string_linenr = $linenr;
5304 # check for missing a space in a string concatenation
5305 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5306 WARN
('MISSING_SPACE',
5307 "break quoted strings at a space character\n" . $hereprev);
5310 # check for an embedded function name in a string when the function is known
5311 # This does not work very well for -f --file checking as it depends on patch
5312 # context providing the function name or a single line form for in-file
5313 # function declarations
5314 if ($line =~ /^\+.*$String/ &&
5315 defined($context_function) &&
5316 get_quoted_string
($line, $rawline) =~ /\b$context_function\b/ &&
5317 length(get_quoted_string
($line, $rawline)) != (length($context_function) + 2)) {
5318 WARN
("EMBEDDED_FUNCTION_NAME",
5319 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
5322 # check for spaces before a quoted newline
5323 if ($rawline =~ /^.*\".*\s\\n/) {
5324 if (WARN
("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5325 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5327 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5332 # concatenated string without spaces between elements
5333 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5334 CHK
("CONCATENATED_STRING",
5335 "Concatenated strings should use spaces between elements\n" . $herecurr);
5338 # uncoalesced string fragments
5339 if ($line =~ /$String\s*"/) {
5340 WARN
("STRING_FRAGMENTS",
5341 "Consecutive strings are generally better as a single string\n" . $herecurr);
5344 # check for non-standard and hex prefixed decimal printf formats
5345 my $show_L = 1; #don't show the same defect twice
5347 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5348 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
5349 $string =~ s/%%/__/g;
5351 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
5353 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
5357 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
5359 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
5362 # check for 0x<decimal>
5363 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
5364 ERROR
("PRINTF_0XDECIMAL",
5365 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5369 # check for line continuations in quoted strings with odd counts of "
5370 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
5371 WARN
("LINE_CONTINUATIONS",
5372 "Avoid line continuations in quoted strings\n" . $herecurr);
5376 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5377 CHK
("REDUNDANT_CODE",
5378 "if this code is redundant consider removing it\n" .
5382 # check for needless "if (<foo>) fn(<foo>)" uses
5383 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5384 my $tested = quotemeta($1);
5385 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5386 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5388 if (WARN
('NEEDLESS_IF',
5389 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5392 my $leading_tabs = "";
5393 my $new_leading_tabs = "";
5394 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5399 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5400 $new_leading_tabs = $1;
5401 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5408 fix_delete_line
($fixlinenr - 1, $prevrawline);
5409 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5415 # check for unnecessary "Out of Memory" messages
5416 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5417 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5418 (defined $1 || defined $3) &&
5421 my $testline = $lines[$linenr - 3];
5423 my ($s, $c) = ctx_statement_block
($linenr - 3, $realcnt, 0);
5424 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5426 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|kmemdup|(?:dev_)?alloc_skb)/) {
5428 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5432 # check for logging functions with KERN_<LEVEL>
5433 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5434 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5436 if (WARN
("UNNECESSARY_KERN_LEVEL",
5437 "Possible unnecessary $level\n" . $herecurr) &&
5439 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5443 # check for logging continuations
5444 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
5445 WARN
("LOGGING_CONTINUATION",
5446 "Avoid logging continuation uses where feasible\n" . $herecurr);
5449 # check for mask then right shift without a parentheses
5450 if ($^V && $^V ge 5.10.0 &&
5451 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5452 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5453 WARN
("MASK_THEN_SHIFT",
5454 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5457 # check for pointer comparisons to NULL
5458 if ($^V && $^V ge 5.10.0) {
5459 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5462 $equal = "" if ($4 eq "!=");
5463 if (CHK
("COMPARISON_TO_NULL",
5464 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5466 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5471 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5472 if ($line =~ /(\b$InitAttribute\b)/) {
5474 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5477 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5478 ERROR
("MISPLACED_INIT",
5479 "$attr should be placed after $var\n" . $herecurr)) ||
5480 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5481 WARN
("MISPLACED_INIT",
5482 "$attr should be placed after $var\n" . $herecurr))) &&
5484 $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;
5489 # check for $InitAttributeData (ie: __initdata) with const
5490 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5492 $attr =~ /($InitAttributePrefix)(.*)/;
5493 my $attr_prefix = $1;
5495 if (ERROR
("INIT_ATTRIBUTE",
5496 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5498 $fixed[$fixlinenr] =~
5499 s/$InitAttributeData/${attr_prefix}initconst/;
5503 # check for $InitAttributeConst (ie: __initconst) without const
5504 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5506 if (ERROR
("INIT_ATTRIBUTE",
5507 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5509 my $lead = $fixed[$fixlinenr] =~
5510 /(^\+\s*(?:static\s+))/;
5512 $lead = "$lead " if ($lead !~ /^\+$/);
5513 $lead = "${lead}const ";
5514 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5518 # check for __read_mostly with const non-pointer (should just be const)
5519 if ($line =~ /\b__read_mostly\b/ &&
5520 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5521 if (ERROR
("CONST_READ_MOSTLY",
5522 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5524 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5528 # don't use __constant_<foo> functions outside of include/uapi/
5529 if ($realfile !~ m
@^include/uapi/@ &&
5530 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5531 my $constant_func = $1;
5532 my $func = $constant_func;
5533 $func =~ s/^__constant_//;
5534 if (WARN
("CONSTANT_CONVERSION",
5535 "$constant_func should be $func\n" . $herecurr) &&
5537 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5541 # prefer usleep_range over udelay
5542 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5544 # ignore udelay's < 10, however
5545 if (! ($delay < 10) ) {
5547 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5549 if ($delay > 2000) {
5551 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5555 # warn about unexpectedly long msleep's
5556 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5559 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5563 # check for comparisons of jiffies
5564 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5565 WARN
("JIFFIES_COMPARISON",
5566 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5569 # check for comparisons of get_jiffies_64()
5570 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5571 WARN
("JIFFIES_COMPARISON",
5572 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5575 # warn about #ifdefs in C files
5576 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5577 # print "#ifdef in C files should be avoided\n";
5578 # print "$herecurr";
5582 # warn about spacing in #ifdefs
5583 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5584 if (ERROR
("SPACING",
5585 "exactly one space required after that #$1\n" . $herecurr) &&
5587 $fixed[$fixlinenr] =~
5588 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5593 # check for spinlock_t definitions without a comment.
5594 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5595 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5597 if (!ctx_has_comment
($first_line, $linenr)) {
5598 CHK
("UNCOMMENTED_DEFINITION",
5599 "$1 definition without comment\n" . $herecurr);
5602 # check for memory barriers without a comment.
5608 read_barrier_depends
5610 my $barrier_stems = qr{
5618 my $all_barriers = qr{
5620 smp_
(?
:$barrier_stems)|
5621 virt_
(?
:$barrier_stems)
5624 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5625 if (!ctx_has_comment
($first_line, $linenr)) {
5626 WARN
("MEMORY_BARRIER",
5627 "memory barrier without comment\n" . $herecurr);
5631 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5633 if ($realfile !~ m
@^include/asm-generic
/@ &&
5634 $realfile !~ m
@/barrier\.h
$@ &&
5635 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5636 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5637 WARN
("MEMORY_BARRIER",
5638 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5641 # check for waitqueue_active without a comment.
5642 if ($line =~ /\bwaitqueue_active\s*\(/) {
5643 if (!ctx_has_comment
($first_line, $linenr)) {
5644 WARN
("WAITQUEUE_ACTIVE",
5645 "waitqueue_active without comment\n" . $herecurr);
5649 # check for smp_read_barrier_depends and read_barrier_depends
5650 if (!$file && $line =~ /\b(smp_|)read_barrier_depends\s*\(/) {
5651 WARN
("READ_BARRIER_DEPENDS",
5652 "$1read_barrier_depends should only be used in READ_ONCE or DEC Alpha code\n" . $herecurr);
5655 # check of hardware specific defines
5656 if ($line =~ m
@^.\s
*\#\s
*if.*\b(__i386__
|__powerpc64__
|__sun__
|__s390x__
)\b@ && $realfile !~ m
@include/asm-@) {
5658 "architecture specific defines should be avoided\n" . $herecurr);
5661 # check that the storage class is not after a type
5662 if ($line =~ /\b($Type)\s+($Storage)\b/) {
5663 WARN
("STORAGE_CLASS",
5664 "storage class '$2' should be located before type '$1'\n" . $herecurr);
5666 # Check that the storage class is at the beginning of a declaration
5667 if ($line =~ /\b$Storage\b/ &&
5668 $line !~ /^.\s*$Storage/ &&
5669 $line =~ /^.\s*(.+?)\$Storage\s/ &&
5670 $1 !~ /[\,\)]\s*$/) {
5671 WARN
("STORAGE_CLASS",
5672 "storage class should be at the beginning of the declaration\n" . $herecurr);
5675 # check the location of the inline attribute, that it is between
5676 # storage class and type.
5677 if ($line =~ /\b$Type\s+$Inline\b/ ||
5678 $line =~ /\b$Inline\s+$Storage\b/) {
5679 ERROR
("INLINE_LOCATION",
5680 "inline keyword should sit between storage class and type\n" . $herecurr);
5683 # Check for __inline__ and __inline, prefer inline
5684 if ($realfile !~ m
@\binclude/uapi/@ &&
5685 $line =~ /\b(__inline__|__inline)\b/) {
5687 "plain inline is preferred over $1\n" . $herecurr) &&
5689 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5694 # Check for __attribute__ packed, prefer __packed
5695 if ($realfile !~ m
@\binclude/uapi/@ &&
5696 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5697 WARN
("PREFER_PACKED",
5698 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5701 # Check for __attribute__ aligned, prefer __aligned
5702 if ($realfile !~ m
@\binclude/uapi/@ &&
5703 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5704 WARN
("PREFER_ALIGNED",
5705 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5708 # Check for __attribute__ format(printf, prefer __printf
5709 if ($realfile !~ m
@\binclude/uapi/@ &&
5710 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5711 if (WARN
("PREFER_PRINTF",
5712 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5714 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5719 # Check for __attribute__ format(scanf, prefer __scanf
5720 if ($realfile !~ m
@\binclude/uapi/@ &&
5721 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5722 if (WARN
("PREFER_SCANF",
5723 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5725 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5729 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5730 if ($^V && $^V ge 5.10.0 &&
5731 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5732 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5733 $line =~ /\b__weak\b/)) {
5734 ERROR
("WEAK_DECLARATION",
5735 "Using weak declarations can have unintended link defects\n" . $herecurr);
5738 # check for c99 types like uint8_t used outside of uapi/ and tools/
5739 if ($realfile !~ m
@\binclude/uapi/@ &&
5740 $realfile !~ m
@\btools/@ &&
5741 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5743 if ($type =~ /\b($typeC99Typedefs)\b/) {
5745 my $kernel_type = 'u';
5746 $kernel_type = 's' if ($type =~ /^_*[si]/);
5749 if (CHK
("PREFER_KERNEL_TYPES",
5750 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5752 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5757 # check for cast of C90 native int or longer types constants
5758 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5761 if (WARN
("TYPECAST_INT_CONSTANT",
5762 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5765 my $newconst = $const;
5766 $newconst =~ s/${Int_type}$//;
5767 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5768 if ($cast =~ /\blong\s+long\b/) {
5770 } elsif ($cast =~ /\blong\b/) {
5773 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5777 # check for sizeof(&)
5778 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5779 WARN
("SIZEOF_ADDRESS",
5780 "sizeof(& should be avoided\n" . $herecurr);
5783 # check for sizeof without parenthesis
5784 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5785 if (WARN
("SIZEOF_PARENTHESIS",
5786 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5788 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5792 # check for struct spinlock declarations
5793 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5794 WARN
("USE_SPINLOCK_T",
5795 "struct spinlock should be spinlock_t\n" . $herecurr);
5798 # check for seq_printf uses that could be seq_puts
5799 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5800 my $fmt = get_quoted_string
($line, $rawline);
5803 if (WARN
("PREFER_SEQ_PUTS",
5804 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5806 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5811 # check for vsprintf extension %p<foo> misuses
5812 if ($^V && $^V ge 5.10.0 &&
5814 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
5815 $1 !~ /^_*volatile_*$/) {
5818 my $bad_specifier = "";
5821 my $lc = $stat =~ tr
@\n@@;
5822 $lc = $lc + $linenr;
5823 for (my $count = $linenr; $count <= $lc; $count++) {
5824 my $fmt = get_quoted_string
($lines[$count - 1], raw_line
($count, 0));
5827 while ($fmt =~ /(\%[\*\d\.]*p(\w))/g) {
5830 if ($extension !~ /[SsBKRraEhMmIiUDdgVCbGNOx]/) {
5831 $bad_specifier = $specifier;
5834 if ($extension eq "x" && !defined($stat_real)) {
5835 if (!defined($stat_real)) {
5836 $stat_real = get_stat_real
($linenr, $lc);
5838 WARN
("VSPRINTF_SPECIFIER_PX",
5839 "Using vsprintf specifier '\%px' potentially exposes the kernel memory layout, if you don't really need the address please consider using '\%p'.\n" . "$here\n$stat_real\n");
5842 if ($bad_specifier ne "") {
5843 my $stat_real = get_stat_real
($linenr, $lc);
5844 my $ext_type = "Invalid";
5846 if ($bad_specifier =~ /p[Ff]/) {
5847 $ext_type = "Deprecated";
5848 $use = " - use %pS instead";
5849 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
5852 WARN
("VSPRINTF_POINTER_EXTENSION",
5853 "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
5858 # Check for misused memsets
5859 if ($^V && $^V ge 5.10.0 &&
5861 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5867 if ($ms_size =~ /^(0x|)0$/i) {
5869 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5870 } elsif ($ms_size =~ /^(0x|)1$/i) {
5872 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5876 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5877 # if ($^V && $^V ge 5.10.0 &&
5879 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5880 # if (WARN("PREFER_ETHER_ADDR_COPY",
5881 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5883 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5887 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5888 # if ($^V && $^V ge 5.10.0 &&
5890 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5891 # WARN("PREFER_ETHER_ADDR_EQUAL",
5892 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5895 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5896 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5897 # if ($^V && $^V ge 5.10.0 &&
5899 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5903 # if ($ms_val =~ /^(?:0x|)0+$/i) {
5904 # if (WARN("PREFER_ETH_ZERO_ADDR",
5905 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5907 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5909 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5910 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
5911 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5913 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5918 # typecasts on min/max could be min_t/max_t
5919 if ($^V && $^V ge 5.10.0 &&
5921 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5922 if (defined $2 || defined $7) {
5924 my $cast1 = deparenthesize
($2);
5926 my $cast2 = deparenthesize
($7);
5930 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5931 $cast = "$cast1 or $cast2";
5932 } elsif ($cast1 ne "") {
5938 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5942 # check usleep_range arguments
5943 if ($^V && $^V ge 5.10.0 &&
5945 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5949 WARN
("USLEEP_RANGE",
5950 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5951 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5953 WARN
("USLEEP_RANGE",
5954 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5958 # check for naked sscanf
5959 if ($^V && $^V ge 5.10.0 &&
5961 $line =~ /\bsscanf\b/ &&
5962 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5963 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5964 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5965 my $lc = $stat =~ tr
@\n@@;
5966 $lc = $lc + $linenr;
5967 my $stat_real = get_stat_real
($linenr, $lc);
5968 WARN
("NAKED_SSCANF",
5969 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5972 # check for simple sscanf that should be kstrto<foo>
5973 if ($^V && $^V ge 5.10.0 &&
5975 $line =~ /\bsscanf\b/) {
5976 my $lc = $stat =~ tr
@\n@@;
5977 $lc = $lc + $linenr;
5978 my $stat_real = get_stat_real
($linenr, $lc);
5979 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5981 my $count = $format =~ tr
@%@%@;
5983 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5984 WARN
("SSCANF_TO_KSTRTO",
5985 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5990 # check for new externs in .h files.
5991 if ($realfile =~ /\.h$/ &&
5992 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5993 if (CHK
("AVOID_EXTERNS",
5994 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5996 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
6000 # check for new externs in .c files.
6001 if ($realfile =~ /\.c$/ && defined $stat &&
6002 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
6004 my $function_name = $1;
6005 my $paren_space = $2;
6008 if (defined $cond) {
6009 substr($s, 0, length($cond), '');
6011 if ($s =~ /^\s*;/ &&
6012 $function_name ne 'uninitialized_var')
6014 WARN
("AVOID_EXTERNS",
6015 "externs should be avoided in .c files\n" . $herecurr);
6018 if ($paren_space =~ /\n/) {
6019 WARN
("FUNCTION_ARGUMENTS",
6020 "arguments for function declarations should follow identifier\n" . $herecurr);
6023 } elsif ($realfile =~ /\.c$/ && defined $stat &&
6024 $stat =~ /^.\s*extern\s+/)
6026 WARN
("AVOID_EXTERNS",
6027 "externs should be avoided in .c files\n" . $herecurr);
6030 # check for function declarations that have arguments without identifier names
6031 if (defined $stat &&
6032 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
6034 my $args = trim
($1);
6035 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
6037 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
6038 WARN
("FUNCTION_ARGUMENTS",
6039 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
6044 # check for function definitions
6045 if ($^V && $^V ge 5.10.0 &&
6047 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
6048 $context_function = $1;
6050 # check for multiline function definition with misplaced open brace
6052 my $cnt = statement_rawlines
($stat);
6053 my $herectx = $here . "\n";
6054 for (my $n = 0; $n < $cnt; $n++) {
6055 my $rl = raw_line
($linenr, $n);
6056 $herectx .= $rl . "\n";
6057 $ok = 1 if ($rl =~ /^[ \+]\{/);
6058 $ok = 1 if ($rl =~ /\{/ && $n == 0);
6059 last if $rl =~ /^[ \+].*\{/;
6063 "open brace '{' following function definitions go on the next line\n" . $herectx);
6067 # checks for new __setup's
6068 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6071 if (!grep(/$name/, @setup_docs)) {
6072 CHK
("UNDOCUMENTED_SETUP",
6073 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
6077 # check for pointless casting of kmalloc return
6078 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
6079 WARN
("UNNECESSARY_CASTS",
6080 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6084 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6085 if ($^V && $^V ge 5.10.0 &&
6086 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6087 CHK
("ALLOC_SIZEOF_STRUCT",
6088 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6091 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6092 if ($^V && $^V ge 5.10.0 &&
6094 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6098 my $newfunc = "kmalloc_array";
6099 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6102 if ($a1 =~ /^sizeof\s*\S/) {
6106 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6107 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6108 my $cnt = statement_rawlines
($stat);
6109 my $herectx = get_stat_here
($linenr, $cnt, $here);
6111 if (WARN
("ALLOC_WITH_MULTIPLY",
6112 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6115 $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;
6120 # check for krealloc arg reuse
6121 if ($^V && $^V ge 5.10.0 &&
6122 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
6123 WARN
("KREALLOC_ARG_REUSE",
6124 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6127 # check for alloc argument mismatch
6128 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6129 WARN
("ALLOC_ARRAY_ARGS",
6130 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6133 # check for multiple semicolons
6134 if ($line =~ /;\s*;\s*$/) {
6135 if (WARN
("ONE_SEMICOLON",
6136 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6138 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6142 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6143 if ($realfile !~ m
@^include/uapi/@ &&
6144 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6146 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6147 if (CHK
("BIT_MACRO",
6148 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6150 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6154 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6155 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6157 if (WARN
("PREFER_IS_ENABLED",
6158 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6160 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6164 # check for case / default statements not preceded by break/fallthrough/switch
6165 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
6167 my $has_statement = 0;
6169 my $prevline = $linenr;
6170 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
6172 my $rline = $rawlines[$prevline - 1];
6173 my $fline = $lines[$prevline - 1];
6174 last if ($fline =~ /^\@\@/);
6175 next if ($fline =~ /^\-/);
6176 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
6177 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
6178 next if ($fline =~ /^.[\s$;]*$/);
6181 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|exit\s*\(\b|return\b|goto\b|continue\b)/);
6183 if (!$has_break && $has_statement) {
6184 WARN
("MISSING_BREAK",
6185 "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
6189 # check for switch/default statements without a break;
6190 if ($^V && $^V ge 5.10.0 &&
6192 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6193 my $cnt = statement_rawlines
($stat);
6194 my $herectx = get_stat_here
($linenr, $cnt, $here);
6196 WARN
("DEFAULT_NO_BREAK",
6197 "switch default: should use break\n" . $herectx);
6200 # check for gcc specific __FUNCTION__
6201 if ($line =~ /\b__FUNCTION__\b/) {
6202 if (WARN
("USE_FUNC",
6203 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
6205 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
6209 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
6210 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6212 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6215 # check for use of yield()
6216 if ($line =~ /\byield\s*\(\s*\)/) {
6218 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
6221 # check for comparisons against true and false
6222 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6230 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6232 my $type = lc($otype);
6233 if ($type =~ /^(?:true|false)$/) {
6234 if (("$test" eq "==" && "$type" eq "true") ||
6235 ("$test" eq "!=" && "$type" eq "false")) {
6239 CHK
("BOOL_COMPARISON",
6240 "Using comparison to $otype is error prone\n" . $herecurr);
6242 ## maybe suggesting a correct construct would better
6243 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6248 # check for bool bitfields
6249 if ($sline =~ /^.\s+bool\s*$Ident\s*:\s*\d+\s*;/) {
6250 WARN
("BOOL_BITFIELD",
6251 "Avoid using bool as bitfield. Prefer bool bitfields as unsigned int or u<8|16|32>\n" . $herecurr);
6254 # check for semaphores initialized locked
6255 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6256 WARN
("CONSIDER_COMPLETION",
6257 "consider using a completion\n" . $herecurr);
6260 # recommend kstrto* over simple_strto* and strict_strto*
6261 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6262 WARN
("CONSIDER_KSTRTO",
6263 "$1 is obsolete, use k$3 instead\n" . $herecurr);
6266 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
6267 if ($line =~ /^.\s*__initcall\s*\(/) {
6268 WARN
("USE_DEVICE_INITCALL",
6269 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6272 # check for various structs that are normally const (ops, kgdb, device_tree)
6273 # and avoid what seem like struct definitions 'struct foo {'
6274 if ($line !~ /\bconst\b/ &&
6275 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
6276 WARN
("CONST_STRUCT",
6277 "struct $1 should normally be const\n" . $herecurr);
6280 # use of NR_CPUS is usually wrong
6281 # ignore definitions of NR_CPUS and usage to define arrays as likely right
6282 if ($line =~ /\bNR_CPUS\b/ &&
6283 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6284 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6285 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6286 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6287 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6290 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6293 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6294 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6295 ERROR
("DEFINE_ARCH_HAS",
6296 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6299 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
6300 if ($^V && $^V ge 5.10.0 &&
6301 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6302 WARN
("LIKELY_MISUSE",
6303 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6306 # whine mightly about in_atomic
6307 if ($line =~ /\bin_atomic\s*\(/) {
6308 if ($realfile =~ m
@^drivers/@) {
6310 "do not use in_atomic in drivers\n" . $herecurr);
6311 } elsif ($realfile !~ m
@^kernel/@) {
6313 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6317 # check for mutex_trylock_recursive usage
6318 if ($line =~ /mutex_trylock_recursive/) {
6320 "recursive locking is bad, do not use this ever.\n" . $herecurr);
6323 # check for lockdep_set_novalidate_class
6324 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6325 $line =~ /__lockdep_no_validate__\s*\)/ ) {
6326 if ($realfile !~ m
@^kernel/lockdep@ &&
6327 $realfile !~ m
@^include/linux/lockdep@ &&
6328 $realfile !~ m
@^drivers/base/core@) {
6330 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6334 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6335 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6336 WARN
("EXPORTED_WORLD_WRITABLE",
6337 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6340 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
6341 # and whether or not function naming is typical and if
6342 # DEVICE_ATTR permissions uses are unusual too
6343 if ($^V && $^V ge 5.10.0 &&
6345 $stat =~ /\bDEVICE_ATTR\s*\(\s*(\w+)\s*,\s*\(?\s*(\s*(?:${multi_mode_perms_string_search}|0[0-7]{3,3})\s*)\s*\)?\s*,\s*(\w+)\s*,\s*(\w+)\s*\)/) {
6350 my $octal_perms = perms_to_octal
($perms);
6351 if ($show =~ /^${var}_show$/ &&
6352 $store =~ /^${var}_store$/ &&
6353 $octal_perms eq "0644") {
6354 if (WARN
("DEVICE_ATTR_RW",
6355 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
6357 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
6359 } elsif ($show =~ /^${var}_show$/ &&
6360 $store =~ /^NULL$/ &&
6361 $octal_perms eq "0444") {
6362 if (WARN
("DEVICE_ATTR_RO",
6363 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
6365 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
6367 } elsif ($show =~ /^NULL$/ &&
6368 $store =~ /^${var}_store$/ &&
6369 $octal_perms eq "0200") {
6370 if (WARN
("DEVICE_ATTR_WO",
6371 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
6373 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
6375 } elsif ($octal_perms eq "0644" ||
6376 $octal_perms eq "0444" ||
6377 $octal_perms eq "0200") {
6378 my $newshow = "$show";
6379 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
6380 my $newstore = $store;
6381 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
6383 if ($show ne $newshow) {
6384 $rename .= " '$show' to '$newshow'";
6386 if ($store ne $newstore) {
6387 $rename .= " '$store' to '$newstore'";
6389 WARN
("DEVICE_ATTR_FUNCTIONS",
6390 "Consider renaming function(s)$rename\n" . $herecurr);
6392 WARN
("DEVICE_ATTR_PERMS",
6393 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
6397 # Mode permission misuses where it seems decimal should be octal
6398 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6399 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
6400 # specific definition of not visible in sysfs.
6401 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
6402 # use the default permissions
6403 if ($^V && $^V ge 5.10.0 &&
6405 $line =~ /$mode_perms_search/) {
6406 foreach my $entry (@mode_permission_funcs) {
6407 my $func = $entry->[0];
6408 my $arg_pos = $entry->[1];
6410 my $lc = $stat =~ tr
@\n@@;
6411 $lc = $lc + $linenr;
6412 my $stat_real = get_stat_real
($linenr, $lc);
6417 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6419 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6420 if ($stat =~ /$test/) {
6422 $val = $6 if ($skip_args ne "");
6423 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
6424 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6425 ($val =~ /^$Octal$/ && length($val) ne 4))) {
6426 ERROR
("NON_OCTAL_PERMISSIONS",
6427 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6429 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6430 ERROR
("EXPORTED_WORLD_WRITABLE",
6431 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6437 # check for uses of S_<PERMS> that could be octal for readability
6438 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
6440 my $octal = perms_to_octal
($oval);
6441 if (WARN
("SYMBOLIC_PERMS",
6442 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6444 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
6448 # validate content of MODULE_LICENSE against list from include/linux/module.h
6449 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6450 my $extracted_string = get_quoted_string
($line, $rawline);
6451 my $valid_licenses = qr{
6454 GPL\
and\ additional\ rights
|
6460 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6461 WARN
("MODULE_LICENSE",
6462 "unknown module license " . $extracted_string . "\n" . $herecurr);
6467 # If we have no input at all, then there is nothing to report on
6468 # so just keep quiet.
6469 if ($#rawlines == -1) {
6473 # In mailback mode only produce a report in the negative, for
6474 # things that appear to be patches.
6475 if ($mailback && ($clean == 1 || !$is_patch)) {
6479 # This is not a patch, and we are are in 'no-patch' mode so
6481 if (!$chk_patch && !$is_patch) {
6485 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
6486 ERROR
("NOT_UNIFIED_DIFF",
6487 "Does not appear to be a unified-diff format patch\n");
6489 if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6490 ERROR
("MISSING_SIGN_OFF",
6491 "Missing Signed-off-by: line(s)\n");
6494 print report_dump
();
6495 if ($summary && !($clean == 1 && $quiet == 1)) {
6496 print "$filename " if ($summary_file);
6497 print "total: $cnt_error errors, $cnt_warn warnings, " .
6498 (($check)?
"$cnt_chk checks, " : "") .
6499 "$cnt_lines lines checked\n";
6503 # If there were any defects found and not already fixing them
6504 if (!$clean and !$fix) {
6507 NOTE
: For some of the reported defects
, checkpatch may be able to
6508 mechanically convert to the typical style using
--fix
or --fix-inplace
.
6511 # If there were whitespace errors which cleanpatch can fix
6512 # then suggest that.
6513 if ($rpt_cleaners) {
6517 NOTE
: Whitespace errors detected
.
6518 You may wish to
use scripts
/cleanpatch or scripts/cleanfile
6523 if ($clean == 0 && $fix &&
6524 ("@rawlines" ne "@fixed" ||
6525 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6526 my $newfile = $filename;
6527 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6531 @fixed = fix_inserted_deleted_lines
(\
@fixed, \
@fixed_inserted, \
@fixed_deleted);
6533 open($f, '>', $newfile)
6534 or die "$P: Can't open $newfile for write\n";
6535 foreach my $fixed_line (@fixed) {
6538 if ($linecount > 3) {
6539 $fixed_line =~ s/^\+//;
6540 print $f $fixed_line . "\n";
6543 print $f $fixed_line . "\n";
6551 Wrote EXPERIMENTAL
--fix correction
(s
) to
'$newfile'
6553 Do _NOT_ trust the results written to this file
.
6554 Do _NOT_ submit these changes without inspecting them
for correctness
.
6556 This EXPERIMENTAL file
is simply a convenience to help rewrite patches
.
6557 No warranties
, expressed
or implied
...
6565 print "$vname has no obvious style problems and is ready for submission.\n";
6567 print "$vname has style problems, please review.\n";