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);
16 use Encode qw(decode encode);
19 my $D = dirname(abs_path($P));
23 use Getopt::Long qw(:config no_auto_abbrev);
46 my $gitroot = $ENV{'GIT_DIR'};
47 $gitroot = ".git" if !defined($gitroot);
55 my $configuration_file = ".checkpatch.conf";
56 my $max_line_length = 100;
57 my $ignore_perl_version = 0;
58 my $minimum_perl_version = 5.10.0;
59 my $min_conf_desc_length = 4;
60 my $spelling_file = "$D/spelling.txt";
62 my $codespellfile = "/usr/share/codespell/dictionary.txt";
63 my $conststructsfile = "$D/const_structs.checkpatch";
66 my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
67 # git output parsing needs US English output, so first set backtick child process LANGUAGE
68 my $git_command ='export LANGUAGE=en_US.UTF-8; git';
70 my ${CONFIG_} = "CONFIG_";
76 Usage: $P [OPTION]... [FILE]...
81 --no-tree run without a kernel tree
82 --no-signoff do not check for 'Signed-off-by' line
83 --patch treat FILE as patchfile (default)
84 --emacs emacs compile window format
85 --terse one line per report
86 --showfile emit diffed file position, not input file position
87 -g, --git treat FILE as a single commit or git revision range
88 single git commit with:
92 multiple git commits with:
96 git merges are ignored
97 -f, --file treat FILE as regular source file
98 --subjective, --strict enable more subjective tests
99 --list-types list the possible message types
100 --types TYPE(,TYPE2...) show only these comma separated message types
101 --ignore TYPE(,TYPE2...) ignore various comma separated message types
102 --show-types show the specific message type in the output
103 --max-line-length=n set the maximum line length, (default $max_line_length)
104 if exceeded, warn on patches
105 requires --strict for use with --file
106 --min-conf-desc-length=n set the min description length, if shorter, warn
107 --tab-size=n set the number of spaces for tab (default $tabsize)
108 --root=PATH PATH to the kernel tree root
109 --no-summary suppress the per-file summary
110 --mailback only produce a report in case of warnings/errors
111 --summary-file include the filename in summary
112 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
113 'values', 'possible', 'type', and 'attr' (default
115 --test-only=WORD report only warnings/errors containing WORD
117 --fix EXPERIMENTAL - may create horrible results
118 If correctable single-line errors exist, create
119 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
120 with potential errors corrected to the preferred
122 --fix-inplace EXPERIMENTAL - may create horrible results
123 Is the same as --fix, but overwrites the input
124 file. It's your fault if there's no backup or git
125 --ignore-perl-version override checking of perl version. expect
127 --codespell Use the codespell dictionary for spelling/typos
128 (default:/usr/share/codespell/dictionary.txt)
129 --codespellfile Use this codespell dictionary
130 --typedefsfile Read additional types from this file
131 --color[=WHEN] Use colors 'always', 'never', or only when output
132 is a terminal ('auto'). Default is 'auto'.
133 --kconfig-prefix=WORD use WORD as a prefix for Kconfig symbols (default
135 -h, --help, --version display this help and exit
137 When FILE is - read standard input.
145 return grep { !$seen{$_}++ } @_;
155 open(my $script, '<', abs_path($P)) or
156 die "$P: Can't read '$P' $!\n";
158 my $text = <$script>;
162 # Also catch when type or level is passed through a variable
163 for ($text =~ /(?:(?:\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
166 @types = sort(uniq(@types));
167 print("#\tMessage type\n\n");
168 foreach my $type (@types) {
169 print(++$count . "\t" . $type . "\n");
175 my $conf = which_conf($configuration_file);
178 open(my $conffile, '<', "$conf")
179 or warn "$P: Can't find a readable $configuration_file file $!\n";
181 while (<$conffile>) {
184 $line =~ s/\s*\n?$//g;
188 next if ($line =~ m/^\s*#/);
189 next if ($line =~ m/^\s*$/);
191 my @words = split(" ", $line);
192 foreach my $word (@words) {
193 last if ($word =~ m/^#/);
194 push (@conf_args, $word);
198 unshift(@ARGV, @conf_args) if @conf_args;
201 # Perl's Getopt::Long allows options to take optional arguments after a space.
202 # Prevent --color by itself from consuming other arguments
204 if ($_ eq "--color" || $_ eq "-color") {
205 $_ = "--color=$color";
210 'q|quiet+' => \$quiet,
212 'signoff!' => \$chk_signoff,
213 'patch!' => \$chk_patch,
216 'showfile!' => \$showfile,
219 'subjective!' => \$check,
220 'strict!' => \$check,
221 'ignore=s' => \@ignore,
223 'show-types!' => \$show_types,
224 'list-types!' => \$list_types,
225 'max-line-length=i' => \$max_line_length,
226 'min-conf-desc-length=i' => \$min_conf_desc_length,
227 'tab-size=i' => \$tabsize,
229 'summary!' => \$summary,
230 'mailback!' => \$mailback,
231 'summary-file!' => \$summary_file,
233 'fix-inplace!' => \$fix_inplace,
234 'ignore-perl-version!' => \$ignore_perl_version,
235 'debug=s' => \%debug,
236 'test-only=s' => \$tst_only,
237 'codespell!' => \$codespell,
238 'codespellfile=s' => \$codespellfile,
239 'typedefsfile=s' => \$typedefsfile,
240 'color=s' => \$color,
241 'no-color' => \$color, #keep old behaviors of -nocolor
242 'nocolor' => \$color, #keep old behaviors of -nocolor
243 'kconfig-prefix=s' => \${CONFIG_},
250 list_types(0) if ($list_types);
252 $fix = 1 if ($fix_inplace);
253 $check_orig = $check;
255 die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file || $fix));
259 my $perl_version_ok = 1;
260 if ($^V && $^V lt $minimum_perl_version) {
261 $perl_version_ok = 0;
262 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
263 exit(1) if (!$ignore_perl_version);
266 #if no filenames are given, push '-' to read patch from stdin
271 if ($color =~ /^[01]$/) {
273 } elsif ($color =~ /^always$/i) {
275 } elsif ($color =~ /^never$/i) {
277 } elsif ($color =~ /^auto$/i) {
278 $color = (-t STDOUT);
280 die "$P: Invalid color mode: $color\n";
283 # skip TAB size 1 to avoid additional checks on $tabsize - 1
284 die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);
286 sub hash_save_array_words {
287 my ($hashRef, $arrayRef) = @_;
289 my @array = split(/,/, join(',', @$arrayRef));
290 foreach my $word (@array) {
291 $word =~ s/\s*\n?$//g;
294 $word =~ tr/[a-z]/[A-Z]/;
296 next if ($word =~ m/^\s*#/);
297 next if ($word =~ m/^\s*$/);
303 sub hash_show_words {
304 my ($hashRef, $prefix) = @_;
306 if (keys %$hashRef) {
307 print "\nNOTE: $prefix message types:";
308 foreach my $word (sort keys %$hashRef) {
315 hash_save_array_words(\%ignore_type, \@ignore);
316 hash_save_array_words(\%use_type, \@use);
319 my $dbg_possible = 0;
322 for my $key (keys %debug) {
324 eval "\${dbg_$key} = '$debug{$key}';";
328 my $rpt_cleaners = 0;
337 if (!top_of_kernel_tree($root)) {
338 die "$P: $root: --root does not point at a valid tree\n";
341 if (top_of_kernel_tree('.')) {
343 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
344 top_of_kernel_tree($1)) {
349 if (!defined $root) {
350 print "Must be run from the top-level dir. of a kernel tree\n";
355 my $emitted_corrupt = 0;
358 [A-Za-z_][A-Za-z\d_]*
359 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
361 our $Storage = qr{extern|static|asmlinkage};
375 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
376 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
377 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
378 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
379 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
381 # Notes to $Attribute:
382 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
404 ____cacheline_aligned|
405 ____cacheline_aligned_in_smp|
406 ____cacheline_internodealigned_in_smp|
410 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
411 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
412 our $Lval = qr{$Ident(?:$Member)*};
414 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
415 our $Binary = qr{(?i)0b[01]+$Int_type?};
416 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
417 our $Int = qr{[0-9]+$Int_type?};
418 our $Octal = qr{0[0-7]+$Int_type?};
419 our $String = qr{"[X\t]*"};
420 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
421 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
422 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
423 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
424 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
425 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
426 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
427 our $Arithmetic = qr{\+|-|\*|\/|%};
431 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
434 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
438 our $NonptrTypeMisordered;
439 our $NonptrTypeWithAttr;
443 our $DeclareMisordered;
445 our $NON_ASCII_UTF8 = qr{
446 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
447 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
448 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
449 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
450 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
451 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
452 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
456 [\x09\x0A\x0D\x20-\x7E] # ASCII
460 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
461 our $typeOtherOSTypedefs = qr{(?x:
462 u_(?:char|short|int|long) | # bsd
463 u(?:nchar|short|int|long) # sysv
465 our $typeKernelTypedefs = qr{(?x:
466 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
469 our $typeTypedefs = qr{(?x:
471 $typeOtherOSTypedefs\b|
472 $typeKernelTypedefs\b
475 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
477 our $logFunctions = qr{(?x:
478 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
479 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
481 WARN(?:_RATELIMIT|_ONCE|)|
484 seq_vprintf|seq_printf|seq_puts
487 our $allocFunctions = qr{(?x:
489 (?:kv|k|v)[czm]alloc(?:_node|_array)? |
492 (?:\w+)?alloc_skb(?:_ip_align)? |
493 # dev_alloc_skb/netdev_alloc_skb, et al
497 our $signature_tags = qr{(?xi:
509 sub edit_distance_min {
511 my $len = scalar @arr;
512 if ((scalar @arr) < 1) {
513 # if underflow, return
517 for my $i (0 .. ($len-1)) {
518 if ($arr[$i] < $min) {
525 sub get_edit_distance {
526 my ($str1, $str2) = @_;
531 my $len1 = length($str1);
532 my $len2 = length($str2);
533 # two dimensional array storing minimum edit distance
535 for my $i (0 .. $len1) {
536 for my $j (0 .. $len2) {
538 $distance[$i][$j] = $j;
540 $distance[$i][$j] = $i;
541 } elsif (substr($str1, $i-1, 1) eq substr($str2, $j-1, 1)) {
542 $distance[$i][$j] = $distance[$i - 1][$j - 1];
544 my $dist1 = $distance[$i][$j - 1]; #insert distance
545 my $dist2 = $distance[$i - 1][$j]; # remove
546 my $dist3 = $distance[$i - 1][$j - 1]; #replace
547 $distance[$i][$j] = 1 + edit_distance_min($dist1, $dist2, $dist3);
551 return $distance[$len1][$len2];
554 sub find_standard_signature {
556 my @standard_signature_tags = (
557 'Signed-off-by:', 'Co-developed-by:', 'Acked-by:', 'Tested-by:',
558 'Reviewed-by:', 'Reported-by:', 'Suggested-by:'
560 foreach my $signature (@standard_signature_tags) {
561 return $signature if (get_edit_distance($sign_off, $signature) <= 2);
567 our @typeListMisordered = (
568 qr{char\s+(?:un)?signed},
569 qr{int\s+(?:(?:un)?signed\s+)?short\s},
570 qr{int\s+short(?:\s+(?:un)?signed)},
571 qr{short\s+int(?:\s+(?:un)?signed)},
572 qr{(?:un)?signed\s+int\s+short},
573 qr{short\s+(?:un)?signed},
574 qr{long\s+int\s+(?:un)?signed},
575 qr{int\s+long\s+(?:un)?signed},
576 qr{long\s+(?:un)?signed\s+int},
577 qr{int\s+(?:un)?signed\s+long},
578 qr{int\s+(?:un)?signed},
579 qr{int\s+long\s+long\s+(?:un)?signed},
580 qr{long\s+long\s+int\s+(?:un)?signed},
581 qr{long\s+long\s+(?:un)?signed\s+int},
582 qr{long\s+long\s+(?:un)?signed},
583 qr{long\s+(?:un)?signed},
588 qr{(?:(?:un)?signed\s+)?char},
589 qr{(?:(?:un)?signed\s+)?short\s+int},
590 qr{(?:(?:un)?signed\s+)?short},
591 qr{(?:(?:un)?signed\s+)?int},
592 qr{(?:(?:un)?signed\s+)?long\s+int},
593 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
594 qr{(?:(?:un)?signed\s+)?long\s+long},
595 qr{(?:(?:un)?signed\s+)?long},
604 qr{${Ident}_handler},
605 qr{${Ident}_handler_fn},
609 our $C90_int_types = qr{(?x:
610 long\s+long\s+int\s+(?:un)?signed|
611 long\s+long\s+(?:un)?signed\s+int|
612 long\s+long\s+(?:un)?signed|
613 (?:(?:un)?signed\s+)?long\s+long\s+int|
614 (?:(?:un)?signed\s+)?long\s+long|
615 int\s+long\s+long\s+(?:un)?signed|
616 int\s+(?:(?:un)?signed\s+)?long\s+long|
618 long\s+int\s+(?:un)?signed|
619 long\s+(?:un)?signed\s+int|
620 long\s+(?:un)?signed|
621 (?:(?:un)?signed\s+)?long\s+int|
622 (?:(?:un)?signed\s+)?long|
623 int\s+long\s+(?:un)?signed|
624 int\s+(?:(?:un)?signed\s+)?long|
627 (?:(?:un)?signed\s+)?int
630 our @typeListFile = ();
631 our @typeListWithAttr = (
633 qr{struct\s+$InitAttribute\s+$Ident},
634 qr{union\s+$InitAttribute\s+$Ident},
637 our @modifierList = (
640 our @modifierListFile = ();
642 our @mode_permission_funcs = (
644 ["module_param_(?:array|named|string)", 4],
645 ["module_param_array_named", 5],
646 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
647 ["proc_create(?:_data|)", 2],
648 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
649 ["IIO_DEV_ATTR_[A-Z_]+", 1],
650 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
651 ["SENSOR_TEMPLATE(?:_2|)", 3],
655 my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';
657 #Create a search pattern for all these functions to speed up a loop below
658 our $mode_perms_search = "";
659 foreach my $entry (@mode_permission_funcs) {
660 $mode_perms_search .= '|' if ($mode_perms_search ne "");
661 $mode_perms_search .= $entry->[0];
663 $mode_perms_search = "(?:${mode_perms_search})";
665 our %deprecated_apis = (
666 "synchronize_rcu_bh" => "synchronize_rcu",
667 "synchronize_rcu_bh_expedited" => "synchronize_rcu_expedited",
668 "call_rcu_bh" => "call_rcu",
669 "rcu_barrier_bh" => "rcu_barrier",
670 "synchronize_sched" => "synchronize_rcu",
671 "synchronize_sched_expedited" => "synchronize_rcu_expedited",
672 "call_rcu_sched" => "call_rcu",
673 "rcu_barrier_sched" => "rcu_barrier",
674 "get_state_synchronize_sched" => "get_state_synchronize_rcu",
675 "cond_synchronize_sched" => "cond_synchronize_rcu",
678 #Create a search pattern for all these strings to speed up a loop below
679 our $deprecated_apis_search = "";
680 foreach my $entry (keys %deprecated_apis) {
681 $deprecated_apis_search .= '|' if ($deprecated_apis_search ne "");
682 $deprecated_apis_search .= $entry;
684 $deprecated_apis_search = "(?:${deprecated_apis_search})";
686 our $mode_perms_world_writable = qr{
694 our %mode_permission_string_types = (
713 #Create a search pattern for all these strings to speed up a loop below
714 our $mode_perms_string_search = "";
715 foreach my $entry (keys %mode_permission_string_types) {
716 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
717 $mode_perms_string_search .= $entry;
719 our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
720 our $multi_mode_perms_string_search = qr{
721 ${single_mode_perms_string_search}
722 (?:\s*\|\s*${single_mode_perms_string_search})*
728 return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
735 while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
736 $curpos = pos($string);
739 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
741 $to |= $mode_permission_string_types{$match};
742 $val .= '\s*\|\s*' if ($val ne "");
746 $oval =~ s/^\s*\|\s*//;
747 $oval =~ s/\s*\|\s*$//;
748 return sprintf("%04o", $to);
751 our $allowed_asm_includes = qr{(?x:
757 # memory.h: ARM has a custom one
759 # Load common spelling mistakes and build regular expression list.
763 if (open(my $spelling, '<', $spelling_file)) {
764 while (<$spelling>) {
767 $line =~ s/\s*\n?$//g;
770 next if ($line =~ m/^\s*#/);
771 next if ($line =~ m/^\s*$/);
773 my ($suspect, $fix) = split(/\|\|/, $line);
775 $spelling_fix{$suspect} = $fix;
779 warn "No typos will be found - file '$spelling_file': $!\n";
783 if (open(my $spelling, '<', $codespellfile)) {
784 while (<$spelling>) {
787 $line =~ s/\s*\n?$//g;
790 next if ($line =~ m/^\s*#/);
791 next if ($line =~ m/^\s*$/);
792 next if ($line =~ m/, disabled/i);
796 my ($suspect, $fix) = split(/->/, $line);
798 $spelling_fix{$suspect} = $fix;
802 warn "No codespell typos will be found - file '$codespellfile': $!\n";
806 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
809 my ($wordsRef, $file) = @_;
811 if (open(my $words, '<', $file)) {
815 $line =~ s/\s*\n?$//g;
818 next if ($line =~ m/^\s*#/);
819 next if ($line =~ m/^\s*$/);
821 print("$file: '$line' invalid - ignored\n");
825 $$wordsRef .= '|' if (defined $$wordsRef);
836 if (show_type("CONST_STRUCT")) {
837 read_words(\$const_structs, $conststructsfile)
838 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
841 if (defined($typedefsfile)) {
842 my $typeOtherTypedefs;
843 read_words(\$typeOtherTypedefs, $typedefsfile)
844 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
845 $typeTypedefs .= '|' . $typeOtherTypedefs if (defined $typeOtherTypedefs);
849 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
850 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
851 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
852 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
853 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
859 (?:$Modifier\s+|const\s+)*
861 (?:typeof|__typeof__)\s*\([^\)]*\)|
865 (?:\s+$Modifier|\s+const)*
867 $NonptrTypeMisordered = qr{
868 (?:$Modifier\s+|const\s+)*
872 (?:\s+$Modifier|\s+const)*
874 $NonptrTypeWithAttr = qr{
875 (?:$Modifier\s+|const\s+)*
877 (?:typeof|__typeof__)\s*\([^\)]*\)|
881 (?:\s+$Modifier|\s+const)*
885 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
886 (?:\s+$Inline|\s+$Modifier)*
888 $TypeMisordered = qr{
889 $NonptrTypeMisordered
890 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
891 (?:\s+$Inline|\s+$Modifier)*
893 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
894 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
898 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
900 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
901 # requires at least perl version v5.10.0
902 # Any use must be runtime checked with $^V
904 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
905 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
906 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
908 our $declaration_macros = qr{(?x:
909 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
910 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
911 (?:SKCIPHER_REQUEST|SHASH_DESC|AHASH_REQUEST)_ON_STACK\s*\(
914 our %allow_repeated_words = (
923 return "" if (!defined($string));
925 while ($string =~ /^\s*\(.*\)\s*$/) {
926 $string =~ s@^\s*\(\s*@@;
927 $string =~ s@\s*\)\s*$@@;
930 $string =~ s@\s+@ @g;
935 sub seed_camelcase_file {
938 return if (!(-f $file));
942 open(my $include_file, '<', "$file")
943 or warn "$P: Can't read '$file' $!\n";
944 my $text = <$include_file>;
945 close($include_file);
947 my @lines = split('\n', $text);
949 foreach my $line (@lines) {
950 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
951 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
953 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
955 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
961 our %maintained_status = ();
963 sub is_maintained_obsolete {
966 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
968 if (!exists($maintained_status{$filename})) {
969 $maintained_status{$filename} = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
972 return $maintained_status{$filename} =~ /obsolete/i;
975 sub is_SPDX_License_valid {
978 return 1 if (!$tree || which("python") eq "" || !(-e "$root/scripts/spdxcheck.py") || !(-e "$gitroot"));
980 my $root_path = abs_path($root);
981 my $status = `cd "$root_path"; echo "$license" | python scripts/spdxcheck.py -`;
982 return 0 if ($status ne "");
986 my $camelcase_seeded = 0;
987 sub seed_camelcase_includes {
988 return if ($camelcase_seeded);
991 my $camelcase_cache = "";
992 my @include_files = ();
994 $camelcase_seeded = 1;
997 my $git_last_include_commit = `${git_command} log --no-merges --pretty=format:"%h%n" -1 -- include`;
998 chomp $git_last_include_commit;
999 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
1001 my $last_mod_date = 0;
1002 $files = `find $root/include -name "*.h"`;
1003 @include_files = split('\n', $files);
1004 foreach my $file (@include_files) {
1005 my $date = POSIX::strftime("%Y%m%d%H%M",
1006 localtime((stat $file)[9]));
1007 $last_mod_date = $date if ($last_mod_date < $date);
1009 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
1012 if ($camelcase_cache ne "" && -f $camelcase_cache) {
1013 open(my $camelcase_file, '<', "$camelcase_cache")
1014 or warn "$P: Can't read '$camelcase_cache' $!\n";
1015 while (<$camelcase_file>) {
1019 close($camelcase_file);
1024 if (-e "$gitroot") {
1025 $files = `${git_command} ls-files "include/*.h"`;
1026 @include_files = split('\n', $files);
1029 foreach my $file (@include_files) {
1030 seed_camelcase_file($file);
1033 if ($camelcase_cache ne "") {
1034 unlink glob ".checkpatch-camelcase.*";
1035 open(my $camelcase_file, '>', "$camelcase_cache")
1036 or warn "$P: Can't write '$camelcase_cache' $!\n";
1037 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
1038 print $camelcase_file ("$_\n");
1040 close($camelcase_file);
1044 sub git_is_single_file {
1045 my ($filename) = @_;
1047 return 0 if ((which("git") eq "") || !(-e "$gitroot"));
1049 my $output = `${git_command} ls-files -- $filename 2>/dev/null`;
1050 my $count = $output =~ tr/\n//;
1051 return $count eq 1 && $output =~ m{^${filename}$};
1054 sub git_commit_info {
1055 my ($commit, $id, $desc) = @_;
1057 return ($id, $desc) if ((which("git") eq "") || !(-e "$gitroot"));
1059 my $output = `${git_command} log --no-color --format='%H %s' -1 $commit 2>&1`;
1060 $output =~ s/^\s*//gm;
1061 my @lines = split("\n", $output);
1063 return ($id, $desc) if ($#lines < 0);
1065 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous/) {
1066 # Maybe one day convert this block of bash into something that returns
1067 # all matching commit ids, but it's very slow...
1069 # echo "checking commits $1..."
1070 # git rev-list --remotes | grep -i "^$1" |
1071 # while read line ; do
1072 # git log --format='%H %s' -1 $line |
1073 # echo "commit $(cut -c 1-12,41-)"
1075 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
1078 $id = substr($lines[0], 0, 12);
1079 $desc = substr($lines[0], 41);
1082 return ($id, $desc);
1085 $chk_signoff = 0 if ($file);
1090 my @fixed_inserted = ();
1091 my @fixed_deleted = ();
1094 # If input is git commits, extract all commits from the commit expressions.
1095 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
1096 die "$P: No git repository found\n" if ($git && !-e "$gitroot");
1100 foreach my $commit_expr (@ARGV) {
1102 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
1103 $git_range = "-$2 $1";
1104 } elsif ($commit_expr =~ m/\.\./) {
1105 $git_range = "$commit_expr";
1107 $git_range = "-1 $commit_expr";
1109 my $lines = `${git_command} log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
1110 foreach my $line (split(/\n/, $lines)) {
1111 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
1112 next if (!defined($1) || !defined($2));
1115 unshift(@commits, $sha1);
1116 $git_commits{$sha1} = $subject;
1119 die "$P: no git commits after extraction!\n" if (@commits == 0);
1124 $allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
1125 for my $filename (@ARGV) {
1127 my $is_git_file = git_is_single_file($filename);
1128 my $oldfile = $file;
1129 $file = 1 if ($is_git_file);
1131 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
1132 die "$P: $filename: git format-patch failed - $!\n";
1134 open($FILE, '-|', "diff -u /dev/null $filename") ||
1135 die "$P: $filename: diff failed - $!\n";
1136 } elsif ($filename eq '-') {
1137 open($FILE, '<&STDIN');
1139 open($FILE, '<', "$filename") ||
1140 die "$P: $filename: open failed - $!\n";
1142 if ($filename eq '-') {
1143 $vname = 'Your patch';
1145 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1151 push(@rawlines, $_);
1152 $vname = qq("$1") if ($filename eq '-' && $_ =~ m/^Subject:\s+(.+)/i);
1156 if ($#ARGV > 0 && $quiet == 0) {
1157 print '-' x length($vname) . "\n";
1159 print '-' x length($vname) . "\n";
1162 if (!process($filename)) {
1168 @fixed_inserted = ();
1169 @fixed_deleted = ();
1171 @modifierListFile = ();
1174 $file = $oldfile if ($is_git_file);
1178 hash_show_words(\%use_type, "Used");
1179 hash_show_words(\%ignore_type, "Ignored");
1181 if (!$perl_version_ok) {
1184 NOTE: perl $^V is not modern enough to detect all possible issues.
1185 An upgrade to at least perl $minimum_perl_version is suggested.
1191 NOTE: If any of the errors are false positives, please report
1192 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1199 sub top_of_kernel_tree {
1203 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1204 "README", "Documentation", "arch", "include", "drivers",
1205 "fs", "init", "ipc", "kernel", "lib", "scripts",
1208 foreach my $check (@tree_check) {
1209 if (! -e $root . '/' . $check) {
1217 my ($formatted_email) = @_;
1221 my $name_comment = "";
1225 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1228 $comment = $3 if defined $3;
1229 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1231 $comment = $2 if defined $2;
1232 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1234 $comment = $2 if defined $2;
1235 $formatted_email =~ s/\Q$address\E.*$//;
1236 $name = $formatted_email;
1237 $name = trim($name);
1238 $name =~ s/^\"|\"$//g;
1239 # If there's a name left after stripping spaces and
1240 # leading quotes, and the address doesn't have both
1241 # leading and trailing angle brackets, the address
1243 # "joe smith joe@smith.com" bad
1244 # "joe smith <joe@smith.com" bad
1245 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1252 # Extract comments from names excluding quoted parts
1253 # "John D. (Doe)" - Do not extract
1254 if ($name =~ s/\"(.+)\"//) {
1257 while ($name =~ s/\s*($balanced_parens)\s*/ /) {
1258 $name_comment .= trim($1);
1260 $name =~ s/^[ \"]+|[ \"]+$//g;
1261 $name = trim("$quoted $name");
1263 $address = trim($address);
1264 $address =~ s/^\<|\>$//g;
1265 $comment = trim($comment);
1267 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1268 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1269 $name = "\"$name\"";
1272 return ($name, $name_comment, $address, $comment);
1276 my ($name, $name_comment, $address, $comment) = @_;
1278 my $formatted_email;
1280 $name =~ s/^[ \"]+|[ \"]+$//g;
1281 $address = trim($address);
1282 $address =~ s/(?:\.|\,|\")+$//; ##trailing commas, dots or quotes
1284 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1285 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1286 $name = "\"$name\"";
1289 $name_comment = trim($name_comment);
1290 $name_comment = " $name_comment" if ($name_comment ne "");
1291 $comment = trim($comment);
1292 $comment = " $comment" if ($comment ne "");
1294 if ("$name" eq "") {
1295 $formatted_email = "$address";
1297 $formatted_email = "$name$name_comment <$address>";
1299 $formatted_email .= "$comment";
1300 return $formatted_email;
1303 sub reformat_email {
1306 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
1307 return format_email($email_name, $name_comment, $email_address, $comment);
1310 sub same_email_addresses {
1311 my ($email1, $email2) = @_;
1313 my ($email1_name, $name1_comment, $email1_address, $comment1) = parse_email($email1);
1314 my ($email2_name, $name2_comment, $email2_address, $comment2) = parse_email($email2);
1316 return $email1_name eq $email2_name &&
1317 $email1_address eq $email2_address &&
1318 $name1_comment eq $name2_comment &&
1319 $comment1 eq $comment2;
1325 foreach my $path (split(/:/, $ENV{PATH})) {
1326 if (-e "$path/$bin") {
1327 return "$path/$bin";
1337 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1338 if (-e "$path/$conf") {
1339 return "$path/$conf";
1351 for my $c (split(//, $str)) {
1355 for (; ($n % $tabsize) != 0; $n++) {
1367 (my $res = shift) =~ tr/\t/ /c;
1374 # Drop the diff line leader and expand tabs
1376 $line = expand_tabs($line);
1378 # Pick the indent from the front of the line.
1379 my ($white) = ($line =~ /^(\s*)/);
1381 return (length($line), length($white));
1384 my $sanitise_quote = '';
1386 sub sanitise_line_reset {
1387 my ($in_comment) = @_;
1390 $sanitise_quote = '*/';
1392 $sanitise_quote = '';
1405 # Always copy over the diff marker.
1406 $res = substr($line, 0, 1);
1408 for ($off = 1; $off < length($line); $off++) {
1409 $c = substr($line, $off, 1);
1411 # Comments we are whacking completely including the begin
1412 # and end, all to $;.
1413 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1414 $sanitise_quote = '*/';
1416 substr($res, $off, 2, "$;$;");
1420 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1421 $sanitise_quote = '';
1422 substr($res, $off, 2, "$;$;");
1426 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1427 $sanitise_quote = '//';
1429 substr($res, $off, 2, $sanitise_quote);
1434 # A \ in a string means ignore the next character.
1435 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1437 substr($res, $off, 2, 'XX');
1442 if ($c eq "'" || $c eq '"') {
1443 if ($sanitise_quote eq '') {
1444 $sanitise_quote = $c;
1446 substr($res, $off, 1, $c);
1448 } elsif ($sanitise_quote eq $c) {
1449 $sanitise_quote = '';
1453 #print "c<$c> SQ<$sanitise_quote>\n";
1454 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1455 substr($res, $off, 1, $;);
1456 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1457 substr($res, $off, 1, $;);
1458 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1459 substr($res, $off, 1, 'X');
1461 substr($res, $off, 1, $c);
1465 if ($sanitise_quote eq '//') {
1466 $sanitise_quote = '';
1469 # The pathname on a #include may be surrounded by '<' and '>'.
1470 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1471 my $clean = 'X' x length($1);
1472 $res =~ s@\<.*\>@<$clean>@;
1474 # The whole of a #error is a string.
1475 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1476 my $clean = 'X' x length($1);
1477 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1480 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1482 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1488 sub get_quoted_string {
1489 my ($line, $rawline) = @_;
1491 return "" if (!defined($line) || !defined($rawline));
1492 return "" if ($line !~ m/($String)/g);
1493 return substr($rawline, $-[0], $+[0] - $-[0]);
1496 sub ctx_statement_block {
1497 my ($linenr, $remain, $off) = @_;
1498 my $line = $linenr - 1;
1501 my $coff = $off - 1;
1515 @stack = (['', 0]) if ($#stack == -1);
1517 #warn "CSB: blk<$blk> remain<$remain>\n";
1518 # If we are about to drop off the end, pull in more
1521 for (; $remain > 0; $line++) {
1522 last if (!defined $lines[$line]);
1523 next if ($lines[$line] =~ /^-/);
1526 $blk .= $lines[$line] . "\n";
1527 $len = length($blk);
1531 # Bail if there is no further context.
1532 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1536 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1542 $c = substr($blk, $off, 1);
1543 $remainder = substr($blk, $off);
1545 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1547 # Handle nested #if/#else.
1548 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1549 push(@stack, [ $type, $level ]);
1550 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1551 ($type, $level) = @{$stack[$#stack - 1]};
1552 } elsif ($remainder =~ /^#\s*endif\b/) {
1553 ($type, $level) = @{pop(@stack)};
1556 # Statement ends at the ';' or a close '}' at the
1558 if ($level == 0 && $c eq ';') {
1562 # An else is really a conditional as long as its not else if
1563 if ($level == 0 && $coff_set == 0 &&
1564 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1565 $remainder =~ /^(else)(?:\s|{)/ &&
1566 $remainder !~ /^else\s+if\b/) {
1567 $coff = $off + length($1) - 1;
1569 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1570 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1573 if (($type eq '' || $type eq '(') && $c eq '(') {
1577 if ($type eq '(' && $c eq ')') {
1579 $type = ($level != 0)? '(' : '';
1581 if ($level == 0 && $coff < $soff) {
1584 #warn "CSB: mark coff<$coff>\n";
1587 if (($type eq '' || $type eq '{') && $c eq '{') {
1591 if ($type eq '{' && $c eq '}') {
1593 $type = ($level != 0)? '{' : '';
1596 if (substr($blk, $off + 1, 1) eq ';') {
1602 # Preprocessor commands end at the newline unless escaped.
1603 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1611 # We are truly at the end, so shuffle to the next line.
1618 my $statement = substr($blk, $soff, $off - $soff + 1);
1619 my $condition = substr($blk, $soff, $coff - $soff + 1);
1621 #warn "STATEMENT<$statement>\n";
1622 #warn "CONDITION<$condition>\n";
1624 #print "coff<$coff> soff<$off> loff<$loff>\n";
1626 return ($statement, $condition,
1627 $line, $remain + 1, $off - $loff + 1, $level);
1630 sub statement_lines {
1633 # Strip the diff line prefixes and rip blank lines at start and end.
1634 $stmt =~ s/(^|\n)./$1/g;
1638 my @stmt_lines = ($stmt =~ /\n/g);
1640 return $#stmt_lines + 2;
1643 sub statement_rawlines {
1646 my @stmt_lines = ($stmt =~ /\n/g);
1648 return $#stmt_lines + 2;
1651 sub statement_block_size {
1654 $stmt =~ s/(^|\n)./$1/g;
1660 my @stmt_lines = ($stmt =~ /\n/g);
1661 my @stmt_statements = ($stmt =~ /;/g);
1663 my $stmt_lines = $#stmt_lines + 2;
1664 my $stmt_statements = $#stmt_statements + 1;
1666 if ($stmt_lines > $stmt_statements) {
1669 return $stmt_statements;
1673 sub ctx_statement_full {
1674 my ($linenr, $remain, $off) = @_;
1675 my ($statement, $condition, $level);
1679 # Grab the first conditional/block pair.
1680 ($statement, $condition, $linenr, $remain, $off, $level) =
1681 ctx_statement_block($linenr, $remain, $off);
1682 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1683 push(@chunks, [ $condition, $statement ]);
1684 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1685 return ($level, $linenr, @chunks);
1688 # Pull in the following conditional/block pairs and see if they
1689 # could continue the statement.
1691 ($statement, $condition, $linenr, $remain, $off, $level) =
1692 ctx_statement_block($linenr, $remain, $off);
1693 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1694 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1696 push(@chunks, [ $condition, $statement ]);
1699 return ($level, $linenr, @chunks);
1703 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1705 my $start = $linenr - 1;
1712 my @stack = ($level);
1713 for ($line = $start; $remain > 0; $line++) {
1714 next if ($rawlines[$line] =~ /^-/);
1717 $blk .= $rawlines[$line];
1719 # Handle nested #if/#else.
1720 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1721 push(@stack, $level);
1722 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1723 $level = $stack[$#stack - 1];
1724 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1725 $level = pop(@stack);
1728 foreach my $c (split(//, $lines[$line])) {
1729 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1735 if ($c eq $close && $level > 0) {
1737 last if ($level == 0);
1738 } elsif ($c eq $open) {
1743 if (!$outer || $level <= 1) {
1744 push(@res, $rawlines[$line]);
1747 last if ($level == 0);
1750 return ($level, @res);
1752 sub ctx_block_outer {
1753 my ($linenr, $remain) = @_;
1755 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1759 my ($linenr, $remain) = @_;
1761 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1765 my ($linenr, $remain, $off) = @_;
1767 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1770 sub ctx_block_level {
1771 my ($linenr, $remain) = @_;
1773 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1775 sub ctx_statement_level {
1776 my ($linenr, $remain, $off) = @_;
1778 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1781 sub ctx_locate_comment {
1782 my ($first_line, $end_line) = @_;
1784 # If c99 comment on the current line, or the line before or after
1785 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@^\+.*(//.*$)@);
1786 return $current_comment if (defined $current_comment);
1787 ($current_comment) = ($rawlines[$end_line - 2] =~ m@^[\+ ].*(//.*$)@);
1788 return $current_comment if (defined $current_comment);
1789 ($current_comment) = ($rawlines[$end_line] =~ m@^[\+ ].*(//.*$)@);
1790 return $current_comment if (defined $current_comment);
1792 # Catch a comment on the end of the line itself.
1793 ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1794 return $current_comment if (defined $current_comment);
1796 # Look through the context and try and figure out if there is a
1799 $current_comment = '';
1800 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1801 my $line = $rawlines[$linenr - 1];
1803 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1806 if ($line =~ m@/\*@) {
1809 if (!$in_comment && $current_comment ne '') {
1810 $current_comment = '';
1812 $current_comment .= $line . "\n" if ($in_comment);
1813 if ($line =~ m@\*/@) {
1818 chomp($current_comment);
1819 return($current_comment);
1821 sub ctx_has_comment {
1822 my ($first_line, $end_line) = @_;
1823 my $cmt = ctx_locate_comment($first_line, $end_line);
1825 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1826 ##print "CMMT: $cmt\n";
1828 return ($cmt ne '');
1832 my ($linenr, $cnt) = @_;
1834 my $offset = $linenr - 1;
1839 $line = $rawlines[$offset++];
1840 next if (defined($line) && $line =~ /^-/);
1848 my ($linenr, $lc) = @_;
1850 my $stat_real = raw_line($linenr, 0);
1851 for (my $count = $linenr + 1; $count <= $lc; $count++) {
1852 $stat_real = $stat_real . "\n" . raw_line($count, 0);
1859 my ($linenr, $cnt, $here) = @_;
1861 my $herectx = $here . "\n";
1862 for (my $n = 0; $n < $cnt; $n++) {
1863 $herectx .= raw_line($linenr, $n) . "\n";
1874 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1877 $coded = sprintf("^%c", unpack('C', $2) + 64);
1886 my $av_preprocessor = 0;
1891 sub annotate_reset {
1892 $av_preprocessor = 0;
1894 @av_paren_type = ('E');
1895 $av_pend_colon = 'O';
1898 sub annotate_values {
1899 my ($stream, $type) = @_;
1902 my $var = '_' x length($stream);
1905 print "$stream\n" if ($dbg_values > 1);
1907 while (length($cur)) {
1908 @av_paren_type = ('E') if ($#av_paren_type < 0);
1909 print " <" . join('', @av_paren_type) .
1910 "> <$type> <$av_pending>" if ($dbg_values > 1);
1911 if ($cur =~ /^(\s+)/o) {
1912 print "WS($1)\n" if ($dbg_values > 1);
1913 if ($1 =~ /\n/ && $av_preprocessor) {
1914 $type = pop(@av_paren_type);
1915 $av_preprocessor = 0;
1918 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1919 print "CAST($1)\n" if ($dbg_values > 1);
1920 push(@av_paren_type, $type);
1923 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1924 print "DECLARE($1)\n" if ($dbg_values > 1);
1927 } elsif ($cur =~ /^($Modifier)\s*/) {
1928 print "MODIFIER($1)\n" if ($dbg_values > 1);
1931 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1932 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1933 $av_preprocessor = 1;
1934 push(@av_paren_type, $type);
1940 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1941 print "UNDEF($1)\n" if ($dbg_values > 1);
1942 $av_preprocessor = 1;
1943 push(@av_paren_type, $type);
1945 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1946 print "PRE_START($1)\n" if ($dbg_values > 1);
1947 $av_preprocessor = 1;
1949 push(@av_paren_type, $type);
1950 push(@av_paren_type, $type);
1953 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1954 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1955 $av_preprocessor = 1;
1957 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1961 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1962 print "PRE_END($1)\n" if ($dbg_values > 1);
1964 $av_preprocessor = 1;
1966 # Assume all arms of the conditional end as this
1967 # one does, and continue as if the #endif was not here.
1968 pop(@av_paren_type);
1969 push(@av_paren_type, $type);
1972 } elsif ($cur =~ /^(\\\n)/o) {
1973 print "PRECONT($1)\n" if ($dbg_values > 1);
1975 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1976 print "ATTR($1)\n" if ($dbg_values > 1);
1977 $av_pending = $type;
1980 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1981 print "SIZEOF($1)\n" if ($dbg_values > 1);
1987 } elsif ($cur =~ /^(if|while|for)\b/o) {
1988 print "COND($1)\n" if ($dbg_values > 1);
1992 } elsif ($cur =~/^(case)/o) {
1993 print "CASE($1)\n" if ($dbg_values > 1);
1994 $av_pend_colon = 'C';
1997 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1998 print "KEYWORD($1)\n" if ($dbg_values > 1);
2001 } elsif ($cur =~ /^(\()/o) {
2002 print "PAREN('$1')\n" if ($dbg_values > 1);
2003 push(@av_paren_type, $av_pending);
2007 } elsif ($cur =~ /^(\))/o) {
2008 my $new_type = pop(@av_paren_type);
2009 if ($new_type ne '_') {
2011 print "PAREN('$1') -> $type\n"
2012 if ($dbg_values > 1);
2014 print "PAREN('$1')\n" if ($dbg_values > 1);
2017 } elsif ($cur =~ /^($Ident)\s*\(/o) {
2018 print "FUNC($1)\n" if ($dbg_values > 1);
2022 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
2023 if (defined $2 && $type eq 'C' || $type eq 'T') {
2024 $av_pend_colon = 'B';
2025 } elsif ($type eq 'E') {
2026 $av_pend_colon = 'L';
2028 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
2031 } elsif ($cur =~ /^($Ident|$Constant)/o) {
2032 print "IDENT($1)\n" if ($dbg_values > 1);
2035 } elsif ($cur =~ /^($Assignment)/o) {
2036 print "ASSIGN($1)\n" if ($dbg_values > 1);
2039 } elsif ($cur =~/^(;|{|})/) {
2040 print "END($1)\n" if ($dbg_values > 1);
2042 $av_pend_colon = 'O';
2044 } elsif ($cur =~/^(,)/) {
2045 print "COMMA($1)\n" if ($dbg_values > 1);
2048 } elsif ($cur =~ /^(\?)/o) {
2049 print "QUESTION($1)\n" if ($dbg_values > 1);
2052 } elsif ($cur =~ /^(:)/o) {
2053 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
2055 substr($var, length($res), 1, $av_pend_colon);
2056 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
2061 $av_pend_colon = 'O';
2063 } elsif ($cur =~ /^(\[)/o) {
2064 print "CLOSE($1)\n" if ($dbg_values > 1);
2067 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
2070 print "OPV($1)\n" if ($dbg_values > 1);
2077 substr($var, length($res), 1, $variant);
2080 } elsif ($cur =~ /^($Operators)/o) {
2081 print "OP($1)\n" if ($dbg_values > 1);
2082 if ($1 ne '++' && $1 ne '--') {
2086 } elsif ($cur =~ /(^.)/o) {
2087 print "C($1)\n" if ($dbg_values > 1);
2090 $cur = substr($cur, length($1));
2091 $res .= $type x length($1);
2095 return ($res, $var);
2099 my ($possible, $line) = @_;
2100 my $notPermitted = qr{(?:
2117 ^(?:typedef|struct|enum)\b
2119 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
2120 if ($possible !~ $notPermitted) {
2121 # Check for modifiers.
2122 $possible =~ s/\s*$Storage\s*//g;
2123 $possible =~ s/\s*$Sparse\s*//g;
2124 if ($possible =~ /^\s*$/) {
2126 } elsif ($possible =~ /\s/) {
2127 $possible =~ s/\s*$Type\s*//g;
2128 for my $modifier (split(' ', $possible)) {
2129 if ($modifier !~ $notPermitted) {
2130 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
2131 push(@modifierListFile, $modifier);
2136 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
2137 push(@typeListFile, $possible);
2141 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
2150 $type =~ tr/[a-z]/[A-Z]/;
2152 return defined $use_type{$type} if (scalar keys %use_type > 0);
2154 return !defined $ignore_type{$type};
2158 my ($level, $type, $msg) = @_;
2160 if (!show_type($type) ||
2161 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
2166 if ($level eq 'ERROR') {
2168 } elsif ($level eq 'WARNING') {
2174 $output .= $prefix . $level . ':';
2176 $output .= BLUE if ($color);
2177 $output .= "$type:";
2179 $output .= RESET if ($color);
2180 $output .= ' ' . $msg . "\n";
2183 my @lines = split("\n", $output, -1);
2184 splice(@lines, 1, 1);
2185 $output = join("\n", @lines);
2187 $output = (split('\n', $output))[0] . "\n" if ($terse);
2189 push(our @report, $output);
2198 sub fixup_current_range {
2199 my ($lineRef, $offset, $length) = @_;
2201 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2204 my $no = $o + $offset;
2205 my $nl = $l + $length;
2206 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2210 sub fix_inserted_deleted_lines {
2211 my ($linesRef, $insertedRef, $deletedRef) = @_;
2213 my $range_last_linenr = 0;
2214 my $delta_offset = 0;
2219 my $next_insert = 0;
2220 my $next_delete = 0;
2224 my $inserted = @{$insertedRef}[$next_insert++];
2225 my $deleted = @{$deletedRef}[$next_delete++];
2227 foreach my $old_line (@{$linesRef}) {
2229 my $line = $old_line; #don't modify the array
2230 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
2232 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2233 $range_last_linenr = $new_linenr;
2234 fixup_current_range(\$line, $delta_offset, 0);
2237 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2238 $deleted = @{$deletedRef}[$next_delete++];
2240 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2243 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2244 push(@lines, ${$inserted}{'LINE'});
2245 $inserted = @{$insertedRef}[$next_insert++];
2247 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2251 push(@lines, $line);
2261 sub fix_insert_line {
2262 my ($linenr, $line) = @_;
2268 push(@fixed_inserted, $inserted);
2271 sub fix_delete_line {
2272 my ($linenr, $line) = @_;
2279 push(@fixed_deleted, $deleted);
2283 my ($type, $msg) = @_;
2285 if (report("ERROR", $type, $msg)) {
2293 my ($type, $msg) = @_;
2295 if (report("WARNING", $type, $msg)) {
2303 my ($type, $msg) = @_;
2305 if ($check && report("CHECK", $type, $msg)) {
2313 sub check_absolute_file {
2314 my ($absolute, $herecurr) = @_;
2315 my $file = $absolute;
2317 ##print "absolute<$absolute>\n";
2319 # See if any suffix of this path is a path within the tree.
2320 while ($file =~ s@^[^/]*/@@) {
2321 if (-f "$root/$file") {
2322 ##print "file<$file>\n";
2330 # It is, so see if the prefix is acceptable.
2331 my $prefix = $absolute;
2332 substr($prefix, -length($file)) = '';
2334 ##print "prefix<$prefix>\n";
2335 if ($prefix ne ".../") {
2336 WARN("USE_RELATIVE_PATH",
2337 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2344 $string =~ s/^\s+|\s+$//g;
2352 $string =~ s/^\s+//;
2360 $string =~ s/\s+$//;
2365 sub string_find_replace {
2366 my ($string, $find, $replace) = @_;
2368 $string =~ s/$find/$replace/g;
2376 my $source_indent = $tabsize;
2377 my $max_spaces_before_tab = $source_indent - 1;
2378 my $spaces_to_tab = " " x $source_indent;
2380 #convert leading spaces to tabs
2381 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2382 #Remove spaces before a tab
2383 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2388 sub pos_last_openparen {
2393 my $opens = $line =~ tr/\(/\(/;
2394 my $closes = $line =~ tr/\)/\)/;
2396 my $last_openparen = 0;
2398 if (($opens == 0) || ($closes >= $opens)) {
2402 my $len = length($line);
2404 for ($pos = 0; $pos < $len; $pos++) {
2405 my $string = substr($line, $pos);
2406 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2407 $pos += length($1) - 1;
2408 } elsif (substr($line, $pos, 1) eq '(') {
2409 $last_openparen = $pos;
2410 } elsif (index($string, '(') == -1) {
2415 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2418 sub get_raw_comment {
2419 my ($line, $rawline) = @_;
2422 for my $i (0 .. (length($line) - 1)) {
2423 if (substr($line, $i, 1) eq "$;") {
2424 $comment .= substr($rawline, $i, 1);
2432 my $filename = shift;
2438 my $stashrawline="";
2448 my $authorsignoff = 0;
2449 my $author_sob = '';
2451 my $is_binding_patch = -1;
2452 my $in_header_lines = $file ? 0 : 1;
2453 my $in_commit_log = 0; #Scanning lines before patch
2454 my $has_patch_separator = 0; #Found a --- line
2455 my $has_commit_log = 0; #Encountered lines before patch
2456 my $commit_log_lines = 0; #Number of commit log lines
2457 my $commit_log_possible_stack_dump = 0;
2458 my $commit_log_long_line = 0;
2459 my $commit_log_has_diff = 0;
2460 my $reported_maintainer_file = 0;
2461 my $non_utf8_charset = 0;
2463 my $last_blank_line = 0;
2464 my $last_coalesced_string_linenr = -1;
2472 # Trace the real file/line as we go.
2477 my $context_function; #undef'd unless there's a known function
2479 my $comment_edge = 0;
2483 my $prev_values = 'E';
2486 my %suppress_ifbraces;
2487 my %suppress_whiletrailers;
2488 my %suppress_export;
2489 my $suppress_statement = 0;
2491 my %signatures = ();
2493 # Pre-scan the patch sanitizing the lines.
2494 # Pre-scan the patch looking for any __setup documentation.
2496 my @setup_docs = ();
2499 my $camelcase_file_seeded = 0;
2501 my $checklicenseline = 1;
2503 sanitise_line_reset();
2505 foreach my $rawline (@rawlines) {
2509 push(@fixed, $rawline) if ($fix);
2511 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2513 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.txt$@) {
2518 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2527 # Guestimate if this is a continuing comment. Run
2528 # the context looking for a comment "edge". If this
2529 # edge is a close comment then we must be in a comment
2533 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2534 next if (defined $rawlines[$ln - 1] &&
2535 $rawlines[$ln - 1] =~ /^-/);
2537 #print "RAW<$rawlines[$ln - 1]>\n";
2538 last if (!defined $rawlines[$ln - 1]);
2539 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2540 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2545 if (defined $edge && $edge eq '*/') {
2549 # Guestimate if this is a continuing comment. If this
2550 # is the start of a diff block and this line starts
2551 # ' *' then it is very likely a comment.
2552 if (!defined $edge &&
2553 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2558 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2559 sanitise_line_reset($in_comment);
2561 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2562 # Standardise the strings and chars within the input to
2563 # simplify matching -- only bother with positive lines.
2564 $line = sanitise_line($rawline);
2566 push(@lines, $line);
2569 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2574 #print "==>$rawline\n";
2575 #print "-->$line\n";
2577 if ($setup_docs && $line =~ /^\+/) {
2578 push(@setup_docs, $line);
2587 foreach my $line (@lines) {
2590 my $sline = $line; #copy of $line
2591 $sline =~ s/$;/ /g; #with comments as spaces
2593 my $rawline = $rawlines[$linenr - 1];
2594 my $raw_comment = get_raw_comment($line, $rawline);
2596 # check if it's a mode change, rename or start of a patch
2597 if (!$in_commit_log &&
2598 ($line =~ /^ mode change [0-7]+ => [0-7]+ \S+\s*$/ ||
2599 ($line =~ /^rename (?:from|to) \S+\s*$/ ||
2600 $line =~ /^diff --git a\/[\w\/\.\_\-]+ b\/\S+\s*$/))) {
2604 #extract the line range in the file after the patch is applied
2605 if (!$in_commit_log &&
2606 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2609 $first_line = $linenr + 1;
2619 %suppress_ifbraces = ();
2620 %suppress_whiletrailers = ();
2621 %suppress_export = ();
2622 $suppress_statement = 0;
2623 if ($context =~ /\b(\w+)\s*\(/) {
2624 $context_function = $1;
2626 undef $context_function;
2630 # track the line number as we move through the hunk, note that
2631 # new versions of GNU diff omit the leading space on completely
2632 # blank context lines so we need to count that too.
2633 } elsif ($line =~ /^( |\+|$)/) {
2635 $realcnt-- if ($realcnt != 0);
2637 # Measure the line length and indent.
2638 ($length, $indent) = line_stats($rawline);
2640 # Track the previous line.
2641 ($prevline, $stashline) = ($stashline, $line);
2642 ($previndent, $stashindent) = ($stashindent, $indent);
2643 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2645 #warn "line<$line>\n";
2647 } elsif ($realcnt == 1) {
2651 my $hunk_line = ($realcnt != 0);
2653 $here = "#$linenr: " if (!$file);
2654 $here = "#$realline: " if ($file);
2657 # extract the filename as it passes
2658 if ($line =~ /^diff --git.*?(\S+)$/) {
2660 $realfile =~ s@^([^/]*)/@@ if (!$file);
2663 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2665 $realfile =~ s@^([^/]*)/@@ if (!$file);
2669 if (!$file && $tree && $p1_prefix ne '' &&
2670 -e "$root/$p1_prefix") {
2671 WARN("PATCH_PREFIX",
2672 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2675 if ($realfile =~ m@^include/asm/@) {
2676 ERROR("MODIFIED_INCLUDE_ASM",
2677 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2682 #make up the handle for any error we report on this line
2684 $prefix = "$realfile:$realline: "
2687 $prefix = "$filename:$realline: ";
2689 $prefix = "$filename:$linenr: ";
2694 if (is_maintained_obsolete($realfile)) {
2696 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2698 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2701 $check = $check_orig;
2703 $checklicenseline = 1;
2705 if ($realfile !~ /^MAINTAINERS/) {
2706 my $last_binding_patch = $is_binding_patch;
2708 $is_binding_patch = () = $realfile =~ m@^(?:Documentation/devicetree/|include/dt-bindings/)@;
2710 if (($last_binding_patch != -1) &&
2711 ($last_binding_patch ^ $is_binding_patch)) {
2712 WARN("DT_SPLIT_BINDING_PATCH",
2713 "DT binding docs and includes should be a separate patch. See: Documentation/devicetree/bindings/submitting-patches.rst\n");
2720 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2722 my $hereline = "$here\n$rawline\n";
2723 my $herecurr = "$here\n$rawline\n";
2724 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2726 $cnt_lines++ if ($realcnt != 0);
2728 # Verify the existence of a commit log if appropriate
2729 # 2 is used because a $signature is counted in $commit_log_lines
2730 if ($in_commit_log) {
2731 if ($line !~ /^\s*$/) {
2732 $commit_log_lines++; #could be a $signature
2734 } elsif ($has_commit_log && $commit_log_lines < 2) {
2735 WARN("COMMIT_MESSAGE",
2736 "Missing commit description - Add an appropriate one\n");
2737 $commit_log_lines = 2; #warn only once
2740 # Check if the commit log has what seems like a diff which can confuse patch
2741 if ($in_commit_log && !$commit_log_has_diff &&
2742 (($line =~ m@^\s+diff\b.*a/([\w/]+)@ &&
2743 $line =~ m@^\s+diff\b.*a/[\w/]+\s+b/$1\b@) ||
2744 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2745 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2746 ERROR("DIFF_IN_COMMIT_MSG",
2747 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2748 $commit_log_has_diff = 1;
2751 # Check for incorrect file permissions
2752 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2753 my $permhere = $here . "FILE: $realfile\n";
2754 if ($realfile !~ m@scripts/@ &&
2755 $realfile !~ /\.(py|pl|awk|sh)$/) {
2756 ERROR("EXECUTE_PERMISSIONS",
2757 "do not set execute permissions for source files\n" . $permhere);
2761 # Check the patch for a From:
2762 if (decode("MIME-Header", $line) =~ /^From:\s*(.*)/) {
2764 my $curline = $linenr;
2765 while(defined($rawlines[$curline]) && ($rawlines[$curline++] =~ /^[ \t]\s*(.*)/)) {
2768 $author = encode("utf8", $author) if ($line =~ /=\?utf-8\?/i);
2770 $author = reformat_email($author);
2773 # Check the patch for a signoff:
2774 if ($line =~ /^\s*signed-off-by:\s*(.*)/i) {
2777 if ($author ne '' && $authorsignoff != 1) {
2778 if (same_email_addresses($1, $author)) {
2782 my ($email_name, $email_comment, $email_address, $comment1) = parse_email($ctx);
2783 my ($author_name, $author_comment, $author_address, $comment2) = parse_email($author);
2785 if ($email_address eq $author_address && $email_name eq $author_name) {
2788 } elsif ($email_address eq $author_address) {
2791 } elsif ($email_name eq $author_name) {
2795 my $address1 = $email_address;
2796 my $address2 = $author_address;
2798 if ($address1 =~ /(\S+)\+\S+(\@.*)/) {
2801 if ($address2 =~ /(\S+)\+\S+(\@.*)/) {
2804 if ($address1 eq $address2) {
2812 # Check for patch separator
2813 if ($line =~ /^---$/) {
2814 $has_patch_separator = 1;
2818 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2819 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2820 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2821 $reported_maintainer_file = 1;
2824 # Check signature styles
2825 if (!$in_header_lines &&
2826 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2827 my $space_before = $1;
2829 my $space_after = $3;
2831 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2833 if ($sign_off !~ /$signature_tags/) {
2834 my $suggested_signature = find_standard_signature($sign_off);
2835 if ($suggested_signature eq "") {
2836 WARN("BAD_SIGN_OFF",
2837 "Non-standard signature: $sign_off\n" . $herecurr);
2839 if (WARN("BAD_SIGN_OFF",
2840 "Non-standard signature: '$sign_off' - perhaps '$suggested_signature'?\n" . $herecurr) &&
2842 $fixed[$fixlinenr] =~ s/$sign_off/$suggested_signature/;
2846 if (defined $space_before && $space_before ne "") {
2847 if (WARN("BAD_SIGN_OFF",
2848 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2850 $fixed[$fixlinenr] =
2851 "$ucfirst_sign_off $email";
2854 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2855 if (WARN("BAD_SIGN_OFF",
2856 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2858 $fixed[$fixlinenr] =
2859 "$ucfirst_sign_off $email";
2863 if (!defined $space_after || $space_after ne " ") {
2864 if (WARN("BAD_SIGN_OFF",
2865 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2867 $fixed[$fixlinenr] =
2868 "$ucfirst_sign_off $email";
2872 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
2873 my $suggested_email = format_email(($email_name, $name_comment, $email_address, $comment));
2874 if ($suggested_email eq "") {
2875 ERROR("BAD_SIGN_OFF",
2876 "Unrecognized email address: '$email'\n" . $herecurr);
2878 my $dequoted = $suggested_email;
2879 $dequoted =~ s/^"//;
2880 $dequoted =~ s/" </ </;
2881 # Don't force email to have quotes
2882 # Allow just an angle bracketed address
2883 if (!same_email_addresses($email, $suggested_email)) {
2884 if (WARN("BAD_SIGN_OFF",
2885 "email address '$email' might be better as '$suggested_email'\n" . $herecurr) &&
2887 $fixed[$fixlinenr] =~ s/\Q$email\E/$suggested_email/;
2891 # Address part shouldn't have comments
2892 my $stripped_address = $email_address;
2893 $stripped_address =~ s/\([^\(\)]*\)//g;
2894 if ($email_address ne $stripped_address) {
2895 if (WARN("BAD_SIGN_OFF",
2896 "address part of email should not have comments: '$email_address'\n" . $herecurr) &&
2898 $fixed[$fixlinenr] =~ s/\Q$email_address\E/$stripped_address/;
2902 # Only one name comment should be allowed
2903 my $comment_count = () = $name_comment =~ /\([^\)]+\)/g;
2904 if ($comment_count > 1) {
2905 WARN("BAD_SIGN_OFF",
2906 "Use a single name comment in email: '$email'\n" . $herecurr);
2910 # stable@vger.kernel.org or stable@kernel.org shouldn't
2911 # have an email name. In addition comments should strictly
2913 if ($email =~ /^.*stable\@(?:vger\.)?kernel\.org/i) {
2914 if (($comment ne "" && $comment !~ /^#.+/) ||
2915 ($email_name ne "")) {
2916 my $cur_name = $email_name;
2917 my $new_comment = $comment;
2918 $cur_name =~ s/[a-zA-Z\s\-\"]+//g;
2920 # Remove brackets enclosing comment text
2921 # and # from start of comments to get comment text
2922 $new_comment =~ s/^\((.*)\)$/$1/;
2923 $new_comment =~ s/^\[(.*)\]$/$1/;
2924 $new_comment =~ s/^[\s\#]+|\s+$//g;
2926 $new_comment = trim("$new_comment $cur_name") if ($cur_name ne $new_comment);
2927 $new_comment = " # $new_comment" if ($new_comment ne "");
2928 my $new_email = "$email_address$new_comment";
2930 if (WARN("BAD_STABLE_ADDRESS_STYLE",
2931 "Invalid email format for stable: '$email', prefer '$new_email'\n" . $herecurr) &&
2933 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
2936 } elsif ($comment ne "" && $comment !~ /^(?:#.+|\(.+\))$/) {
2937 my $new_comment = $comment;
2939 # Extract comment text from within brackets or
2940 # c89 style /*...*/ comments
2941 $new_comment =~ s/^\[(.*)\]$/$1/;
2942 $new_comment =~ s/^\/\*(.*)\*\/$/$1/;
2944 $new_comment = trim($new_comment);
2945 $new_comment =~ s/^[^\w]$//; # Single lettered comment with non word character is usually a typo
2946 $new_comment = "($new_comment)" if ($new_comment ne "");
2947 my $new_email = format_email($email_name, $name_comment, $email_address, $new_comment);
2949 if (WARN("BAD_SIGN_OFF",
2950 "Unexpected content after email: '$email', should be: '$new_email'\n" . $herecurr) &&
2952 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
2957 # Check for duplicate signatures
2958 my $sig_nospace = $line;
2959 $sig_nospace =~ s/\s//g;
2960 $sig_nospace = lc($sig_nospace);
2961 if (defined $signatures{$sig_nospace}) {
2962 WARN("BAD_SIGN_OFF",
2963 "Duplicate signature\n" . $herecurr);
2965 $signatures{$sig_nospace} = 1;
2968 # Check Co-developed-by: immediately followed by Signed-off-by: with same name and email
2969 if ($sign_off =~ /^co-developed-by:$/i) {
2970 if ($email eq $author) {
2971 WARN("BAD_SIGN_OFF",
2972 "Co-developed-by: should not be used to attribute nominal patch author '$author'\n" . "$here\n" . $rawline);
2974 if (!defined $lines[$linenr]) {
2975 WARN("BAD_SIGN_OFF",
2976 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline);
2977 } elsif ($rawlines[$linenr] !~ /^\s*signed-off-by:\s*(.*)/i) {
2978 WARN("BAD_SIGN_OFF",
2979 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
2980 } elsif ($1 ne $email) {
2981 WARN("BAD_SIGN_OFF",
2982 "Co-developed-by and Signed-off-by: name/email do not match \n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
2987 # Check email subject for common tools that don't need to be mentioned
2988 if ($in_header_lines &&
2989 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2990 WARN("EMAIL_SUBJECT",
2991 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2994 # Check for Gerrit Change-Ids not in any patch context
2995 if ($realfile eq '' && !$has_patch_separator && $line =~ /^\s*change-id:/i) {
2996 if (ERROR("GERRIT_CHANGE_ID",
2997 "Remove Gerrit Change-Id's before submitting upstream\n" . $herecurr) &&
2999 fix_delete_line($fixlinenr, $rawline);
3003 # Check if the commit log is in a possible stack dump
3004 if ($in_commit_log && !$commit_log_possible_stack_dump &&
3005 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
3006 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
3008 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/) ||
3009 $line =~ /^(?:\s+\w+:\s+[0-9a-fA-F]+){3,3}/ ||
3010 $line =~ /^\s*\#\d+\s*\[[0-9a-fA-F]+\]\s*\w+ at [0-9a-fA-F]+/) {
3011 # stack dump address styles
3012 $commit_log_possible_stack_dump = 1;
3015 # Check for line lengths > 75 in commit log, warn once
3016 if ($in_commit_log && !$commit_log_long_line &&
3017 length($line) > 75 &&
3018 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
3019 # file delta changes
3020 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
3022 $line =~ /^\s*(?:Fixes:|Link:|$signature_tags)/i ||
3023 # A Fixes: or Link: line or signature tag line
3024 $commit_log_possible_stack_dump)) {
3025 WARN("COMMIT_LOG_LONG_LINE",
3026 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
3027 $commit_log_long_line = 1;
3030 # Reset possible stack dump if a blank line is found
3031 if ($in_commit_log && $commit_log_possible_stack_dump &&
3033 $commit_log_possible_stack_dump = 0;
3036 # Check for lines starting with a #
3037 if ($in_commit_log && $line =~ /^#/) {
3038 if (WARN("COMMIT_COMMENT_SYMBOL",
3039 "Commit log lines starting with '#' are dropped by git as comments\n" . $herecurr) &&
3041 $fixed[$fixlinenr] =~ s/^/ /;
3045 # Check for git id commit length and improperly formed commit descriptions
3046 if ($in_commit_log && !$commit_log_possible_stack_dump &&
3047 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink|base-commit):/i &&
3048 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
3049 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
3050 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
3051 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
3052 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
3053 my $init_char = "c";
3054 my $orig_commit = "";
3061 my $id = '0123456789ab';
3062 my $orig_desc = "commit description";
3063 my $description = "";
3065 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
3067 $orig_commit = lc($2);
3068 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
3069 $orig_commit = lc($1);
3072 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
3073 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
3074 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
3075 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
3076 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
3079 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
3080 defined $rawlines[$linenr] &&
3081 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
3084 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
3085 defined $rawlines[$linenr] &&
3086 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
3087 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
3089 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
3090 $orig_desc .= " " . $1;
3094 ($id, $description) = git_commit_info($orig_commit,
3098 ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
3099 ERROR("GIT_COMMIT_ID",
3100 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
3104 # Check for added, moved or deleted files
3105 if (!$reported_maintainer_file && !$in_commit_log &&
3106 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
3107 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
3108 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
3109 (defined($1) || defined($2))))) {
3111 $reported_maintainer_file = 1;
3112 WARN("FILE_PATH_CHANGES",
3113 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
3116 # Check for adding new DT bindings not in schema format
3117 if (!$in_commit_log &&
3118 ($line =~ /^new file mode\s*\d+\s*$/) &&
3119 ($realfile =~ m@^Documentation/devicetree/bindings/.*\.txt$@)) {
3120 WARN("DT_SCHEMA_BINDING_PATCH",
3121 "DT bindings should be in DT schema format. See: Documentation/devicetree/writing-schema.rst\n");
3124 # Check for wrappage within a valid hunk of the file
3125 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
3126 ERROR("CORRUPTED_PATCH",
3127 "patch seems to be corrupt (line wrapped?)\n" .
3128 $herecurr) if (!$emitted_corrupt++);
3131 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
3132 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
3133 $rawline !~ m/^$UTF8*$/) {
3134 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
3136 my $blank = copy_spacing($rawline);
3137 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
3138 my $hereptr = "$hereline$ptr\n";
3141 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
3144 # Check if it's the start of a commit log
3145 # (not a header line and we haven't seen the patch filename)
3146 if ($in_header_lines && $realfile =~ /^$/ &&
3147 !($rawline =~ /^\s+(?:\S|$)/ ||
3148 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
3149 $in_header_lines = 0;
3151 $has_commit_log = 1;
3154 # Check if there is UTF-8 in a commit log when a mail header has explicitly
3155 # declined it, i.e defined some charset where it is missing.
3156 if ($in_header_lines &&
3157 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
3159 $non_utf8_charset = 1;
3162 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
3163 $rawline =~ /$NON_ASCII_UTF8/) {
3164 WARN("UTF8_BEFORE_PATCH",
3165 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
3168 # Check for absolute kernel paths in commit message
3169 if ($tree && $in_commit_log) {
3170 while ($line =~ m{(?:^|\s)(/\S*)}g) {
3173 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
3174 check_absolute_file($1, $herecurr)) {
3177 check_absolute_file($file, $herecurr);
3182 # Check for various typo / spelling mistakes
3183 if (defined($misspellings) &&
3184 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
3185 while ($rawline =~ /(?:^|[^\w\-'`])($misspellings)(?:[^\w\-'`]|$)/gi) {
3187 my $blank = copy_spacing($rawline);
3188 my $ptr = substr($blank, 0, $-[1]) . "^" x length($typo);
3189 my $hereptr = "$hereline$ptr\n";
3190 my $typo_fix = $spelling_fix{lc($typo)};
3191 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
3192 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
3193 my $msg_level = \&WARN;
3194 $msg_level = \&CHK if ($file);
3195 if (&{$msg_level}("TYPO_SPELLING",
3196 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $hereptr) &&
3198 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
3203 # check for invalid commit id
3204 if ($in_commit_log && $line =~ /(^fixes:|\bcommit)\s+([0-9a-f]{6,40})\b/i) {
3207 ($id, $description) = git_commit_info($2, undef, undef);
3208 if (!defined($id)) {
3209 WARN("UNKNOWN_COMMIT_ID",
3210 "Unknown commit id '$2', maybe rebased or not pulled?\n" . $herecurr);
3214 # check for repeated words separated by a single space
3215 # avoid false positive from list command eg, '-rw-r--r-- 1 root root'
3216 if (($rawline =~ /^\+/ || $in_commit_log) &&
3217 $rawline !~ /[bcCdDlMnpPs\?-][rwxsStT-]{9}/) {
3218 pos($rawline) = 1 if (!$in_commit_log);
3219 while ($rawline =~ /\b($word_pattern) (?=($word_pattern))/g) {
3223 my $start_pos = $-[1];
3224 my $end_pos = $+[2];
3225 if ($first =~ /(?:struct|union|enum)/) {
3226 pos($rawline) += length($first) + length($second) + 1;
3230 next if (lc($first) ne lc($second));
3231 next if ($first eq 'long');
3233 # check for character before and after the word matches
3234 my $start_char = '';
3236 $start_char = substr($rawline, $start_pos - 1, 1) if ($start_pos > ($in_commit_log ? 0 : 1));
3237 $end_char = substr($rawline, $end_pos, 1) if ($end_pos < length($rawline));
3239 next if ($start_char =~ /^\S$/);
3240 next if (index(" \t.,;?!", $end_char) == -1);
3242 # avoid repeating hex occurrences like 'ff ff fe 09 ...'
3243 if ($first =~ /\b[0-9a-f]{2,}\b/i) {
3244 next if (!exists($allow_repeated_words{lc($first)}));
3247 if (WARN("REPEATED_WORD",
3248 "Possible repeated word: '$first'\n" . $herecurr) &&
3250 $fixed[$fixlinenr] =~ s/\b$first $second\b/$first/;
3254 # if it's a repeated word on consecutive lines in a comment block
3255 if ($prevline =~ /$;+\s*$/ &&
3256 $prevrawline =~ /($word_pattern)\s*$/) {
3258 if ($rawline =~ /^\+\s*\*\s*$last_word /) {
3259 if (WARN("REPEATED_WORD",
3260 "Possible repeated word: '$last_word'\n" . $hereprev) &&
3262 $fixed[$fixlinenr] =~ s/(\+\s*\*\s*)$last_word /$1/;
3268 # ignore non-hunk lines and lines being removed
3269 next if (!$hunk_line || $line =~ /^-/);
3271 #trailing whitespace
3272 if ($line =~ /^\+.*\015/) {
3273 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3274 if (ERROR("DOS_LINE_ENDINGS",
3275 "DOS line endings\n" . $herevet) &&
3277 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
3279 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
3280 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3281 if (ERROR("TRAILING_WHITESPACE",
3282 "trailing whitespace\n" . $herevet) &&
3284 $fixed[$fixlinenr] =~ s/\s+$//;
3290 # Check for FSF mailing addresses.
3291 if ($rawline =~ /\bwrite to the Free/i ||
3292 $rawline =~ /\b675\s+Mass\s+Ave/i ||
3293 $rawline =~ /\b59\s+Temple\s+Pl/i ||
3294 $rawline =~ /\b51\s+Franklin\s+St/i) {
3295 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3296 my $msg_level = \&ERROR;
3297 $msg_level = \&CHK if ($file);
3298 &{$msg_level}("FSF_MAILING_ADDRESS",
3299 "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)
3302 # check for Kconfig help text having a real description
3303 # Only applies when adding the entry originally, after that we do not have
3304 # sufficient context to determine whether it is indeed long enough.
3305 if ($realfile =~ /Kconfig/ &&
3306 # 'choice' is usually the last thing on the line (though
3307 # Kconfig supports named choices), so use a word boundary
3308 # (\b) rather than a whitespace character (\s)
3309 $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
3312 my $ln = $linenr + 1;
3316 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
3317 $f = $lines[$ln - 1];
3318 $cnt-- if ($lines[$ln - 1] !~ /^-/);
3319 $is_end = $lines[$ln - 1] =~ /^\+/;
3321 next if ($f =~ /^-/);
3322 last if (!$file && $f =~ /^\@\@/);
3324 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
3326 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
3333 next if ($f =~ /^$/);
3335 # This only checks context lines in the patch
3336 # and so hopefully shouldn't trigger false
3337 # positives, even though some of these are
3338 # common words in help texts
3339 if ($f =~ /^\s*(?:config|menuconfig|choice|endchoice|
3340 if|endif|menu|endmenu|source)\b/x) {
3346 if ($is_start && $is_end && $length < $min_conf_desc_length) {
3347 WARN("CONFIG_DESCRIPTION",
3348 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
3350 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
3353 # check MAINTAINERS entries
3354 if ($realfile =~ /^MAINTAINERS$/) {
3355 # check MAINTAINERS entries for the right form
3356 if ($rawline =~ /^\+[A-Z]:/ &&
3357 $rawline !~ /^\+[A-Z]:\t\S/) {
3358 if (WARN("MAINTAINERS_STYLE",
3359 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
3361 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
3364 # check MAINTAINERS entries for the right ordering too
3365 my $preferred_order = 'MRLSWQBCPTFXNK';
3366 if ($rawline =~ /^\+[A-Z]:/ &&
3367 $prevrawline =~ /^[\+ ][A-Z]:/) {
3368 $rawline =~ /^\+([A-Z]):\s*(.*)/;
3371 $prevrawline =~ /^[\+ ]([A-Z]):\s*(.*)/;
3374 my $curindex = index($preferred_order, $cur);
3375 my $previndex = index($preferred_order, $prev);
3376 if ($curindex < 0) {
3377 WARN("MAINTAINERS_STYLE",
3378 "Unknown MAINTAINERS entry type: '$cur'\n" . $herecurr);
3380 if ($previndex >= 0 && $curindex < $previndex) {
3381 WARN("MAINTAINERS_STYLE",
3382 "Misordered MAINTAINERS entry - list '$cur:' before '$prev:'\n" . $hereprev);
3383 } elsif ((($prev eq 'F' && $cur eq 'F') ||
3384 ($prev eq 'X' && $cur eq 'X')) &&
3385 ($prevval cmp $curval) > 0) {
3386 WARN("MAINTAINERS_STYLE",
3387 "Misordered MAINTAINERS entry - list file patterns in alphabetic order\n" . $hereprev);
3393 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
3394 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
3397 'EXTRA_AFLAGS' => 'asflags-y',
3398 'EXTRA_CFLAGS' => 'ccflags-y',
3399 'EXTRA_CPPFLAGS' => 'cppflags-y',
3400 'EXTRA_LDFLAGS' => 'ldflags-y',
3403 WARN("DEPRECATED_VARIABLE",
3404 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
3407 # check for DT compatible documentation
3408 if (defined $root &&
3409 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
3410 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
3412 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
3414 my $dt_path = $root . "/Documentation/devicetree/bindings/";
3415 my $vp_file = $dt_path . "vendor-prefixes.yaml";
3417 foreach my $compat (@compats) {
3418 my $compat2 = $compat;
3419 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
3420 my $compat3 = $compat;
3421 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
3422 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
3424 WARN("UNDOCUMENTED_DT_STRING",
3425 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
3428 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
3430 `grep -Eq "\\"\\^\Q$vendor\E,\\.\\*\\":" $vp_file`;
3432 WARN("UNDOCUMENTED_DT_STRING",
3433 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
3438 # check for using SPDX license tag at beginning of files
3439 if ($realline == $checklicenseline) {
3440 if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
3441 $checklicenseline = 2;
3442 } elsif ($rawline =~ /^\+/) {
3444 if ($realfile =~ /\.(h|s|S)$/) {
3446 } elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
3448 } elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc|yaml)$/) {
3450 } elsif ($realfile =~ /\.rst$/) {
3454 # check SPDX comment style for .[chsS] files
3455 if ($realfile =~ /\.[chsS]$/ &&
3456 $rawline =~ /SPDX-License-Identifier:/ &&
3457 $rawline !~ m@^\+\s*\Q$comment\E\s*@) {
3458 WARN("SPDX_LICENSE_TAG",
3459 "Improper SPDX comment style for '$realfile', please use '$comment' instead\n" . $herecurr);
3462 if ($comment !~ /^$/ &&
3463 $rawline !~ m@^\+\Q$comment\E SPDX-License-Identifier: @) {
3464 WARN("SPDX_LICENSE_TAG",
3465 "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
3466 } elsif ($rawline =~ /(SPDX-License-Identifier: .*)/) {
3467 my $spdx_license = $1;
3468 if (!is_SPDX_License_valid($spdx_license)) {
3469 WARN("SPDX_LICENSE_TAG",
3470 "'$spdx_license' is not supported in LICENSES/...\n" . $herecurr);
3472 if ($realfile =~ m@^Documentation/devicetree/bindings/@ &&
3473 not $spdx_license =~ /GPL-2\.0.*BSD-2-Clause/) {
3474 my $msg_level = \&WARN;
3475 $msg_level = \&CHK if ($file);
3476 if (&{$msg_level}("SPDX_LICENSE_TAG",
3478 "DT binding documents should be licensed (GPL-2.0-only OR BSD-2-Clause)\n" . $herecurr) &&
3480 $fixed[$fixlinenr] =~ s/SPDX-License-Identifier: .*/SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)/;
3487 # check for embedded filenames
3488 if ($rawline =~ /^\+.*\Q$realfile\E/) {
3489 WARN("EMBEDDED_FILENAME",
3490 "It's generally not useful to have the filename in the file\n" . $herecurr);
3493 # check we are in a valid source file if not then ignore this hunk
3494 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
3496 # check for using SPDX-License-Identifier on the wrong line number
3497 if ($realline != $checklicenseline &&
3498 $rawline =~ /\bSPDX-License-Identifier:/ &&
3499 substr($line, @-, @+ - @-) eq "$;" x (@+ - @-)) {
3500 WARN("SPDX_LICENSE_TAG",
3501 "Misplaced SPDX-License-Identifier tag - use line $checklicenseline instead\n" . $herecurr);
3504 # line length limit (with some exclusions)
3506 # There are a few types of lines that may extend beyond $max_line_length:
3507 # logging functions like pr_info that end in a string
3508 # lines with a single string
3509 # #defines that are a single string
3510 # lines with an RFC3986 like URL
3512 # There are 3 different line length message types:
3513 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
3514 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
3515 # LONG_LINE all other lines longer than $max_line_length
3517 # if LONG_LINE is ignored, the other 2 types are also ignored
3520 if ($line =~ /^\+/ && $length > $max_line_length) {
3521 my $msg_type = "LONG_LINE";
3523 # Check the allowed long line types first
3525 # logging functions that end in a string that starts
3526 # before $max_line_length
3527 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
3528 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3531 # lines with only strings (w/ possible termination)
3532 # #defines with only strings
3533 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
3534 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
3537 # More special cases
3538 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3539 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3542 # URL ($rawline is used in case the URL is in a comment)
3543 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
3546 # Otherwise set the alternate message types
3548 # a comment starts before $max_line_length
3549 } elsif ($line =~ /($;[\s$;]*)$/ &&
3550 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3551 $msg_type = "LONG_LINE_COMMENT"
3553 # a quoted string starts before $max_line_length
3554 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3555 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3556 $msg_type = "LONG_LINE_STRING"
3559 if ($msg_type ne "" &&
3560 (show_type("LONG_LINE") || show_type($msg_type))) {
3561 my $msg_level = \&WARN;
3562 $msg_level = \&CHK if ($file);
3563 &{$msg_level}($msg_type,
3564 "line length of $length exceeds $max_line_length columns\n" . $herecurr);
3568 # check for adding lines without a newline.
3569 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3570 if (WARN("MISSING_EOF_NEWLINE",
3571 "adding a line without newline at end of file\n" . $herecurr) &&
3573 fix_delete_line($fixlinenr+1, "No newline at end of file");
3577 # check we are in a valid source file C or perl if not then ignore this hunk
3578 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3580 # at the beginning of a line any tabs must come first and anything
3581 # more than $tabsize must use tabs.
3582 if ($rawline =~ /^\+\s* \t\s*\S/ ||
3583 $rawline =~ /^\+\s* \s*/) {
3584 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3586 if (ERROR("CODE_INDENT",
3587 "code indent should use tabs where possible\n" . $herevet) &&
3589 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3593 # check for space before tabs.
3594 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3595 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3596 if (WARN("SPACE_BEFORE_TAB",
3597 "please, no space before tabs\n" . $herevet) &&
3599 while ($fixed[$fixlinenr] =~
3600 s/(^\+.*) {$tabsize,$tabsize}\t/$1\t\t/) {}
3601 while ($fixed[$fixlinenr] =~
3602 s/(^\+.*) +\t/$1\t/) {}
3606 # check for assignments on the start of a line
3607 if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3609 if (CHK("ASSIGNMENT_CONTINUATIONS",
3610 "Assignment operator '$1' should be on the previous line\n" . $hereprev) &&
3611 $fix && $prevrawline =~ /^\+/) {
3612 # add assignment operator to the previous line, remove from current line
3613 $fixed[$fixlinenr - 1] .= " $operator";
3614 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3618 # check for && or || at the start of a line
3619 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3621 if (CHK("LOGICAL_CONTINUATIONS",
3622 "Logical continuations should be on the previous line\n" . $hereprev) &&
3623 $fix && $prevrawline =~ /^\+/) {
3624 # insert logical operator at last non-comment, non-whitepsace char on previous line
3625 $prevline =~ /[\s$;]*$/;
3626 my $line_end = substr($prevrawline, $-[0]);
3627 $fixed[$fixlinenr - 1] =~ s/\Q$line_end\E$/ $operator$line_end/;
3628 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3632 # check indentation starts on a tab stop
3633 if ($perl_version_ok &&
3634 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3635 my $indent = length($1);
3636 if ($indent % $tabsize) {
3638 "Statements should start on a tabstop\n" . $herecurr) &&
3640 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/$tabsize)@e;
3645 # check multi-line statement indentation matches previous line
3646 if ($perl_version_ok &&
3647 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3648 $prevline =~ /^\+(\t*)(.*)$/;
3652 my $pos = pos_last_openparen($rest);
3654 $line =~ /^(\+| )([ \t]*)/;
3657 my $goodtabindent = $oldindent .
3658 "\t" x ($pos / $tabsize) .
3659 " " x ($pos % $tabsize);
3660 my $goodspaceindent = $oldindent . " " x $pos;
3662 if ($newindent ne $goodtabindent &&
3663 $newindent ne $goodspaceindent) {
3665 if (CHK("PARENTHESIS_ALIGNMENT",
3666 "Alignment should match open parenthesis\n" . $hereprev) &&
3667 $fix && $line =~ /^\+/) {
3668 $fixed[$fixlinenr] =~
3669 s/^\+[ \t]*/\+$goodtabindent/;
3675 # check for space after cast like "(int) foo" or "(struct foo) bar"
3676 # avoid checking a few false positives:
3677 # "sizeof(<type>)" or "__alignof__(<type>)"
3678 # function pointer declarations like "(*foo)(int) = bar;"
3679 # structure definitions like "(struct foo) { 0 };"
3680 # multiline macros that define functions
3681 # known attributes or the __attribute__ keyword
3682 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3683 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3685 "No space is necessary after a cast\n" . $herecurr) &&
3687 $fixed[$fixlinenr] =~
3688 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3692 # Block comment styles
3693 # Networking with an initial /*
3694 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3695 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3696 $rawline =~ /^\+[ \t]*\*/ &&
3697 $realline > 3) { # Do not warn about the initial copyright comment block after SPDX-License-Identifier
3698 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3699 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3702 # Block comments use * on subsequent lines
3703 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3704 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
3705 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3706 $rawline =~ /^\+/ && #line is new
3707 $rawline !~ /^\+[ \t]*\*/) { #no leading *
3708 WARN("BLOCK_COMMENT_STYLE",
3709 "Block comments use * on subsequent lines\n" . $hereprev);
3712 # Block comments use */ on trailing lines
3713 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
3714 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3715 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3716 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
3717 WARN("BLOCK_COMMENT_STYLE",
3718 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3721 # Block comment * alignment
3722 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3723 $line =~ /^\+[ \t]*$;/ && #leading comment
3724 $rawline =~ /^\+[ \t]*\*/ && #leading *
3725 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
3726 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3727 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3729 $prevrawline =~ m@^\+([ \t]*/?)\*@;
3731 $oldindent = expand_tabs($1);
3733 $prevrawline =~ m@^\+(.*/?)\*@;
3734 $oldindent = expand_tabs($1);
3736 $rawline =~ m@^\+([ \t]*)\*@;
3738 $newindent = expand_tabs($newindent);
3739 if (length($oldindent) ne length($newindent)) {
3740 WARN("BLOCK_COMMENT_STYLE",
3741 "Block comments should align the * on each line\n" . $hereprev);
3745 # check for missing blank lines after struct/union declarations
3746 # with exceptions for various attributes and macros
3747 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3749 !($line =~ /^\+\s*$/ ||
3750 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3751 $line =~ /^\+\s*MODULE_/i ||
3752 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3753 $line =~ /^\+[a-z_]*init/ ||
3754 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3755 $line =~ /^\+\s*DECLARE/ ||
3756 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3757 $line =~ /^\+\s*__setup/)) {
3758 if (CHK("LINE_SPACING",
3759 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3761 fix_insert_line($fixlinenr, "\+");
3765 # check for multiple consecutive blank lines
3766 if ($prevline =~ /^[\+ ]\s*$/ &&
3767 $line =~ /^\+\s*$/ &&
3768 $last_blank_line != ($linenr - 1)) {
3769 if (CHK("LINE_SPACING",
3770 "Please don't use multiple blank lines\n" . $hereprev) &&
3772 fix_delete_line($fixlinenr, $rawline);
3775 $last_blank_line = $linenr;
3778 # check for missing blank lines after declarations
3779 if ($sline =~ /^\+\s+\S/ && #Not at char 1
3780 # actual declarations
3781 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3782 # function pointer declarations
3783 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3784 # foo bar; where foo is some local typedef or #define
3785 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3786 # known declaration macros
3787 $prevline =~ /^\+\s+$declaration_macros/) &&
3788 # for "else if" which can look like "$Ident $Ident"
3789 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3790 # other possible extensions of declaration lines
3791 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3792 # not starting a section or a macro "\" extended line
3793 $prevline =~ /(?:\{\s*|\\)$/) &&
3794 # looks like a declaration
3795 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3796 # function pointer declarations
3797 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3798 # foo bar; where foo is some local typedef or #define
3799 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3800 # known declaration macros
3801 $sline =~ /^\+\s+$declaration_macros/ ||
3802 # start of struct or union or enum
3803 $sline =~ /^\+\s+(?:static\s+)?(?:const\s+)?(?:union|struct|enum|typedef)\b/ ||
3804 # start or end of block or continuation of declaration
3805 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3806 # bitfield continuation
3807 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3808 # other possible extensions of declaration lines
3809 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3810 # indentation of previous and current line are the same
3811 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3812 if (WARN("LINE_SPACING",
3813 "Missing a blank line after declarations\n" . $hereprev) &&
3815 fix_insert_line($fixlinenr, "\+");
3819 # check for spaces at the beginning of a line.
3821 # 1) within comments
3822 # 2) indented preprocessor commands
3824 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3825 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3826 if (WARN("LEADING_SPACE",
3827 "please, no spaces at the start of a line\n" . $herevet) &&
3829 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3833 # check we are in a valid C source file if not then ignore this hunk
3834 next if ($realfile !~ /\.(h|c)$/);
3836 # check for unusual line ending [ or (
3837 if ($line =~ /^\+.*([\[\(])\s*$/) {
3838 CHK("OPEN_ENDED_LINE",
3839 "Lines should not end with a '$1'\n" . $herecurr);
3842 # check if this appears to be the start function declaration, save the name
3843 if ($sline =~ /^\+\{\s*$/ &&
3844 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3845 $context_function = $1;
3848 # check if this appears to be the end of function declaration
3849 if ($sline =~ /^\+\}\s*$/) {
3850 undef $context_function;
3853 # check indentation of any line with a bare else
3854 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3855 # if the previous line is a break or return and is indented 1 tab more...
3856 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3857 my $tabs = length($1) + 1;
3858 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3859 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3860 defined $lines[$linenr] &&
3861 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3862 WARN("UNNECESSARY_ELSE",
3863 "else is not generally useful after a break or return\n" . $hereprev);
3867 # check indentation of a line with a break;
3868 # if the previous line is a goto, return or break
3869 # and is indented the same # of tabs
3870 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3872 if ($prevline =~ /^\+$tabs(goto|return|break)\b/) {
3873 if (WARN("UNNECESSARY_BREAK",
3874 "break is not useful after a $1\n" . $hereprev) &&
3876 fix_delete_line($fixlinenr, $rawline);
3881 # check for RCS/CVS revision markers
3882 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3884 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3887 # check for old HOTPLUG __dev<foo> section markings
3888 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3889 WARN("HOTPLUG_SECTION",
3890 "Using $1 is unnecessary\n" . $herecurr);
3893 # Check for potential 'bare' types
3894 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3896 #print "LINE<$line>\n";
3897 if ($linenr > $suppress_statement &&
3898 $realcnt && $sline =~ /.\s*\S/) {
3899 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3900 ctx_statement_block($linenr, $realcnt, 0);
3901 $stat =~ s/\n./\n /g;
3902 $cond =~ s/\n./\n /g;
3904 #print "linenr<$linenr> <$stat>\n";
3905 # If this statement has no statement boundaries within
3906 # it there is no point in retrying a statement scan
3907 # until we hit end of it.
3908 my $frag = $stat; $frag =~ s/;+\s*$//;
3909 if ($frag !~ /(?:{|;)/) {
3910 #print "skip<$line_nr_next>\n";
3911 $suppress_statement = $line_nr_next;
3914 # Find the real next line.
3915 $realline_next = $line_nr_next;
3916 if (defined $realline_next &&
3917 (!defined $lines[$realline_next - 1] ||
3918 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3925 # Ignore goto labels.
3926 if ($s =~ /$Ident:\*$/s) {
3928 # Ignore functions being called
3929 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3931 } elsif ($s =~ /^.\s*else\b/s) {
3933 # declarations always start with types
3934 } 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) {
3937 possible($type, "A:" . $s);
3939 # definitions in global scope can only start with types
3940 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3941 possible($1, "B:" . $s);
3944 # any (foo ... *) is a pointer cast, and foo is a type
3945 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3946 possible($1, "C:" . $s);
3949 # Check for any sort of function declaration.
3950 # int foo(something bar, other baz);
3951 # void (*store_gdt)(x86_descr_ptr *);
3952 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3953 my ($name_len) = length($1);
3956 substr($ctx, 0, $name_len + 1, '');
3957 $ctx =~ s/\)[^\)]*$//;
3959 for my $arg (split(/\s*,\s*/, $ctx)) {
3960 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3962 possible($1, "D:" . $s);
3970 # Checks which may be anchored in the context.
3973 # Check for switch () and associated case and default
3974 # statements should be at the same indent.
3975 if ($line=~/\bswitch\s*\(.*\)/) {
3978 my @ctx = ctx_block_outer($linenr, $realcnt);
3980 for my $ctx (@ctx) {
3981 my ($clen, $cindent) = line_stats($ctx);
3982 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3983 $indent != $cindent) {
3984 $err .= "$sep$ctx\n";
3991 ERROR("SWITCH_CASE_INDENT_LEVEL",
3992 "switch and case should be at the same indent\n$hereline$err");
3996 # if/while/etc brace do not go on next line, unless defining a do while loop,
3997 # or if that brace on the next line is for something else
3998 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3999 my $pre_ctx = "$1$2";
4001 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
4003 if ($line =~ /^\+\t{6,}/) {
4004 WARN("DEEP_INDENTATION",
4005 "Too many leading tabs - consider code refactoring\n" . $herecurr);
4008 my $ctx_cnt = $realcnt - $#ctx - 1;
4009 my $ctx = join("\n", @ctx);
4011 my $ctx_ln = $linenr;
4012 my $ctx_skip = $realcnt;
4014 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
4015 defined $lines[$ctx_ln - 1] &&
4016 $lines[$ctx_ln - 1] =~ /^-/)) {
4017 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
4018 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
4022 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
4023 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
4025 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
4027 "that open brace { should be on the previous line\n" .
4028 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4030 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
4031 $ctx =~ /\)\s*\;\s*$/ &&
4032 defined $lines[$ctx_ln - 1])
4034 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
4035 if ($nindent > $indent) {
4036 WARN("TRAILING_SEMICOLON",
4037 "trailing semicolon indicates no statements, indent implies otherwise\n" .
4038 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4043 # Check relative indent for conditionals and blocks.
4044 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
4045 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4046 ctx_statement_block($linenr, $realcnt, 0)
4047 if (!defined $stat);
4048 my ($s, $c) = ($stat, $cond);
4050 substr($s, 0, length($c), '');
4052 # remove inline comments
4056 # Find out how long the conditional actually is.
4057 my @newlines = ($c =~ /\n/gs);
4058 my $cond_lines = 1 + $#newlines;
4060 # Make sure we remove the line prefixes as we have
4061 # none on the first line, and are going to readd them
4064 while ($s =~ /\n\s+\\\n/) {
4065 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
4068 # We want to check the first line inside the block
4069 # starting at the end of the conditional, so remove:
4070 # 1) any blank line termination
4071 # 2) any opening brace { on end of the line
4073 my $continuation = 0;
4075 $s =~ s/^.*\bdo\b//;
4077 if ($s =~ s/^\s*\\//) {
4080 if ($s =~ s/^\s*?\n//) {
4085 # Also ignore a loop construct at the end of a
4086 # preprocessor statement.
4087 if (($prevline =~ /^.\s*#\s*define\s/ ||
4088 $prevline =~ /\\\s*$/) && $continuation == 0) {
4094 while ($cond_ptr != $cond_lines) {
4095 $cond_ptr = $cond_lines;
4097 # If we see an #else/#elif then the code
4099 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
4104 # 1) blank lines, they should be at 0,
4105 # 2) preprocessor lines, and
4107 if ($continuation ||
4109 $s =~ /^\s*#\s*?/ ||
4110 $s =~ /^\s*$Ident\s*:/) {
4111 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
4112 if ($s =~ s/^.*?\n//) {
4118 my (undef, $sindent) = line_stats("+" . $s);
4119 my $stat_real = raw_line($linenr, $cond_lines);
4121 # Check if either of these lines are modified, else
4122 # this is not this patch's fault.
4123 if (!defined($stat_real) ||
4124 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
4127 if (defined($stat_real) && $cond_lines > 1) {
4128 $stat_real = "[...]\n$stat_real";
4131 #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";
4133 if ($check && $s ne '' &&
4134 (($sindent % $tabsize) != 0 ||
4135 ($sindent < $indent) ||
4136 ($sindent == $indent &&
4137 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
4138 ($sindent > $indent + $tabsize))) {
4139 WARN("SUSPECT_CODE_INDENT",
4140 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
4144 # Track the 'values' across context and added lines.
4145 my $opline = $line; $opline =~ s/^./ /;
4146 my ($curr_values, $curr_vars) =
4147 annotate_values($opline . "\n", $prev_values);
4148 $curr_values = $prev_values . $curr_values;
4150 my $outline = $opline; $outline =~ s/\t/ /g;
4151 print "$linenr > .$outline\n";
4152 print "$linenr > $curr_values\n";
4153 print "$linenr > $curr_vars\n";
4155 $prev_values = substr($curr_values, -1);
4157 #ignore lines not being added
4158 next if ($line =~ /^[^\+]/);
4160 # check for self assignments used to avoid compiler warnings
4161 # e.g.: int foo = foo, *bar = NULL;
4162 # struct foo bar = *(&(bar));
4163 if ($line =~ /^\+\s*(?:$Declare)?([A-Za-z_][A-Za-z\d_]*)\s*=/) {
4165 if ($line =~ /^\+\s*(?:$Declare)?$var\s*=\s*(?:$var|\*\s*\(?\s*&\s*\(?\s*$var\s*\)?\s*\)?)\s*[;,]/) {
4166 WARN("SELF_ASSIGNMENT",
4167 "Do not use self-assignments to avoid compiler warnings\n" . $herecurr);
4171 # check for dereferences that span multiple lines
4172 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
4173 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
4174 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
4176 $line =~ /^.\s*($Lval)/;
4179 WARN("MULTILINE_DEREFERENCE",
4180 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
4183 # check for declarations of signed or unsigned without int
4184 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
4187 $var = "" if (!defined $var);
4188 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
4192 $pointer = "" if (!defined $pointer);
4194 if (WARN("UNSPECIFIED_INT",
4195 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
4197 my $decl = trim($sign) . " int ";
4198 my $comp_pointer = $pointer;
4199 $comp_pointer =~ s/\s//g;
4200 $decl .= $comp_pointer;
4201 $decl = rtrim($decl) if ($var eq "");
4202 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
4207 # TEST: allow direct testing of the type matcher.
4209 if ($line =~ /^.\s*$Declare\s*$/) {
4211 "TEST: is type\n" . $herecurr);
4212 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
4213 ERROR("TEST_NOT_TYPE",
4214 "TEST: is not type ($1 is)\n". $herecurr);
4218 # TEST: allow direct testing of the attribute matcher.
4220 if ($line =~ /^.\s*$Modifier\s*$/) {
4222 "TEST: is attr\n" . $herecurr);
4223 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
4224 ERROR("TEST_NOT_ATTR",
4225 "TEST: is not attr ($1 is)\n". $herecurr);
4230 # check for initialisation to aggregates open brace on the next line
4231 if ($line =~ /^.\s*{/ &&
4232 $prevline =~ /(?:^|[^=])=\s*$/) {
4233 if (ERROR("OPEN_BRACE",
4234 "that open brace { should be on the previous line\n" . $hereprev) &&
4235 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4236 fix_delete_line($fixlinenr - 1, $prevrawline);
4237 fix_delete_line($fixlinenr, $rawline);
4238 my $fixedline = $prevrawline;
4239 $fixedline =~ s/\s*=\s*$/ = {/;
4240 fix_insert_line($fixlinenr, $fixedline);
4242 $fixedline =~ s/^(.\s*)\{\s*/$1/;
4243 fix_insert_line($fixlinenr, $fixedline);
4248 # Checks which are anchored on the added line.
4251 # check for malformed paths in #include statements (uses RAW line)
4252 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
4254 if ($path =~ m{//}) {
4255 ERROR("MALFORMED_INCLUDE",
4256 "malformed #include filename\n" . $herecurr);
4258 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
4259 ERROR("UAPI_INCLUDE",
4260 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
4264 # no C99 // comments
4265 if ($line =~ m{//}) {
4266 if (ERROR("C99_COMMENTS",
4267 "do not use C99 // comments\n" . $herecurr) &&
4269 my $line = $fixed[$fixlinenr];
4270 if ($line =~ /\/\/(.*)$/) {
4271 my $comment = trim($1);
4272 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
4276 # Remove C99 comments.
4278 $opline =~ s@//.*@@;
4280 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
4281 # the whole statement.
4282 #print "APW <$lines[$realline_next - 1]>\n";
4283 if (defined $realline_next &&
4284 exists $lines[$realline_next - 1] &&
4285 !defined $suppress_export{$realline_next} &&
4286 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
4287 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
4288 # Handle definitions which produce identifiers with
4291 # EXPORT_SYMBOL(something_foo);
4293 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
4294 $name =~ /^${Ident}_$2/) {
4295 #print "FOO C name<$name>\n";
4296 $suppress_export{$realline_next} = 1;
4298 } elsif ($stat !~ /(?:
4300 ^.DEFINE_$Ident\(\Q$name\E\)|
4301 ^.DECLARE_$Ident\(\Q$name\E\)|
4302 ^.LIST_HEAD\(\Q$name\E\)|
4303 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
4304 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
4306 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
4307 $suppress_export{$realline_next} = 2;
4309 $suppress_export{$realline_next} = 1;
4312 if (!defined $suppress_export{$linenr} &&
4313 $prevline =~ /^.\s*$/ &&
4314 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
4315 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
4316 #print "FOO B <$lines[$linenr - 1]>\n";
4317 $suppress_export{$linenr} = 2;
4319 if (defined $suppress_export{$linenr} &&
4320 $suppress_export{$linenr} == 2) {
4321 WARN("EXPORT_SYMBOL",
4322 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
4325 # check for global initialisers.
4326 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
4327 if (ERROR("GLOBAL_INITIALISERS",
4328 "do not initialise globals to $1\n" . $herecurr) &&
4330 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
4333 # check for static initialisers.
4334 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
4335 if (ERROR("INITIALISED_STATIC",
4336 "do not initialise statics to $1\n" .
4339 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
4343 # check for misordered declarations of char/short/int/long with signed/unsigned
4344 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
4346 WARN("MISORDERED_TYPE",
4347 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
4350 # check for unnecessary <signed> int declarations of short/long/long long
4351 while ($sline =~ m{\b($TypeMisordered(\s*\*)*|$C90_int_types)\b}g) {
4352 my $type = trim($1);
4353 next if ($type !~ /\bint\b/);
4354 next if ($type !~ /\b(?:short|long\s+long|long)\b/);
4355 my $new_type = $type;
4356 $new_type =~ s/\b\s*int\s*\b/ /;
4357 $new_type =~ s/\b\s*(?:un)?signed\b\s*/ /;
4358 $new_type =~ s/^const\s+//;
4359 $new_type = "unsigned $new_type" if ($type =~ /\bunsigned\b/);
4360 $new_type = "const $new_type" if ($type =~ /^const\b/);
4361 $new_type =~ s/\s+/ /g;
4362 $new_type = trim($new_type);
4363 if (WARN("UNNECESSARY_INT",
4364 "Prefer '$new_type' over '$type' as the int is unnecessary\n" . $herecurr) &&
4366 $fixed[$fixlinenr] =~ s/\b\Q$type\E\b/$new_type/;
4370 # check for static const char * arrays.
4371 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
4372 WARN("STATIC_CONST_CHAR_ARRAY",
4373 "static const char * array should probably be static const char * const\n" .
4377 # check for initialized const char arrays that should be static const
4378 if ($line =~ /^\+\s*const\s+(char|unsigned\s+char|_*u8|(?:[us]_)?int8_t)\s+\w+\s*\[\s*(?:\w+\s*)?\]\s*=\s*"/) {
4379 if (WARN("STATIC_CONST_CHAR_ARRAY",
4380 "const array should probably be static const\n" . $herecurr) &&
4382 $fixed[$fixlinenr] =~ s/(^.\s*)const\b/${1}static const/;
4386 # check for static char foo[] = "bar" declarations.
4387 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
4388 WARN("STATIC_CONST_CHAR_ARRAY",
4389 "static char array declaration should probably be static const char\n" .
4393 # check for const <foo> const where <foo> is not a pointer or array type
4394 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
4396 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
4398 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
4399 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
4401 "'const $found const' should probably be 'const $found'\n" . $herecurr);
4405 # check for const static or static <non ptr type> const declarations
4406 # prefer 'static const <foo>' over 'const static <foo>' and 'static <foo> const'
4407 if ($sline =~ /^\+\s*const\s+static\s+($Type)\b/ ||
4408 $sline =~ /^\+\s*static\s+($BasicType)\s+const\b/) {
4409 if (WARN("STATIC_CONST",
4410 "Move const after static - use 'static const $1'\n" . $herecurr) &&
4412 $fixed[$fixlinenr] =~ s/\bconst\s+static\b/static const/;
4413 $fixed[$fixlinenr] =~ s/\bstatic\s+($BasicType)\s+const\b/static const $1/;
4417 # check for non-global char *foo[] = {"bar", ...} declarations.
4418 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
4419 WARN("STATIC_CONST_CHAR_ARRAY",
4420 "char * array declaration might be better as static const\n" .
4424 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
4425 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
4427 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
4429 if (WARN("ARRAY_SIZE",
4430 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
4432 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
4437 # check for function declarations without arguments like "int foo()"
4438 if ($line =~ /(\b$Type\s*$Ident)\s*\(\s*\)/) {
4439 if (ERROR("FUNCTION_WITHOUT_ARGS",
4440 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
4442 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
4446 # check for new typedefs, only function parameters and sparse annotations
4448 if ($line =~ /\btypedef\s/ &&
4449 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
4450 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
4451 $line !~ /\b$typeTypedefs\b/ &&
4452 $line !~ /\b__bitwise\b/) {
4453 WARN("NEW_TYPEDEFS",
4454 "do not add new typedefs\n" . $herecurr);
4457 # * goes on variable not on type
4459 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
4461 my ($ident, $from, $to) = ($1, $2, $2);
4463 # Should start with a space.
4464 $to =~ s/^(\S)/ $1/;
4465 # Should not end with a space.
4467 # '*'s should not have spaces between.
4468 while ($to =~ s/\*\s+\*/\*\*/) {
4471 ## print "1: from<$from> to<$to> ident<$ident>\n";
4473 if (ERROR("POINTER_LOCATION",
4474 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
4476 my $sub_from = $ident;
4477 my $sub_to = $ident;
4478 $sub_to =~ s/\Q$from\E/$to/;
4479 $fixed[$fixlinenr] =~
4480 s@\Q$sub_from\E@$sub_to@;
4484 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
4486 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
4488 # Should start with a space.
4489 $to =~ s/^(\S)/ $1/;
4490 # Should not end with a space.
4492 # '*'s should not have spaces between.
4493 while ($to =~ s/\*\s+\*/\*\*/) {
4495 # Modifiers should have spaces.
4496 $to =~ s/(\b$Modifier$)/$1 /;
4498 ## print "2: from<$from> to<$to> ident<$ident>\n";
4499 if ($from ne $to && $ident !~ /^$Modifier$/) {
4500 if (ERROR("POINTER_LOCATION",
4501 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
4504 my $sub_from = $match;
4505 my $sub_to = $match;
4506 $sub_to =~ s/\Q$from\E/$to/;
4507 $fixed[$fixlinenr] =~
4508 s@\Q$sub_from\E@$sub_to@;
4513 # avoid BUG() or BUG_ON()
4514 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
4515 my $msg_level = \&WARN;
4516 $msg_level = \&CHK if ($file);
4517 &{$msg_level}("AVOID_BUG",
4518 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
4521 # avoid LINUX_VERSION_CODE
4522 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
4523 WARN("LINUX_VERSION_CODE",
4524 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
4527 # check for uses of printk_ratelimit
4528 if ($line =~ /\bprintk_ratelimit\s*\(/) {
4529 WARN("PRINTK_RATELIMITED",
4530 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
4533 # printk should use KERN_* levels
4534 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
4535 WARN("PRINTK_WITHOUT_KERN_LEVEL",
4536 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
4539 # prefer variants of (subsystem|netdev|dev|pr)_<level> to printk(KERN_<LEVEL>
4540 if ($line =~ /\b(printk(_once|_ratelimited)?)\s*\(\s*KERN_([A-Z]+)/) {
4544 $modifier = "" if (!defined($modifier));
4545 my $level = lc($orig);
4546 $level = "warn" if ($level eq "warning");
4547 my $level2 = $level;
4548 $level2 = "dbg" if ($level eq "debug");
4549 $level .= $modifier;
4550 $level2 .= $modifier;
4551 WARN("PREFER_PR_LEVEL",
4552 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to $printk(KERN_$orig ...\n" . $herecurr);
4555 # prefer dev_<level> to dev_printk(KERN_<LEVEL>
4556 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
4558 my $level = lc($orig);
4559 $level = "warn" if ($level eq "warning");
4560 $level = "dbg" if ($level eq "debug");
4561 WARN("PREFER_DEV_LEVEL",
4562 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
4565 # trace_printk should not be used in production code.
4566 if ($line =~ /\b(trace_printk|trace_puts|ftrace_vprintk)\s*\(/) {
4567 WARN("TRACE_PRINTK",
4568 "Do not use $1() in production code (this can be ignored if built only with a debug config option)\n" . $herecurr);
4571 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
4572 # number of false positives, but assembly files are not checked, so at
4573 # least the arch entry code will not trigger this warning.
4574 if ($line =~ /\bENOSYS\b/) {
4576 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
4579 # ENOTSUPP is not a standard error code and should be avoided in new patches.
4580 # Folks usually mean EOPNOTSUPP (also called ENOTSUP), when they type ENOTSUPP.
4581 # Similarly to ENOSYS warning a small number of false positives is expected.
4582 if (!$file && $line =~ /\bENOTSUPP\b/) {
4583 if (WARN("ENOTSUPP",
4584 "ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP\n" . $herecurr) &&
4586 $fixed[$fixlinenr] =~ s/\bENOTSUPP\b/EOPNOTSUPP/;
4590 # function brace can't be on same line, except for #defines of do while,
4591 # or if closed on same line
4592 if ($perl_version_ok &&
4593 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
4594 $sline !~ /\#\s*define\b.*do\s*\{/ &&
4596 if (ERROR("OPEN_BRACE",
4597 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
4599 fix_delete_line($fixlinenr, $rawline);
4600 my $fixed_line = $rawline;
4601 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*)\{(.*)$/;
4604 fix_insert_line($fixlinenr, ltrim($line1));
4605 fix_insert_line($fixlinenr, "\+{");
4606 if ($line2 !~ /^\s*$/) {
4607 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
4612 # open braces for enum, union and struct go on the same line.
4613 if ($line =~ /^.\s*{/ &&
4614 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
4615 if (ERROR("OPEN_BRACE",
4616 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
4617 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4618 fix_delete_line($fixlinenr - 1, $prevrawline);
4619 fix_delete_line($fixlinenr, $rawline);
4620 my $fixedline = rtrim($prevrawline) . " {";
4621 fix_insert_line($fixlinenr, $fixedline);
4622 $fixedline = $rawline;
4623 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
4624 if ($fixedline !~ /^\+\s*$/) {
4625 fix_insert_line($fixlinenr, $fixedline);
4630 # missing space after union, struct or enum definition
4631 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4633 "missing space after $1 definition\n" . $herecurr) &&
4635 $fixed[$fixlinenr] =~
4636 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4640 # Function pointer declarations
4641 # check spacing between type, funcptr, and args
4642 # canonical declaration is "type (*funcptr)(args...)"
4643 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4645 my $pre_pointer_space = $2;
4646 my $post_pointer_space = $3;
4648 my $post_funcname_space = $5;
4649 my $pre_args_space = $6;
4651 # the $Declare variable will capture all spaces after the type
4652 # so check it for a missing trailing missing space but pointer return types
4653 # don't need a space so don't warn for those.
4654 my $post_declare_space = "";
4655 if ($declare =~ /(\s+)$/) {
4656 $post_declare_space = $1;
4657 $declare = rtrim($declare);
4659 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4661 "missing space after return type\n" . $herecurr);
4662 $post_declare_space = " ";
4665 # unnecessary space "type (*funcptr)(args...)"
4666 # This test is not currently implemented because these declarations are
4668 # int foo(int bar, ...)
4669 # and this is form shouldn't/doesn't generate a checkpatch warning.
4671 # elsif ($declare =~ /\s{2,}$/) {
4673 # "Multiple spaces after return type\n" . $herecurr);
4676 # unnecessary space "type ( *funcptr)(args...)"
4677 if (defined $pre_pointer_space &&
4678 $pre_pointer_space =~ /^\s/) {
4680 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4683 # unnecessary space "type (* funcptr)(args...)"
4684 if (defined $post_pointer_space &&
4685 $post_pointer_space =~ /^\s/) {
4687 "Unnecessary space before function pointer name\n" . $herecurr);
4690 # unnecessary space "type (*funcptr )(args...)"
4691 if (defined $post_funcname_space &&
4692 $post_funcname_space =~ /^\s/) {
4694 "Unnecessary space after function pointer name\n" . $herecurr);
4697 # unnecessary space "type (*funcptr) (args...)"
4698 if (defined $pre_args_space &&
4699 $pre_args_space =~ /^\s/) {
4701 "Unnecessary space before function pointer arguments\n" . $herecurr);
4704 if (show_type("SPACING") && $fix) {
4705 $fixed[$fixlinenr] =~
4706 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4710 # check for spacing round square brackets; allowed:
4711 # 1. with a type on the left -- int [] a;
4712 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4713 # 3. inside a curly brace -- = { [0...10] = 5 }
4714 while ($line =~ /(.*?\s)\[/g) {
4715 my ($where, $prefix) = ($-[1], $1);
4716 if ($prefix !~ /$Type\s+$/ &&
4717 ($where != 0 || $prefix !~ /^.\s+$/) &&
4718 $prefix !~ /[{,:]\s+$/) {
4719 if (ERROR("BRACKET_SPACE",
4720 "space prohibited before open square bracket '['\n" . $herecurr) &&
4722 $fixed[$fixlinenr] =~
4723 s/^(\+.*?)\s+\[/$1\[/;
4728 # check for spaces between functions and their parentheses.
4729 while ($line =~ /($Ident)\s+\(/g) {
4731 my $ctx_before = substr($line, 0, $-[1]);
4732 my $ctx = "$ctx_before$name";
4734 # Ignore those directives where spaces _are_ permitted.
4736 if|for|while|switch|return|case|
4737 volatile|__volatile__|
4738 __attribute__|format|__extension__|
4741 # cpp #define statements have non-optional spaces, ie
4742 # if there is a space between the name and the open
4743 # parenthesis it is simply not a parameter group.
4744 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4746 # cpp #elif statement condition may start with a (
4747 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4749 # If this whole things ends with a type its most
4750 # likely a typedef for a function.
4751 } elsif ($ctx =~ /$Type$/) {
4755 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4757 $fixed[$fixlinenr] =~
4758 s/\b$name\s+\(/$name\(/;
4763 # Check operator spacing.
4764 if (!($line=~/\#\s*include/)) {
4765 my $fixed_line = "";
4769 <<=|>>=|<=|>=|==|!=|
4770 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4771 =>|->|<<|>>|<|>|=|!|~|
4772 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4775 my @elements = split(/($ops|;)/, $opline);
4777 ## print("element count: <" . $#elements . ">\n");
4778 ## foreach my $el (@elements) {
4779 ## print("el: <$el>\n");
4782 my @fix_elements = ();
4785 foreach my $el (@elements) {
4786 push(@fix_elements, substr($rawline, $off, length($el)));
4787 $off += length($el);
4792 my $blank = copy_spacing($opline);
4793 my $last_after = -1;
4795 for (my $n = 0; $n < $#elements; $n += 2) {
4797 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4799 ## print("n: <$n> good: <$good>\n");
4801 $off += length($elements[$n]);
4803 # Pick up the preceding and succeeding characters.
4804 my $ca = substr($opline, 0, $off);
4806 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4807 $cc = substr($opline, $off + length($elements[$n + 1]));
4809 my $cb = "$ca$;$cc";
4812 $a = 'V' if ($elements[$n] ne '');
4813 $a = 'W' if ($elements[$n] =~ /\s$/);
4814 $a = 'C' if ($elements[$n] =~ /$;$/);
4815 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4816 $a = 'O' if ($elements[$n] eq '');
4817 $a = 'E' if ($ca =~ /^\s*$/);
4819 my $op = $elements[$n + 1];
4822 if (defined $elements[$n + 2]) {
4823 $c = 'V' if ($elements[$n + 2] ne '');
4824 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4825 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4826 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4827 $c = 'O' if ($elements[$n + 2] eq '');
4828 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4833 my $ctx = "${a}x${c}";
4835 my $at = "(ctx:$ctx)";
4837 my $ptr = substr($blank, 0, $off) . "^";
4838 my $hereptr = "$hereline$ptr\n";
4840 # Pull out the value of this operator.
4841 my $op_type = substr($curr_values, $off + 1, 1);
4843 # Get the full operator variant.
4844 my $opv = $op . substr($curr_vars, $off, 1);
4846 # Ignore operators passed as parameters.
4847 if ($op_type ne 'V' &&
4848 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4851 # } elsif ($op =~ /^$;+$/) {
4853 # ; should have either the end of line or a space or \ after it
4854 } elsif ($op eq ';') {
4855 if ($ctx !~ /.x[WEBC]/ &&
4856 $cc !~ /^\\/ && $cc !~ /^;/) {
4857 if (ERROR("SPACING",
4858 "space required after that '$op' $at\n" . $hereptr)) {
4859 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4865 } elsif ($op eq '//') {
4867 # : when part of a bitfield
4868 } elsif ($opv eq ':B') {
4869 # skip the bitfield test for now
4873 } elsif ($op eq '->') {
4874 if ($ctx =~ /Wx.|.xW/) {
4875 if (ERROR("SPACING",
4876 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4877 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4878 if (defined $fix_elements[$n + 2]) {
4879 $fix_elements[$n + 2] =~ s/^\s+//;
4885 # , must not have a space before and must have a space on the right.
4886 } elsif ($op eq ',') {
4887 my $rtrim_before = 0;
4888 my $space_after = 0;
4889 if ($ctx =~ /Wx./) {
4890 if (ERROR("SPACING",
4891 "space prohibited before that '$op' $at\n" . $hereptr)) {
4896 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4897 if (ERROR("SPACING",
4898 "space required after that '$op' $at\n" . $hereptr)) {
4904 if ($rtrim_before || $space_after) {
4905 if ($rtrim_before) {
4906 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4908 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4915 # '*' as part of a type definition -- reported already.
4916 } elsif ($opv eq '*_') {
4917 #warn "'*' is part of type\n";
4919 # unary operators should have a space before and
4920 # none after. May be left adjacent to another
4921 # unary operator, or a cast
4922 } elsif ($op eq '!' || $op eq '~' ||
4923 $opv eq '*U' || $opv eq '-U' ||
4924 $opv eq '&U' || $opv eq '&&U') {
4925 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4926 if (ERROR("SPACING",
4927 "space required before that '$op' $at\n" . $hereptr)) {
4928 if ($n != $last_after + 2) {
4929 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4934 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4935 # A unary '*' may be const
4937 } elsif ($ctx =~ /.xW/) {
4938 if (ERROR("SPACING",
4939 "space prohibited after that '$op' $at\n" . $hereptr)) {
4940 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4941 if (defined $fix_elements[$n + 2]) {
4942 $fix_elements[$n + 2] =~ s/^\s+//;
4948 # unary ++ and unary -- are allowed no space on one side.
4949 } elsif ($op eq '++' or $op eq '--') {
4950 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4951 if (ERROR("SPACING",
4952 "space required one side of that '$op' $at\n" . $hereptr)) {
4953 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4957 if ($ctx =~ /Wx[BE]/ ||
4958 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4959 if (ERROR("SPACING",
4960 "space prohibited before that '$op' $at\n" . $hereptr)) {
4961 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4965 if ($ctx =~ /ExW/) {
4966 if (ERROR("SPACING",
4967 "space prohibited after that '$op' $at\n" . $hereptr)) {
4968 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4969 if (defined $fix_elements[$n + 2]) {
4970 $fix_elements[$n + 2] =~ s/^\s+//;
4976 # << and >> may either have or not have spaces both sides
4977 } elsif ($op eq '<<' or $op eq '>>' or
4978 $op eq '&' or $op eq '^' or $op eq '|' or
4979 $op eq '+' or $op eq '-' or
4980 $op eq '*' or $op eq '/' or
4984 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4986 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4987 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4988 $fix_elements[$n + 2] =~ s/^\s+//;
4991 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4993 "space preferred before that '$op' $at\n" . $hereptr)) {
4994 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4998 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4999 if (ERROR("SPACING",
5000 "need consistent spacing around '$op' $at\n" . $hereptr)) {
5001 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5002 if (defined $fix_elements[$n + 2]) {
5003 $fix_elements[$n + 2] =~ s/^\s+//;
5009 # A colon needs no spaces before when it is
5010 # terminating a case value or a label.
5011 } elsif ($opv eq ':C' || $opv eq ':L') {
5012 if ($ctx =~ /Wx./) {
5013 if (ERROR("SPACING",
5014 "space prohibited before that '$op' $at\n" . $hereptr)) {
5015 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5020 # All the others need spaces both sides.
5021 } elsif ($ctx !~ /[EWC]x[CWE]/) {
5024 # Ignore email addresses <foo@bar>
5026 $cc =~ /^\S+\@\S+>/) ||
5028 $ca =~ /<\S+\@\S+$/))
5033 # for asm volatile statements
5034 # ignore a colon with another
5035 # colon immediately before or after
5037 ($ca =~ /:$/ || $cc =~ /^:/)) {
5041 # messages are ERROR, but ?: are CHK
5043 my $msg_level = \&ERROR;
5044 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
5046 if (&{$msg_level}("SPACING",
5047 "spaces required around that '$op' $at\n" . $hereptr)) {
5048 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5049 if (defined $fix_elements[$n + 2]) {
5050 $fix_elements[$n + 2] =~ s/^\s+//;
5056 $off += length($elements[$n + 1]);
5058 ## print("n: <$n> GOOD: <$good>\n");
5060 $fixed_line = $fixed_line . $good;
5063 if (($#elements % 2) == 0) {
5064 $fixed_line = $fixed_line . $fix_elements[$#elements];
5067 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
5068 $fixed[$fixlinenr] = $fixed_line;
5074 # check for whitespace before a non-naked semicolon
5075 if ($line =~ /^\+.*\S\s+;\s*$/) {
5077 "space prohibited before semicolon\n" . $herecurr) &&
5079 1 while $fixed[$fixlinenr] =~
5080 s/^(\+.*\S)\s+;/$1;/;
5084 # check for multiple assignments
5085 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
5086 CHK("MULTIPLE_ASSIGNMENTS",
5087 "multiple assignments should be avoided\n" . $herecurr);
5090 ## # check for multiple declarations, allowing for a function declaration
5092 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
5093 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
5095 ## # Remove any bracketed sections to ensure we do not
5096 ## # falsely report the parameters of functions.
5098 ## while ($ln =~ s/\([^\(\)]*\)//g) {
5100 ## if ($ln =~ /,/) {
5101 ## WARN("MULTIPLE_DECLARATION",
5102 ## "declaring multiple variables together should be avoided\n" . $herecurr);
5106 #need space before brace following if, while, etc
5107 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
5108 $line =~ /\b(?:else|do)\{/) {
5109 if (ERROR("SPACING",
5110 "space required before the open brace '{'\n" . $herecurr) &&
5112 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|else|\)))\{/$1 {/;
5116 ## # check for blank lines before declarations
5117 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
5118 ## $prevrawline =~ /^.\s*$/) {
5120 ## "No blank lines before declarations\n" . $hereprev);
5124 # closing brace should have a space following it when it has anything
5126 if ($line =~ /}(?!(?:,|;|\)|\}))\S/) {
5127 if (ERROR("SPACING",
5128 "space required after that close brace '}'\n" . $herecurr) &&
5130 $fixed[$fixlinenr] =~
5131 s/}((?!(?:,|;|\)))\S)/} $1/;
5135 # check spacing on square brackets
5136 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
5137 if (ERROR("SPACING",
5138 "space prohibited after that open square bracket '['\n" . $herecurr) &&
5140 $fixed[$fixlinenr] =~
5144 if ($line =~ /\s\]/) {
5145 if (ERROR("SPACING",
5146 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
5148 $fixed[$fixlinenr] =~
5153 # check spacing on parentheses
5154 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
5155 $line !~ /for\s*\(\s+;/) {
5156 if (ERROR("SPACING",
5157 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
5159 $fixed[$fixlinenr] =~
5163 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
5164 $line !~ /for\s*\(.*;\s+\)/ &&
5165 $line !~ /:\s+\)/) {
5166 if (ERROR("SPACING",
5167 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
5169 $fixed[$fixlinenr] =~
5174 # check unnecessary parentheses around addressof/dereference single $Lvals
5175 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
5177 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
5179 if (CHK("UNNECESSARY_PARENTHESES",
5180 "Unnecessary parentheses around $var\n" . $herecurr) &&
5182 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
5186 # check for unnecessary parentheses around function pointer uses
5187 # ie: (foo->bar)(); should be foo->bar();
5188 # but not "if (foo->bar) (" to avoid some false positives
5189 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
5191 if (CHK("UNNECESSARY_PARENTHESES",
5192 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
5194 my $var2 = deparenthesize($var);
5196 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
5200 # check for unnecessary parentheses around comparisons in if uses
5201 # when !drivers/staging or command-line uses --strict
5202 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
5203 $perl_version_ok && defined($stat) &&
5204 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
5206 my $test = substr($2, 1, -1);
5208 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
5210 # avoid parentheses around potential macro args
5211 next if ($match =~ /^\s*\w+\s*$/);
5212 if (!defined($herectx)) {
5213 $herectx = $here . "\n";
5214 my $cnt = statement_rawlines($if_stat);
5215 for (my $n = 0; $n < $cnt; $n++) {
5216 my $rl = raw_line($linenr, $n);
5217 $herectx .= $rl . "\n";
5218 last if $rl =~ /^[ \+].*\{/;
5221 CHK("UNNECESSARY_PARENTHESES",
5222 "Unnecessary parentheses around '$match'\n" . $herectx);
5226 #goto labels aren't indented, allow a single space however
5227 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
5228 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
5229 if (WARN("INDENTED_LABEL",
5230 "labels should not be indented\n" . $herecurr) &&
5232 $fixed[$fixlinenr] =~
5237 # check if a statement with a comma should be two statements like:
5238 # foo = bar(), /* comma should be semicolon */
5240 if (defined($stat) &&
5241 $stat =~ /^\+\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*,\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*;\s*$/) {
5242 my $cnt = statement_rawlines($stat);
5243 my $herectx = get_stat_here($linenr, $cnt, $here);
5244 WARN("SUSPECT_COMMA_SEMICOLON",
5245 "Possible comma where semicolon could be used\n" . $herectx);
5248 # return is not a function
5249 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
5251 if ($perl_version_ok &&
5252 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
5254 $value = deparenthesize($value);
5255 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
5256 ERROR("RETURN_PARENTHESES",
5257 "return is not a function, parentheses are not required\n" . $herecurr);
5259 } elsif ($spacing !~ /\s+/) {
5261 "space required before the open parenthesis '('\n" . $herecurr);
5265 # unnecessary return in a void function
5266 # at end-of-function, with the previous line a single leading tab, then return;
5267 # and the line before that not a goto label target like "out:"
5268 if ($sline =~ /^[ \+]}\s*$/ &&
5269 $prevline =~ /^\+\treturn\s*;\s*$/ &&
5271 $lines[$linenr - 3] =~ /^[ +]/ &&
5272 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
5274 "void function return statements are not generally useful\n" . $hereprev);
5277 # if statements using unnecessary parentheses - ie: if ((foo == bar))
5278 if ($perl_version_ok &&
5279 $line =~ /\bif\s*((?:\(\s*){2,})/) {
5280 my $openparens = $1;
5281 my $count = $openparens =~ tr@\(@\(@;
5283 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
5284 my $comp = $4; #Not $1 because of $LvalOrFunc
5285 $msg = " - maybe == should be = ?" if ($comp eq "==");
5286 WARN("UNNECESSARY_PARENTHESES",
5287 "Unnecessary parentheses$msg\n" . $herecurr);
5291 # comparisons with a constant or upper case identifier on the left
5292 # avoid cases like "foo + BAR < baz"
5293 # only fix matches surrounded by parentheses to avoid incorrect
5294 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
5295 if ($perl_version_ok &&
5296 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
5301 my $newcomp = $comp;
5302 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
5303 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
5304 WARN("CONSTANT_COMPARISON",
5305 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
5309 } elsif ($comp eq "<=") {
5311 } elsif ($comp eq ">") {
5313 } elsif ($comp eq ">=") {
5316 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
5320 # Return of what appears to be an errno should normally be negative
5321 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
5323 if ($name ne 'EOF' && $name ne 'ERROR') {
5324 WARN("USE_NEGATIVE_ERRNO",
5325 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
5329 # Need a space before open parenthesis after if, while etc
5330 if ($line =~ /\b(if|while|for|switch)\(/) {
5331 if (ERROR("SPACING",
5332 "space required before the open parenthesis '('\n" . $herecurr) &&
5334 $fixed[$fixlinenr] =~
5335 s/\b(if|while|for|switch)\(/$1 \(/;
5339 # Check for illegal assignment in if conditional -- and check for trailing
5340 # statements after the conditional.
5341 if ($line =~ /do\s*(?!{)/) {
5342 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
5343 ctx_statement_block($linenr, $realcnt, 0)
5344 if (!defined $stat);
5345 my ($stat_next) = ctx_statement_block($line_nr_next,
5346 $remain_next, $off_next);
5347 $stat_next =~ s/\n./\n /g;
5348 ##print "stat<$stat> stat_next<$stat_next>\n";
5350 if ($stat_next =~ /^\s*while\b/) {
5351 # If the statement carries leading newlines,
5352 # then count those as offsets.
5354 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
5356 statement_rawlines($whitespace) - 1;
5358 $suppress_whiletrailers{$line_nr_next +
5362 if (!defined $suppress_whiletrailers{$linenr} &&
5363 defined($stat) && defined($cond) &&
5364 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
5365 my ($s, $c) = ($stat, $cond);
5367 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
5368 if (ERROR("ASSIGN_IN_IF",
5369 "do not use assignment in if condition\n" . $herecurr) &&
5370 $fix && $perl_version_ok) {
5371 if ($rawline =~ /^\+(\s+)if\s*\(\s*(\!)?\s*\(\s*(($Lval)\s*=\s*$LvalOrFunc)\s*\)\s*(?:($Compare)\s*($FuncArg))?\s*\)\s*(\{)?\s*$/) {
5379 fix_delete_line($fixlinenr, $rawline);
5380 fix_insert_line($fixlinenr, "$space$statement;");
5381 my $newline = "${space}if (";
5382 $newline .= '!' if defined($not);
5383 $newline .= '(' if (defined $not && defined($test) && defined($against));
5384 $newline .= "$assigned";
5385 $newline .= " $test $against" if (defined($test) && defined($against));
5386 $newline .= ')' if (defined $not && defined($test) && defined($against));
5388 $newline .= " {" if (defined($brace));
5389 fix_insert_line($fixlinenr + 1, $newline);
5394 # Find out what is on the end of the line after the
5396 substr($s, 0, length($c), '');
5398 $s =~ s/$;//g; # Remove any comments
5399 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
5400 $c !~ /}\s*while\s*/)
5402 # Find out how long the conditional actually is.
5403 my @newlines = ($c =~ /\n/gs);
5404 my $cond_lines = 1 + $#newlines;
5407 $stat_real = raw_line($linenr, $cond_lines)
5408 . "\n" if ($cond_lines);
5409 if (defined($stat_real) && $cond_lines > 1) {
5410 $stat_real = "[...]\n$stat_real";
5413 ERROR("TRAILING_STATEMENTS",
5414 "trailing statements should be on next line\n" . $herecurr . $stat_real);
5418 # Check for bitwise tests written as boolean
5430 WARN("HEXADECIMAL_BOOLEAN_TEST",
5431 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
5434 # if and else should not have general statements after it
5435 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
5437 $s =~ s/$;//g; # Remove any comments
5438 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
5439 ERROR("TRAILING_STATEMENTS",
5440 "trailing statements should be on next line\n" . $herecurr);
5443 # if should not continue a brace
5444 if ($line =~ /}\s*if\b/) {
5445 ERROR("TRAILING_STATEMENTS",
5446 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
5449 # case and default should not have general statements after them
5450 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
5452 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
5456 ERROR("TRAILING_STATEMENTS",
5457 "trailing statements should be on next line\n" . $herecurr);
5460 # Check for }<nl>else {, these must be at the same
5461 # indent level to be relevant to each other.
5462 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
5463 $previndent == $indent) {
5464 if (ERROR("ELSE_AFTER_BRACE",
5465 "else should follow close brace '}'\n" . $hereprev) &&
5466 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5467 fix_delete_line($fixlinenr - 1, $prevrawline);
5468 fix_delete_line($fixlinenr, $rawline);
5469 my $fixedline = $prevrawline;
5470 $fixedline =~ s/}\s*$//;
5471 if ($fixedline !~ /^\+\s*$/) {
5472 fix_insert_line($fixlinenr, $fixedline);
5474 $fixedline = $rawline;
5475 $fixedline =~ s/^(.\s*)else/$1} else/;
5476 fix_insert_line($fixlinenr, $fixedline);
5480 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
5481 $previndent == $indent) {
5482 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
5484 # Find out what is on the end of the line after the
5486 substr($s, 0, length($c), '');
5489 if ($s =~ /^\s*;/) {
5490 if (ERROR("WHILE_AFTER_BRACE",
5491 "while should follow close brace '}'\n" . $hereprev) &&
5492 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5493 fix_delete_line($fixlinenr - 1, $prevrawline);
5494 fix_delete_line($fixlinenr, $rawline);
5495 my $fixedline = $prevrawline;
5496 my $trailing = $rawline;
5497 $trailing =~ s/^\+//;
5498 $trailing = trim($trailing);
5499 $fixedline =~ s/}\s*$/} $trailing/;
5500 fix_insert_line($fixlinenr, $fixedline);
5505 #Specific variable tests
5506 while ($line =~ m{($Constant|$Lval)}g) {
5510 if ($var !~ /^$Constant$/ &&
5511 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
5512 #Ignore some autogenerated defines and enum values
5513 $var !~ /^(?:[A-Z]+_){1,5}[A-Z]{1,3}[a-z]/ &&
5514 #Ignore Page<foo> variants
5515 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
5516 #Ignore SI style variants like nS, mV and dB
5517 #(ie: max_uV, regulator_min_uA_show, RANGE_mA_VALUE)
5518 $var !~ /^(?:[a-z0-9_]*|[A-Z0-9_]*)?_?[a-z][A-Z](?:_[a-z0-9_]+|_[A-Z0-9_]+)?$/ &&
5519 #Ignore some three character SI units explicitly, like MiB and KHz
5520 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
5521 while ($var =~ m{($Ident)}g) {
5523 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
5525 seed_camelcase_includes();
5526 if (!$file && !$camelcase_file_seeded) {
5527 seed_camelcase_file($realfile);
5528 $camelcase_file_seeded = 1;
5531 if (!defined $camelcase{$word}) {
5532 $camelcase{$word} = 1;
5534 "Avoid CamelCase: <$word>\n" . $herecurr);
5540 #no spaces allowed after \ in define
5541 if ($line =~ /\#\s*define.*\\\s+$/) {
5542 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
5543 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
5545 $fixed[$fixlinenr] =~ s/\s+$//;
5549 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
5550 # itself <asm/foo.h> (uses RAW line)
5551 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
5553 my $checkfile = "include/linux/$file";
5554 if (-f "$root/$checkfile" &&
5555 $realfile ne $checkfile &&
5556 $1 !~ /$allowed_asm_includes/)
5558 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
5559 if ($asminclude > 0) {
5560 if ($realfile =~ m{^arch/}) {
5561 CHK("ARCH_INCLUDE_LINUX",
5562 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5564 WARN("INCLUDE_LINUX",
5565 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5571 # multi-statement macros should be enclosed in a do while loop, grab the
5572 # first statement and ensure its the whole macro if its not enclosed
5573 # in a known good container
5574 if ($realfile !~ m@/vmlinux.lds.h$@ &&
5575 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
5578 my ($off, $dstat, $dcond, $rest);
5580 my $has_flow_statement = 0;
5581 my $has_arg_concat = 0;
5582 ($dstat, $dcond, $ln, $cnt, $off) =
5583 ctx_statement_block($linenr, $realcnt, 0);
5585 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
5586 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
5588 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
5589 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
5591 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
5592 my $define_args = $1;
5593 my $define_stmt = $dstat;
5596 if (defined $define_args && $define_args ne "") {
5597 $define_args = substr($define_args, 1, length($define_args) - 2);
5598 $define_args =~ s/\s*//g;
5599 $define_args =~ s/\\\+?//g;
5600 @def_args = split(",", $define_args);
5604 $dstat =~ s/\\\n.//g;
5605 $dstat =~ s/^\s*//s;
5606 $dstat =~ s/\s*$//s;
5608 # Flatten any parentheses and braces
5609 while ($dstat =~ s/\([^\(\)]*\)/1u/ ||
5610 $dstat =~ s/\{[^\{\}]*\}/1u/ ||
5611 $dstat =~ s/.\[[^\[\]]*\]/1u/)
5615 # Flatten any obvious string concatenation.
5616 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
5617 $dstat =~ s/$Ident\s*($String)/$1/)
5621 # Make asm volatile uses seem like a generic function
5622 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
5624 my $exceptions = qr{
5637 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
5640 my $stmt_cnt = statement_rawlines($ctx);
5641 my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
5644 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
5645 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
5646 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
5647 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
5648 $dstat !~ /$exceptions/ &&
5649 $dstat !~ /^\.$Ident\s*=/ && # .foo =
5650 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
5651 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
5652 $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ && # while (...) {...}
5653 $dstat !~ /^for\s*$Constant$/ && # for (...)
5654 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
5655 $dstat !~ /^do\s*{/ && # do {...
5656 $dstat !~ /^\(\{/ && # ({...
5657 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
5659 if ($dstat =~ /^\s*if\b/) {
5660 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5661 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5662 } elsif ($dstat =~ /;/) {
5663 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5664 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5666 ERROR("COMPLEX_MACRO",
5667 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5672 # Make $define_stmt single line, comment-free, etc
5673 my @stmt_array = split('\n', $define_stmt);
5676 foreach my $l (@stmt_array) {
5681 } elsif ($l =~ /^[\+ ]/) {
5682 $define_stmt .= substr($l, 1);
5685 $define_stmt =~ s/$;//g;
5686 $define_stmt =~ s/\s+/ /g;
5687 $define_stmt = trim($define_stmt);
5689 # check if any macro arguments are reused (ignore '...' and 'type')
5690 foreach my $arg (@def_args) {
5691 next if ($arg =~ /\.\.\./);
5692 next if ($arg =~ /^type$/i);
5693 my $tmp_stmt = $define_stmt;
5694 $tmp_stmt =~ s/\b(sizeof|typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
5695 $tmp_stmt =~ s/\#+\s*$arg\b//g;
5696 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
5697 my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
5699 CHK("MACRO_ARG_REUSE",
5700 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
5702 # check if any macro arguments may have other precedence issues
5703 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
5704 ((defined($1) && $1 ne ',') ||
5705 (defined($2) && $2 ne ','))) {
5706 CHK("MACRO_ARG_PRECEDENCE",
5707 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
5711 # check for macros with flow control, but without ## concatenation
5712 # ## concatenation is commonly a macro that defines a function so ignore those
5713 if ($has_flow_statement && !$has_arg_concat) {
5714 my $cnt = statement_rawlines($ctx);
5715 my $herectx = get_stat_here($linenr, $cnt, $here);
5717 WARN("MACRO_WITH_FLOW_CONTROL",
5718 "Macros with flow control statements should be avoided\n" . "$herectx");
5721 # check for line continuations outside of #defines, preprocessor #, and asm
5724 if ($prevline !~ /^..*\\$/ &&
5725 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
5726 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
5727 $line =~ /^\+.*\\$/) {
5728 WARN("LINE_CONTINUATIONS",
5729 "Avoid unnecessary line continuations\n" . $herecurr);
5733 # do {} while (0) macro tests:
5734 # single-statement macros do not need to be enclosed in do while (0) loop,
5735 # macro should not end with a semicolon
5736 if ($perl_version_ok &&
5737 $realfile !~ m@/vmlinux.lds.h$@ &&
5738 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5741 my ($off, $dstat, $dcond, $rest);
5743 ($dstat, $dcond, $ln, $cnt, $off) =
5744 ctx_statement_block($linenr, $realcnt, 0);
5747 $dstat =~ s/\\\n.//g;
5750 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5755 my $cnt = statement_rawlines($ctx);
5756 my $herectx = get_stat_here($linenr, $cnt, $here);
5758 if (($stmts =~ tr/;/;/) == 1 &&
5759 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5760 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5761 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5763 if (defined $semis && $semis ne "") {
5764 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5765 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5767 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5769 my $cnt = statement_rawlines($ctx);
5770 my $herectx = get_stat_here($linenr, $cnt, $here);
5772 WARN("TRAILING_SEMICOLON",
5773 "macros should not use a trailing semicolon\n" . "$herectx");
5777 # check for redundant bracing round if etc
5778 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5779 my ($level, $endln, @chunks) =
5780 ctx_statement_full($linenr, $realcnt, 1);
5781 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5782 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5783 if ($#chunks > 0 && $level == 0) {
5787 my $herectx = $here . "\n";
5788 my $ln = $linenr - 1;
5789 for my $chunk (@chunks) {
5790 my ($cond, $block) = @{$chunk};
5792 # If the condition carries leading newlines, then count those as offsets.
5793 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5794 my $offset = statement_rawlines($whitespace) - 1;
5796 $allowed[$allow] = 0;
5797 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5799 # We have looked at and allowed this specific line.
5800 $suppress_ifbraces{$ln + $offset} = 1;
5802 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5803 $ln += statement_rawlines($block) - 1;
5805 substr($block, 0, length($cond), '');
5807 $seen++ if ($block =~ /^\s*{/);
5809 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5810 if (statement_lines($cond) > 1) {
5811 #print "APW: ALLOWED: cond<$cond>\n";
5812 $allowed[$allow] = 1;
5814 if ($block =~/\b(?:if|for|while)\b/) {
5815 #print "APW: ALLOWED: block<$block>\n";
5816 $allowed[$allow] = 1;
5818 if (statement_block_size($block) > 1) {
5819 #print "APW: ALLOWED: lines block<$block>\n";
5820 $allowed[$allow] = 1;
5825 my $sum_allowed = 0;
5826 foreach (@allowed) {
5829 if ($sum_allowed == 0) {
5831 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5832 } elsif ($sum_allowed != $allow &&
5835 "braces {} should be used on all arms of this statement\n" . $herectx);
5840 if (!defined $suppress_ifbraces{$linenr - 1} &&
5841 $line =~ /\b(if|while|for|else)\b/) {
5844 # Check the pre-context.
5845 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5846 #print "APW: ALLOWED: pre<$1>\n";
5850 my ($level, $endln, @chunks) =
5851 ctx_statement_full($linenr, $realcnt, $-[0]);
5853 # Check the condition.
5854 my ($cond, $block) = @{$chunks[0]};
5855 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5856 if (defined $cond) {
5857 substr($block, 0, length($cond), '');
5859 if (statement_lines($cond) > 1) {
5860 #print "APW: ALLOWED: cond<$cond>\n";
5863 if ($block =~/\b(?:if|for|while)\b/) {
5864 #print "APW: ALLOWED: block<$block>\n";
5867 if (statement_block_size($block) > 1) {
5868 #print "APW: ALLOWED: lines block<$block>\n";
5871 # Check the post-context.
5872 if (defined $chunks[1]) {
5873 my ($cond, $block) = @{$chunks[1]};
5874 if (defined $cond) {
5875 substr($block, 0, length($cond), '');
5877 if ($block =~ /^\s*\{/) {
5878 #print "APW: ALLOWED: chunk-1 block<$block>\n";
5882 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5883 my $cnt = statement_rawlines($block);
5884 my $herectx = get_stat_here($linenr, $cnt, $here);
5887 "braces {} are not necessary for single statement blocks\n" . $herectx);
5891 # check for single line unbalanced braces
5892 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5893 $sline =~ /^.\s*else\s*\{\s*$/) {
5894 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5897 # check for unnecessary blank lines around braces
5898 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5900 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5901 $fix && $prevrawline =~ /^\+/) {
5902 fix_delete_line($fixlinenr - 1, $prevrawline);
5905 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5907 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5909 fix_delete_line($fixlinenr, $rawline);
5913 # no volatiles please
5914 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5915 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5917 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5920 # Check for user-visible strings broken across lines, which breaks the ability
5921 # to grep for the string. Make exceptions when the previous string ends in a
5922 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5923 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5924 if ($line =~ /^\+\s*$String/ &&
5925 $prevline =~ /"\s*$/ &&
5926 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5927 if (WARN("SPLIT_STRING",
5928 "quoted string split across lines\n" . $hereprev) &&
5930 $prevrawline =~ /^\+.*"\s*$/ &&
5931 $last_coalesced_string_linenr != $linenr - 1) {
5932 my $extracted_string = get_quoted_string($line, $rawline);
5933 my $comma_close = "";
5934 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5938 fix_delete_line($fixlinenr - 1, $prevrawline);
5939 fix_delete_line($fixlinenr, $rawline);
5940 my $fixedline = $prevrawline;
5941 $fixedline =~ s/"\s*$//;
5942 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5943 fix_insert_line($fixlinenr - 1, $fixedline);
5944 $fixedline = $rawline;
5945 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5946 if ($fixedline !~ /\+\s*$/) {
5947 fix_insert_line($fixlinenr, $fixedline);
5949 $last_coalesced_string_linenr = $linenr;
5953 # check for missing a space in a string concatenation
5954 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5955 WARN('MISSING_SPACE',
5956 "break quoted strings at a space character\n" . $hereprev);
5959 # check for an embedded function name in a string when the function is known
5960 # This does not work very well for -f --file checking as it depends on patch
5961 # context providing the function name or a single line form for in-file
5962 # function declarations
5963 if ($line =~ /^\+.*$String/ &&
5964 defined($context_function) &&
5965 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
5966 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
5967 WARN("EMBEDDED_FUNCTION_NAME",
5968 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
5971 # check for spaces before a quoted newline
5972 if ($rawline =~ /^.*\".*\s\\n/) {
5973 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5974 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5976 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5981 # concatenated string without spaces between elements
5982 if ($line =~ /$String[A-Za-z0-9_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5983 if (CHK("CONCATENATED_STRING",
5984 "Concatenated strings should use spaces between elements\n" . $herecurr) &&
5986 while ($line =~ /($String)/g) {
5987 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
5988 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
5989 $fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
5994 # uncoalesced string fragments
5995 if ($line =~ /$String\s*"/) {
5996 if (WARN("STRING_FRAGMENTS",
5997 "Consecutive strings are generally better as a single string\n" . $herecurr) &&
5999 while ($line =~ /($String)(?=\s*")/g) {
6000 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6001 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
6006 # check for non-standard and hex prefixed decimal printf formats
6007 my $show_L = 1; #don't show the same defect twice
6009 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
6010 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
6011 $string =~ s/%%/__/g;
6013 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
6015 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
6019 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
6021 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
6024 # check for 0x<decimal>
6025 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
6026 ERROR("PRINTF_0XDECIMAL",
6027 "Prefixing 0x with decimal output is defective\n" . $herecurr);
6031 # check for line continuations in quoted strings with odd counts of "
6032 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
6033 WARN("LINE_CONTINUATIONS",
6034 "Avoid line continuations in quoted strings\n" . $herecurr);
6038 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
6040 "Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
6044 if ($line =~ /^.\s*\#\s*if\s+1\b/) {
6046 "Consider removing the #if 1 and its #endif\n" . $herecurr);
6049 # check for needless "if (<foo>) fn(<foo>)" uses
6050 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
6051 my $tested = quotemeta($1);
6052 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
6053 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
6055 if (WARN('NEEDLESS_IF',
6056 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
6059 my $leading_tabs = "";
6060 my $new_leading_tabs = "";
6061 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
6066 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
6067 $new_leading_tabs = $1;
6068 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
6075 fix_delete_line($fixlinenr - 1, $prevrawline);
6076 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
6082 # check for unnecessary "Out of Memory" messages
6083 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
6084 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
6085 (defined $1 || defined $3) &&
6088 my $testline = $lines[$linenr - 3];
6090 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
6091 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
6093 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
6094 $s !~ /\b__GFP_NOWARN\b/ ) {
6096 "Possible unnecessary 'out of memory' message\n" . $hereprev);
6100 # check for logging functions with KERN_<LEVEL>
6101 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
6102 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
6104 if (WARN("UNNECESSARY_KERN_LEVEL",
6105 "Possible unnecessary $level\n" . $herecurr) &&
6107 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
6111 # check for logging continuations
6112 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
6113 WARN("LOGGING_CONTINUATION",
6114 "Avoid logging continuation uses where feasible\n" . $herecurr);
6117 # check for unnecessary use of %h[xudi] and %hh[xudi] in logging functions
6118 if (defined $stat &&
6119 $line =~ /\b$logFunctions\s*\(/ &&
6120 index($stat, '"') >= 0) {
6121 my $lc = $stat =~ tr@\n@@;
6122 $lc = $lc + $linenr;
6123 my $stat_real = get_stat_real($linenr, $lc);
6124 pos($stat_real) = index($stat_real, '"');
6125 while ($stat_real =~ /[^\"%]*(%[\#\d\.\*\-]*(h+)[idux])/g) {
6128 my $lineoff = substr($stat_real, 0, $-[1]) =~ tr@\n@@;
6129 if (WARN("UNNECESSARY_MODIFIER",
6130 "Integer promotion: Using '$h' in '$pspec' is unnecessary\n" . "$here\n$stat_real\n") &&
6131 $fix && $fixed[$fixlinenr + $lineoff] =~ /^\+/) {
6134 $fixed[$fixlinenr + $lineoff] =~ s/\Q$pspec\E/$nspec/;
6139 # check for mask then right shift without a parentheses
6140 if ($perl_version_ok &&
6141 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
6142 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
6143 WARN("MASK_THEN_SHIFT",
6144 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
6147 # check for pointer comparisons to NULL
6148 if ($perl_version_ok) {
6149 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
6152 $equal = "" if ($4 eq "!=");
6153 if (CHK("COMPARISON_TO_NULL",
6154 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
6156 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
6161 # check for bad placement of section $InitAttribute (e.g.: __initdata)
6162 if ($line =~ /(\b$InitAttribute\b)/) {
6164 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
6167 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
6168 ERROR("MISPLACED_INIT",
6169 "$attr should be placed after $var\n" . $herecurr)) ||
6170 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
6171 WARN("MISPLACED_INIT",
6172 "$attr should be placed after $var\n" . $herecurr))) &&
6174 $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;
6179 # check for $InitAttributeData (ie: __initdata) with const
6180 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
6182 $attr =~ /($InitAttributePrefix)(.*)/;
6183 my $attr_prefix = $1;
6185 if (ERROR("INIT_ATTRIBUTE",
6186 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
6188 $fixed[$fixlinenr] =~
6189 s/$InitAttributeData/${attr_prefix}initconst/;
6193 # check for $InitAttributeConst (ie: __initconst) without const
6194 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
6196 if (ERROR("INIT_ATTRIBUTE",
6197 "Use of $attr requires a separate use of const\n" . $herecurr) &&
6199 my $lead = $fixed[$fixlinenr] =~
6200 /(^\+\s*(?:static\s+))/;
6202 $lead = "$lead " if ($lead !~ /^\+$/);
6203 $lead = "${lead}const ";
6204 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
6208 # check for __read_mostly with const non-pointer (should just be const)
6209 if ($line =~ /\b__read_mostly\b/ &&
6210 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
6211 if (ERROR("CONST_READ_MOSTLY",
6212 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
6214 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
6218 # don't use __constant_<foo> functions outside of include/uapi/
6219 if ($realfile !~ m@^include/uapi/@ &&
6220 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
6221 my $constant_func = $1;
6222 my $func = $constant_func;
6223 $func =~ s/^__constant_//;
6224 if (WARN("CONSTANT_CONVERSION",
6225 "$constant_func should be $func\n" . $herecurr) &&
6227 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
6231 # prefer usleep_range over udelay
6232 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
6234 # ignore udelay's < 10, however
6235 if (! ($delay < 10) ) {
6237 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6239 if ($delay > 2000) {
6241 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
6245 # warn about unexpectedly long msleep's
6246 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
6249 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6253 # check for comparisons of jiffies
6254 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
6255 WARN("JIFFIES_COMPARISON",
6256 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
6259 # check for comparisons of get_jiffies_64()
6260 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
6261 WARN("JIFFIES_COMPARISON",
6262 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
6265 # warn about #ifdefs in C files
6266 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
6267 # print "#ifdef in C files should be avoided\n";
6268 # print "$herecurr";
6272 # warn about spacing in #ifdefs
6273 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
6274 if (ERROR("SPACING",
6275 "exactly one space required after that #$1\n" . $herecurr) &&
6277 $fixed[$fixlinenr] =~
6278 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
6283 # check for spinlock_t definitions without a comment.
6284 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
6285 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
6287 if (!ctx_has_comment($first_line, $linenr)) {
6288 CHK("UNCOMMENTED_DEFINITION",
6289 "$1 definition without comment\n" . $herecurr);
6292 # check for memory barriers without a comment.
6299 my $barrier_stems = qr{
6307 my $all_barriers = qr{
6309 smp_(?:$barrier_stems)|
6310 virt_(?:$barrier_stems)
6313 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
6314 if (!ctx_has_comment($first_line, $linenr)) {
6315 WARN("MEMORY_BARRIER",
6316 "memory barrier without comment\n" . $herecurr);
6320 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
6322 if ($realfile !~ m@^include/asm-generic/@ &&
6323 $realfile !~ m@/barrier\.h$@ &&
6324 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
6325 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
6326 WARN("MEMORY_BARRIER",
6327 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6330 # check for waitqueue_active without a comment.
6331 if ($line =~ /\bwaitqueue_active\s*\(/) {
6332 if (!ctx_has_comment($first_line, $linenr)) {
6333 WARN("WAITQUEUE_ACTIVE",
6334 "waitqueue_active without comment\n" . $herecurr);
6338 # check for data_race without a comment.
6339 if ($line =~ /\bdata_race\s*\(/) {
6340 if (!ctx_has_comment($first_line, $linenr)) {
6342 "data_race without comment\n" . $herecurr);
6346 # check of hardware specific defines
6347 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
6349 "architecture specific defines should be avoided\n" . $herecurr);
6352 # check that the storage class is not after a type
6353 if ($line =~ /\b($Type)\s+($Storage)\b/) {
6354 WARN("STORAGE_CLASS",
6355 "storage class '$2' should be located before type '$1'\n" . $herecurr);
6357 # Check that the storage class is at the beginning of a declaration
6358 if ($line =~ /\b$Storage\b/ &&
6359 $line !~ /^.\s*$Storage/ &&
6360 $line =~ /^.\s*(.+?)\$Storage\s/ &&
6361 $1 !~ /[\,\)]\s*$/) {
6362 WARN("STORAGE_CLASS",
6363 "storage class should be at the beginning of the declaration\n" . $herecurr);
6366 # check the location of the inline attribute, that it is between
6367 # storage class and type.
6368 if ($line =~ /\b$Type\s+$Inline\b/ ||
6369 $line =~ /\b$Inline\s+$Storage\b/) {
6370 ERROR("INLINE_LOCATION",
6371 "inline keyword should sit between storage class and type\n" . $herecurr);
6374 # Check for __inline__ and __inline, prefer inline
6375 if ($realfile !~ m@\binclude/uapi/@ &&
6376 $line =~ /\b(__inline__|__inline)\b/) {
6378 "plain inline is preferred over $1\n" . $herecurr) &&
6380 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
6385 # Check for compiler attributes
6386 if ($realfile !~ m@\binclude/uapi/@ &&
6387 $rawline =~ /\b__attribute__\s*\(\s*($balanced_parens)\s*\)/) {
6389 $attr =~ s/\s*\(\s*(.*)\)\s*/$1/;
6392 "alias" => "__alias",
6393 "aligned" => "__aligned",
6394 "always_inline" => "__always_inline",
6395 "assume_aligned" => "__assume_aligned",
6397 "const" => "__attribute_const__",
6399 "designated_init" => "__designated_init",
6400 "externally_visible" => "__visible",
6401 "format" => "printf|scanf",
6402 "gnu_inline" => "__gnu_inline",
6403 "malloc" => "__malloc",
6405 "no_caller_saved_registers" => "__no_caller_saved_registers",
6406 "noclone" => "__noclone",
6407 "noinline" => "noinline",
6408 "nonstring" => "__nonstring",
6409 "noreturn" => "__noreturn",
6410 "packed" => "__packed",
6412 "section" => "__section",
6417 while ($attr =~ /\s*(\w+)\s*(${balanced_parens})?/g) {
6420 $params = $2 if defined($2);
6421 my $curr_attr = $orig_attr;
6422 $curr_attr =~ s/^[\s_]+|[\s_]+$//g;
6423 if (exists($attr_list{$curr_attr})) {
6424 my $new = $attr_list{$curr_attr};
6425 if ($curr_attr eq "format" && $params) {
6426 $params =~ /^\s*\(\s*(\w+)\s*,\s*(.*)/;
6429 $new = "$new$params";
6431 if (WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6432 "Prefer $new over __attribute__(($orig_attr$params))\n" . $herecurr) &&
6434 my $remove = "\Q$orig_attr\E" . '\s*' . "\Q$params\E" . '(?:\s*,\s*)?';
6435 $fixed[$fixlinenr] =~ s/$remove//;
6436 $fixed[$fixlinenr] =~ s/\b__attribute__/$new __attribute__/;
6437 $fixed[$fixlinenr] =~ s/\}\Q$new\E/} $new/;
6438 $fixed[$fixlinenr] =~ s/ __attribute__\s*\(\s*\(\s*\)\s*\)//;
6443 # Check for __attribute__ unused, prefer __always_unused or __maybe_unused
6444 if ($attr =~ /^_*unused/) {
6445 WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6446 "__always_unused or __maybe_unused is preferred over __attribute__((__unused__))\n" . $herecurr);
6450 # Check for __attribute__ weak, or __weak declarations (may have link issues)
6451 if ($perl_version_ok &&
6452 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
6453 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
6454 $line =~ /\b__weak\b/)) {
6455 ERROR("WEAK_DECLARATION",
6456 "Using weak declarations can have unintended link defects\n" . $herecurr);
6459 # check for c99 types like uint8_t used outside of uapi/ and tools/
6460 if ($realfile !~ m@\binclude/uapi/@ &&
6461 $realfile !~ m@\btools/@ &&
6462 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
6464 if ($type =~ /\b($typeC99Typedefs)\b/) {
6466 my $kernel_type = 'u';
6467 $kernel_type = 's' if ($type =~ /^_*[si]/);
6470 if (CHK("PREFER_KERNEL_TYPES",
6471 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6473 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6478 # check for cast of C90 native int or longer types constants
6479 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
6482 if (WARN("TYPECAST_INT_CONSTANT",
6483 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
6486 my $newconst = $const;
6487 $newconst =~ s/${Int_type}$//;
6488 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6489 if ($cast =~ /\blong\s+long\b/) {
6491 } elsif ($cast =~ /\blong\b/) {
6494 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6498 # check for sizeof(&)
6499 if ($line =~ /\bsizeof\s*\(\s*\&/) {
6500 WARN("SIZEOF_ADDRESS",
6501 "sizeof(& should be avoided\n" . $herecurr);
6504 # check for sizeof without parenthesis
6505 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
6506 if (WARN("SIZEOF_PARENTHESIS",
6507 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6509 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
6513 # check for struct spinlock declarations
6514 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
6515 WARN("USE_SPINLOCK_T",
6516 "struct spinlock should be spinlock_t\n" . $herecurr);
6519 # check for seq_printf uses that could be seq_puts
6520 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
6521 my $fmt = get_quoted_string($line, $rawline);
6524 if (WARN("PREFER_SEQ_PUTS",
6525 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
6527 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6532 # check for vsprintf extension %p<foo> misuses
6533 if ($perl_version_ok &&
6535 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
6536 $1 !~ /^_*volatile_*$/) {
6539 my $lc = $stat =~ tr@\n@@;
6540 $lc = $lc + $linenr;
6541 for (my $count = $linenr; $count <= $lc; $count++) {
6545 my $bad_specifier = "";
6546 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
6549 while ($fmt =~ /(\%[\*\d\.]*p(\w)(\w*))/g) {
6553 if ($extension !~ /[SsBKRraEehMmIiUDdgVCbGNOxtf]/ ||
6554 ($extension eq "f" &&
6555 defined $qualifier && $qualifier !~ /^w/)) {
6556 $bad_specifier = $specifier;
6559 if ($extension eq "x" && !defined($stat_real)) {
6560 if (!defined($stat_real)) {
6561 $stat_real = get_stat_real($linenr, $lc);
6563 WARN("VSPRINTF_SPECIFIER_PX",
6564 "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");
6567 if ($bad_specifier ne "") {
6568 my $stat_real = get_stat_real($linenr, $lc);
6569 my $ext_type = "Invalid";
6571 if ($bad_specifier =~ /p[Ff]/) {
6572 $use = " - use %pS instead";
6573 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6576 WARN("VSPRINTF_POINTER_EXTENSION",
6577 "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6582 # Check for misused memsets
6583 if ($perl_version_ok &&
6585 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
6591 if ($ms_size =~ /^(0x|)0$/i) {
6593 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6594 } elsif ($ms_size =~ /^(0x|)1$/i) {
6596 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6600 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6601 # if ($perl_version_ok &&
6603 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6604 # if (WARN("PREFER_ETHER_ADDR_COPY",
6605 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6607 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
6611 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6612 # if ($perl_version_ok &&
6614 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6615 # WARN("PREFER_ETHER_ADDR_EQUAL",
6616 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6619 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6620 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
6621 # if ($perl_version_ok &&
6623 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6627 # if ($ms_val =~ /^(?:0x|)0+$/i) {
6628 # if (WARN("PREFER_ETH_ZERO_ADDR",
6629 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
6631 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
6633 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
6634 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
6635 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
6637 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
6642 # strlcpy uses that should likely be strscpy
6643 if ($line =~ /\bstrlcpy\s*\(/) {
6645 "Prefer strscpy over strlcpy - see: https://lore.kernel.org/r/CAHk-=wgfRnXz0W3D37d01q3JFkr_i_uTL=V6A6G1oUZcprmknw\@mail.gmail.com/\n" . $herecurr);
6648 # typecasts on min/max could be min_t/max_t
6649 if ($perl_version_ok &&
6651 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
6652 if (defined $2 || defined $7) {
6654 my $cast1 = deparenthesize($2);
6656 my $cast2 = deparenthesize($7);
6660 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
6661 $cast = "$cast1 or $cast2";
6662 } elsif ($cast1 ne "") {
6668 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
6672 # check usleep_range arguments
6673 if ($perl_version_ok &&
6675 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
6679 WARN("USLEEP_RANGE",
6680 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6681 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
6683 WARN("USLEEP_RANGE",
6684 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6688 # check for naked sscanf
6689 if ($perl_version_ok &&
6691 $line =~ /\bsscanf\b/ &&
6692 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
6693 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
6694 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
6695 my $lc = $stat =~ tr@\n@@;
6696 $lc = $lc + $linenr;
6697 my $stat_real = get_stat_real($linenr, $lc);
6698 WARN("NAKED_SSCANF",
6699 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
6702 # check for simple sscanf that should be kstrto<foo>
6703 if ($perl_version_ok &&
6705 $line =~ /\bsscanf\b/) {
6706 my $lc = $stat =~ tr@\n@@;
6707 $lc = $lc + $linenr;
6708 my $stat_real = get_stat_real($linenr, $lc);
6709 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
6711 my $count = $format =~ tr@%@%@;
6713 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
6714 WARN("SSCANF_TO_KSTRTO",
6715 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
6720 # check for new externs in .h files.
6721 if ($realfile =~ /\.h$/ &&
6722 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
6723 if (CHK("AVOID_EXTERNS",
6724 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
6726 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
6730 # check for new externs in .c files.
6731 if ($realfile =~ /\.c$/ && defined $stat &&
6732 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
6734 my $function_name = $1;
6735 my $paren_space = $2;
6738 if (defined $cond) {
6739 substr($s, 0, length($cond), '');
6743 WARN("AVOID_EXTERNS",
6744 "externs should be avoided in .c files\n" . $herecurr);
6747 if ($paren_space =~ /\n/) {
6748 WARN("FUNCTION_ARGUMENTS",
6749 "arguments for function declarations should follow identifier\n" . $herecurr);
6752 } elsif ($realfile =~ /\.c$/ && defined $stat &&
6753 $stat =~ /^.\s*extern\s+/)
6755 WARN("AVOID_EXTERNS",
6756 "externs should be avoided in .c files\n" . $herecurr);
6759 # check for function declarations that have arguments without identifier names
6760 if (defined $stat &&
6761 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
6763 my $args = trim($1);
6764 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
6766 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
6767 WARN("FUNCTION_ARGUMENTS",
6768 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
6773 # check for function definitions
6774 if ($perl_version_ok &&
6776 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
6777 $context_function = $1;
6779 # check for multiline function definition with misplaced open brace
6781 my $cnt = statement_rawlines($stat);
6782 my $herectx = $here . "\n";
6783 for (my $n = 0; $n < $cnt; $n++) {
6784 my $rl = raw_line($linenr, $n);
6785 $herectx .= $rl . "\n";
6786 $ok = 1 if ($rl =~ /^[ \+]\{/);
6787 $ok = 1 if ($rl =~ /\{/ && $n == 0);
6788 last if $rl =~ /^[ \+].*\{/;
6792 "open brace '{' following function definitions go on the next line\n" . $herectx);
6796 # checks for new __setup's
6797 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6800 if (!grep(/$name/, @setup_docs)) {
6801 CHK("UNDOCUMENTED_SETUP",
6802 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
6806 # check for pointless casting of alloc functions
6807 if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
6808 WARN("UNNECESSARY_CASTS",
6809 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6813 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6814 if ($perl_version_ok &&
6815 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6816 CHK("ALLOC_SIZEOF_STRUCT",
6817 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6820 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6821 if ($perl_version_ok &&
6823 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6827 my $newfunc = "kmalloc_array";
6828 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6831 if ($a1 =~ /^sizeof\s*\S/) {
6835 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6836 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6837 my $cnt = statement_rawlines($stat);
6838 my $herectx = get_stat_here($linenr, $cnt, $here);
6840 if (WARN("ALLOC_WITH_MULTIPLY",
6841 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6844 $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;
6849 # check for krealloc arg reuse
6850 if ($perl_version_ok &&
6851 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*($Lval)\s*,/ &&
6853 WARN("KREALLOC_ARG_REUSE",
6854 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6857 # check for alloc argument mismatch
6858 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6859 WARN("ALLOC_ARRAY_ARGS",
6860 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6863 # check for multiple semicolons
6864 if ($line =~ /;\s*;\s*$/) {
6865 if (WARN("ONE_SEMICOLON",
6866 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6868 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6872 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6873 if ($realfile !~ m@^include/uapi/@ &&
6874 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6876 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6877 if (CHK("BIT_MACRO",
6878 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6880 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6884 # check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
6885 if ($rawline =~ /\bIS_ENABLED\s*\(\s*(\w+)\s*\)/ && $1 !~ /^${CONFIG_}/) {
6886 WARN("IS_ENABLED_CONFIG",
6887 "IS_ENABLED($1) is normally used as IS_ENABLED(${CONFIG_}$1)\n" . $herecurr);
6890 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6891 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(${CONFIG_}[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6893 if (WARN("PREFER_IS_ENABLED",
6894 "Prefer IS_ENABLED(<FOO>) to ${CONFIG_}<FOO> || ${CONFIG_}<FOO>_MODULE\n" . $herecurr) &&
6896 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6900 # check for /* fallthrough */ like comment, prefer fallthrough;
6901 my @fallthroughs = (
6904 'lint -fallthrough[ \t]*',
6905 'intentional(?:ly)?[ \t]*fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)',
6906 '(?:else,?\s*)?FALL(?:S | |-)?THR(?:OUGH|U|EW)[ \t.!]*(?:-[^\n\r]*)?',
6907 'Fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
6908 'fall(?:s | |-)?thr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
6910 if ($raw_comment ne '') {
6911 foreach my $ft (@fallthroughs) {
6912 if ($raw_comment =~ /$ft/) {
6913 my $msg_level = \&WARN;
6914 $msg_level = \&CHK if ($file);
6915 &{$msg_level}("PREFER_FALLTHROUGH",
6916 "Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
6922 # check for switch/default statements without a break;
6923 if ($perl_version_ok &&
6925 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6926 my $cnt = statement_rawlines($stat);
6927 my $herectx = get_stat_here($linenr, $cnt, $here);
6929 WARN("DEFAULT_NO_BREAK",
6930 "switch default: should use break\n" . $herectx);
6933 # check for gcc specific __FUNCTION__
6934 if ($line =~ /\b__FUNCTION__\b/) {
6935 if (WARN("USE_FUNC",
6936 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
6938 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
6942 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
6943 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6945 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6948 # check for use of yield()
6949 if ($line =~ /\byield\s*\(\s*\)/) {
6951 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
6954 # check for comparisons against true and false
6955 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6963 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6965 my $type = lc($otype);
6966 if ($type =~ /^(?:true|false)$/) {
6967 if (("$test" eq "==" && "$type" eq "true") ||
6968 ("$test" eq "!=" && "$type" eq "false")) {
6972 CHK("BOOL_COMPARISON",
6973 "Using comparison to $otype is error prone\n" . $herecurr);
6975 ## maybe suggesting a correct construct would better
6976 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6981 # check for semaphores initialized locked
6982 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6983 WARN("CONSIDER_COMPLETION",
6984 "consider using a completion\n" . $herecurr);
6987 # recommend kstrto* over simple_strto* and strict_strto*
6988 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6989 WARN("CONSIDER_KSTRTO",
6990 "$1 is obsolete, use k$3 instead\n" . $herecurr);
6993 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
6994 if ($line =~ /^.\s*__initcall\s*\(/) {
6995 WARN("USE_DEVICE_INITCALL",
6996 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6999 # check for spin_is_locked(), suggest lockdep instead
7000 if ($line =~ /\bspin_is_locked\(/) {
7002 "Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
7005 # check for deprecated apis
7006 if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
7007 my $deprecated_api = $1;
7008 my $new_api = $deprecated_apis{$deprecated_api};
7009 WARN("DEPRECATED_API",
7010 "Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
7013 # check for various structs that are normally const (ops, kgdb, device_tree)
7014 # and avoid what seem like struct definitions 'struct foo {'
7015 if (defined($const_structs) &&
7016 $line !~ /\bconst\b/ &&
7017 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
7018 WARN("CONST_STRUCT",
7019 "struct $1 should normally be const\n" . $herecurr);
7022 # use of NR_CPUS is usually wrong
7023 # ignore definitions of NR_CPUS and usage to define arrays as likely right
7024 if ($line =~ /\bNR_CPUS\b/ &&
7025 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
7026 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
7027 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
7028 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
7029 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
7032 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
7035 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
7036 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
7037 ERROR("DEFINE_ARCH_HAS",
7038 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
7041 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
7042 if ($perl_version_ok &&
7043 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
7044 WARN("LIKELY_MISUSE",
7045 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
7048 # nested likely/unlikely calls
7049 if ($line =~ /\b(?:(?:un)?likely)\s*\(\s*!?\s*(IS_ERR(?:_OR_NULL|_VALUE)?|WARN)/) {
7050 WARN("LIKELY_MISUSE",
7051 "nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
7054 # whine mightly about in_atomic
7055 if ($line =~ /\bin_atomic\s*\(/) {
7056 if ($realfile =~ m@^drivers/@) {
7058 "do not use in_atomic in drivers\n" . $herecurr);
7059 } elsif ($realfile !~ m@^kernel/@) {
7061 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
7065 # check for lockdep_set_novalidate_class
7066 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
7067 $line =~ /__lockdep_no_validate__\s*\)/ ) {
7068 if ($realfile !~ m@^kernel/lockdep@ &&
7069 $realfile !~ m@^include/linux/lockdep@ &&
7070 $realfile !~ m@^drivers/base/core@) {
7072 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
7076 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
7077 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
7078 WARN("EXPORTED_WORLD_WRITABLE",
7079 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
7082 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
7083 # and whether or not function naming is typical and if
7084 # DEVICE_ATTR permissions uses are unusual too
7085 if ($perl_version_ok &&
7087 $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*\)/) {
7092 my $octal_perms = perms_to_octal($perms);
7093 if ($show =~ /^${var}_show$/ &&
7094 $store =~ /^${var}_store$/ &&
7095 $octal_perms eq "0644") {
7096 if (WARN("DEVICE_ATTR_RW",
7097 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
7099 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
7101 } elsif ($show =~ /^${var}_show$/ &&
7102 $store =~ /^NULL$/ &&
7103 $octal_perms eq "0444") {
7104 if (WARN("DEVICE_ATTR_RO",
7105 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
7107 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
7109 } elsif ($show =~ /^NULL$/ &&
7110 $store =~ /^${var}_store$/ &&
7111 $octal_perms eq "0200") {
7112 if (WARN("DEVICE_ATTR_WO",
7113 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
7115 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
7117 } elsif ($octal_perms eq "0644" ||
7118 $octal_perms eq "0444" ||
7119 $octal_perms eq "0200") {
7120 my $newshow = "$show";
7121 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
7122 my $newstore = $store;
7123 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
7125 if ($show ne $newshow) {
7126 $rename .= " '$show' to '$newshow'";
7128 if ($store ne $newstore) {
7129 $rename .= " '$store' to '$newstore'";
7131 WARN("DEVICE_ATTR_FUNCTIONS",
7132 "Consider renaming function(s)$rename\n" . $herecurr);
7134 WARN("DEVICE_ATTR_PERMS",
7135 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
7139 # Mode permission misuses where it seems decimal should be octal
7140 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
7141 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
7142 # specific definition of not visible in sysfs.
7143 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
7144 # use the default permissions
7145 if ($perl_version_ok &&
7147 $line =~ /$mode_perms_search/) {
7148 foreach my $entry (@mode_permission_funcs) {
7149 my $func = $entry->[0];
7150 my $arg_pos = $entry->[1];
7152 my $lc = $stat =~ tr@\n@@;
7153 $lc = $lc + $linenr;
7154 my $stat_real = get_stat_real($linenr, $lc);
7159 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
7161 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
7162 if ($stat =~ /$test/) {
7164 $val = $6 if ($skip_args ne "");
7165 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
7166 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
7167 ($val =~ /^$Octal$/ && length($val) ne 4))) {
7168 ERROR("NON_OCTAL_PERMISSIONS",
7169 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
7171 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
7172 ERROR("EXPORTED_WORLD_WRITABLE",
7173 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
7179 # check for uses of S_<PERMS> that could be octal for readability
7180 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
7182 my $octal = perms_to_octal($oval);
7183 if (WARN("SYMBOLIC_PERMS",
7184 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
7186 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
7190 # validate content of MODULE_LICENSE against list from include/linux/module.h
7191 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
7192 my $extracted_string = get_quoted_string($line, $rawline);
7193 my $valid_licenses = qr{
7196 GPL\ and\ additional\ rights|
7202 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
7203 WARN("MODULE_LICENSE",
7204 "unknown module license " . $extracted_string . "\n" . $herecurr);
7208 # check for sysctl duplicate constants
7209 if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
7210 WARN("DUPLICATED_SYSCTL_CONST",
7211 "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
7215 # If we have no input at all, then there is nothing to report on
7216 # so just keep quiet.
7217 if ($#rawlines == -1) {
7221 # In mailback mode only produce a report in the negative, for
7222 # things that appear to be patches.
7223 if ($mailback && ($clean == 1 || !$is_patch)) {
7227 # This is not a patch, and we are in 'no-patch' mode so
7229 if (!$chk_patch && !$is_patch) {
7233 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
7234 ERROR("NOT_UNIFIED_DIFF",
7235 "Does not appear to be a unified-diff format patch\n");
7237 if ($is_patch && $has_commit_log && $chk_signoff) {
7238 if ($signoff == 0) {
7239 ERROR("MISSING_SIGN_OFF",
7240 "Missing Signed-off-by: line(s)\n");
7241 } elsif ($authorsignoff != 1) {
7242 # authorsignoff values:
7243 # 0 -> missing sign off
7244 # 1 -> sign off identical
7245 # 2 -> names and addresses match, comments mismatch
7246 # 3 -> addresses match, names different
7247 # 4 -> names match, addresses different
7248 # 5 -> names match, addresses excluding subaddress details (refer RFC 5233) match
7250 my $sob_msg = "'From: $author' != 'Signed-off-by: $author_sob'";
7252 if ($authorsignoff == 0) {
7253 ERROR("NO_AUTHOR_SIGN_OFF",
7254 "Missing Signed-off-by: line by nominal patch author '$author'\n");
7255 } elsif ($authorsignoff == 2) {
7256 CHK("FROM_SIGN_OFF_MISMATCH",
7257 "From:/Signed-off-by: email comments mismatch: $sob_msg\n");
7258 } elsif ($authorsignoff == 3) {
7259 WARN("FROM_SIGN_OFF_MISMATCH",
7260 "From:/Signed-off-by: email name mismatch: $sob_msg\n");
7261 } elsif ($authorsignoff == 4) {
7262 WARN("FROM_SIGN_OFF_MISMATCH",
7263 "From:/Signed-off-by: email address mismatch: $sob_msg\n");
7264 } elsif ($authorsignoff == 5) {
7265 WARN("FROM_SIGN_OFF_MISMATCH",
7266 "From:/Signed-off-by: email subaddress mismatch: $sob_msg\n");
7271 print report_dump();
7272 if ($summary && !($clean == 1 && $quiet == 1)) {
7273 print "$filename " if ($summary_file);
7274 print "total: $cnt_error errors, $cnt_warn warnings, " .
7275 (($check)? "$cnt_chk checks, " : "") .
7276 "$cnt_lines lines checked\n";
7280 # If there were any defects found and not already fixing them
7281 if (!$clean and !$fix) {
7284 NOTE: For some of the reported defects, checkpatch may be able to
7285 mechanically convert to the typical style using --fix or --fix-inplace.
7288 # If there were whitespace errors which cleanpatch can fix
7289 # then suggest that.
7290 if ($rpt_cleaners) {
7294 NOTE: Whitespace errors detected.
7295 You may wish to use scripts/cleanpatch or scripts/cleanfile
7300 if ($clean == 0 && $fix &&
7301 ("@rawlines" ne "@fixed" ||
7302 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
7303 my $newfile = $filename;
7304 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
7308 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
7310 open($f, '>', $newfile)
7311 or die "$P: Can't open $newfile for write\n";
7312 foreach my $fixed_line (@fixed) {
7315 if ($linecount > 3) {
7316 $fixed_line =~ s/^\+//;
7317 print $f $fixed_line . "\n";
7320 print $f $fixed_line . "\n";
7328 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
7330 Do _NOT_ trust the results written to this file.
7331 Do _NOT_ submit these changes without inspecting them for correctness.
7333 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
7334 No warranties, expressed or implied...
7342 print "$vname has no obvious style problems and is ready for submission.\n";
7344 print "$vname has style problems, please review.\n";