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);
27 my %verbose_messages = ();
28 my %verbose_emitted = ();
49 my $gitroot = $ENV{'GIT_DIR'};
50 $gitroot = ".git" if !defined($gitroot);
58 my $configuration_file = ".checkpatch.conf";
59 my $max_line_length = 100;
60 my $ignore_perl_version = 0;
61 my $minimum_perl_version = 5.10.0;
62 my $min_conf_desc_length = 4;
63 my $spelling_file = "$D/spelling.txt";
65 my $codespellfile = "/usr/share/codespell/dictionary.txt";
66 my $conststructsfile = "$D/const_structs.checkpatch";
67 my $docsfile = "$D/../Documentation/dev-tools/checkpatch.rst";
70 my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
71 # git output parsing needs US English output, so first set backtick child process LANGUAGE
72 my $git_command ='export LANGUAGE=en_US.UTF-8; git';
74 my ${CONFIG_} = "CONFIG_";
80 Usage: $P [OPTION]... [FILE]...
85 -v, --verbose verbose mode
86 --no-tree run without a kernel tree
87 --no-signoff do not check for 'Signed-off-by' line
88 --patch treat FILE as patchfile (default)
89 --emacs emacs compile window format
90 --terse one line per report
91 --showfile emit diffed file position, not input file position
92 -g, --git treat FILE as a single commit or git revision range
93 single git commit with:
97 multiple git commits with:
101 git merges are ignored
102 -f, --file treat FILE as regular source file
103 --subjective, --strict enable more subjective tests
104 --list-types list the possible message types
105 --types TYPE(,TYPE2...) show only these comma separated message types
106 --ignore TYPE(,TYPE2...) ignore various comma separated message types
107 --show-types show the specific message type in the output
108 --max-line-length=n set the maximum line length, (default $max_line_length)
109 if exceeded, warn on patches
110 requires --strict for use with --file
111 --min-conf-desc-length=n set the min description length, if shorter, warn
112 --tab-size=n set the number of spaces for tab (default $tabsize)
113 --root=PATH PATH to the kernel tree root
114 --no-summary suppress the per-file summary
115 --mailback only produce a report in case of warnings/errors
116 --summary-file include the filename in summary
117 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
118 'values', 'possible', 'type', and 'attr' (default
120 --test-only=WORD report only warnings/errors containing WORD
122 --fix EXPERIMENTAL - may create horrible results
123 If correctable single-line errors exist, create
124 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
125 with potential errors corrected to the preferred
127 --fix-inplace EXPERIMENTAL - may create horrible results
128 Is the same as --fix, but overwrites the input
129 file. It's your fault if there's no backup or git
130 --ignore-perl-version override checking of perl version. expect
132 --codespell Use the codespell dictionary for spelling/typos
133 (default:/usr/share/codespell/dictionary.txt)
134 --codespellfile Use this codespell dictionary
135 --typedefsfile Read additional types from this file
136 --color[=WHEN] Use colors 'always', 'never', or only when output
137 is a terminal ('auto'). Default is 'auto'.
138 --kconfig-prefix=WORD use WORD as a prefix for Kconfig symbols (default
140 -h, --help, --version display this help and exit
142 When FILE is - read standard input.
150 return grep { !$seen{$_}++ } @_;
160 open(my $script, '<', abs_path($P)) or
161 die "$P: Can't read '$P' $!\n";
163 my $text = <$script>;
167 # Also catch when type or level is passed through a variable
168 while ($text =~ /(?:(\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
170 if (exists($types{$2})) {
171 $types{$2} .= ",$1" if ($types{$2} ne $1);
176 $types{$2} = "UNDETERMINED";
180 print("#\tMessage type\n\n");
182 print(" ( Color coding: ");
183 print(RED . "ERROR" . RESET);
185 print(YELLOW . "WARNING" . RESET);
187 print(GREEN . "CHECK" . RESET);
189 print("Multiple levels / Undetermined");
193 foreach my $type (sort keys %types) {
194 my $orig_type = $type;
196 my $level = $types{$type};
197 if ($level eq "ERROR") {
198 $type = RED . $type . RESET;
199 } elsif ($level eq "WARN") {
200 $type = YELLOW . $type . RESET;
201 } elsif ($level eq "CHK") {
202 $type = GREEN . $type . RESET;
205 print(++$count . "\t" . $type . "\n");
206 if ($verbose && exists($verbose_messages{$orig_type})) {
207 my $message = $verbose_messages{$orig_type};
208 $message =~ s/\n/\n\t/g;
209 print("\t" . $message . "\n\n");
216 my $conf = which_conf($configuration_file);
219 open(my $conffile, '<', "$conf")
220 or warn "$P: Can't find a readable $configuration_file file $!\n";
222 while (<$conffile>) {
225 $line =~ s/\s*\n?$//g;
229 next if ($line =~ m/^\s*#/);
230 next if ($line =~ m/^\s*$/);
232 my @words = split(" ", $line);
233 foreach my $word (@words) {
234 last if ($word =~ m/^#/);
235 push (@conf_args, $word);
239 unshift(@ARGV, @conf_args) if @conf_args;
243 open(my $docs, '<', "$docsfile")
244 or warn "$P: Can't read the documentation file $docsfile $!\n";
255 if ($line =~ /^\s*\*\*(.+)\*\*$/) {
257 $verbose_messages{$type} = trim($desc);
263 if ($line =~ /^(?:\s{4,}|$)/) {
268 $verbose_messages{$type} = trim($desc);
277 $verbose_messages{$type} = trim($desc);
282 # Perl's Getopt::Long allows options to take optional arguments after a space.
283 # Prevent --color by itself from consuming other arguments
285 if ($_ eq "--color" || $_ eq "-color") {
286 $_ = "--color=$color";
291 'q|quiet+' => \$quiet,
292 'v|verbose!' => \$verbose,
294 'signoff!' => \$chk_signoff,
295 'patch!' => \$chk_patch,
298 'showfile!' => \$showfile,
301 'subjective!' => \$check,
302 'strict!' => \$check,
303 'ignore=s' => \@ignore,
305 'show-types!' => \$show_types,
306 'list-types!' => \$list_types,
307 'max-line-length=i' => \$max_line_length,
308 'min-conf-desc-length=i' => \$min_conf_desc_length,
309 'tab-size=i' => \$tabsize,
311 'summary!' => \$summary,
312 'mailback!' => \$mailback,
313 'summary-file!' => \$summary_file,
315 'fix-inplace!' => \$fix_inplace,
316 'ignore-perl-version!' => \$ignore_perl_version,
317 'debug=s' => \%debug,
318 'test-only=s' => \$tst_only,
319 'codespell!' => \$codespell,
320 'codespellfile=s' => \$codespellfile,
321 'typedefsfile=s' => \$typedefsfile,
322 'color=s' => \$color,
323 'no-color' => \$color, #keep old behaviors of -nocolor
324 'nocolor' => \$color, #keep old behaviors of -nocolor
325 'kconfig-prefix=s' => \${CONFIG_},
332 die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file || $fix));
333 die "$P: --verbose cannot be used with --terse\n" if ($verbose && $terse);
335 if ($color =~ /^[01]$/) {
337 } elsif ($color =~ /^always$/i) {
339 } elsif ($color =~ /^never$/i) {
341 } elsif ($color =~ /^auto$/i) {
342 $color = (-t STDOUT);
344 die "$P: Invalid color mode: $color\n";
347 load_docs() if ($verbose);
348 list_types(0) if ($list_types);
350 $fix = 1 if ($fix_inplace);
351 $check_orig = $check;
355 my $perl_version_ok = 1;
356 if ($^V && $^V lt $minimum_perl_version) {
357 $perl_version_ok = 0;
358 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
359 exit(1) if (!$ignore_perl_version);
362 #if no filenames are given, push '-' to read patch from stdin
367 # skip TAB size 1 to avoid additional checks on $tabsize - 1
368 die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);
370 sub hash_save_array_words {
371 my ($hashRef, $arrayRef) = @_;
373 my @array = split(/,/, join(',', @$arrayRef));
374 foreach my $word (@array) {
375 $word =~ s/\s*\n?$//g;
378 $word =~ tr/[a-z]/[A-Z]/;
380 next if ($word =~ m/^\s*#/);
381 next if ($word =~ m/^\s*$/);
387 sub hash_show_words {
388 my ($hashRef, $prefix) = @_;
390 if (keys %$hashRef) {
391 print "\nNOTE: $prefix message types:";
392 foreach my $word (sort keys %$hashRef) {
399 hash_save_array_words(\%ignore_type, \@ignore);
400 hash_save_array_words(\%use_type, \@use);
403 my $dbg_possible = 0;
406 for my $key (keys %debug) {
408 eval "\${dbg_$key} = '$debug{$key}';";
412 my $rpt_cleaners = 0;
421 if (!top_of_kernel_tree($root)) {
422 die "$P: $root: --root does not point at a valid tree\n";
425 if (top_of_kernel_tree('.')) {
427 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
428 top_of_kernel_tree($1)) {
433 if (!defined $root) {
434 print "Must be run from the top-level dir. of a kernel tree\n";
439 my $emitted_corrupt = 0;
442 [A-Za-z_][A-Za-z\d_]*
443 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
445 our $Storage = qr{extern|static|asmlinkage};
459 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
460 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
461 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
462 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
463 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
465 # Notes to $Attribute:
466 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
489 ____cacheline_aligned|
490 ____cacheline_aligned_in_smp|
491 ____cacheline_internodealigned_in_smp|
493 __alloc_size\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\)
496 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
497 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
498 our $Lval = qr{$Ident(?:$Member)*};
500 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
501 our $Binary = qr{(?i)0b[01]+$Int_type?};
502 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
503 our $Int = qr{[0-9]+$Int_type?};
504 our $Octal = qr{0[0-7]+$Int_type?};
505 our $String = qr{(?:\b[Lu])?"[X\t]*"};
506 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
507 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
508 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
509 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
510 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
511 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
512 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
513 our $Arithmetic = qr{\+|-|\*|\/|%};
517 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
520 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
524 our $NonptrTypeMisordered;
525 our $NonptrTypeWithAttr;
529 our $DeclareMisordered;
531 our $NON_ASCII_UTF8 = qr{
532 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
533 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
534 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
535 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
536 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
537 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
538 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
542 [\x09\x0A\x0D\x20-\x7E] # ASCII
546 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
547 our $typeOtherOSTypedefs = qr{(?x:
548 u_(?:char|short|int|long) | # bsd
549 u(?:nchar|short|int|long) # sysv
551 our $typeKernelTypedefs = qr{(?x:
552 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
555 our $typeTypedefs = qr{(?x:
557 $typeOtherOSTypedefs\b|
558 $typeKernelTypedefs\b
561 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
563 our $logFunctions = qr{(?x:
564 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
565 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
567 WARN(?:_RATELIMIT|_ONCE|)|
570 seq_vprintf|seq_printf|seq_puts
573 our $allocFunctions = qr{(?x:
575 (?:kv|k|v)[czm]alloc(?:_array)?(?:_node)? |
578 (?:\w+)?alloc_skb(?:_ip_align)? |
579 # dev_alloc_skb/netdev_alloc_skb, et al
583 our $signature_tags = qr{(?xi:
595 our $tracing_logging_tags = qr{(?xi:
619 sub edit_distance_min {
621 my $len = scalar @arr;
622 if ((scalar @arr) < 1) {
623 # if underflow, return
627 for my $i (0 .. ($len-1)) {
628 if ($arr[$i] < $min) {
635 sub get_edit_distance {
636 my ($str1, $str2) = @_;
641 my $len1 = length($str1);
642 my $len2 = length($str2);
643 # two dimensional array storing minimum edit distance
645 for my $i (0 .. $len1) {
646 for my $j (0 .. $len2) {
648 $distance[$i][$j] = $j;
650 $distance[$i][$j] = $i;
651 } elsif (substr($str1, $i-1, 1) eq substr($str2, $j-1, 1)) {
652 $distance[$i][$j] = $distance[$i - 1][$j - 1];
654 my $dist1 = $distance[$i][$j - 1]; #insert distance
655 my $dist2 = $distance[$i - 1][$j]; # remove
656 my $dist3 = $distance[$i - 1][$j - 1]; #replace
657 $distance[$i][$j] = 1 + edit_distance_min($dist1, $dist2, $dist3);
661 return $distance[$len1][$len2];
664 sub find_standard_signature {
666 my @standard_signature_tags = (
667 'Signed-off-by:', 'Co-developed-by:', 'Acked-by:', 'Tested-by:',
668 'Reviewed-by:', 'Reported-by:', 'Suggested-by:'
670 foreach my $signature (@standard_signature_tags) {
671 return $signature if (get_edit_distance($sign_off, $signature) <= 2);
677 our @typeListMisordered = (
678 qr{char\s+(?:un)?signed},
679 qr{int\s+(?:(?:un)?signed\s+)?short\s},
680 qr{int\s+short(?:\s+(?:un)?signed)},
681 qr{short\s+int(?:\s+(?:un)?signed)},
682 qr{(?:un)?signed\s+int\s+short},
683 qr{short\s+(?:un)?signed},
684 qr{long\s+int\s+(?:un)?signed},
685 qr{int\s+long\s+(?:un)?signed},
686 qr{long\s+(?:un)?signed\s+int},
687 qr{int\s+(?:un)?signed\s+long},
688 qr{int\s+(?:un)?signed},
689 qr{int\s+long\s+long\s+(?:un)?signed},
690 qr{long\s+long\s+int\s+(?:un)?signed},
691 qr{long\s+long\s+(?:un)?signed\s+int},
692 qr{long\s+long\s+(?:un)?signed},
693 qr{long\s+(?:un)?signed},
698 qr{(?:(?:un)?signed\s+)?char},
699 qr{(?:(?:un)?signed\s+)?short\s+int},
700 qr{(?:(?:un)?signed\s+)?short},
701 qr{(?:(?:un)?signed\s+)?int},
702 qr{(?:(?:un)?signed\s+)?long\s+int},
703 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
704 qr{(?:(?:un)?signed\s+)?long\s+long},
705 qr{(?:(?:un)?signed\s+)?long},
714 qr{${Ident}_handler},
715 qr{${Ident}_handler_fn},
719 our $C90_int_types = qr{(?x:
720 long\s+long\s+int\s+(?:un)?signed|
721 long\s+long\s+(?:un)?signed\s+int|
722 long\s+long\s+(?:un)?signed|
723 (?:(?:un)?signed\s+)?long\s+long\s+int|
724 (?:(?:un)?signed\s+)?long\s+long|
725 int\s+long\s+long\s+(?:un)?signed|
726 int\s+(?:(?:un)?signed\s+)?long\s+long|
728 long\s+int\s+(?:un)?signed|
729 long\s+(?:un)?signed\s+int|
730 long\s+(?:un)?signed|
731 (?:(?:un)?signed\s+)?long\s+int|
732 (?:(?:un)?signed\s+)?long|
733 int\s+long\s+(?:un)?signed|
734 int\s+(?:(?:un)?signed\s+)?long|
737 (?:(?:un)?signed\s+)?int
740 our @typeListFile = ();
741 our @typeListWithAttr = (
743 qr{struct\s+$InitAttribute\s+$Ident},
744 qr{union\s+$InitAttribute\s+$Ident},
747 our @modifierList = (
750 our @modifierListFile = ();
752 our @mode_permission_funcs = (
754 ["module_param_(?:array|named|string)", 4],
755 ["module_param_array_named", 5],
756 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
757 ["proc_create(?:_data|)", 2],
758 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
759 ["IIO_DEV_ATTR_[A-Z_]+", 1],
760 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
761 ["SENSOR_TEMPLATE(?:_2|)", 3],
765 my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';
767 #Create a search pattern for all these functions to speed up a loop below
768 our $mode_perms_search = "";
769 foreach my $entry (@mode_permission_funcs) {
770 $mode_perms_search .= '|' if ($mode_perms_search ne "");
771 $mode_perms_search .= $entry->[0];
773 $mode_perms_search = "(?:${mode_perms_search})";
775 our %deprecated_apis = (
776 "synchronize_rcu_bh" => "synchronize_rcu",
777 "synchronize_rcu_bh_expedited" => "synchronize_rcu_expedited",
778 "call_rcu_bh" => "call_rcu",
779 "rcu_barrier_bh" => "rcu_barrier",
780 "synchronize_sched" => "synchronize_rcu",
781 "synchronize_sched_expedited" => "synchronize_rcu_expedited",
782 "call_rcu_sched" => "call_rcu",
783 "rcu_barrier_sched" => "rcu_barrier",
784 "get_state_synchronize_sched" => "get_state_synchronize_rcu",
785 "cond_synchronize_sched" => "cond_synchronize_rcu",
788 #Create a search pattern for all these strings to speed up a loop below
789 our $deprecated_apis_search = "";
790 foreach my $entry (keys %deprecated_apis) {
791 $deprecated_apis_search .= '|' if ($deprecated_apis_search ne "");
792 $deprecated_apis_search .= $entry;
794 $deprecated_apis_search = "(?:${deprecated_apis_search})";
796 our $mode_perms_world_writable = qr{
804 our %mode_permission_string_types = (
823 #Create a search pattern for all these strings to speed up a loop below
824 our $mode_perms_string_search = "";
825 foreach my $entry (keys %mode_permission_string_types) {
826 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
827 $mode_perms_string_search .= $entry;
829 our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
830 our $multi_mode_perms_string_search = qr{
831 ${single_mode_perms_string_search}
832 (?:\s*\|\s*${single_mode_perms_string_search})*
838 return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
845 while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
846 $curpos = pos($string);
849 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
851 $to |= $mode_permission_string_types{$match};
852 $val .= '\s*\|\s*' if ($val ne "");
856 $oval =~ s/^\s*\|\s*//;
857 $oval =~ s/\s*\|\s*$//;
858 return sprintf("%04o", $to);
861 our $allowed_asm_includes = qr{(?x:
867 # memory.h: ARM has a custom one
869 # Load common spelling mistakes and build regular expression list.
873 if (open(my $spelling, '<', $spelling_file)) {
874 while (<$spelling>) {
877 $line =~ s/\s*\n?$//g;
880 next if ($line =~ m/^\s*#/);
881 next if ($line =~ m/^\s*$/);
883 my ($suspect, $fix) = split(/\|\|/, $line);
885 $spelling_fix{$suspect} = $fix;
889 warn "No typos will be found - file '$spelling_file': $!\n";
893 if (open(my $spelling, '<', $codespellfile)) {
894 while (<$spelling>) {
897 $line =~ s/\s*\n?$//g;
900 next if ($line =~ m/^\s*#/);
901 next if ($line =~ m/^\s*$/);
902 next if ($line =~ m/, disabled/i);
906 my ($suspect, $fix) = split(/->/, $line);
908 $spelling_fix{$suspect} = $fix;
912 warn "No codespell typos will be found - file '$codespellfile': $!\n";
916 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
919 my ($wordsRef, $file) = @_;
921 if (open(my $words, '<', $file)) {
925 $line =~ s/\s*\n?$//g;
928 next if ($line =~ m/^\s*#/);
929 next if ($line =~ m/^\s*$/);
931 print("$file: '$line' invalid - ignored\n");
935 $$wordsRef .= '|' if (defined $$wordsRef);
946 if (show_type("CONST_STRUCT")) {
947 read_words(\$const_structs, $conststructsfile)
948 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
951 if (defined($typedefsfile)) {
952 my $typeOtherTypedefs;
953 read_words(\$typeOtherTypedefs, $typedefsfile)
954 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
955 $typeTypedefs .= '|' . $typeOtherTypedefs if (defined $typeOtherTypedefs);
959 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
960 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
961 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
962 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
963 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
969 (?:$Modifier\s+|const\s+)*
971 (?:typeof|__typeof__)\s*\([^\)]*\)|
975 (?:\s+$Modifier|\s+const)*
977 $NonptrTypeMisordered = qr{
978 (?:$Modifier\s+|const\s+)*
982 (?:\s+$Modifier|\s+const)*
984 $NonptrTypeWithAttr = qr{
985 (?:$Modifier\s+|const\s+)*
987 (?:typeof|__typeof__)\s*\([^\)]*\)|
991 (?:\s+$Modifier|\s+const)*
995 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
996 (?:\s+$Inline|\s+$Modifier)*
998 $TypeMisordered = qr{
999 $NonptrTypeMisordered
1000 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
1001 (?:\s+$Inline|\s+$Modifier)*
1003 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
1004 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
1008 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
1010 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
1011 # requires at least perl version v5.10.0
1012 # Any use must be runtime checked with $^V
1014 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
1015 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
1016 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
1018 our $declaration_macros = qr{(?x:
1019 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
1020 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
1021 (?:SKCIPHER_REQUEST|SHASH_DESC|AHASH_REQUEST)_ON_STACK\s*\(
1024 our %allow_repeated_words = (
1031 sub deparenthesize {
1033 return "" if (!defined($string));
1035 while ($string =~ /^\s*\(.*\)\s*$/) {
1036 $string =~ s@^\s*\(\s*@@;
1037 $string =~ s@\s*\)\s*$@@;
1040 $string =~ s@\s+@ @g;
1045 sub seed_camelcase_file {
1048 return if (!(-f $file));
1052 open(my $include_file, '<', "$file")
1053 or warn "$P: Can't read '$file' $!\n";
1054 my $text = <$include_file>;
1055 close($include_file);
1057 my @lines = split('\n', $text);
1059 foreach my $line (@lines) {
1060 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
1061 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
1063 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
1065 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
1071 our %maintained_status = ();
1073 sub is_maintained_obsolete {
1074 my ($filename) = @_;
1076 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
1078 if (!exists($maintained_status{$filename})) {
1079 $maintained_status{$filename} = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
1082 return $maintained_status{$filename} =~ /obsolete/i;
1085 sub is_SPDX_License_valid {
1088 return 1 if (!$tree || which("python3") eq "" || !(-x "$root/scripts/spdxcheck.py") || !(-e "$gitroot"));
1090 my $root_path = abs_path($root);
1091 my $status = `cd "$root_path"; echo "$license" | scripts/spdxcheck.py -`;
1092 return 0 if ($status ne "");
1096 my $camelcase_seeded = 0;
1097 sub seed_camelcase_includes {
1098 return if ($camelcase_seeded);
1101 my $camelcase_cache = "";
1102 my @include_files = ();
1104 $camelcase_seeded = 1;
1106 if (-e "$gitroot") {
1107 my $git_last_include_commit = `${git_command} log --no-merges --pretty=format:"%h%n" -1 -- include`;
1108 chomp $git_last_include_commit;
1109 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
1111 my $last_mod_date = 0;
1112 $files = `find $root/include -name "*.h"`;
1113 @include_files = split('\n', $files);
1114 foreach my $file (@include_files) {
1115 my $date = POSIX::strftime("%Y%m%d%H%M",
1116 localtime((stat $file)[9]));
1117 $last_mod_date = $date if ($last_mod_date < $date);
1119 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
1122 if ($camelcase_cache ne "" && -f $camelcase_cache) {
1123 open(my $camelcase_file, '<', "$camelcase_cache")
1124 or warn "$P: Can't read '$camelcase_cache' $!\n";
1125 while (<$camelcase_file>) {
1129 close($camelcase_file);
1134 if (-e "$gitroot") {
1135 $files = `${git_command} ls-files "include/*.h"`;
1136 @include_files = split('\n', $files);
1139 foreach my $file (@include_files) {
1140 seed_camelcase_file($file);
1143 if ($camelcase_cache ne "") {
1144 unlink glob ".checkpatch-camelcase.*";
1145 open(my $camelcase_file, '>', "$camelcase_cache")
1146 or warn "$P: Can't write '$camelcase_cache' $!\n";
1147 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
1148 print $camelcase_file ("$_\n");
1150 close($camelcase_file);
1154 sub git_is_single_file {
1155 my ($filename) = @_;
1157 return 0 if ((which("git") eq "") || !(-e "$gitroot"));
1159 my $output = `${git_command} ls-files -- $filename 2>/dev/null`;
1160 my $count = $output =~ tr/\n//;
1161 return $count eq 1 && $output =~ m{^${filename}$};
1164 sub git_commit_info {
1165 my ($commit, $id, $desc) = @_;
1167 return ($id, $desc) if ((which("git") eq "") || !(-e "$gitroot"));
1169 my $output = `${git_command} log --no-color --format='%H %s' -1 $commit 2>&1`;
1170 $output =~ s/^\s*//gm;
1171 my @lines = split("\n", $output);
1173 return ($id, $desc) if ($#lines < 0);
1175 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous/) {
1176 # Maybe one day convert this block of bash into something that returns
1177 # all matching commit ids, but it's very slow...
1179 # echo "checking commits $1..."
1180 # git rev-list --remotes | grep -i "^$1" |
1181 # while read line ; do
1182 # git log --format='%H %s' -1 $line |
1183 # echo "commit $(cut -c 1-12,41-)"
1185 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./ ||
1186 $lines[0] =~ /^fatal: bad object $commit/) {
1189 $id = substr($lines[0], 0, 12);
1190 $desc = substr($lines[0], 41);
1193 return ($id, $desc);
1196 $chk_signoff = 0 if ($file);
1201 my @fixed_inserted = ();
1202 my @fixed_deleted = ();
1205 # If input is git commits, extract all commits from the commit expressions.
1206 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
1207 die "$P: No git repository found\n" if ($git && !-e "$gitroot");
1211 foreach my $commit_expr (@ARGV) {
1213 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
1214 $git_range = "-$2 $1";
1215 } elsif ($commit_expr =~ m/\.\./) {
1216 $git_range = "$commit_expr";
1218 $git_range = "-1 $commit_expr";
1220 my $lines = `${git_command} log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
1221 foreach my $line (split(/\n/, $lines)) {
1222 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
1223 next if (!defined($1) || !defined($2));
1226 unshift(@commits, $sha1);
1227 $git_commits{$sha1} = $subject;
1230 die "$P: no git commits after extraction!\n" if (@commits == 0);
1235 $allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
1236 for my $filename (@ARGV) {
1238 my $is_git_file = git_is_single_file($filename);
1239 my $oldfile = $file;
1240 $file = 1 if ($is_git_file);
1242 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
1243 die "$P: $filename: git format-patch failed - $!\n";
1245 open($FILE, '-|', "diff -u /dev/null $filename") ||
1246 die "$P: $filename: diff failed - $!\n";
1247 } elsif ($filename eq '-') {
1248 open($FILE, '<&STDIN');
1250 open($FILE, '<', "$filename") ||
1251 die "$P: $filename: open failed - $!\n";
1253 if ($filename eq '-') {
1254 $vname = 'Your patch';
1256 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1262 push(@rawlines, $_);
1263 $vname = qq("$1") if ($filename eq '-' && $_ =~ m/^Subject:\s+(.+)/i);
1267 if ($#ARGV > 0 && $quiet == 0) {
1268 print '-' x length($vname) . "\n";
1270 print '-' x length($vname) . "\n";
1273 if (!process($filename)) {
1279 @fixed_inserted = ();
1280 @fixed_deleted = ();
1282 @modifierListFile = ();
1285 $file = $oldfile if ($is_git_file);
1289 hash_show_words(\%use_type, "Used");
1290 hash_show_words(\%ignore_type, "Ignored");
1292 if (!$perl_version_ok) {
1295 NOTE: perl $^V is not modern enough to detect all possible issues.
1296 An upgrade to at least perl $minimum_perl_version is suggested.
1302 NOTE: If any of the errors are false positives, please report
1303 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1310 sub top_of_kernel_tree {
1314 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1315 "README", "Documentation", "arch", "include", "drivers",
1316 "fs", "init", "ipc", "kernel", "lib", "scripts",
1319 foreach my $check (@tree_check) {
1320 if (! -e $root . '/' . $check) {
1328 my ($formatted_email) = @_;
1332 my $name_comment = "";
1336 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1339 $comment = $3 if defined $3;
1340 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1342 $comment = $2 if defined $2;
1343 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1345 $comment = $2 if defined $2;
1346 $formatted_email =~ s/\Q$address\E.*$//;
1347 $name = $formatted_email;
1348 $name = trim($name);
1349 $name =~ s/^\"|\"$//g;
1350 # If there's a name left after stripping spaces and
1351 # leading quotes, and the address doesn't have both
1352 # leading and trailing angle brackets, the address
1354 # "joe smith joe@smith.com" bad
1355 # "joe smith <joe@smith.com" bad
1356 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1363 # Extract comments from names excluding quoted parts
1364 # "John D. (Doe)" - Do not extract
1365 if ($name =~ s/\"(.+)\"//) {
1368 while ($name =~ s/\s*($balanced_parens)\s*/ /) {
1369 $name_comment .= trim($1);
1371 $name =~ s/^[ \"]+|[ \"]+$//g;
1372 $name = trim("$quoted $name");
1374 $address = trim($address);
1375 $address =~ s/^\<|\>$//g;
1376 $comment = trim($comment);
1378 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1379 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1380 $name = "\"$name\"";
1383 return ($name, $name_comment, $address, $comment);
1387 my ($name, $name_comment, $address, $comment) = @_;
1389 my $formatted_email;
1391 $name =~ s/^[ \"]+|[ \"]+$//g;
1392 $address = trim($address);
1393 $address =~ s/(?:\.|\,|\")+$//; ##trailing commas, dots or quotes
1395 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1396 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1397 $name = "\"$name\"";
1400 $name_comment = trim($name_comment);
1401 $name_comment = " $name_comment" if ($name_comment ne "");
1402 $comment = trim($comment);
1403 $comment = " $comment" if ($comment ne "");
1405 if ("$name" eq "") {
1406 $formatted_email = "$address";
1408 $formatted_email = "$name$name_comment <$address>";
1410 $formatted_email .= "$comment";
1411 return $formatted_email;
1414 sub reformat_email {
1417 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
1418 return format_email($email_name, $name_comment, $email_address, $comment);
1421 sub same_email_addresses {
1422 my ($email1, $email2) = @_;
1424 my ($email1_name, $name1_comment, $email1_address, $comment1) = parse_email($email1);
1425 my ($email2_name, $name2_comment, $email2_address, $comment2) = parse_email($email2);
1427 return $email1_name eq $email2_name &&
1428 $email1_address eq $email2_address &&
1429 $name1_comment eq $name2_comment &&
1430 $comment1 eq $comment2;
1436 foreach my $path (split(/:/, $ENV{PATH})) {
1437 if (-e "$path/$bin") {
1438 return "$path/$bin";
1448 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1449 if (-e "$path/$conf") {
1450 return "$path/$conf";
1462 for my $c (split(//, $str)) {
1466 for (; ($n % $tabsize) != 0; $n++) {
1478 (my $res = shift) =~ tr/\t/ /c;
1485 # Drop the diff line leader and expand tabs
1487 $line = expand_tabs($line);
1489 # Pick the indent from the front of the line.
1490 my ($white) = ($line =~ /^(\s*)/);
1492 return (length($line), length($white));
1495 my $sanitise_quote = '';
1497 sub sanitise_line_reset {
1498 my ($in_comment) = @_;
1501 $sanitise_quote = '*/';
1503 $sanitise_quote = '';
1516 # Always copy over the diff marker.
1517 $res = substr($line, 0, 1);
1519 for ($off = 1; $off < length($line); $off++) {
1520 $c = substr($line, $off, 1);
1522 # Comments we are whacking completely including the begin
1523 # and end, all to $;.
1524 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1525 $sanitise_quote = '*/';
1527 substr($res, $off, 2, "$;$;");
1531 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1532 $sanitise_quote = '';
1533 substr($res, $off, 2, "$;$;");
1537 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1538 $sanitise_quote = '//';
1540 substr($res, $off, 2, $sanitise_quote);
1545 # A \ in a string means ignore the next character.
1546 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1548 substr($res, $off, 2, 'XX');
1553 if ($c eq "'" || $c eq '"') {
1554 if ($sanitise_quote eq '') {
1555 $sanitise_quote = $c;
1557 substr($res, $off, 1, $c);
1559 } elsif ($sanitise_quote eq $c) {
1560 $sanitise_quote = '';
1564 #print "c<$c> SQ<$sanitise_quote>\n";
1565 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1566 substr($res, $off, 1, $;);
1567 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1568 substr($res, $off, 1, $;);
1569 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1570 substr($res, $off, 1, 'X');
1572 substr($res, $off, 1, $c);
1576 if ($sanitise_quote eq '//') {
1577 $sanitise_quote = '';
1580 # The pathname on a #include may be surrounded by '<' and '>'.
1581 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1582 my $clean = 'X' x length($1);
1583 $res =~ s@\<.*\>@<$clean>@;
1585 # The whole of a #error is a string.
1586 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1587 my $clean = 'X' x length($1);
1588 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1591 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1593 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1599 sub get_quoted_string {
1600 my ($line, $rawline) = @_;
1602 return "" if (!defined($line) || !defined($rawline));
1603 return "" if ($line !~ m/($String)/g);
1604 return substr($rawline, $-[0], $+[0] - $-[0]);
1607 sub ctx_statement_block {
1608 my ($linenr, $remain, $off) = @_;
1609 my $line = $linenr - 1;
1612 my $coff = $off - 1;
1626 @stack = (['', 0]) if ($#stack == -1);
1628 #warn "CSB: blk<$blk> remain<$remain>\n";
1629 # If we are about to drop off the end, pull in more
1632 for (; $remain > 0; $line++) {
1633 last if (!defined $lines[$line]);
1634 next if ($lines[$line] =~ /^-/);
1637 $blk .= $lines[$line] . "\n";
1638 $len = length($blk);
1642 # Bail if there is no further context.
1643 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1647 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1653 $c = substr($blk, $off, 1);
1654 $remainder = substr($blk, $off);
1656 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1658 # Handle nested #if/#else.
1659 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1660 push(@stack, [ $type, $level ]);
1661 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1662 ($type, $level) = @{$stack[$#stack - 1]};
1663 } elsif ($remainder =~ /^#\s*endif\b/) {
1664 ($type, $level) = @{pop(@stack)};
1667 # Statement ends at the ';' or a close '}' at the
1669 if ($level == 0 && $c eq ';') {
1673 # An else is really a conditional as long as its not else if
1674 if ($level == 0 && $coff_set == 0 &&
1675 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1676 $remainder =~ /^(else)(?:\s|{)/ &&
1677 $remainder !~ /^else\s+if\b/) {
1678 $coff = $off + length($1) - 1;
1680 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1681 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1684 if (($type eq '' || $type eq '(') && $c eq '(') {
1688 if ($type eq '(' && $c eq ')') {
1690 $type = ($level != 0)? '(' : '';
1692 if ($level == 0 && $coff < $soff) {
1695 #warn "CSB: mark coff<$coff>\n";
1698 if (($type eq '' || $type eq '{') && $c eq '{') {
1702 if ($type eq '{' && $c eq '}') {
1704 $type = ($level != 0)? '{' : '';
1707 if (substr($blk, $off + 1, 1) eq ';') {
1713 # Preprocessor commands end at the newline unless escaped.
1714 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1722 # We are truly at the end, so shuffle to the next line.
1729 my $statement = substr($blk, $soff, $off - $soff + 1);
1730 my $condition = substr($blk, $soff, $coff - $soff + 1);
1732 #warn "STATEMENT<$statement>\n";
1733 #warn "CONDITION<$condition>\n";
1735 #print "coff<$coff> soff<$off> loff<$loff>\n";
1737 return ($statement, $condition,
1738 $line, $remain + 1, $off - $loff + 1, $level);
1741 sub statement_lines {
1744 # Strip the diff line prefixes and rip blank lines at start and end.
1745 $stmt =~ s/(^|\n)./$1/g;
1749 my @stmt_lines = ($stmt =~ /\n/g);
1751 return $#stmt_lines + 2;
1754 sub statement_rawlines {
1757 my @stmt_lines = ($stmt =~ /\n/g);
1759 return $#stmt_lines + 2;
1762 sub statement_block_size {
1765 $stmt =~ s/(^|\n)./$1/g;
1771 my @stmt_lines = ($stmt =~ /\n/g);
1772 my @stmt_statements = ($stmt =~ /;/g);
1774 my $stmt_lines = $#stmt_lines + 2;
1775 my $stmt_statements = $#stmt_statements + 1;
1777 if ($stmt_lines > $stmt_statements) {
1780 return $stmt_statements;
1784 sub ctx_statement_full {
1785 my ($linenr, $remain, $off) = @_;
1786 my ($statement, $condition, $level);
1790 # Grab the first conditional/block pair.
1791 ($statement, $condition, $linenr, $remain, $off, $level) =
1792 ctx_statement_block($linenr, $remain, $off);
1793 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1794 push(@chunks, [ $condition, $statement ]);
1795 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1796 return ($level, $linenr, @chunks);
1799 # Pull in the following conditional/block pairs and see if they
1800 # could continue the statement.
1802 ($statement, $condition, $linenr, $remain, $off, $level) =
1803 ctx_statement_block($linenr, $remain, $off);
1804 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1805 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1807 push(@chunks, [ $condition, $statement ]);
1810 return ($level, $linenr, @chunks);
1814 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1816 my $start = $linenr - 1;
1823 my @stack = ($level);
1824 for ($line = $start; $remain > 0; $line++) {
1825 next if ($rawlines[$line] =~ /^-/);
1828 $blk .= $rawlines[$line];
1830 # Handle nested #if/#else.
1831 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1832 push(@stack, $level);
1833 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1834 $level = $stack[$#stack - 1];
1835 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1836 $level = pop(@stack);
1839 foreach my $c (split(//, $lines[$line])) {
1840 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1846 if ($c eq $close && $level > 0) {
1848 last if ($level == 0);
1849 } elsif ($c eq $open) {
1854 if (!$outer || $level <= 1) {
1855 push(@res, $rawlines[$line]);
1858 last if ($level == 0);
1861 return ($level, @res);
1863 sub ctx_block_outer {
1864 my ($linenr, $remain) = @_;
1866 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1870 my ($linenr, $remain) = @_;
1872 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1876 my ($linenr, $remain, $off) = @_;
1878 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1881 sub ctx_block_level {
1882 my ($linenr, $remain) = @_;
1884 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1886 sub ctx_statement_level {
1887 my ($linenr, $remain, $off) = @_;
1889 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1892 sub ctx_locate_comment {
1893 my ($first_line, $end_line) = @_;
1895 # If c99 comment on the current line, or the line before or after
1896 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@^\+.*(//.*$)@);
1897 return $current_comment if (defined $current_comment);
1898 ($current_comment) = ($rawlines[$end_line - 2] =~ m@^[\+ ].*(//.*$)@);
1899 return $current_comment if (defined $current_comment);
1900 ($current_comment) = ($rawlines[$end_line] =~ m@^[\+ ].*(//.*$)@);
1901 return $current_comment if (defined $current_comment);
1903 # Catch a comment on the end of the line itself.
1904 ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1905 return $current_comment if (defined $current_comment);
1907 # Look through the context and try and figure out if there is a
1910 $current_comment = '';
1911 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1912 my $line = $rawlines[$linenr - 1];
1914 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1917 if ($line =~ m@/\*@) {
1920 if (!$in_comment && $current_comment ne '') {
1921 $current_comment = '';
1923 $current_comment .= $line . "\n" if ($in_comment);
1924 if ($line =~ m@\*/@) {
1929 chomp($current_comment);
1930 return($current_comment);
1932 sub ctx_has_comment {
1933 my ($first_line, $end_line) = @_;
1934 my $cmt = ctx_locate_comment($first_line, $end_line);
1936 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1937 ##print "CMMT: $cmt\n";
1939 return ($cmt ne '');
1943 my ($linenr, $cnt) = @_;
1945 my $offset = $linenr - 1;
1950 $line = $rawlines[$offset++];
1951 next if (defined($line) && $line =~ /^-/);
1959 my ($linenr, $lc) = @_;
1961 my $stat_real = raw_line($linenr, 0);
1962 for (my $count = $linenr + 1; $count <= $lc; $count++) {
1963 $stat_real = $stat_real . "\n" . raw_line($count, 0);
1970 my ($linenr, $cnt, $here) = @_;
1972 my $herectx = $here . "\n";
1973 for (my $n = 0; $n < $cnt; $n++) {
1974 $herectx .= raw_line($linenr, $n) . "\n";
1985 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1988 $coded = sprintf("^%c", unpack('C', $2) + 64);
1997 my $av_preprocessor = 0;
2002 sub annotate_reset {
2003 $av_preprocessor = 0;
2005 @av_paren_type = ('E');
2006 $av_pend_colon = 'O';
2009 sub annotate_values {
2010 my ($stream, $type) = @_;
2013 my $var = '_' x length($stream);
2016 print "$stream\n" if ($dbg_values > 1);
2018 while (length($cur)) {
2019 @av_paren_type = ('E') if ($#av_paren_type < 0);
2020 print " <" . join('', @av_paren_type) .
2021 "> <$type> <$av_pending>" if ($dbg_values > 1);
2022 if ($cur =~ /^(\s+)/o) {
2023 print "WS($1)\n" if ($dbg_values > 1);
2024 if ($1 =~ /\n/ && $av_preprocessor) {
2025 $type = pop(@av_paren_type);
2026 $av_preprocessor = 0;
2029 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
2030 print "CAST($1)\n" if ($dbg_values > 1);
2031 push(@av_paren_type, $type);
2034 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
2035 print "DECLARE($1)\n" if ($dbg_values > 1);
2038 } elsif ($cur =~ /^($Modifier)\s*/) {
2039 print "MODIFIER($1)\n" if ($dbg_values > 1);
2042 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
2043 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
2044 $av_preprocessor = 1;
2045 push(@av_paren_type, $type);
2051 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
2052 print "UNDEF($1)\n" if ($dbg_values > 1);
2053 $av_preprocessor = 1;
2054 push(@av_paren_type, $type);
2056 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
2057 print "PRE_START($1)\n" if ($dbg_values > 1);
2058 $av_preprocessor = 1;
2060 push(@av_paren_type, $type);
2061 push(@av_paren_type, $type);
2064 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
2065 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
2066 $av_preprocessor = 1;
2068 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
2072 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
2073 print "PRE_END($1)\n" if ($dbg_values > 1);
2075 $av_preprocessor = 1;
2077 # Assume all arms of the conditional end as this
2078 # one does, and continue as if the #endif was not here.
2079 pop(@av_paren_type);
2080 push(@av_paren_type, $type);
2083 } elsif ($cur =~ /^(\\\n)/o) {
2084 print "PRECONT($1)\n" if ($dbg_values > 1);
2086 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
2087 print "ATTR($1)\n" if ($dbg_values > 1);
2088 $av_pending = $type;
2091 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
2092 print "SIZEOF($1)\n" if ($dbg_values > 1);
2098 } elsif ($cur =~ /^(if|while|for)\b/o) {
2099 print "COND($1)\n" if ($dbg_values > 1);
2103 } elsif ($cur =~/^(case)/o) {
2104 print "CASE($1)\n" if ($dbg_values > 1);
2105 $av_pend_colon = 'C';
2108 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
2109 print "KEYWORD($1)\n" if ($dbg_values > 1);
2112 } elsif ($cur =~ /^(\()/o) {
2113 print "PAREN('$1')\n" if ($dbg_values > 1);
2114 push(@av_paren_type, $av_pending);
2118 } elsif ($cur =~ /^(\))/o) {
2119 my $new_type = pop(@av_paren_type);
2120 if ($new_type ne '_') {
2122 print "PAREN('$1') -> $type\n"
2123 if ($dbg_values > 1);
2125 print "PAREN('$1')\n" if ($dbg_values > 1);
2128 } elsif ($cur =~ /^($Ident)\s*\(/o) {
2129 print "FUNC($1)\n" if ($dbg_values > 1);
2133 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
2134 if (defined $2 && $type eq 'C' || $type eq 'T') {
2135 $av_pend_colon = 'B';
2136 } elsif ($type eq 'E') {
2137 $av_pend_colon = 'L';
2139 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
2142 } elsif ($cur =~ /^($Ident|$Constant)/o) {
2143 print "IDENT($1)\n" if ($dbg_values > 1);
2146 } elsif ($cur =~ /^($Assignment)/o) {
2147 print "ASSIGN($1)\n" if ($dbg_values > 1);
2150 } elsif ($cur =~/^(;|{|})/) {
2151 print "END($1)\n" if ($dbg_values > 1);
2153 $av_pend_colon = 'O';
2155 } elsif ($cur =~/^(,)/) {
2156 print "COMMA($1)\n" if ($dbg_values > 1);
2159 } elsif ($cur =~ /^(\?)/o) {
2160 print "QUESTION($1)\n" if ($dbg_values > 1);
2163 } elsif ($cur =~ /^(:)/o) {
2164 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
2166 substr($var, length($res), 1, $av_pend_colon);
2167 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
2172 $av_pend_colon = 'O';
2174 } elsif ($cur =~ /^(\[)/o) {
2175 print "CLOSE($1)\n" if ($dbg_values > 1);
2178 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
2181 print "OPV($1)\n" if ($dbg_values > 1);
2188 substr($var, length($res), 1, $variant);
2191 } elsif ($cur =~ /^($Operators)/o) {
2192 print "OP($1)\n" if ($dbg_values > 1);
2193 if ($1 ne '++' && $1 ne '--') {
2197 } elsif ($cur =~ /(^.)/o) {
2198 print "C($1)\n" if ($dbg_values > 1);
2201 $cur = substr($cur, length($1));
2202 $res .= $type x length($1);
2206 return ($res, $var);
2210 my ($possible, $line) = @_;
2211 my $notPermitted = qr{(?:
2228 ^(?:typedef|struct|enum)\b
2230 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
2231 if ($possible !~ $notPermitted) {
2232 # Check for modifiers.
2233 $possible =~ s/\s*$Storage\s*//g;
2234 $possible =~ s/\s*$Sparse\s*//g;
2235 if ($possible =~ /^\s*$/) {
2237 } elsif ($possible =~ /\s/) {
2238 $possible =~ s/\s*$Type\s*//g;
2239 for my $modifier (split(' ', $possible)) {
2240 if ($modifier !~ $notPermitted) {
2241 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
2242 push(@modifierListFile, $modifier);
2247 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
2248 push(@typeListFile, $possible);
2252 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
2261 $type =~ tr/[a-z]/[A-Z]/;
2263 return defined $use_type{$type} if (scalar keys %use_type > 0);
2265 return !defined $ignore_type{$type};
2269 my ($level, $type, $msg) = @_;
2271 if (!show_type($type) ||
2272 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
2277 if ($level eq 'ERROR') {
2279 } elsif ($level eq 'WARNING') {
2285 $output .= $prefix . $level . ':';
2287 $output .= BLUE if ($color);
2288 $output .= "$type:";
2290 $output .= RESET if ($color);
2291 $output .= ' ' . $msg . "\n";
2294 my @lines = split("\n", $output, -1);
2295 splice(@lines, 1, 1);
2296 $output = join("\n", @lines);
2300 $output = (split('\n', $output))[0] . "\n";
2303 if ($verbose && exists($verbose_messages{$type}) &&
2304 !exists($verbose_emitted{$type})) {
2305 $output .= $verbose_messages{$type} . "\n\n";
2306 $verbose_emitted{$type} = 1;
2309 push(our @report, $output);
2318 sub fixup_current_range {
2319 my ($lineRef, $offset, $length) = @_;
2321 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2324 my $no = $o + $offset;
2325 my $nl = $l + $length;
2326 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2330 sub fix_inserted_deleted_lines {
2331 my ($linesRef, $insertedRef, $deletedRef) = @_;
2333 my $range_last_linenr = 0;
2334 my $delta_offset = 0;
2339 my $next_insert = 0;
2340 my $next_delete = 0;
2344 my $inserted = @{$insertedRef}[$next_insert++];
2345 my $deleted = @{$deletedRef}[$next_delete++];
2347 foreach my $old_line (@{$linesRef}) {
2349 my $line = $old_line; #don't modify the array
2350 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
2352 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2353 $range_last_linenr = $new_linenr;
2354 fixup_current_range(\$line, $delta_offset, 0);
2357 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2358 $deleted = @{$deletedRef}[$next_delete++];
2360 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2363 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2364 push(@lines, ${$inserted}{'LINE'});
2365 $inserted = @{$insertedRef}[$next_insert++];
2367 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2371 push(@lines, $line);
2381 sub fix_insert_line {
2382 my ($linenr, $line) = @_;
2388 push(@fixed_inserted, $inserted);
2391 sub fix_delete_line {
2392 my ($linenr, $line) = @_;
2399 push(@fixed_deleted, $deleted);
2403 my ($type, $msg) = @_;
2405 if (report("ERROR", $type, $msg)) {
2413 my ($type, $msg) = @_;
2415 if (report("WARNING", $type, $msg)) {
2423 my ($type, $msg) = @_;
2425 if ($check && report("CHECK", $type, $msg)) {
2433 sub check_absolute_file {
2434 my ($absolute, $herecurr) = @_;
2435 my $file = $absolute;
2437 ##print "absolute<$absolute>\n";
2439 # See if any suffix of this path is a path within the tree.
2440 while ($file =~ s@^[^/]*/@@) {
2441 if (-f "$root/$file") {
2442 ##print "file<$file>\n";
2450 # It is, so see if the prefix is acceptable.
2451 my $prefix = $absolute;
2452 substr($prefix, -length($file)) = '';
2454 ##print "prefix<$prefix>\n";
2455 if ($prefix ne ".../") {
2456 WARN("USE_RELATIVE_PATH",
2457 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2464 $string =~ s/^\s+|\s+$//g;
2472 $string =~ s/^\s+//;
2480 $string =~ s/\s+$//;
2485 sub string_find_replace {
2486 my ($string, $find, $replace) = @_;
2488 $string =~ s/$find/$replace/g;
2496 my $source_indent = $tabsize;
2497 my $max_spaces_before_tab = $source_indent - 1;
2498 my $spaces_to_tab = " " x $source_indent;
2500 #convert leading spaces to tabs
2501 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2502 #Remove spaces before a tab
2503 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2508 sub pos_last_openparen {
2513 my $opens = $line =~ tr/\(/\(/;
2514 my $closes = $line =~ tr/\)/\)/;
2516 my $last_openparen = 0;
2518 if (($opens == 0) || ($closes >= $opens)) {
2522 my $len = length($line);
2524 for ($pos = 0; $pos < $len; $pos++) {
2525 my $string = substr($line, $pos);
2526 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2527 $pos += length($1) - 1;
2528 } elsif (substr($line, $pos, 1) eq '(') {
2529 $last_openparen = $pos;
2530 } elsif (index($string, '(') == -1) {
2535 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2538 sub get_raw_comment {
2539 my ($line, $rawline) = @_;
2542 for my $i (0 .. (length($line) - 1)) {
2543 if (substr($line, $i, 1) eq "$;") {
2544 $comment .= substr($rawline, $i, 1);
2551 sub exclude_global_initialisers {
2552 my ($realfile) = @_;
2554 # Do not check for BPF programs (tools/testing/selftests/bpf/progs/*.c, samples/bpf/*_kern.c, *.bpf.c).
2555 return $realfile =~ m@^tools/testing/selftests/bpf/progs/.*\.c$@ ||
2556 $realfile =~ m@^samples/bpf/.*_kern\.c$@ ||
2557 $realfile =~ m@/bpf/.*\.bpf\.c$@;
2561 my $filename = shift;
2567 my $stashrawline="";
2577 my $authorsignoff = 0;
2578 my $author_sob = '';
2580 my $is_binding_patch = -1;
2581 my $in_header_lines = $file ? 0 : 1;
2582 my $in_commit_log = 0; #Scanning lines before patch
2583 my $has_patch_separator = 0; #Found a --- line
2584 my $has_commit_log = 0; #Encountered lines before patch
2585 my $commit_log_lines = 0; #Number of commit log lines
2586 my $commit_log_possible_stack_dump = 0;
2587 my $commit_log_long_line = 0;
2588 my $commit_log_has_diff = 0;
2589 my $reported_maintainer_file = 0;
2590 my $non_utf8_charset = 0;
2592 my $last_git_commit_id_linenr = -1;
2594 my $last_blank_line = 0;
2595 my $last_coalesced_string_linenr = -1;
2603 # Trace the real file/line as we go.
2608 my $context_function; #undef'd unless there's a known function
2610 my $comment_edge = 0;
2614 my $prev_values = 'E';
2617 my %suppress_ifbraces;
2618 my %suppress_whiletrailers;
2619 my %suppress_export;
2620 my $suppress_statement = 0;
2622 my %signatures = ();
2624 # Pre-scan the patch sanitizing the lines.
2625 # Pre-scan the patch looking for any __setup documentation.
2627 my @setup_docs = ();
2630 my $camelcase_file_seeded = 0;
2632 my $checklicenseline = 1;
2634 sanitise_line_reset();
2636 foreach my $rawline (@rawlines) {
2640 push(@fixed, $rawline) if ($fix);
2642 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2644 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.txt$@) {
2649 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2658 # Guestimate if this is a continuing comment. Run
2659 # the context looking for a comment "edge". If this
2660 # edge is a close comment then we must be in a comment
2664 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2665 next if (defined $rawlines[$ln - 1] &&
2666 $rawlines[$ln - 1] =~ /^-/);
2668 #print "RAW<$rawlines[$ln - 1]>\n";
2669 last if (!defined $rawlines[$ln - 1]);
2670 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2671 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2676 if (defined $edge && $edge eq '*/') {
2680 # Guestimate if this is a continuing comment. If this
2681 # is the start of a diff block and this line starts
2682 # ' *' then it is very likely a comment.
2683 if (!defined $edge &&
2684 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2689 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2690 sanitise_line_reset($in_comment);
2692 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2693 # Standardise the strings and chars within the input to
2694 # simplify matching -- only bother with positive lines.
2695 $line = sanitise_line($rawline);
2697 push(@lines, $line);
2700 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2705 #print "==>$rawline\n";
2706 #print "-->$line\n";
2708 if ($setup_docs && $line =~ /^\+/) {
2709 push(@setup_docs, $line);
2718 foreach my $line (@lines) {
2721 my $sline = $line; #copy of $line
2722 $sline =~ s/$;/ /g; #with comments as spaces
2724 my $rawline = $rawlines[$linenr - 1];
2725 my $raw_comment = get_raw_comment($line, $rawline);
2727 # check if it's a mode change, rename or start of a patch
2728 if (!$in_commit_log &&
2729 ($line =~ /^ mode change [0-7]+ => [0-7]+ \S+\s*$/ ||
2730 ($line =~ /^rename (?:from|to) \S+\s*$/ ||
2731 $line =~ /^diff --git a\/[\w\/\.\_\-]+ b\/\S+\s*$/))) {
2735 #extract the line range in the file after the patch is applied
2736 if (!$in_commit_log &&
2737 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2740 $first_line = $linenr + 1;
2750 %suppress_ifbraces = ();
2751 %suppress_whiletrailers = ();
2752 %suppress_export = ();
2753 $suppress_statement = 0;
2754 if ($context =~ /\b(\w+)\s*\(/) {
2755 $context_function = $1;
2757 undef $context_function;
2761 # track the line number as we move through the hunk, note that
2762 # new versions of GNU diff omit the leading space on completely
2763 # blank context lines so we need to count that too.
2764 } elsif ($line =~ /^( |\+|$)/) {
2766 $realcnt-- if ($realcnt != 0);
2768 # Measure the line length and indent.
2769 ($length, $indent) = line_stats($rawline);
2771 # Track the previous line.
2772 ($prevline, $stashline) = ($stashline, $line);
2773 ($previndent, $stashindent) = ($stashindent, $indent);
2774 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2776 #warn "line<$line>\n";
2778 } elsif ($realcnt == 1) {
2782 my $hunk_line = ($realcnt != 0);
2784 $here = "#$linenr: " if (!$file);
2785 $here = "#$realline: " if ($file);
2788 # extract the filename as it passes
2789 if ($line =~ /^diff --git.*?(\S+)$/) {
2791 $realfile =~ s@^([^/]*)/@@ if (!$file);
2794 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2796 $realfile =~ s@^([^/]*)/@@ if (!$file);
2800 if (!$file && $tree && $p1_prefix ne '' &&
2801 -e "$root/$p1_prefix") {
2802 WARN("PATCH_PREFIX",
2803 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2806 if ($realfile =~ m@^include/asm/@) {
2807 ERROR("MODIFIED_INCLUDE_ASM",
2808 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2813 #make up the handle for any error we report on this line
2815 $prefix = "$realfile:$realline: "
2818 $prefix = "$filename:$realline: ";
2820 $prefix = "$filename:$linenr: ";
2825 if (is_maintained_obsolete($realfile)) {
2827 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2829 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2832 $check = $check_orig;
2834 $checklicenseline = 1;
2836 if ($realfile !~ /^MAINTAINERS/) {
2837 my $last_binding_patch = $is_binding_patch;
2839 $is_binding_patch = () = $realfile =~ m@^(?:Documentation/devicetree/|include/dt-bindings/)@;
2841 if (($last_binding_patch != -1) &&
2842 ($last_binding_patch ^ $is_binding_patch)) {
2843 WARN("DT_SPLIT_BINDING_PATCH",
2844 "DT binding docs and includes should be a separate patch. See: Documentation/devicetree/bindings/submitting-patches.rst\n");
2851 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2853 my $hereline = "$here\n$rawline\n";
2854 my $herecurr = "$here\n$rawline\n";
2855 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2857 $cnt_lines++ if ($realcnt != 0);
2859 # Verify the existence of a commit log if appropriate
2860 # 2 is used because a $signature is counted in $commit_log_lines
2861 if ($in_commit_log) {
2862 if ($line !~ /^\s*$/) {
2863 $commit_log_lines++; #could be a $signature
2865 } elsif ($has_commit_log && $commit_log_lines < 2) {
2866 WARN("COMMIT_MESSAGE",
2867 "Missing commit description - Add an appropriate one\n");
2868 $commit_log_lines = 2; #warn only once
2871 # Check if the commit log has what seems like a diff which can confuse patch
2872 if ($in_commit_log && !$commit_log_has_diff &&
2873 (($line =~ m@^\s+diff\b.*a/([\w/]+)@ &&
2874 $line =~ m@^\s+diff\b.*a/[\w/]+\s+b/$1\b@) ||
2875 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2876 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2877 ERROR("DIFF_IN_COMMIT_MSG",
2878 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2879 $commit_log_has_diff = 1;
2882 # Check for incorrect file permissions
2883 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2884 my $permhere = $here . "FILE: $realfile\n";
2885 if ($realfile !~ m@scripts/@ &&
2886 $realfile !~ /\.(py|pl|awk|sh)$/) {
2887 ERROR("EXECUTE_PERMISSIONS",
2888 "do not set execute permissions for source files\n" . $permhere);
2892 # Check the patch for a From:
2893 if (decode("MIME-Header", $line) =~ /^From:\s*(.*)/) {
2895 my $curline = $linenr;
2896 while(defined($rawlines[$curline]) && ($rawlines[$curline++] =~ /^[ \t]\s*(.*)/)) {
2899 $author = encode("utf8", $author) if ($line =~ /=\?utf-8\?/i);
2901 $author = reformat_email($author);
2904 # Check the patch for a signoff:
2905 if ($line =~ /^\s*signed-off-by:\s*(.*)/i) {
2908 if ($author ne '' && $authorsignoff != 1) {
2909 if (same_email_addresses($1, $author)) {
2913 my ($email_name, $email_comment, $email_address, $comment1) = parse_email($ctx);
2914 my ($author_name, $author_comment, $author_address, $comment2) = parse_email($author);
2916 if (lc $email_address eq lc $author_address && $email_name eq $author_name) {
2919 } elsif (lc $email_address eq lc $author_address) {
2922 } elsif ($email_name eq $author_name) {
2926 my $address1 = $email_address;
2927 my $address2 = $author_address;
2929 if ($address1 =~ /(\S+)\+\S+(\@.*)/) {
2932 if ($address2 =~ /(\S+)\+\S+(\@.*)/) {
2935 if ($address1 eq $address2) {
2943 # Check for patch separator
2944 if ($line =~ /^---$/) {
2945 $has_patch_separator = 1;
2949 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2950 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2951 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2952 $reported_maintainer_file = 1;
2955 # Check signature styles
2956 if (!$in_header_lines &&
2957 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2958 my $space_before = $1;
2960 my $space_after = $3;
2962 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2964 if ($sign_off !~ /$signature_tags/) {
2965 my $suggested_signature = find_standard_signature($sign_off);
2966 if ($suggested_signature eq "") {
2967 WARN("BAD_SIGN_OFF",
2968 "Non-standard signature: $sign_off\n" . $herecurr);
2970 if (WARN("BAD_SIGN_OFF",
2971 "Non-standard signature: '$sign_off' - perhaps '$suggested_signature'?\n" . $herecurr) &&
2973 $fixed[$fixlinenr] =~ s/$sign_off/$suggested_signature/;
2977 if (defined $space_before && $space_before ne "") {
2978 if (WARN("BAD_SIGN_OFF",
2979 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2981 $fixed[$fixlinenr] =
2982 "$ucfirst_sign_off $email";
2985 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2986 if (WARN("BAD_SIGN_OFF",
2987 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2989 $fixed[$fixlinenr] =
2990 "$ucfirst_sign_off $email";
2994 if (!defined $space_after || $space_after ne " ") {
2995 if (WARN("BAD_SIGN_OFF",
2996 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2998 $fixed[$fixlinenr] =
2999 "$ucfirst_sign_off $email";
3003 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
3004 my $suggested_email = format_email(($email_name, $name_comment, $email_address, $comment));
3005 if ($suggested_email eq "") {
3006 ERROR("BAD_SIGN_OFF",
3007 "Unrecognized email address: '$email'\n" . $herecurr);
3009 my $dequoted = $suggested_email;
3010 $dequoted =~ s/^"//;
3011 $dequoted =~ s/" </ </;
3012 # Don't force email to have quotes
3013 # Allow just an angle bracketed address
3014 if (!same_email_addresses($email, $suggested_email)) {
3015 if (WARN("BAD_SIGN_OFF",
3016 "email address '$email' might be better as '$suggested_email'\n" . $herecurr) &&
3018 $fixed[$fixlinenr] =~ s/\Q$email\E/$suggested_email/;
3022 # Address part shouldn't have comments
3023 my $stripped_address = $email_address;
3024 $stripped_address =~ s/\([^\(\)]*\)//g;
3025 if ($email_address ne $stripped_address) {
3026 if (WARN("BAD_SIGN_OFF",
3027 "address part of email should not have comments: '$email_address'\n" . $herecurr) &&
3029 $fixed[$fixlinenr] =~ s/\Q$email_address\E/$stripped_address/;
3033 # Only one name comment should be allowed
3034 my $comment_count = () = $name_comment =~ /\([^\)]+\)/g;
3035 if ($comment_count > 1) {
3036 WARN("BAD_SIGN_OFF",
3037 "Use a single name comment in email: '$email'\n" . $herecurr);
3041 # stable@vger.kernel.org or stable@kernel.org shouldn't
3042 # have an email name. In addition comments should strictly
3044 if ($email =~ /^.*stable\@(?:vger\.)?kernel\.org/i) {
3045 if (($comment ne "" && $comment !~ /^#.+/) ||
3046 ($email_name ne "")) {
3047 my $cur_name = $email_name;
3048 my $new_comment = $comment;
3049 $cur_name =~ s/[a-zA-Z\s\-\"]+//g;
3051 # Remove brackets enclosing comment text
3052 # and # from start of comments to get comment text
3053 $new_comment =~ s/^\((.*)\)$/$1/;
3054 $new_comment =~ s/^\[(.*)\]$/$1/;
3055 $new_comment =~ s/^[\s\#]+|\s+$//g;
3057 $new_comment = trim("$new_comment $cur_name") if ($cur_name ne $new_comment);
3058 $new_comment = " # $new_comment" if ($new_comment ne "");
3059 my $new_email = "$email_address$new_comment";
3061 if (WARN("BAD_STABLE_ADDRESS_STYLE",
3062 "Invalid email format for stable: '$email', prefer '$new_email'\n" . $herecurr) &&
3064 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3067 } elsif ($comment ne "" && $comment !~ /^(?:#.+|\(.+\))$/) {
3068 my $new_comment = $comment;
3070 # Extract comment text from within brackets or
3071 # c89 style /*...*/ comments
3072 $new_comment =~ s/^\[(.*)\]$/$1/;
3073 $new_comment =~ s/^\/\*(.*)\*\/$/$1/;
3075 $new_comment = trim($new_comment);
3076 $new_comment =~ s/^[^\w]$//; # Single lettered comment with non word character is usually a typo
3077 $new_comment = "($new_comment)" if ($new_comment ne "");
3078 my $new_email = format_email($email_name, $name_comment, $email_address, $new_comment);
3080 if (WARN("BAD_SIGN_OFF",
3081 "Unexpected content after email: '$email', should be: '$new_email'\n" . $herecurr) &&
3083 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3088 # Check for duplicate signatures
3089 my $sig_nospace = $line;
3090 $sig_nospace =~ s/\s//g;
3091 $sig_nospace = lc($sig_nospace);
3092 if (defined $signatures{$sig_nospace}) {
3093 WARN("BAD_SIGN_OFF",
3094 "Duplicate signature\n" . $herecurr);
3096 $signatures{$sig_nospace} = 1;
3099 # Check Co-developed-by: immediately followed by Signed-off-by: with same name and email
3100 if ($sign_off =~ /^co-developed-by:$/i) {
3101 if ($email eq $author) {
3102 WARN("BAD_SIGN_OFF",
3103 "Co-developed-by: should not be used to attribute nominal patch author '$author'\n" . "$here\n" . $rawline);
3105 if (!defined $lines[$linenr]) {
3106 WARN("BAD_SIGN_OFF",
3107 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline);
3108 } elsif ($rawlines[$linenr] !~ /^\s*signed-off-by:\s*(.*)/i) {
3109 WARN("BAD_SIGN_OFF",
3110 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3111 } elsif ($1 ne $email) {
3112 WARN("BAD_SIGN_OFF",
3113 "Co-developed-by and Signed-off-by: name/email do not match \n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3118 # Check email subject for common tools that don't need to be mentioned
3119 if ($in_header_lines &&
3120 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
3121 WARN("EMAIL_SUBJECT",
3122 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
3125 # Check for Gerrit Change-Ids not in any patch context
3126 if ($realfile eq '' && !$has_patch_separator && $line =~ /^\s*change-id:/i) {
3127 if (ERROR("GERRIT_CHANGE_ID",
3128 "Remove Gerrit Change-Id's before submitting upstream\n" . $herecurr) &&
3130 fix_delete_line($fixlinenr, $rawline);
3134 # Check if the commit log is in a possible stack dump
3135 if ($in_commit_log && !$commit_log_possible_stack_dump &&
3136 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
3137 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
3139 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/) ||
3140 $line =~ /^(?:\s+\w+:\s+[0-9a-fA-F]+){3,3}/ ||
3141 $line =~ /^\s*\#\d+\s*\[[0-9a-fA-F]+\]\s*\w+ at [0-9a-fA-F]+/) {
3142 # stack dump address styles
3143 $commit_log_possible_stack_dump = 1;
3146 # Check for line lengths > 75 in commit log, warn once
3147 if ($in_commit_log && !$commit_log_long_line &&
3148 length($line) > 75 &&
3149 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
3150 # file delta changes
3151 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
3153 $line =~ /^\s*(?:Fixes:|Link:|$signature_tags)/i ||
3154 # A Fixes: or Link: line or signature tag line
3155 $commit_log_possible_stack_dump)) {
3156 WARN("COMMIT_LOG_LONG_LINE",
3157 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
3158 $commit_log_long_line = 1;
3161 # Reset possible stack dump if a blank line is found
3162 if ($in_commit_log && $commit_log_possible_stack_dump &&
3164 $commit_log_possible_stack_dump = 0;
3167 # Check for lines starting with a #
3168 if ($in_commit_log && $line =~ /^#/) {
3169 if (WARN("COMMIT_COMMENT_SYMBOL",
3170 "Commit log lines starting with '#' are dropped by git as comments\n" . $herecurr) &&
3172 $fixed[$fixlinenr] =~ s/^/ /;
3176 # Check for git id commit length and improperly formed commit descriptions
3177 # A correctly formed commit description is:
3178 # commit <SHA-1 hash length 12+ chars> ("Complete commit subject")
3179 # with the commit subject '("' prefix and '")' suffix
3180 # This is a fairly compilicated block as it tests for what appears to be
3181 # bare SHA-1 hash with minimum length of 5. It also avoids several types of
3182 # possible SHA-1 matches.
3183 # A commit match can span multiple lines so this block attempts to find a
3184 # complete typical commit on a maximum of 3 lines
3185 if ($perl_version_ok &&
3186 $in_commit_log && !$commit_log_possible_stack_dump &&
3187 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink|base-commit):/i &&
3188 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
3189 (($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
3190 ($line =~ /\bcommit\s*$/i && defined($rawlines[$linenr]) && $rawlines[$linenr] =~ /^\s*[0-9a-f]{5,}\b/i)) ||
3191 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
3192 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
3193 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
3194 my $init_char = "c";
3195 my $orig_commit = "";
3200 my $id = '0123456789ab';
3201 my $orig_desc = "commit description";
3202 my $description = "";
3203 my $herectx = $herecurr;
3208 if ($line =~ /(?:\bcommit\s+[0-9a-f]{5,}|\bcommit\s*$)/i) {
3209 for (my $n = 0; $n < 2; $n++) {
3210 if ($input =~ /\bcommit\s+[0-9a-f]{5,}\s*($balanced_parens)/i) {
3213 # Always strip leading/trailing parens then double quotes if existing
3214 $orig_desc = substr($orig_desc, 1, -1);
3215 if ($orig_desc =~ /^".*"$/) {
3216 $orig_desc = substr($orig_desc, 1, -1);
3221 last if ($#lines < $linenr + $n);
3222 $input .= " " . trim($rawlines[$linenr + $n]);
3223 $herectx .= "$rawlines[$linenr + $n]\n";
3225 $herectx = $herecurr if (!$has_parens);
3228 if ($input =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
3230 $orig_commit = lc($2);
3231 $short = 0 if ($input =~ /\bcommit\s+[0-9a-f]{12,40}/i);
3232 $long = 1 if ($input =~ /\bcommit\s+[0-9a-f]{41,}/i);
3233 $space = 0 if ($input =~ /\bcommit [0-9a-f]/i);
3234 $case = 0 if ($input =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
3235 } elsif ($input =~ /\b([0-9a-f]{12,40})\b/i) {
3236 $orig_commit = lc($1);
3239 ($id, $description) = git_commit_info($orig_commit,
3243 ($short || $long || $space || $case || ($orig_desc ne $description) || !$has_quotes) &&
3244 $last_git_commit_id_linenr != $linenr - 1) {
3245 ERROR("GIT_COMMIT_ID",
3246 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herectx);
3248 #don't report the next line if this line ends in commit and the sha1 hash is the next line
3249 $last_git_commit_id_linenr = $linenr if ($line =~ /\bcommit\s*$/i);
3252 # Check for added, moved or deleted files
3253 if (!$reported_maintainer_file && !$in_commit_log &&
3254 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
3255 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
3256 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
3257 (defined($1) || defined($2))))) {
3259 $reported_maintainer_file = 1;
3260 WARN("FILE_PATH_CHANGES",
3261 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
3264 # Check for adding new DT bindings not in schema format
3265 if (!$in_commit_log &&
3266 ($line =~ /^new file mode\s*\d+\s*$/) &&
3267 ($realfile =~ m@^Documentation/devicetree/bindings/.*\.txt$@)) {
3268 WARN("DT_SCHEMA_BINDING_PATCH",
3269 "DT bindings should be in DT schema format. See: Documentation/devicetree/bindings/writing-schema.rst\n");
3272 # Check for wrappage within a valid hunk of the file
3273 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
3274 ERROR("CORRUPTED_PATCH",
3275 "patch seems to be corrupt (line wrapped?)\n" .
3276 $herecurr) if (!$emitted_corrupt++);
3279 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
3280 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
3281 $rawline !~ m/^$UTF8*$/) {
3282 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
3284 my $blank = copy_spacing($rawline);
3285 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
3286 my $hereptr = "$hereline$ptr\n";
3289 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
3292 # Check if it's the start of a commit log
3293 # (not a header line and we haven't seen the patch filename)
3294 if ($in_header_lines && $realfile =~ /^$/ &&
3295 !($rawline =~ /^\s+(?:\S|$)/ ||
3296 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
3297 $in_header_lines = 0;
3299 $has_commit_log = 1;
3302 # Check if there is UTF-8 in a commit log when a mail header has explicitly
3303 # declined it, i.e defined some charset where it is missing.
3304 if ($in_header_lines &&
3305 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
3307 $non_utf8_charset = 1;
3310 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
3311 $rawline =~ /$NON_ASCII_UTF8/) {
3312 WARN("UTF8_BEFORE_PATCH",
3313 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
3316 # Check for absolute kernel paths in commit message
3317 if ($tree && $in_commit_log) {
3318 while ($line =~ m{(?:^|\s)(/\S*)}g) {
3321 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
3322 check_absolute_file($1, $herecurr)) {
3325 check_absolute_file($file, $herecurr);
3330 # Check for various typo / spelling mistakes
3331 if (defined($misspellings) &&
3332 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
3333 while ($rawline =~ /(?:^|[^\w\-'`])($misspellings)(?:[^\w\-'`]|$)/gi) {
3335 my $blank = copy_spacing($rawline);
3336 my $ptr = substr($blank, 0, $-[1]) . "^" x length($typo);
3337 my $hereptr = "$hereline$ptr\n";
3338 my $typo_fix = $spelling_fix{lc($typo)};
3339 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
3340 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
3341 my $msg_level = \&WARN;
3342 $msg_level = \&CHK if ($file);
3343 if (&{$msg_level}("TYPO_SPELLING",
3344 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $hereptr) &&
3346 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
3351 # check for invalid commit id
3352 if ($in_commit_log && $line =~ /(^fixes:|\bcommit)\s+([0-9a-f]{6,40})\b/i) {
3355 ($id, $description) = git_commit_info($2, undef, undef);
3356 if (!defined($id)) {
3357 WARN("UNKNOWN_COMMIT_ID",
3358 "Unknown commit id '$2', maybe rebased or not pulled?\n" . $herecurr);
3362 # check for repeated words separated by a single space
3363 # avoid false positive from list command eg, '-rw-r--r-- 1 root root'
3364 if (($rawline =~ /^\+/ || $in_commit_log) &&
3365 $rawline !~ /[bcCdDlMnpPs\?-][rwxsStT-]{9}/) {
3366 pos($rawline) = 1 if (!$in_commit_log);
3367 while ($rawline =~ /\b($word_pattern) (?=($word_pattern))/g) {
3371 my $start_pos = $-[1];
3372 my $end_pos = $+[2];
3373 if ($first =~ /(?:struct|union|enum)/) {
3374 pos($rawline) += length($first) + length($second) + 1;
3378 next if (lc($first) ne lc($second));
3379 next if ($first eq 'long');
3381 # check for character before and after the word matches
3382 my $start_char = '';
3384 $start_char = substr($rawline, $start_pos - 1, 1) if ($start_pos > ($in_commit_log ? 0 : 1));
3385 $end_char = substr($rawline, $end_pos, 1) if ($end_pos < length($rawline));
3387 next if ($start_char =~ /^\S$/);
3388 next if (index(" \t.,;?!", $end_char) == -1);
3390 # avoid repeating hex occurrences like 'ff ff fe 09 ...'
3391 if ($first =~ /\b[0-9a-f]{2,}\b/i) {
3392 next if (!exists($allow_repeated_words{lc($first)}));
3395 if (WARN("REPEATED_WORD",
3396 "Possible repeated word: '$first'\n" . $herecurr) &&
3398 $fixed[$fixlinenr] =~ s/\b$first $second\b/$first/;
3402 # if it's a repeated word on consecutive lines in a comment block
3403 if ($prevline =~ /$;+\s*$/ &&
3404 $prevrawline =~ /($word_pattern)\s*$/) {
3406 if ($rawline =~ /^\+\s*\*\s*$last_word /) {
3407 if (WARN("REPEATED_WORD",
3408 "Possible repeated word: '$last_word'\n" . $hereprev) &&
3410 $fixed[$fixlinenr] =~ s/(\+\s*\*\s*)$last_word /$1/;
3416 # ignore non-hunk lines and lines being removed
3417 next if (!$hunk_line || $line =~ /^-/);
3419 #trailing whitespace
3420 if ($line =~ /^\+.*\015/) {
3421 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3422 if (ERROR("DOS_LINE_ENDINGS",
3423 "DOS line endings\n" . $herevet) &&
3425 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
3427 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
3428 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3429 if (ERROR("TRAILING_WHITESPACE",
3430 "trailing whitespace\n" . $herevet) &&
3432 $fixed[$fixlinenr] =~ s/\s+$//;
3438 # Check for FSF mailing addresses.
3439 if ($rawline =~ /\bwrite to the Free/i ||
3440 $rawline =~ /\b675\s+Mass\s+Ave/i ||
3441 $rawline =~ /\b59\s+Temple\s+Pl/i ||
3442 $rawline =~ /\b51\s+Franklin\s+St/i) {
3443 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3444 my $msg_level = \&ERROR;
3445 $msg_level = \&CHK if ($file);
3446 &{$msg_level}("FSF_MAILING_ADDRESS",
3447 "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)
3450 # check for Kconfig help text having a real description
3451 # Only applies when adding the entry originally, after that we do not have
3452 # sufficient context to determine whether it is indeed long enough.
3453 if ($realfile =~ /Kconfig/ &&
3454 # 'choice' is usually the last thing on the line (though
3455 # Kconfig supports named choices), so use a word boundary
3456 # (\b) rather than a whitespace character (\s)
3457 $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
3460 my $ln = $linenr + 1;
3464 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
3465 $f = $lines[$ln - 1];
3466 $cnt-- if ($lines[$ln - 1] !~ /^-/);
3467 $is_end = $lines[$ln - 1] =~ /^\+/;
3469 next if ($f =~ /^-/);
3470 last if (!$file && $f =~ /^\@\@/);
3472 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
3474 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
3481 next if ($f =~ /^$/);
3483 # This only checks context lines in the patch
3484 # and so hopefully shouldn't trigger false
3485 # positives, even though some of these are
3486 # common words in help texts
3487 if ($f =~ /^\s*(?:config|menuconfig|choice|endchoice|
3488 if|endif|menu|endmenu|source)\b/x) {
3494 if ($is_start && $is_end && $length < $min_conf_desc_length) {
3495 WARN("CONFIG_DESCRIPTION",
3496 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
3498 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
3501 # check MAINTAINERS entries
3502 if ($realfile =~ /^MAINTAINERS$/) {
3503 # check MAINTAINERS entries for the right form
3504 if ($rawline =~ /^\+[A-Z]:/ &&
3505 $rawline !~ /^\+[A-Z]:\t\S/) {
3506 if (WARN("MAINTAINERS_STYLE",
3507 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
3509 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
3512 # check MAINTAINERS entries for the right ordering too
3513 my $preferred_order = 'MRLSWQBCPTFXNK';
3514 if ($rawline =~ /^\+[A-Z]:/ &&
3515 $prevrawline =~ /^[\+ ][A-Z]:/) {
3516 $rawline =~ /^\+([A-Z]):\s*(.*)/;
3519 $prevrawline =~ /^[\+ ]([A-Z]):\s*(.*)/;
3522 my $curindex = index($preferred_order, $cur);
3523 my $previndex = index($preferred_order, $prev);
3524 if ($curindex < 0) {
3525 WARN("MAINTAINERS_STYLE",
3526 "Unknown MAINTAINERS entry type: '$cur'\n" . $herecurr);
3528 if ($previndex >= 0 && $curindex < $previndex) {
3529 WARN("MAINTAINERS_STYLE",
3530 "Misordered MAINTAINERS entry - list '$cur:' before '$prev:'\n" . $hereprev);
3531 } elsif ((($prev eq 'F' && $cur eq 'F') ||
3532 ($prev eq 'X' && $cur eq 'X')) &&
3533 ($prevval cmp $curval) > 0) {
3534 WARN("MAINTAINERS_STYLE",
3535 "Misordered MAINTAINERS entry - list file patterns in alphabetic order\n" . $hereprev);
3541 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
3542 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
3545 'EXTRA_AFLAGS' => 'asflags-y',
3546 'EXTRA_CFLAGS' => 'ccflags-y',
3547 'EXTRA_CPPFLAGS' => 'cppflags-y',
3548 'EXTRA_LDFLAGS' => 'ldflags-y',
3551 WARN("DEPRECATED_VARIABLE",
3552 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
3555 # check for DT compatible documentation
3556 if (defined $root &&
3557 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
3558 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
3560 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
3562 my $dt_path = $root . "/Documentation/devicetree/bindings/";
3563 my $vp_file = $dt_path . "vendor-prefixes.yaml";
3565 foreach my $compat (@compats) {
3566 my $compat2 = $compat;
3567 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
3568 my $compat3 = $compat;
3569 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
3570 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
3572 WARN("UNDOCUMENTED_DT_STRING",
3573 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
3576 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
3578 `grep -Eq "\\"\\^\Q$vendor\E,\\.\\*\\":" $vp_file`;
3580 WARN("UNDOCUMENTED_DT_STRING",
3581 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
3586 # check for using SPDX license tag at beginning of files
3587 if ($realline == $checklicenseline) {
3588 if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
3589 $checklicenseline = 2;
3590 } elsif ($rawline =~ /^\+/) {
3592 if ($realfile =~ /\.(h|s|S)$/) {
3594 } elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
3596 } elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc|yaml)$/) {
3598 } elsif ($realfile =~ /\.rst$/) {
3602 # check SPDX comment style for .[chsS] files
3603 if ($realfile =~ /\.[chsS]$/ &&
3604 $rawline =~ /SPDX-License-Identifier:/ &&
3605 $rawline !~ m@^\+\s*\Q$comment\E\s*@) {
3606 WARN("SPDX_LICENSE_TAG",
3607 "Improper SPDX comment style for '$realfile', please use '$comment' instead\n" . $herecurr);
3610 if ($comment !~ /^$/ &&
3611 $rawline !~ m@^\+\Q$comment\E SPDX-License-Identifier: @) {
3612 WARN("SPDX_LICENSE_TAG",
3613 "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
3614 } elsif ($rawline =~ /(SPDX-License-Identifier: .*)/) {
3615 my $spdx_license = $1;
3616 if (!is_SPDX_License_valid($spdx_license)) {
3617 WARN("SPDX_LICENSE_TAG",
3618 "'$spdx_license' is not supported in LICENSES/...\n" . $herecurr);
3620 if ($realfile =~ m@^Documentation/devicetree/bindings/@ &&
3621 not $spdx_license =~ /GPL-2\.0.*BSD-2-Clause/) {
3622 my $msg_level = \&WARN;
3623 $msg_level = \&CHK if ($file);
3624 if (&{$msg_level}("SPDX_LICENSE_TAG",
3626 "DT binding documents should be licensed (GPL-2.0-only OR BSD-2-Clause)\n" . $herecurr) &&
3628 $fixed[$fixlinenr] =~ s/SPDX-License-Identifier: .*/SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)/;
3635 # check for embedded filenames
3636 if ($rawline =~ /^\+.*\Q$realfile\E/) {
3637 WARN("EMBEDDED_FILENAME",
3638 "It's generally not useful to have the filename in the file\n" . $herecurr);
3641 # check we are in a valid source file if not then ignore this hunk
3642 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
3644 # check for using SPDX-License-Identifier on the wrong line number
3645 if ($realline != $checklicenseline &&
3646 $rawline =~ /\bSPDX-License-Identifier:/ &&
3647 substr($line, @-, @+ - @-) eq "$;" x (@+ - @-)) {
3648 WARN("SPDX_LICENSE_TAG",
3649 "Misplaced SPDX-License-Identifier tag - use line $checklicenseline instead\n" . $herecurr);
3652 # line length limit (with some exclusions)
3654 # There are a few types of lines that may extend beyond $max_line_length:
3655 # logging functions like pr_info that end in a string
3656 # lines with a single string
3657 # #defines that are a single string
3658 # lines with an RFC3986 like URL
3660 # There are 3 different line length message types:
3661 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
3662 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
3663 # LONG_LINE all other lines longer than $max_line_length
3665 # if LONG_LINE is ignored, the other 2 types are also ignored
3668 if ($line =~ /^\+/ && $length > $max_line_length) {
3669 my $msg_type = "LONG_LINE";
3671 # Check the allowed long line types first
3673 # logging functions that end in a string that starts
3674 # before $max_line_length
3675 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
3676 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3679 # lines with only strings (w/ possible termination)
3680 # #defines with only strings
3681 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
3682 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
3685 # More special cases
3686 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3687 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3690 # URL ($rawline is used in case the URL is in a comment)
3691 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
3694 # Otherwise set the alternate message types
3696 # a comment starts before $max_line_length
3697 } elsif ($line =~ /($;[\s$;]*)$/ &&
3698 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3699 $msg_type = "LONG_LINE_COMMENT"
3701 # a quoted string starts before $max_line_length
3702 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3703 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3704 $msg_type = "LONG_LINE_STRING"
3707 if ($msg_type ne "" &&
3708 (show_type("LONG_LINE") || show_type($msg_type))) {
3709 my $msg_level = \&WARN;
3710 $msg_level = \&CHK if ($file);
3711 &{$msg_level}($msg_type,
3712 "line length of $length exceeds $max_line_length columns\n" . $herecurr);
3716 # check for adding lines without a newline.
3717 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3718 if (WARN("MISSING_EOF_NEWLINE",
3719 "adding a line without newline at end of file\n" . $herecurr) &&
3721 fix_delete_line($fixlinenr+1, "No newline at end of file");
3725 # check for .L prefix local symbols in .S files
3726 if ($realfile =~ /\.S$/ &&
3727 $line =~ /^\+\s*(?:[A-Z]+_)?SYM_[A-Z]+_(?:START|END)(?:_[A-Z_]+)?\s*\(\s*\.L/) {
3728 WARN("AVOID_L_PREFIX",
3729 "Avoid using '.L' prefixed local symbol names for denoting a range of code via 'SYM_*_START/END' annotations; see Documentation/asm-annotations.rst\n" . $herecurr);
3732 # check we are in a valid source file C or perl if not then ignore this hunk
3733 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3735 # at the beginning of a line any tabs must come first and anything
3736 # more than $tabsize must use tabs.
3737 if ($rawline =~ /^\+\s* \t\s*\S/ ||
3738 $rawline =~ /^\+\s* \s*/) {
3739 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3741 if (ERROR("CODE_INDENT",
3742 "code indent should use tabs where possible\n" . $herevet) &&
3744 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3748 # check for space before tabs.
3749 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3750 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3751 if (WARN("SPACE_BEFORE_TAB",
3752 "please, no space before tabs\n" . $herevet) &&
3754 while ($fixed[$fixlinenr] =~
3755 s/(^\+.*) {$tabsize,$tabsize}\t/$1\t\t/) {}
3756 while ($fixed[$fixlinenr] =~
3757 s/(^\+.*) +\t/$1\t/) {}
3761 # check for assignments on the start of a line
3762 if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3764 if (CHK("ASSIGNMENT_CONTINUATIONS",
3765 "Assignment operator '$1' should be on the previous line\n" . $hereprev) &&
3766 $fix && $prevrawline =~ /^\+/) {
3767 # add assignment operator to the previous line, remove from current line
3768 $fixed[$fixlinenr - 1] .= " $operator";
3769 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3773 # check for && or || at the start of a line
3774 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3776 if (CHK("LOGICAL_CONTINUATIONS",
3777 "Logical continuations should be on the previous line\n" . $hereprev) &&
3778 $fix && $prevrawline =~ /^\+/) {
3779 # insert logical operator at last non-comment, non-whitepsace char on previous line
3780 $prevline =~ /[\s$;]*$/;
3781 my $line_end = substr($prevrawline, $-[0]);
3782 $fixed[$fixlinenr - 1] =~ s/\Q$line_end\E$/ $operator$line_end/;
3783 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3787 # check indentation starts on a tab stop
3788 if ($perl_version_ok &&
3789 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3790 my $indent = length($1);
3791 if ($indent % $tabsize) {
3793 "Statements should start on a tabstop\n" . $herecurr) &&
3795 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/$tabsize)@e;
3800 # check multi-line statement indentation matches previous line
3801 if ($perl_version_ok &&
3802 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3803 $prevline =~ /^\+(\t*)(.*)$/;
3807 my $pos = pos_last_openparen($rest);
3809 $line =~ /^(\+| )([ \t]*)/;
3812 my $goodtabindent = $oldindent .
3813 "\t" x ($pos / $tabsize) .
3814 " " x ($pos % $tabsize);
3815 my $goodspaceindent = $oldindent . " " x $pos;
3817 if ($newindent ne $goodtabindent &&
3818 $newindent ne $goodspaceindent) {
3820 if (CHK("PARENTHESIS_ALIGNMENT",
3821 "Alignment should match open parenthesis\n" . $hereprev) &&
3822 $fix && $line =~ /^\+/) {
3823 $fixed[$fixlinenr] =~
3824 s/^\+[ \t]*/\+$goodtabindent/;
3830 # check for space after cast like "(int) foo" or "(struct foo) bar"
3831 # avoid checking a few false positives:
3832 # "sizeof(<type>)" or "__alignof__(<type>)"
3833 # function pointer declarations like "(*foo)(int) = bar;"
3834 # structure definitions like "(struct foo) { 0 };"
3835 # multiline macros that define functions
3836 # known attributes or the __attribute__ keyword
3837 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3838 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3840 "No space is necessary after a cast\n" . $herecurr) &&
3842 $fixed[$fixlinenr] =~
3843 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3847 # Block comment styles
3848 # Networking with an initial /*
3849 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3850 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3851 $rawline =~ /^\+[ \t]*\*/ &&
3852 $realline > 3) { # Do not warn about the initial copyright comment block after SPDX-License-Identifier
3853 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3854 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3857 # Block comments use * on subsequent lines
3858 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3859 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
3860 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3861 $rawline =~ /^\+/ && #line is new
3862 $rawline !~ /^\+[ \t]*\*/) { #no leading *
3863 WARN("BLOCK_COMMENT_STYLE",
3864 "Block comments use * on subsequent lines\n" . $hereprev);
3867 # Block comments use */ on trailing lines
3868 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
3869 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3870 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3871 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
3872 WARN("BLOCK_COMMENT_STYLE",
3873 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3876 # Block comment * alignment
3877 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3878 $line =~ /^\+[ \t]*$;/ && #leading comment
3879 $rawline =~ /^\+[ \t]*\*/ && #leading *
3880 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
3881 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3882 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3884 $prevrawline =~ m@^\+([ \t]*/?)\*@;
3886 $oldindent = expand_tabs($1);
3888 $prevrawline =~ m@^\+(.*/?)\*@;
3889 $oldindent = expand_tabs($1);
3891 $rawline =~ m@^\+([ \t]*)\*@;
3893 $newindent = expand_tabs($newindent);
3894 if (length($oldindent) ne length($newindent)) {
3895 WARN("BLOCK_COMMENT_STYLE",
3896 "Block comments should align the * on each line\n" . $hereprev);
3900 # check for missing blank lines after struct/union declarations
3901 # with exceptions for various attributes and macros
3902 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3904 !($line =~ /^\+\s*$/ ||
3905 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3906 $line =~ /^\+\s*MODULE_/i ||
3907 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3908 $line =~ /^\+[a-z_]*init/ ||
3909 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3910 $line =~ /^\+\s*DECLARE/ ||
3911 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3912 $line =~ /^\+\s*__setup/)) {
3913 if (CHK("LINE_SPACING",
3914 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3916 fix_insert_line($fixlinenr, "\+");
3920 # check for multiple consecutive blank lines
3921 if ($prevline =~ /^[\+ ]\s*$/ &&
3922 $line =~ /^\+\s*$/ &&
3923 $last_blank_line != ($linenr - 1)) {
3924 if (CHK("LINE_SPACING",
3925 "Please don't use multiple blank lines\n" . $hereprev) &&
3927 fix_delete_line($fixlinenr, $rawline);
3930 $last_blank_line = $linenr;
3933 # check for missing blank lines after declarations
3934 # (declarations must have the same indentation and not be at the start of line)
3935 if (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/) {
3939 # remove $Attribute/$Sparse uses to simplify comparisons
3940 $sl =~ s/\b(?:$Attribute|$Sparse)\b//g;
3941 $pl =~ s/\b(?:$Attribute|$Sparse)\b//g;
3942 if (($pl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3943 # function pointer declarations
3944 $pl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3945 # foo bar; where foo is some local typedef or #define
3946 $pl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3947 # known declaration macros
3948 $pl =~ /^\+\s+$declaration_macros/) &&
3949 # for "else if" which can look like "$Ident $Ident"
3950 !($pl =~ /^\+\s+$c90_Keywords\b/ ||
3951 # other possible extensions of declaration lines
3952 $pl =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3953 # not starting a section or a macro "\" extended line
3954 $pl =~ /(?:\{\s*|\\)$/) &&
3955 # looks like a declaration
3956 !($sl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3957 # function pointer declarations
3958 $sl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3959 # foo bar; where foo is some local typedef or #define
3960 $sl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3961 # known declaration macros
3962 $sl =~ /^\+\s+$declaration_macros/ ||
3963 # start of struct or union or enum
3964 $sl =~ /^\+\s+(?:static\s+)?(?:const\s+)?(?:union|struct|enum|typedef)\b/ ||
3965 # start or end of block or continuation of declaration
3966 $sl =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3967 # bitfield continuation
3968 $sl =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3969 # other possible extensions of declaration lines
3970 $sl =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/)) {
3971 if (WARN("LINE_SPACING",
3972 "Missing a blank line after declarations\n" . $hereprev) &&
3974 fix_insert_line($fixlinenr, "\+");
3979 # check for spaces at the beginning of a line.
3981 # 1) within comments
3982 # 2) indented preprocessor commands
3984 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3985 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3986 if (WARN("LEADING_SPACE",
3987 "please, no spaces at the start of a line\n" . $herevet) &&
3989 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3993 # check we are in a valid C source file if not then ignore this hunk
3994 next if ($realfile !~ /\.(h|c)$/);
3996 # check for unusual line ending [ or (
3997 if ($line =~ /^\+.*([\[\(])\s*$/) {
3998 CHK("OPEN_ENDED_LINE",
3999 "Lines should not end with a '$1'\n" . $herecurr);
4002 # check if this appears to be the start function declaration, save the name
4003 if ($sline =~ /^\+\{\s*$/ &&
4004 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
4005 $context_function = $1;
4008 # check if this appears to be the end of function declaration
4009 if ($sline =~ /^\+\}\s*$/) {
4010 undef $context_function;
4013 # check indentation of any line with a bare else
4014 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
4015 # if the previous line is a break or return and is indented 1 tab more...
4016 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
4017 my $tabs = length($1) + 1;
4018 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
4019 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
4020 defined $lines[$linenr] &&
4021 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
4022 WARN("UNNECESSARY_ELSE",
4023 "else is not generally useful after a break or return\n" . $hereprev);
4027 # check indentation of a line with a break;
4028 # if the previous line is a goto, return or break
4029 # and is indented the same # of tabs
4030 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
4032 if ($prevline =~ /^\+$tabs(goto|return|break)\b/) {
4033 if (WARN("UNNECESSARY_BREAK",
4034 "break is not useful after a $1\n" . $hereprev) &&
4036 fix_delete_line($fixlinenr, $rawline);
4041 # check for RCS/CVS revision markers
4042 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
4044 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
4047 # check for old HOTPLUG __dev<foo> section markings
4048 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
4049 WARN("HOTPLUG_SECTION",
4050 "Using $1 is unnecessary\n" . $herecurr);
4053 # Check for potential 'bare' types
4054 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
4056 #print "LINE<$line>\n";
4057 if ($linenr > $suppress_statement &&
4058 $realcnt && $sline =~ /.\s*\S/) {
4059 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4060 ctx_statement_block($linenr, $realcnt, 0);
4061 $stat =~ s/\n./\n /g;
4062 $cond =~ s/\n./\n /g;
4064 #print "linenr<$linenr> <$stat>\n";
4065 # If this statement has no statement boundaries within
4066 # it there is no point in retrying a statement scan
4067 # until we hit end of it.
4068 my $frag = $stat; $frag =~ s/;+\s*$//;
4069 if ($frag !~ /(?:{|;)/) {
4070 #print "skip<$line_nr_next>\n";
4071 $suppress_statement = $line_nr_next;
4074 # Find the real next line.
4075 $realline_next = $line_nr_next;
4076 if (defined $realline_next &&
4077 (!defined $lines[$realline_next - 1] ||
4078 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
4085 # Ignore goto labels.
4086 if ($s =~ /$Ident:\*$/s) {
4088 # Ignore functions being called
4089 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
4091 } elsif ($s =~ /^.\s*else\b/s) {
4093 # declarations always start with types
4094 } 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) {
4097 possible($type, "A:" . $s);
4099 # definitions in global scope can only start with types
4100 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
4101 possible($1, "B:" . $s);
4104 # any (foo ... *) is a pointer cast, and foo is a type
4105 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
4106 possible($1, "C:" . $s);
4109 # Check for any sort of function declaration.
4110 # int foo(something bar, other baz);
4111 # void (*store_gdt)(x86_descr_ptr *);
4112 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
4113 my ($name_len) = length($1);
4116 substr($ctx, 0, $name_len + 1, '');
4117 $ctx =~ s/\)[^\)]*$//;
4119 for my $arg (split(/\s*,\s*/, $ctx)) {
4120 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
4122 possible($1, "D:" . $s);
4130 # Checks which may be anchored in the context.
4133 # Check for switch () and associated case and default
4134 # statements should be at the same indent.
4135 if ($line=~/\bswitch\s*\(.*\)/) {
4138 my @ctx = ctx_block_outer($linenr, $realcnt);
4140 for my $ctx (@ctx) {
4141 my ($clen, $cindent) = line_stats($ctx);
4142 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
4143 $indent != $cindent) {
4144 $err .= "$sep$ctx\n";
4151 ERROR("SWITCH_CASE_INDENT_LEVEL",
4152 "switch and case should be at the same indent\n$hereline$err");
4156 # if/while/etc brace do not go on next line, unless defining a do while loop,
4157 # or if that brace on the next line is for something else
4158 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
4159 my $pre_ctx = "$1$2";
4161 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
4163 if ($line =~ /^\+\t{6,}/) {
4164 WARN("DEEP_INDENTATION",
4165 "Too many leading tabs - consider code refactoring\n" . $herecurr);
4168 my $ctx_cnt = $realcnt - $#ctx - 1;
4169 my $ctx = join("\n", @ctx);
4171 my $ctx_ln = $linenr;
4172 my $ctx_skip = $realcnt;
4174 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
4175 defined $lines[$ctx_ln - 1] &&
4176 $lines[$ctx_ln - 1] =~ /^-/)) {
4177 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
4178 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
4182 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
4183 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
4185 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
4187 "that open brace { should be on the previous line\n" .
4188 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4190 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
4191 $ctx =~ /\)\s*\;\s*$/ &&
4192 defined $lines[$ctx_ln - 1])
4194 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
4195 if ($nindent > $indent) {
4196 WARN("TRAILING_SEMICOLON",
4197 "trailing semicolon indicates no statements, indent implies otherwise\n" .
4198 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4203 # Check relative indent for conditionals and blocks.
4204 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
4205 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4206 ctx_statement_block($linenr, $realcnt, 0)
4207 if (!defined $stat);
4208 my ($s, $c) = ($stat, $cond);
4210 substr($s, 0, length($c), '');
4212 # remove inline comments
4216 # Find out how long the conditional actually is.
4217 my @newlines = ($c =~ /\n/gs);
4218 my $cond_lines = 1 + $#newlines;
4220 # Make sure we remove the line prefixes as we have
4221 # none on the first line, and are going to readd them
4224 while ($s =~ /\n\s+\\\n/) {
4225 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
4228 # We want to check the first line inside the block
4229 # starting at the end of the conditional, so remove:
4230 # 1) any blank line termination
4231 # 2) any opening brace { on end of the line
4233 my $continuation = 0;
4235 $s =~ s/^.*\bdo\b//;
4237 if ($s =~ s/^\s*\\//) {
4240 if ($s =~ s/^\s*?\n//) {
4245 # Also ignore a loop construct at the end of a
4246 # preprocessor statement.
4247 if (($prevline =~ /^.\s*#\s*define\s/ ||
4248 $prevline =~ /\\\s*$/) && $continuation == 0) {
4254 while ($cond_ptr != $cond_lines) {
4255 $cond_ptr = $cond_lines;
4257 # If we see an #else/#elif then the code
4259 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
4264 # 1) blank lines, they should be at 0,
4265 # 2) preprocessor lines, and
4267 if ($continuation ||
4269 $s =~ /^\s*#\s*?/ ||
4270 $s =~ /^\s*$Ident\s*:/) {
4271 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
4272 if ($s =~ s/^.*?\n//) {
4278 my (undef, $sindent) = line_stats("+" . $s);
4279 my $stat_real = raw_line($linenr, $cond_lines);
4281 # Check if either of these lines are modified, else
4282 # this is not this patch's fault.
4283 if (!defined($stat_real) ||
4284 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
4287 if (defined($stat_real) && $cond_lines > 1) {
4288 $stat_real = "[...]\n$stat_real";
4291 #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";
4293 if ($check && $s ne '' &&
4294 (($sindent % $tabsize) != 0 ||
4295 ($sindent < $indent) ||
4296 ($sindent == $indent &&
4297 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
4298 ($sindent > $indent + $tabsize))) {
4299 WARN("SUSPECT_CODE_INDENT",
4300 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
4304 # Track the 'values' across context and added lines.
4305 my $opline = $line; $opline =~ s/^./ /;
4306 my ($curr_values, $curr_vars) =
4307 annotate_values($opline . "\n", $prev_values);
4308 $curr_values = $prev_values . $curr_values;
4310 my $outline = $opline; $outline =~ s/\t/ /g;
4311 print "$linenr > .$outline\n";
4312 print "$linenr > $curr_values\n";
4313 print "$linenr > $curr_vars\n";
4315 $prev_values = substr($curr_values, -1);
4317 #ignore lines not being added
4318 next if ($line =~ /^[^\+]/);
4320 # check for self assignments used to avoid compiler warnings
4321 # e.g.: int foo = foo, *bar = NULL;
4322 # struct foo bar = *(&(bar));
4323 if ($line =~ /^\+\s*(?:$Declare)?([A-Za-z_][A-Za-z\d_]*)\s*=/) {
4325 if ($line =~ /^\+\s*(?:$Declare)?$var\s*=\s*(?:$var|\*\s*\(?\s*&\s*\(?\s*$var\s*\)?\s*\)?)\s*[;,]/) {
4326 WARN("SELF_ASSIGNMENT",
4327 "Do not use self-assignments to avoid compiler warnings\n" . $herecurr);
4331 # check for dereferences that span multiple lines
4332 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
4333 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
4334 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
4336 $line =~ /^.\s*($Lval)/;
4339 WARN("MULTILINE_DEREFERENCE",
4340 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
4343 # check for declarations of signed or unsigned without int
4344 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
4347 $var = "" if (!defined $var);
4348 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
4352 $pointer = "" if (!defined $pointer);
4354 if (WARN("UNSPECIFIED_INT",
4355 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
4357 my $decl = trim($sign) . " int ";
4358 my $comp_pointer = $pointer;
4359 $comp_pointer =~ s/\s//g;
4360 $decl .= $comp_pointer;
4361 $decl = rtrim($decl) if ($var eq "");
4362 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
4367 # TEST: allow direct testing of the type matcher.
4369 if ($line =~ /^.\s*$Declare\s*$/) {
4371 "TEST: is type\n" . $herecurr);
4372 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
4373 ERROR("TEST_NOT_TYPE",
4374 "TEST: is not type ($1 is)\n". $herecurr);
4378 # TEST: allow direct testing of the attribute matcher.
4380 if ($line =~ /^.\s*$Modifier\s*$/) {
4382 "TEST: is attr\n" . $herecurr);
4383 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
4384 ERROR("TEST_NOT_ATTR",
4385 "TEST: is not attr ($1 is)\n". $herecurr);
4390 # check for initialisation to aggregates open brace on the next line
4391 if ($line =~ /^.\s*{/ &&
4392 $prevline =~ /(?:^|[^=])=\s*$/) {
4393 if (ERROR("OPEN_BRACE",
4394 "that open brace { should be on the previous line\n" . $hereprev) &&
4395 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4396 fix_delete_line($fixlinenr - 1, $prevrawline);
4397 fix_delete_line($fixlinenr, $rawline);
4398 my $fixedline = $prevrawline;
4399 $fixedline =~ s/\s*=\s*$/ = {/;
4400 fix_insert_line($fixlinenr, $fixedline);
4402 $fixedline =~ s/^(.\s*)\{\s*/$1/;
4403 fix_insert_line($fixlinenr, $fixedline);
4408 # Checks which are anchored on the added line.
4411 # check for malformed paths in #include statements (uses RAW line)
4412 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
4414 if ($path =~ m{//}) {
4415 ERROR("MALFORMED_INCLUDE",
4416 "malformed #include filename\n" . $herecurr);
4418 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
4419 ERROR("UAPI_INCLUDE",
4420 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
4424 # no C99 // comments
4425 if ($line =~ m{//}) {
4426 if (ERROR("C99_COMMENTS",
4427 "do not use C99 // comments\n" . $herecurr) &&
4429 my $line = $fixed[$fixlinenr];
4430 if ($line =~ /\/\/(.*)$/) {
4431 my $comment = trim($1);
4432 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
4436 # Remove C99 comments.
4438 $opline =~ s@//.*@@;
4440 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
4441 # the whole statement.
4442 #print "APW <$lines[$realline_next - 1]>\n";
4443 if (defined $realline_next &&
4444 exists $lines[$realline_next - 1] &&
4445 !defined $suppress_export{$realline_next} &&
4446 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4447 # Handle definitions which produce identifiers with
4450 # EXPORT_SYMBOL(something_foo);
4452 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
4453 $name =~ /^${Ident}_$2/) {
4454 #print "FOO C name<$name>\n";
4455 $suppress_export{$realline_next} = 1;
4457 } elsif ($stat !~ /(?:
4459 ^.DEFINE_$Ident\(\Q$name\E\)|
4460 ^.DECLARE_$Ident\(\Q$name\E\)|
4461 ^.LIST_HEAD\(\Q$name\E\)|
4462 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
4463 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
4465 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
4466 $suppress_export{$realline_next} = 2;
4468 $suppress_export{$realline_next} = 1;
4471 if (!defined $suppress_export{$linenr} &&
4472 $prevline =~ /^.\s*$/ &&
4473 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4474 #print "FOO B <$lines[$linenr - 1]>\n";
4475 $suppress_export{$linenr} = 2;
4477 if (defined $suppress_export{$linenr} &&
4478 $suppress_export{$linenr} == 2) {
4479 WARN("EXPORT_SYMBOL",
4480 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
4483 # check for global initialisers.
4484 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/ &&
4485 !exclude_global_initialisers($realfile)) {
4486 if (ERROR("GLOBAL_INITIALISERS",
4487 "do not initialise globals to $1\n" . $herecurr) &&
4489 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
4492 # check for static initialisers.
4493 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
4494 if (ERROR("INITIALISED_STATIC",
4495 "do not initialise statics to $1\n" .
4498 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
4502 # check for misordered declarations of char/short/int/long with signed/unsigned
4503 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
4505 WARN("MISORDERED_TYPE",
4506 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
4509 # check for unnecessary <signed> int declarations of short/long/long long
4510 while ($sline =~ m{\b($TypeMisordered(\s*\*)*|$C90_int_types)\b}g) {
4511 my $type = trim($1);
4512 next if ($type !~ /\bint\b/);
4513 next if ($type !~ /\b(?:short|long\s+long|long)\b/);
4514 my $new_type = $type;
4515 $new_type =~ s/\b\s*int\s*\b/ /;
4516 $new_type =~ s/\b\s*(?:un)?signed\b\s*/ /;
4517 $new_type =~ s/^const\s+//;
4518 $new_type = "unsigned $new_type" if ($type =~ /\bunsigned\b/);
4519 $new_type = "const $new_type" if ($type =~ /^const\b/);
4520 $new_type =~ s/\s+/ /g;
4521 $new_type = trim($new_type);
4522 if (WARN("UNNECESSARY_INT",
4523 "Prefer '$new_type' over '$type' as the int is unnecessary\n" . $herecurr) &&
4525 $fixed[$fixlinenr] =~ s/\b\Q$type\E\b/$new_type/;
4529 # check for static const char * arrays.
4530 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
4531 WARN("STATIC_CONST_CHAR_ARRAY",
4532 "static const char * array should probably be static const char * const\n" .
4536 # check for initialized const char arrays that should be static const
4537 if ($line =~ /^\+\s*const\s+(char|unsigned\s+char|_*u8|(?:[us]_)?int8_t)\s+\w+\s*\[\s*(?:\w+\s*)?\]\s*=\s*"/) {
4538 if (WARN("STATIC_CONST_CHAR_ARRAY",
4539 "const array should probably be static const\n" . $herecurr) &&
4541 $fixed[$fixlinenr] =~ s/(^.\s*)const\b/${1}static const/;
4545 # check for static char foo[] = "bar" declarations.
4546 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
4547 WARN("STATIC_CONST_CHAR_ARRAY",
4548 "static char array declaration should probably be static const char\n" .
4552 # check for const <foo> const where <foo> is not a pointer or array type
4553 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
4555 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
4557 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
4558 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
4560 "'const $found const' should probably be 'const $found'\n" . $herecurr);
4564 # check for const static or static <non ptr type> const declarations
4565 # prefer 'static const <foo>' over 'const static <foo>' and 'static <foo> const'
4566 if ($sline =~ /^\+\s*const\s+static\s+($Type)\b/ ||
4567 $sline =~ /^\+\s*static\s+($BasicType)\s+const\b/) {
4568 if (WARN("STATIC_CONST",
4569 "Move const after static - use 'static const $1'\n" . $herecurr) &&
4571 $fixed[$fixlinenr] =~ s/\bconst\s+static\b/static const/;
4572 $fixed[$fixlinenr] =~ s/\bstatic\s+($BasicType)\s+const\b/static const $1/;
4576 # check for non-global char *foo[] = {"bar", ...} declarations.
4577 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
4578 WARN("STATIC_CONST_CHAR_ARRAY",
4579 "char * array declaration might be better as static const\n" .
4583 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
4584 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
4586 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
4588 if (WARN("ARRAY_SIZE",
4589 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
4591 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
4596 # check for function declarations without arguments like "int foo()"
4597 if ($line =~ /(\b$Type\s*$Ident)\s*\(\s*\)/) {
4598 if (ERROR("FUNCTION_WITHOUT_ARGS",
4599 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
4601 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
4605 # check for new typedefs, only function parameters and sparse annotations
4607 if ($line =~ /\btypedef\s/ &&
4608 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
4609 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
4610 $line !~ /\b$typeTypedefs\b/ &&
4611 $line !~ /\b__bitwise\b/) {
4612 WARN("NEW_TYPEDEFS",
4613 "do not add new typedefs\n" . $herecurr);
4616 # * goes on variable not on type
4618 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
4620 my ($ident, $from, $to) = ($1, $2, $2);
4622 # Should start with a space.
4623 $to =~ s/^(\S)/ $1/;
4624 # Should not end with a space.
4626 # '*'s should not have spaces between.
4627 while ($to =~ s/\*\s+\*/\*\*/) {
4630 ## print "1: from<$from> to<$to> ident<$ident>\n";
4632 if (ERROR("POINTER_LOCATION",
4633 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
4635 my $sub_from = $ident;
4636 my $sub_to = $ident;
4637 $sub_to =~ s/\Q$from\E/$to/;
4638 $fixed[$fixlinenr] =~
4639 s@\Q$sub_from\E@$sub_to@;
4643 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
4645 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
4647 # Should start with a space.
4648 $to =~ s/^(\S)/ $1/;
4649 # Should not end with a space.
4651 # '*'s should not have spaces between.
4652 while ($to =~ s/\*\s+\*/\*\*/) {
4654 # Modifiers should have spaces.
4655 $to =~ s/(\b$Modifier$)/$1 /;
4657 ## print "2: from<$from> to<$to> ident<$ident>\n";
4658 if ($from ne $to && $ident !~ /^$Modifier$/) {
4659 if (ERROR("POINTER_LOCATION",
4660 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
4663 my $sub_from = $match;
4664 my $sub_to = $match;
4665 $sub_to =~ s/\Q$from\E/$to/;
4666 $fixed[$fixlinenr] =~
4667 s@\Q$sub_from\E@$sub_to@;
4672 # avoid BUG() or BUG_ON()
4673 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
4674 my $msg_level = \&WARN;
4675 $msg_level = \&CHK if ($file);
4676 &{$msg_level}("AVOID_BUG",
4677 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
4680 # avoid LINUX_VERSION_CODE
4681 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
4682 WARN("LINUX_VERSION_CODE",
4683 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
4686 # check for uses of printk_ratelimit
4687 if ($line =~ /\bprintk_ratelimit\s*\(/) {
4688 WARN("PRINTK_RATELIMITED",
4689 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
4692 # printk should use KERN_* levels
4693 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
4694 WARN("PRINTK_WITHOUT_KERN_LEVEL",
4695 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
4698 # prefer variants of (subsystem|netdev|dev|pr)_<level> to printk(KERN_<LEVEL>
4699 if ($line =~ /\b(printk(_once|_ratelimited)?)\s*\(\s*KERN_([A-Z]+)/) {
4703 $modifier = "" if (!defined($modifier));
4704 my $level = lc($orig);
4705 $level = "warn" if ($level eq "warning");
4706 my $level2 = $level;
4707 $level2 = "dbg" if ($level eq "debug");
4708 $level .= $modifier;
4709 $level2 .= $modifier;
4710 WARN("PREFER_PR_LEVEL",
4711 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to $printk(KERN_$orig ...\n" . $herecurr);
4714 # prefer dev_<level> to dev_printk(KERN_<LEVEL>
4715 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
4717 my $level = lc($orig);
4718 $level = "warn" if ($level eq "warning");
4719 $level = "dbg" if ($level eq "debug");
4720 WARN("PREFER_DEV_LEVEL",
4721 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
4724 # trace_printk should not be used in production code.
4725 if ($line =~ /\b(trace_printk|trace_puts|ftrace_vprintk)\s*\(/) {
4726 WARN("TRACE_PRINTK",
4727 "Do not use $1() in production code (this can be ignored if built only with a debug config option)\n" . $herecurr);
4730 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
4731 # number of false positives, but assembly files are not checked, so at
4732 # least the arch entry code will not trigger this warning.
4733 if ($line =~ /\bENOSYS\b/) {
4735 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
4738 # ENOTSUPP is not a standard error code and should be avoided in new patches.
4739 # Folks usually mean EOPNOTSUPP (also called ENOTSUP), when they type ENOTSUPP.
4740 # Similarly to ENOSYS warning a small number of false positives is expected.
4741 if (!$file && $line =~ /\bENOTSUPP\b/) {
4742 if (WARN("ENOTSUPP",
4743 "ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP\n" . $herecurr) &&
4745 $fixed[$fixlinenr] =~ s/\bENOTSUPP\b/EOPNOTSUPP/;
4749 # function brace can't be on same line, except for #defines of do while,
4750 # or if closed on same line
4751 if ($perl_version_ok &&
4752 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
4753 $sline !~ /\#\s*define\b.*do\s*\{/ &&
4755 if (ERROR("OPEN_BRACE",
4756 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
4758 fix_delete_line($fixlinenr, $rawline);
4759 my $fixed_line = $rawline;
4760 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*)\{(.*)$/;
4763 fix_insert_line($fixlinenr, ltrim($line1));
4764 fix_insert_line($fixlinenr, "\+{");
4765 if ($line2 !~ /^\s*$/) {
4766 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
4771 # open braces for enum, union and struct go on the same line.
4772 if ($line =~ /^.\s*{/ &&
4773 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
4774 if (ERROR("OPEN_BRACE",
4775 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
4776 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4777 fix_delete_line($fixlinenr - 1, $prevrawline);
4778 fix_delete_line($fixlinenr, $rawline);
4779 my $fixedline = rtrim($prevrawline) . " {";
4780 fix_insert_line($fixlinenr, $fixedline);
4781 $fixedline = $rawline;
4782 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
4783 if ($fixedline !~ /^\+\s*$/) {
4784 fix_insert_line($fixlinenr, $fixedline);
4789 # missing space after union, struct or enum definition
4790 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4792 "missing space after $1 definition\n" . $herecurr) &&
4794 $fixed[$fixlinenr] =~
4795 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4799 # Function pointer declarations
4800 # check spacing between type, funcptr, and args
4801 # canonical declaration is "type (*funcptr)(args...)"
4802 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4804 my $pre_pointer_space = $2;
4805 my $post_pointer_space = $3;
4807 my $post_funcname_space = $5;
4808 my $pre_args_space = $6;
4810 # the $Declare variable will capture all spaces after the type
4811 # so check it for a missing trailing missing space but pointer return types
4812 # don't need a space so don't warn for those.
4813 my $post_declare_space = "";
4814 if ($declare =~ /(\s+)$/) {
4815 $post_declare_space = $1;
4816 $declare = rtrim($declare);
4818 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4820 "missing space after return type\n" . $herecurr);
4821 $post_declare_space = " ";
4824 # unnecessary space "type (*funcptr)(args...)"
4825 # This test is not currently implemented because these declarations are
4827 # int foo(int bar, ...)
4828 # and this is form shouldn't/doesn't generate a checkpatch warning.
4830 # elsif ($declare =~ /\s{2,}$/) {
4832 # "Multiple spaces after return type\n" . $herecurr);
4835 # unnecessary space "type ( *funcptr)(args...)"
4836 if (defined $pre_pointer_space &&
4837 $pre_pointer_space =~ /^\s/) {
4839 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4842 # unnecessary space "type (* funcptr)(args...)"
4843 if (defined $post_pointer_space &&
4844 $post_pointer_space =~ /^\s/) {
4846 "Unnecessary space before function pointer name\n" . $herecurr);
4849 # unnecessary space "type (*funcptr )(args...)"
4850 if (defined $post_funcname_space &&
4851 $post_funcname_space =~ /^\s/) {
4853 "Unnecessary space after function pointer name\n" . $herecurr);
4856 # unnecessary space "type (*funcptr) (args...)"
4857 if (defined $pre_args_space &&
4858 $pre_args_space =~ /^\s/) {
4860 "Unnecessary space before function pointer arguments\n" . $herecurr);
4863 if (show_type("SPACING") && $fix) {
4864 $fixed[$fixlinenr] =~
4865 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4869 # check for spacing round square brackets; allowed:
4870 # 1. with a type on the left -- int [] a;
4871 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4872 # 3. inside a curly brace -- = { [0...10] = 5 }
4873 while ($line =~ /(.*?\s)\[/g) {
4874 my ($where, $prefix) = ($-[1], $1);
4875 if ($prefix !~ /$Type\s+$/ &&
4876 ($where != 0 || $prefix !~ /^.\s+$/) &&
4877 $prefix !~ /[{,:]\s+$/) {
4878 if (ERROR("BRACKET_SPACE",
4879 "space prohibited before open square bracket '['\n" . $herecurr) &&
4881 $fixed[$fixlinenr] =~
4882 s/^(\+.*?)\s+\[/$1\[/;
4887 # check for spaces between functions and their parentheses.
4888 while ($line =~ /($Ident)\s+\(/g) {
4890 my $ctx_before = substr($line, 0, $-[1]);
4891 my $ctx = "$ctx_before$name";
4893 # Ignore those directives where spaces _are_ permitted.
4895 if|for|while|switch|return|case|
4896 volatile|__volatile__|
4897 __attribute__|format|__extension__|
4900 # cpp #define statements have non-optional spaces, ie
4901 # if there is a space between the name and the open
4902 # parenthesis it is simply not a parameter group.
4903 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4905 # cpp #elif statement condition may start with a (
4906 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4908 # If this whole things ends with a type its most
4909 # likely a typedef for a function.
4910 } elsif ($ctx =~ /$Type$/) {
4914 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4916 $fixed[$fixlinenr] =~
4917 s/\b$name\s+\(/$name\(/;
4922 # Check operator spacing.
4923 if (!($line=~/\#\s*include/)) {
4924 my $fixed_line = "";
4928 <<=|>>=|<=|>=|==|!=|
4929 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4930 =>|->|<<|>>|<|>|=|!|~|
4931 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4934 my @elements = split(/($ops|;)/, $opline);
4936 ## print("element count: <" . $#elements . ">\n");
4937 ## foreach my $el (@elements) {
4938 ## print("el: <$el>\n");
4941 my @fix_elements = ();
4944 foreach my $el (@elements) {
4945 push(@fix_elements, substr($rawline, $off, length($el)));
4946 $off += length($el);
4951 my $blank = copy_spacing($opline);
4952 my $last_after = -1;
4954 for (my $n = 0; $n < $#elements; $n += 2) {
4956 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4958 ## print("n: <$n> good: <$good>\n");
4960 $off += length($elements[$n]);
4962 # Pick up the preceding and succeeding characters.
4963 my $ca = substr($opline, 0, $off);
4965 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4966 $cc = substr($opline, $off + length($elements[$n + 1]));
4968 my $cb = "$ca$;$cc";
4971 $a = 'V' if ($elements[$n] ne '');
4972 $a = 'W' if ($elements[$n] =~ /\s$/);
4973 $a = 'C' if ($elements[$n] =~ /$;$/);
4974 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4975 $a = 'O' if ($elements[$n] eq '');
4976 $a = 'E' if ($ca =~ /^\s*$/);
4978 my $op = $elements[$n + 1];
4981 if (defined $elements[$n + 2]) {
4982 $c = 'V' if ($elements[$n + 2] ne '');
4983 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4984 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4985 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4986 $c = 'O' if ($elements[$n + 2] eq '');
4987 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4992 my $ctx = "${a}x${c}";
4994 my $at = "(ctx:$ctx)";
4996 my $ptr = substr($blank, 0, $off) . "^";
4997 my $hereptr = "$hereline$ptr\n";
4999 # Pull out the value of this operator.
5000 my $op_type = substr($curr_values, $off + 1, 1);
5002 # Get the full operator variant.
5003 my $opv = $op . substr($curr_vars, $off, 1);
5005 # Ignore operators passed as parameters.
5006 if ($op_type ne 'V' &&
5007 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
5010 # } elsif ($op =~ /^$;+$/) {
5012 # ; should have either the end of line or a space or \ after it
5013 } elsif ($op eq ';') {
5014 if ($ctx !~ /.x[WEBC]/ &&
5015 $cc !~ /^\\/ && $cc !~ /^;/) {
5016 if (ERROR("SPACING",
5017 "space required after that '$op' $at\n" . $hereptr)) {
5018 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5024 } elsif ($op eq '//') {
5026 # : when part of a bitfield
5027 } elsif ($opv eq ':B') {
5028 # skip the bitfield test for now
5032 } elsif ($op eq '->') {
5033 if ($ctx =~ /Wx.|.xW/) {
5034 if (ERROR("SPACING",
5035 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
5036 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5037 if (defined $fix_elements[$n + 2]) {
5038 $fix_elements[$n + 2] =~ s/^\s+//;
5044 # , must not have a space before and must have a space on the right.
5045 } elsif ($op eq ',') {
5046 my $rtrim_before = 0;
5047 my $space_after = 0;
5048 if ($ctx =~ /Wx./) {
5049 if (ERROR("SPACING",
5050 "space prohibited before that '$op' $at\n" . $hereptr)) {
5055 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
5056 if (ERROR("SPACING",
5057 "space required after that '$op' $at\n" . $hereptr)) {
5063 if ($rtrim_before || $space_after) {
5064 if ($rtrim_before) {
5065 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5067 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5074 # '*' as part of a type definition -- reported already.
5075 } elsif ($opv eq '*_') {
5076 #warn "'*' is part of type\n";
5078 # unary operators should have a space before and
5079 # none after. May be left adjacent to another
5080 # unary operator, or a cast
5081 } elsif ($op eq '!' || $op eq '~' ||
5082 $opv eq '*U' || $opv eq '-U' ||
5083 $opv eq '&U' || $opv eq '&&U') {
5084 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
5085 if (ERROR("SPACING",
5086 "space required before that '$op' $at\n" . $hereptr)) {
5087 if ($n != $last_after + 2) {
5088 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
5093 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
5094 # A unary '*' may be const
5096 } elsif ($ctx =~ /.xW/) {
5097 if (ERROR("SPACING",
5098 "space prohibited after that '$op' $at\n" . $hereptr)) {
5099 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
5100 if (defined $fix_elements[$n + 2]) {
5101 $fix_elements[$n + 2] =~ s/^\s+//;
5107 # unary ++ and unary -- are allowed no space on one side.
5108 } elsif ($op eq '++' or $op eq '--') {
5109 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
5110 if (ERROR("SPACING",
5111 "space required one side of that '$op' $at\n" . $hereptr)) {
5112 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5116 if ($ctx =~ /Wx[BE]/ ||
5117 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
5118 if (ERROR("SPACING",
5119 "space prohibited before that '$op' $at\n" . $hereptr)) {
5120 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5124 if ($ctx =~ /ExW/) {
5125 if (ERROR("SPACING",
5126 "space prohibited after that '$op' $at\n" . $hereptr)) {
5127 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5128 if (defined $fix_elements[$n + 2]) {
5129 $fix_elements[$n + 2] =~ s/^\s+//;
5135 # << and >> may either have or not have spaces both sides
5136 } elsif ($op eq '<<' or $op eq '>>' or
5137 $op eq '&' or $op eq '^' or $op eq '|' or
5138 $op eq '+' or $op eq '-' or
5139 $op eq '*' or $op eq '/' or
5143 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
5145 "spaces preferred around that '$op' $at\n" . $hereptr)) {
5146 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5147 $fix_elements[$n + 2] =~ s/^\s+//;
5150 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
5152 "space preferred before that '$op' $at\n" . $hereptr)) {
5153 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
5157 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
5158 if (ERROR("SPACING",
5159 "need consistent spacing around '$op' $at\n" . $hereptr)) {
5160 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5161 if (defined $fix_elements[$n + 2]) {
5162 $fix_elements[$n + 2] =~ s/^\s+//;
5168 # A colon needs no spaces before when it is
5169 # terminating a case value or a label.
5170 } elsif ($opv eq ':C' || $opv eq ':L') {
5171 if ($ctx =~ /Wx./ and $realfile !~ m@.*\.lds\.h$@) {
5172 if (ERROR("SPACING",
5173 "space prohibited before that '$op' $at\n" . $hereptr)) {
5174 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5179 # All the others need spaces both sides.
5180 } elsif ($ctx !~ /[EWC]x[CWE]/) {
5183 # Ignore email addresses <foo@bar>
5185 $cc =~ /^\S+\@\S+>/) ||
5187 $ca =~ /<\S+\@\S+$/))
5192 # for asm volatile statements
5193 # ignore a colon with another
5194 # colon immediately before or after
5196 ($ca =~ /:$/ || $cc =~ /^:/)) {
5200 # messages are ERROR, but ?: are CHK
5202 my $msg_level = \&ERROR;
5203 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
5205 if (&{$msg_level}("SPACING",
5206 "spaces required around that '$op' $at\n" . $hereptr)) {
5207 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5208 if (defined $fix_elements[$n + 2]) {
5209 $fix_elements[$n + 2] =~ s/^\s+//;
5215 $off += length($elements[$n + 1]);
5217 ## print("n: <$n> GOOD: <$good>\n");
5219 $fixed_line = $fixed_line . $good;
5222 if (($#elements % 2) == 0) {
5223 $fixed_line = $fixed_line . $fix_elements[$#elements];
5226 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
5227 $fixed[$fixlinenr] = $fixed_line;
5233 # check for whitespace before a non-naked semicolon
5234 if ($line =~ /^\+.*\S\s+;\s*$/) {
5236 "space prohibited before semicolon\n" . $herecurr) &&
5238 1 while $fixed[$fixlinenr] =~
5239 s/^(\+.*\S)\s+;/$1;/;
5243 # check for multiple assignments
5244 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
5245 CHK("MULTIPLE_ASSIGNMENTS",
5246 "multiple assignments should be avoided\n" . $herecurr);
5249 ## # check for multiple declarations, allowing for a function declaration
5251 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
5252 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
5254 ## # Remove any bracketed sections to ensure we do not
5255 ## # falsely report the parameters of functions.
5257 ## while ($ln =~ s/\([^\(\)]*\)//g) {
5259 ## if ($ln =~ /,/) {
5260 ## WARN("MULTIPLE_DECLARATION",
5261 ## "declaring multiple variables together should be avoided\n" . $herecurr);
5265 #need space before brace following if, while, etc
5266 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
5267 $line =~ /\b(?:else|do)\{/) {
5268 if (ERROR("SPACING",
5269 "space required before the open brace '{'\n" . $herecurr) &&
5271 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|else|\)))\{/$1 {/;
5275 ## # check for blank lines before declarations
5276 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
5277 ## $prevrawline =~ /^.\s*$/) {
5279 ## "No blank lines before declarations\n" . $hereprev);
5283 # closing brace should have a space following it when it has anything
5285 if ($line =~ /}(?!(?:,|;|\)|\}))\S/) {
5286 if (ERROR("SPACING",
5287 "space required after that close brace '}'\n" . $herecurr) &&
5289 $fixed[$fixlinenr] =~
5290 s/}((?!(?:,|;|\)))\S)/} $1/;
5294 # check spacing on square brackets
5295 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
5296 if (ERROR("SPACING",
5297 "space prohibited after that open square bracket '['\n" . $herecurr) &&
5299 $fixed[$fixlinenr] =~
5303 if ($line =~ /\s\]/) {
5304 if (ERROR("SPACING",
5305 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
5307 $fixed[$fixlinenr] =~
5312 # check spacing on parentheses
5313 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
5314 $line !~ /for\s*\(\s+;/) {
5315 if (ERROR("SPACING",
5316 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
5318 $fixed[$fixlinenr] =~
5322 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
5323 $line !~ /for\s*\(.*;\s+\)/ &&
5324 $line !~ /:\s+\)/) {
5325 if (ERROR("SPACING",
5326 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
5328 $fixed[$fixlinenr] =~
5333 # check unnecessary parentheses around addressof/dereference single $Lvals
5334 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
5336 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
5338 if (CHK("UNNECESSARY_PARENTHESES",
5339 "Unnecessary parentheses around $var\n" . $herecurr) &&
5341 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
5345 # check for unnecessary parentheses around function pointer uses
5346 # ie: (foo->bar)(); should be foo->bar();
5347 # but not "if (foo->bar) (" to avoid some false positives
5348 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
5350 if (CHK("UNNECESSARY_PARENTHESES",
5351 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
5353 my $var2 = deparenthesize($var);
5355 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
5359 # check for unnecessary parentheses around comparisons in if uses
5360 # when !drivers/staging or command-line uses --strict
5361 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
5362 $perl_version_ok && defined($stat) &&
5363 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
5365 my $test = substr($2, 1, -1);
5367 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
5369 # avoid parentheses around potential macro args
5370 next if ($match =~ /^\s*\w+\s*$/);
5371 if (!defined($herectx)) {
5372 $herectx = $here . "\n";
5373 my $cnt = statement_rawlines($if_stat);
5374 for (my $n = 0; $n < $cnt; $n++) {
5375 my $rl = raw_line($linenr, $n);
5376 $herectx .= $rl . "\n";
5377 last if $rl =~ /^[ \+].*\{/;
5380 CHK("UNNECESSARY_PARENTHESES",
5381 "Unnecessary parentheses around '$match'\n" . $herectx);
5385 # check that goto labels aren't indented (allow a single space indentation)
5386 # and ignore bitfield definitions like foo:1
5387 # Strictly, labels can have whitespace after the identifier and before the :
5388 # but this is not allowed here as many ?: uses would appear to be labels
5389 if ($sline =~ /^.\s+[A-Za-z_][A-Za-z\d_]*:(?!\s*\d+)/ &&
5390 $sline !~ /^. [A-Za-z\d_][A-Za-z\d_]*:/ &&
5391 $sline !~ /^.\s+default:/) {
5392 if (WARN("INDENTED_LABEL",
5393 "labels should not be indented\n" . $herecurr) &&
5395 $fixed[$fixlinenr] =~
5400 # check if a statement with a comma should be two statements like:
5401 # foo = bar(), /* comma should be semicolon */
5403 if (defined($stat) &&
5404 $stat =~ /^\+\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*,\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*;\s*$/) {
5405 my $cnt = statement_rawlines($stat);
5406 my $herectx = get_stat_here($linenr, $cnt, $here);
5407 WARN("SUSPECT_COMMA_SEMICOLON",
5408 "Possible comma where semicolon could be used\n" . $herectx);
5411 # return is not a function
5412 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
5414 if ($perl_version_ok &&
5415 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
5417 $value = deparenthesize($value);
5418 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
5419 ERROR("RETURN_PARENTHESES",
5420 "return is not a function, parentheses are not required\n" . $herecurr);
5422 } elsif ($spacing !~ /\s+/) {
5424 "space required before the open parenthesis '('\n" . $herecurr);
5428 # unnecessary return in a void function
5429 # at end-of-function, with the previous line a single leading tab, then return;
5430 # and the line before that not a goto label target like "out:"
5431 if ($sline =~ /^[ \+]}\s*$/ &&
5432 $prevline =~ /^\+\treturn\s*;\s*$/ &&
5434 $lines[$linenr - 3] =~ /^[ +]/ &&
5435 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
5437 "void function return statements are not generally useful\n" . $hereprev);
5440 # if statements using unnecessary parentheses - ie: if ((foo == bar))
5441 if ($perl_version_ok &&
5442 $line =~ /\bif\s*((?:\(\s*){2,})/) {
5443 my $openparens = $1;
5444 my $count = $openparens =~ tr@\(@\(@;
5446 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
5447 my $comp = $4; #Not $1 because of $LvalOrFunc
5448 $msg = " - maybe == should be = ?" if ($comp eq "==");
5449 WARN("UNNECESSARY_PARENTHESES",
5450 "Unnecessary parentheses$msg\n" . $herecurr);
5454 # comparisons with a constant or upper case identifier on the left
5455 # avoid cases like "foo + BAR < baz"
5456 # only fix matches surrounded by parentheses to avoid incorrect
5457 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
5458 if ($perl_version_ok &&
5459 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
5464 my $newcomp = $comp;
5465 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
5466 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
5467 WARN("CONSTANT_COMPARISON",
5468 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
5472 } elsif ($comp eq "<=") {
5474 } elsif ($comp eq ">") {
5476 } elsif ($comp eq ">=") {
5479 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
5483 # Return of what appears to be an errno should normally be negative
5484 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
5486 if ($name ne 'EOF' && $name ne 'ERROR' && $name !~ /^EPOLL/) {
5487 WARN("USE_NEGATIVE_ERRNO",
5488 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
5492 # Need a space before open parenthesis after if, while etc
5493 if ($line =~ /\b(if|while|for|switch)\(/) {
5494 if (ERROR("SPACING",
5495 "space required before the open parenthesis '('\n" . $herecurr) &&
5497 $fixed[$fixlinenr] =~
5498 s/\b(if|while|for|switch)\(/$1 \(/;
5502 # Check for illegal assignment in if conditional -- and check for trailing
5503 # statements after the conditional.
5504 if ($line =~ /do\s*(?!{)/) {
5505 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
5506 ctx_statement_block($linenr, $realcnt, 0)
5507 if (!defined $stat);
5508 my ($stat_next) = ctx_statement_block($line_nr_next,
5509 $remain_next, $off_next);
5510 $stat_next =~ s/\n./\n /g;
5511 ##print "stat<$stat> stat_next<$stat_next>\n";
5513 if ($stat_next =~ /^\s*while\b/) {
5514 # If the statement carries leading newlines,
5515 # then count those as offsets.
5517 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
5519 statement_rawlines($whitespace) - 1;
5521 $suppress_whiletrailers{$line_nr_next +
5525 if (!defined $suppress_whiletrailers{$linenr} &&
5526 defined($stat) && defined($cond) &&
5527 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
5528 my ($s, $c) = ($stat, $cond);
5530 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
5531 if (ERROR("ASSIGN_IN_IF",
5532 "do not use assignment in if condition\n" . $herecurr) &&
5533 $fix && $perl_version_ok) {
5534 if ($rawline =~ /^\+(\s+)if\s*\(\s*(\!)?\s*\(\s*(($Lval)\s*=\s*$LvalOrFunc)\s*\)\s*(?:($Compare)\s*($FuncArg))?\s*\)\s*(\{)?\s*$/) {
5542 fix_delete_line($fixlinenr, $rawline);
5543 fix_insert_line($fixlinenr, "$space$statement;");
5544 my $newline = "${space}if (";
5545 $newline .= '!' if defined($not);
5546 $newline .= '(' if (defined $not && defined($test) && defined($against));
5547 $newline .= "$assigned";
5548 $newline .= " $test $against" if (defined($test) && defined($against));
5549 $newline .= ')' if (defined $not && defined($test) && defined($against));
5551 $newline .= " {" if (defined($brace));
5552 fix_insert_line($fixlinenr + 1, $newline);
5557 # Find out what is on the end of the line after the
5559 substr($s, 0, length($c), '');
5561 $s =~ s/$;//g; # Remove any comments
5562 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
5563 $c !~ /}\s*while\s*/)
5565 # Find out how long the conditional actually is.
5566 my @newlines = ($c =~ /\n/gs);
5567 my $cond_lines = 1 + $#newlines;
5570 $stat_real = raw_line($linenr, $cond_lines)
5571 . "\n" if ($cond_lines);
5572 if (defined($stat_real) && $cond_lines > 1) {
5573 $stat_real = "[...]\n$stat_real";
5576 ERROR("TRAILING_STATEMENTS",
5577 "trailing statements should be on next line\n" . $herecurr . $stat_real);
5581 # Check for bitwise tests written as boolean
5593 WARN("HEXADECIMAL_BOOLEAN_TEST",
5594 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
5597 # if and else should not have general statements after it
5598 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
5600 $s =~ s/$;//g; # Remove any comments
5601 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
5602 ERROR("TRAILING_STATEMENTS",
5603 "trailing statements should be on next line\n" . $herecurr);
5606 # if should not continue a brace
5607 if ($line =~ /}\s*if\b/) {
5608 ERROR("TRAILING_STATEMENTS",
5609 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
5612 # case and default should not have general statements after them
5613 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
5615 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
5619 ERROR("TRAILING_STATEMENTS",
5620 "trailing statements should be on next line\n" . $herecurr);
5623 # Check for }<nl>else {, these must be at the same
5624 # indent level to be relevant to each other.
5625 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
5626 $previndent == $indent) {
5627 if (ERROR("ELSE_AFTER_BRACE",
5628 "else should follow close brace '}'\n" . $hereprev) &&
5629 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5630 fix_delete_line($fixlinenr - 1, $prevrawline);
5631 fix_delete_line($fixlinenr, $rawline);
5632 my $fixedline = $prevrawline;
5633 $fixedline =~ s/}\s*$//;
5634 if ($fixedline !~ /^\+\s*$/) {
5635 fix_insert_line($fixlinenr, $fixedline);
5637 $fixedline = $rawline;
5638 $fixedline =~ s/^(.\s*)else/$1} else/;
5639 fix_insert_line($fixlinenr, $fixedline);
5643 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
5644 $previndent == $indent) {
5645 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
5647 # Find out what is on the end of the line after the
5649 substr($s, 0, length($c), '');
5652 if ($s =~ /^\s*;/) {
5653 if (ERROR("WHILE_AFTER_BRACE",
5654 "while should follow close brace '}'\n" . $hereprev) &&
5655 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5656 fix_delete_line($fixlinenr - 1, $prevrawline);
5657 fix_delete_line($fixlinenr, $rawline);
5658 my $fixedline = $prevrawline;
5659 my $trailing = $rawline;
5660 $trailing =~ s/^\+//;
5661 $trailing = trim($trailing);
5662 $fixedline =~ s/}\s*$/} $trailing/;
5663 fix_insert_line($fixlinenr, $fixedline);
5668 #Specific variable tests
5669 while ($line =~ m{($Constant|$Lval)}g) {
5673 if ($var !~ /^$Constant$/ &&
5674 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
5675 #Ignore some autogenerated defines and enum values
5676 $var !~ /^(?:[A-Z]+_){1,5}[A-Z]{1,3}[a-z]/ &&
5677 #Ignore Page<foo> variants
5678 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
5679 #Ignore SI style variants like nS, mV and dB
5680 #(ie: max_uV, regulator_min_uA_show, RANGE_mA_VALUE)
5681 $var !~ /^(?:[a-z0-9_]*|[A-Z0-9_]*)?_?[a-z][A-Z](?:_[a-z0-9_]+|_[A-Z0-9_]+)?$/ &&
5682 #Ignore some three character SI units explicitly, like MiB and KHz
5683 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
5684 while ($var =~ m{($Ident)}g) {
5686 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
5688 seed_camelcase_includes();
5689 if (!$file && !$camelcase_file_seeded) {
5690 seed_camelcase_file($realfile);
5691 $camelcase_file_seeded = 1;
5694 if (!defined $camelcase{$word}) {
5695 $camelcase{$word} = 1;
5697 "Avoid CamelCase: <$word>\n" . $herecurr);
5703 #no spaces allowed after \ in define
5704 if ($line =~ /\#\s*define.*\\\s+$/) {
5705 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
5706 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
5708 $fixed[$fixlinenr] =~ s/\s+$//;
5712 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
5713 # itself <asm/foo.h> (uses RAW line)
5714 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
5716 my $checkfile = "include/linux/$file";
5717 if (-f "$root/$checkfile" &&
5718 $realfile ne $checkfile &&
5719 $1 !~ /$allowed_asm_includes/)
5721 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
5722 if ($asminclude > 0) {
5723 if ($realfile =~ m{^arch/}) {
5724 CHK("ARCH_INCLUDE_LINUX",
5725 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5727 WARN("INCLUDE_LINUX",
5728 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5734 # multi-statement macros should be enclosed in a do while loop, grab the
5735 # first statement and ensure its the whole macro if its not enclosed
5736 # in a known good container
5737 if ($realfile !~ m@/vmlinux.lds.h$@ &&
5738 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
5741 my ($off, $dstat, $dcond, $rest);
5743 my $has_flow_statement = 0;
5744 my $has_arg_concat = 0;
5745 ($dstat, $dcond, $ln, $cnt, $off) =
5746 ctx_statement_block($linenr, $realcnt, 0);
5748 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
5749 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
5751 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
5752 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
5754 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
5755 my $define_args = $1;
5756 my $define_stmt = $dstat;
5759 if (defined $define_args && $define_args ne "") {
5760 $define_args = substr($define_args, 1, length($define_args) - 2);
5761 $define_args =~ s/\s*//g;
5762 $define_args =~ s/\\\+?//g;
5763 @def_args = split(",", $define_args);
5767 $dstat =~ s/\\\n.//g;
5768 $dstat =~ s/^\s*//s;
5769 $dstat =~ s/\s*$//s;
5771 # Flatten any parentheses and braces
5772 while ($dstat =~ s/\([^\(\)]*\)/1u/ ||
5773 $dstat =~ s/\{[^\{\}]*\}/1u/ ||
5774 $dstat =~ s/.\[[^\[\]]*\]/1u/)
5778 # Flatten any obvious string concatenation.
5779 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
5780 $dstat =~ s/$Ident\s*($String)/$1/)
5784 # Make asm volatile uses seem like a generic function
5785 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
5787 my $exceptions = qr{
5800 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
5803 my $stmt_cnt = statement_rawlines($ctx);
5804 my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
5807 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
5808 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
5809 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
5810 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
5811 $dstat !~ /$exceptions/ &&
5812 $dstat !~ /^\.$Ident\s*=/ && # .foo =
5813 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
5814 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
5815 $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ && # while (...) {...}
5816 $dstat !~ /^for\s*$Constant$/ && # for (...)
5817 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
5818 $dstat !~ /^do\s*{/ && # do {...
5819 $dstat !~ /^\(\{/ && # ({...
5820 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
5822 if ($dstat =~ /^\s*if\b/) {
5823 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5824 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5825 } elsif ($dstat =~ /;/) {
5826 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5827 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5829 ERROR("COMPLEX_MACRO",
5830 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5835 # Make $define_stmt single line, comment-free, etc
5836 my @stmt_array = split('\n', $define_stmt);
5839 foreach my $l (@stmt_array) {
5844 } elsif ($l =~ /^[\+ ]/) {
5845 $define_stmt .= substr($l, 1);
5848 $define_stmt =~ s/$;//g;
5849 $define_stmt =~ s/\s+/ /g;
5850 $define_stmt = trim($define_stmt);
5852 # check if any macro arguments are reused (ignore '...' and 'type')
5853 foreach my $arg (@def_args) {
5854 next if ($arg =~ /\.\.\./);
5855 next if ($arg =~ /^type$/i);
5856 my $tmp_stmt = $define_stmt;
5857 $tmp_stmt =~ s/\b(__must_be_array|offsetof|sizeof|sizeof_field|__stringify|typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
5858 $tmp_stmt =~ s/\#+\s*$arg\b//g;
5859 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
5860 my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
5862 CHK("MACRO_ARG_REUSE",
5863 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
5865 # check if any macro arguments may have other precedence issues
5866 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
5867 ((defined($1) && $1 ne ',') ||
5868 (defined($2) && $2 ne ','))) {
5869 CHK("MACRO_ARG_PRECEDENCE",
5870 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
5874 # check for macros with flow control, but without ## concatenation
5875 # ## concatenation is commonly a macro that defines a function so ignore those
5876 if ($has_flow_statement && !$has_arg_concat) {
5877 my $cnt = statement_rawlines($ctx);
5878 my $herectx = get_stat_here($linenr, $cnt, $here);
5880 WARN("MACRO_WITH_FLOW_CONTROL",
5881 "Macros with flow control statements should be avoided\n" . "$herectx");
5884 # check for line continuations outside of #defines, preprocessor #, and asm
5887 if ($prevline !~ /^..*\\$/ &&
5888 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
5889 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
5890 $line =~ /^\+.*\\$/) {
5891 WARN("LINE_CONTINUATIONS",
5892 "Avoid unnecessary line continuations\n" . $herecurr);
5896 # do {} while (0) macro tests:
5897 # single-statement macros do not need to be enclosed in do while (0) loop,
5898 # macro should not end with a semicolon
5899 if ($perl_version_ok &&
5900 $realfile !~ m@/vmlinux.lds.h$@ &&
5901 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5904 my ($off, $dstat, $dcond, $rest);
5906 ($dstat, $dcond, $ln, $cnt, $off) =
5907 ctx_statement_block($linenr, $realcnt, 0);
5910 $dstat =~ s/\\\n.//g;
5913 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5918 my $cnt = statement_rawlines($ctx);
5919 my $herectx = get_stat_here($linenr, $cnt, $here);
5921 if (($stmts =~ tr/;/;/) == 1 &&
5922 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5923 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5924 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5926 if (defined $semis && $semis ne "") {
5927 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5928 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5930 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5932 my $cnt = statement_rawlines($ctx);
5933 my $herectx = get_stat_here($linenr, $cnt, $here);
5935 WARN("TRAILING_SEMICOLON",
5936 "macros should not use a trailing semicolon\n" . "$herectx");
5940 # check for redundant bracing round if etc
5941 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5942 my ($level, $endln, @chunks) =
5943 ctx_statement_full($linenr, $realcnt, 1);
5944 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5945 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5946 if ($#chunks > 0 && $level == 0) {
5950 my $herectx = $here . "\n";
5951 my $ln = $linenr - 1;
5952 for my $chunk (@chunks) {
5953 my ($cond, $block) = @{$chunk};
5955 # If the condition carries leading newlines, then count those as offsets.
5956 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5957 my $offset = statement_rawlines($whitespace) - 1;
5959 $allowed[$allow] = 0;
5960 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5962 # We have looked at and allowed this specific line.
5963 $suppress_ifbraces{$ln + $offset} = 1;
5965 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5966 $ln += statement_rawlines($block) - 1;
5968 substr($block, 0, length($cond), '');
5970 $seen++ if ($block =~ /^\s*{/);
5972 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5973 if (statement_lines($cond) > 1) {
5974 #print "APW: ALLOWED: cond<$cond>\n";
5975 $allowed[$allow] = 1;
5977 if ($block =~/\b(?:if|for|while)\b/) {
5978 #print "APW: ALLOWED: block<$block>\n";
5979 $allowed[$allow] = 1;
5981 if (statement_block_size($block) > 1) {
5982 #print "APW: ALLOWED: lines block<$block>\n";
5983 $allowed[$allow] = 1;
5988 my $sum_allowed = 0;
5989 foreach (@allowed) {
5992 if ($sum_allowed == 0) {
5994 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5995 } elsif ($sum_allowed != $allow &&
5998 "braces {} should be used on all arms of this statement\n" . $herectx);
6003 if (!defined $suppress_ifbraces{$linenr - 1} &&
6004 $line =~ /\b(if|while|for|else)\b/) {
6007 # Check the pre-context.
6008 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
6009 #print "APW: ALLOWED: pre<$1>\n";
6013 my ($level, $endln, @chunks) =
6014 ctx_statement_full($linenr, $realcnt, $-[0]);
6016 # Check the condition.
6017 my ($cond, $block) = @{$chunks[0]};
6018 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
6019 if (defined $cond) {
6020 substr($block, 0, length($cond), '');
6022 if (statement_lines($cond) > 1) {
6023 #print "APW: ALLOWED: cond<$cond>\n";
6026 if ($block =~/\b(?:if|for|while)\b/) {
6027 #print "APW: ALLOWED: block<$block>\n";
6030 if (statement_block_size($block) > 1) {
6031 #print "APW: ALLOWED: lines block<$block>\n";
6034 # Check the post-context.
6035 if (defined $chunks[1]) {
6036 my ($cond, $block) = @{$chunks[1]};
6037 if (defined $cond) {
6038 substr($block, 0, length($cond), '');
6040 if ($block =~ /^\s*\{/) {
6041 #print "APW: ALLOWED: chunk-1 block<$block>\n";
6045 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
6046 my $cnt = statement_rawlines($block);
6047 my $herectx = get_stat_here($linenr, $cnt, $here);
6050 "braces {} are not necessary for single statement blocks\n" . $herectx);
6054 # check for single line unbalanced braces
6055 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
6056 $sline =~ /^.\s*else\s*\{\s*$/) {
6057 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
6060 # check for unnecessary blank lines around braces
6061 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
6063 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
6064 $fix && $prevrawline =~ /^\+/) {
6065 fix_delete_line($fixlinenr - 1, $prevrawline);
6068 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
6070 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
6072 fix_delete_line($fixlinenr, $rawline);
6076 # no volatiles please
6077 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
6078 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
6080 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
6083 # Check for user-visible strings broken across lines, which breaks the ability
6084 # to grep for the string. Make exceptions when the previous string ends in a
6085 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
6086 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
6087 if ($line =~ /^\+\s*$String/ &&
6088 $prevline =~ /"\s*$/ &&
6089 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
6090 if (WARN("SPLIT_STRING",
6091 "quoted string split across lines\n" . $hereprev) &&
6093 $prevrawline =~ /^\+.*"\s*$/ &&
6094 $last_coalesced_string_linenr != $linenr - 1) {
6095 my $extracted_string = get_quoted_string($line, $rawline);
6096 my $comma_close = "";
6097 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
6101 fix_delete_line($fixlinenr - 1, $prevrawline);
6102 fix_delete_line($fixlinenr, $rawline);
6103 my $fixedline = $prevrawline;
6104 $fixedline =~ s/"\s*$//;
6105 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
6106 fix_insert_line($fixlinenr - 1, $fixedline);
6107 $fixedline = $rawline;
6108 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
6109 if ($fixedline !~ /\+\s*$/) {
6110 fix_insert_line($fixlinenr, $fixedline);
6112 $last_coalesced_string_linenr = $linenr;
6116 # check for missing a space in a string concatenation
6117 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
6118 WARN('MISSING_SPACE',
6119 "break quoted strings at a space character\n" . $hereprev);
6122 # check for an embedded function name in a string when the function is known
6123 # This does not work very well for -f --file checking as it depends on patch
6124 # context providing the function name or a single line form for in-file
6125 # function declarations
6126 if ($line =~ /^\+.*$String/ &&
6127 defined($context_function) &&
6128 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
6129 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
6130 WARN("EMBEDDED_FUNCTION_NAME",
6131 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
6134 # check for unnecessary function tracing like uses
6135 # This does not use $logFunctions because there are many instances like
6136 # 'dprintk(FOO, "%s()\n", __func__);' which do not match $logFunctions
6137 if ($rawline =~ /^\+.*\([^"]*"$tracing_logging_tags{0,3}%s(?:\s*\(\s*\)\s*)?$tracing_logging_tags{0,3}(?:\\n)?"\s*,\s*__func__\s*\)\s*;/) {
6138 if (WARN("TRACING_LOGGING",
6139 "Unnecessary ftrace-like logging - prefer using ftrace\n" . $herecurr) &&
6141 fix_delete_line($fixlinenr, $rawline);
6145 # check for spaces before a quoted newline
6146 if ($rawline =~ /^.*\".*\s\\n/) {
6147 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
6148 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
6150 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
6155 # concatenated string without spaces between elements
6156 if ($line =~ /$String[A-Z_]/ ||
6157 ($line =~ /([A-Za-z0-9_]+)$String/ && $1 !~ /^[Lu]$/)) {
6158 if (CHK("CONCATENATED_STRING",
6159 "Concatenated strings should use spaces between elements\n" . $herecurr) &&
6161 while ($line =~ /($String)/g) {
6162 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6163 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
6164 $fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
6169 # uncoalesced string fragments
6170 if ($line =~ /$String\s*[Lu]?"/) {
6171 if (WARN("STRING_FRAGMENTS",
6172 "Consecutive strings are generally better as a single string\n" . $herecurr) &&
6174 while ($line =~ /($String)(?=\s*")/g) {
6175 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6176 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
6181 # check for non-standard and hex prefixed decimal printf formats
6182 my $show_L = 1; #don't show the same defect twice
6184 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
6185 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
6186 $string =~ s/%%/__/g;
6188 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
6190 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
6194 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
6196 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
6199 # check for 0x<decimal>
6200 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
6201 ERROR("PRINTF_0XDECIMAL",
6202 "Prefixing 0x with decimal output is defective\n" . $herecurr);
6206 # check for line continuations in quoted strings with odd counts of "
6207 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
6208 WARN("LINE_CONTINUATIONS",
6209 "Avoid line continuations in quoted strings\n" . $herecurr);
6213 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
6215 "Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
6219 if ($line =~ /^.\s*\#\s*if\s+1\b/) {
6221 "Consider removing the #if 1 and its #endif\n" . $herecurr);
6224 # check for needless "if (<foo>) fn(<foo>)" uses
6225 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
6226 my $tested = quotemeta($1);
6227 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
6228 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
6230 if (WARN('NEEDLESS_IF',
6231 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
6234 my $leading_tabs = "";
6235 my $new_leading_tabs = "";
6236 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
6241 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
6242 $new_leading_tabs = $1;
6243 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
6250 fix_delete_line($fixlinenr - 1, $prevrawline);
6251 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
6257 # check for unnecessary "Out of Memory" messages
6258 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
6259 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
6260 (defined $1 || defined $3) &&
6263 my $testline = $lines[$linenr - 3];
6265 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
6266 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
6268 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
6269 $s !~ /\b__GFP_NOWARN\b/ ) {
6271 "Possible unnecessary 'out of memory' message\n" . $hereprev);
6275 # check for logging functions with KERN_<LEVEL>
6276 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
6277 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
6279 if (WARN("UNNECESSARY_KERN_LEVEL",
6280 "Possible unnecessary $level\n" . $herecurr) &&
6282 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
6286 # check for logging continuations
6287 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
6288 WARN("LOGGING_CONTINUATION",
6289 "Avoid logging continuation uses where feasible\n" . $herecurr);
6292 # check for unnecessary use of %h[xudi] and %hh[xudi] in logging functions
6293 if (defined $stat &&
6294 $line =~ /\b$logFunctions\s*\(/ &&
6295 index($stat, '"') >= 0) {
6296 my $lc = $stat =~ tr@\n@@;
6297 $lc = $lc + $linenr;
6298 my $stat_real = get_stat_real($linenr, $lc);
6299 pos($stat_real) = index($stat_real, '"');
6300 while ($stat_real =~ /[^\"%]*(%[\#\d\.\*\-]*(h+)[idux])/g) {
6303 my $lineoff = substr($stat_real, 0, $-[1]) =~ tr@\n@@;
6304 if (WARN("UNNECESSARY_MODIFIER",
6305 "Integer promotion: Using '$h' in '$pspec' is unnecessary\n" . "$here\n$stat_real\n") &&
6306 $fix && $fixed[$fixlinenr + $lineoff] =~ /^\+/) {
6309 $fixed[$fixlinenr + $lineoff] =~ s/\Q$pspec\E/$nspec/;
6314 # check for mask then right shift without a parentheses
6315 if ($perl_version_ok &&
6316 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
6317 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
6318 WARN("MASK_THEN_SHIFT",
6319 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
6322 # check for pointer comparisons to NULL
6323 if ($perl_version_ok) {
6324 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
6327 $equal = "" if ($4 eq "!=");
6328 if (CHK("COMPARISON_TO_NULL",
6329 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
6331 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
6336 # check for bad placement of section $InitAttribute (e.g.: __initdata)
6337 if ($line =~ /(\b$InitAttribute\b)/) {
6339 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
6342 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
6343 ERROR("MISPLACED_INIT",
6344 "$attr should be placed after $var\n" . $herecurr)) ||
6345 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
6346 WARN("MISPLACED_INIT",
6347 "$attr should be placed after $var\n" . $herecurr))) &&
6349 $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;
6354 # check for $InitAttributeData (ie: __initdata) with const
6355 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
6357 $attr =~ /($InitAttributePrefix)(.*)/;
6358 my $attr_prefix = $1;
6360 if (ERROR("INIT_ATTRIBUTE",
6361 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
6363 $fixed[$fixlinenr] =~
6364 s/$InitAttributeData/${attr_prefix}initconst/;
6368 # check for $InitAttributeConst (ie: __initconst) without const
6369 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
6371 if (ERROR("INIT_ATTRIBUTE",
6372 "Use of $attr requires a separate use of const\n" . $herecurr) &&
6374 my $lead = $fixed[$fixlinenr] =~
6375 /(^\+\s*(?:static\s+))/;
6377 $lead = "$lead " if ($lead !~ /^\+$/);
6378 $lead = "${lead}const ";
6379 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
6383 # check for __read_mostly with const non-pointer (should just be const)
6384 if ($line =~ /\b__read_mostly\b/ &&
6385 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
6386 if (ERROR("CONST_READ_MOSTLY",
6387 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
6389 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
6393 # don't use __constant_<foo> functions outside of include/uapi/
6394 if ($realfile !~ m@^include/uapi/@ &&
6395 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
6396 my $constant_func = $1;
6397 my $func = $constant_func;
6398 $func =~ s/^__constant_//;
6399 if (WARN("CONSTANT_CONVERSION",
6400 "$constant_func should be $func\n" . $herecurr) &&
6402 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
6406 # prefer usleep_range over udelay
6407 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
6409 # ignore udelay's < 10, however
6410 if (! ($delay < 10) ) {
6412 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6414 if ($delay > 2000) {
6416 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
6420 # warn about unexpectedly long msleep's
6421 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
6424 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6428 # check for comparisons of jiffies
6429 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
6430 WARN("JIFFIES_COMPARISON",
6431 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
6434 # check for comparisons of get_jiffies_64()
6435 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
6436 WARN("JIFFIES_COMPARISON",
6437 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
6440 # warn about #ifdefs in C files
6441 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
6442 # print "#ifdef in C files should be avoided\n";
6443 # print "$herecurr";
6447 # warn about spacing in #ifdefs
6448 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
6449 if (ERROR("SPACING",
6450 "exactly one space required after that #$1\n" . $herecurr) &&
6452 $fixed[$fixlinenr] =~
6453 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
6458 # check for spinlock_t definitions without a comment.
6459 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
6460 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
6462 if (!ctx_has_comment($first_line, $linenr)) {
6463 CHK("UNCOMMENTED_DEFINITION",
6464 "$1 definition without comment\n" . $herecurr);
6467 # check for memory barriers without a comment.
6474 my $barrier_stems = qr{
6482 my $all_barriers = qr{
6484 smp_(?:$barrier_stems)|
6485 virt_(?:$barrier_stems)
6488 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
6489 if (!ctx_has_comment($first_line, $linenr)) {
6490 WARN("MEMORY_BARRIER",
6491 "memory barrier without comment\n" . $herecurr);
6495 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
6497 if ($realfile !~ m@^include/asm-generic/@ &&
6498 $realfile !~ m@/barrier\.h$@ &&
6499 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
6500 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
6501 WARN("MEMORY_BARRIER",
6502 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6505 # check for waitqueue_active without a comment.
6506 if ($line =~ /\bwaitqueue_active\s*\(/) {
6507 if (!ctx_has_comment($first_line, $linenr)) {
6508 WARN("WAITQUEUE_ACTIVE",
6509 "waitqueue_active without comment\n" . $herecurr);
6513 # check for data_race without a comment.
6514 if ($line =~ /\bdata_race\s*\(/) {
6515 if (!ctx_has_comment($first_line, $linenr)) {
6517 "data_race without comment\n" . $herecurr);
6521 # check of hardware specific defines
6522 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
6524 "architecture specific defines should be avoided\n" . $herecurr);
6527 # check that the storage class is not after a type
6528 if ($line =~ /\b($Type)\s+($Storage)\b/) {
6529 WARN("STORAGE_CLASS",
6530 "storage class '$2' should be located before type '$1'\n" . $herecurr);
6532 # Check that the storage class is at the beginning of a declaration
6533 if ($line =~ /\b$Storage\b/ &&
6534 $line !~ /^.\s*$Storage/ &&
6535 $line =~ /^.\s*(.+?)\$Storage\s/ &&
6536 $1 !~ /[\,\)]\s*$/) {
6537 WARN("STORAGE_CLASS",
6538 "storage class should be at the beginning of the declaration\n" . $herecurr);
6541 # check the location of the inline attribute, that it is between
6542 # storage class and type.
6543 if ($line =~ /\b$Type\s+$Inline\b/ ||
6544 $line =~ /\b$Inline\s+$Storage\b/) {
6545 ERROR("INLINE_LOCATION",
6546 "inline keyword should sit between storage class and type\n" . $herecurr);
6549 # Check for __inline__ and __inline, prefer inline
6550 if ($realfile !~ m@\binclude/uapi/@ &&
6551 $line =~ /\b(__inline__|__inline)\b/) {
6553 "plain inline is preferred over $1\n" . $herecurr) &&
6555 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
6560 # Check for compiler attributes
6561 if ($realfile !~ m@\binclude/uapi/@ &&
6562 $rawline =~ /\b__attribute__\s*\(\s*($balanced_parens)\s*\)/) {
6564 $attr =~ s/\s*\(\s*(.*)\)\s*/$1/;
6567 "alias" => "__alias",
6568 "aligned" => "__aligned",
6569 "always_inline" => "__always_inline",
6570 "assume_aligned" => "__assume_aligned",
6572 "const" => "__attribute_const__",
6574 "designated_init" => "__designated_init",
6575 "externally_visible" => "__visible",
6576 "format" => "printf|scanf",
6577 "gnu_inline" => "__gnu_inline",
6578 "malloc" => "__malloc",
6580 "no_caller_saved_registers" => "__no_caller_saved_registers",
6581 "noclone" => "__noclone",
6582 "noinline" => "noinline",
6583 "nonstring" => "__nonstring",
6584 "noreturn" => "__noreturn",
6585 "packed" => "__packed",
6587 "section" => "__section",
6592 while ($attr =~ /\s*(\w+)\s*(${balanced_parens})?/g) {
6595 $params = $2 if defined($2);
6596 my $curr_attr = $orig_attr;
6597 $curr_attr =~ s/^[\s_]+|[\s_]+$//g;
6598 if (exists($attr_list{$curr_attr})) {
6599 my $new = $attr_list{$curr_attr};
6600 if ($curr_attr eq "format" && $params) {
6601 $params =~ /^\s*\(\s*(\w+)\s*,\s*(.*)/;
6604 $new = "$new$params";
6606 if (WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6607 "Prefer $new over __attribute__(($orig_attr$params))\n" . $herecurr) &&
6609 my $remove = "\Q$orig_attr\E" . '\s*' . "\Q$params\E" . '(?:\s*,\s*)?';
6610 $fixed[$fixlinenr] =~ s/$remove//;
6611 $fixed[$fixlinenr] =~ s/\b__attribute__/$new __attribute__/;
6612 $fixed[$fixlinenr] =~ s/\}\Q$new\E/} $new/;
6613 $fixed[$fixlinenr] =~ s/ __attribute__\s*\(\s*\(\s*\)\s*\)//;
6618 # Check for __attribute__ unused, prefer __always_unused or __maybe_unused
6619 if ($attr =~ /^_*unused/) {
6620 WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6621 "__always_unused or __maybe_unused is preferred over __attribute__((__unused__))\n" . $herecurr);
6625 # Check for __attribute__ weak, or __weak declarations (may have link issues)
6626 if ($perl_version_ok &&
6627 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
6628 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
6629 $line =~ /\b__weak\b/)) {
6630 ERROR("WEAK_DECLARATION",
6631 "Using weak declarations can have unintended link defects\n" . $herecurr);
6634 # check for c99 types like uint8_t used outside of uapi/ and tools/
6635 if ($realfile !~ m@\binclude/uapi/@ &&
6636 $realfile !~ m@\btools/@ &&
6637 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
6639 if ($type =~ /\b($typeC99Typedefs)\b/) {
6641 my $kernel_type = 'u';
6642 $kernel_type = 's' if ($type =~ /^_*[si]/);
6645 if (CHK("PREFER_KERNEL_TYPES",
6646 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6648 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6653 # check for cast of C90 native int or longer types constants
6654 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
6658 my $newconst = $const;
6659 $newconst =~ s/${Int_type}$//;
6660 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6661 if ($cast =~ /\blong\s+long\b/) {
6663 } elsif ($cast =~ /\blong\b/) {
6666 if (WARN("TYPECAST_INT_CONSTANT",
6667 "Unnecessary typecast of c90 int constant - '$cast$const' could be '$const$suffix'\n" . $herecurr) &&
6669 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6673 # check for sizeof(&)
6674 if ($line =~ /\bsizeof\s*\(\s*\&/) {
6675 WARN("SIZEOF_ADDRESS",
6676 "sizeof(& should be avoided\n" . $herecurr);
6679 # check for sizeof without parenthesis
6680 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
6681 if (WARN("SIZEOF_PARENTHESIS",
6682 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6684 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
6688 # check for struct spinlock declarations
6689 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
6690 WARN("USE_SPINLOCK_T",
6691 "struct spinlock should be spinlock_t\n" . $herecurr);
6694 # check for seq_printf uses that could be seq_puts
6695 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
6696 my $fmt = get_quoted_string($line, $rawline);
6699 if (WARN("PREFER_SEQ_PUTS",
6700 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
6702 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6707 # check for vsprintf extension %p<foo> misuses
6708 if ($perl_version_ok &&
6710 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
6711 $1 !~ /^_*volatile_*$/) {
6714 my $lc = $stat =~ tr@\n@@;
6715 $lc = $lc + $linenr;
6716 for (my $count = $linenr; $count <= $lc; $count++) {
6720 my $bad_specifier = "";
6721 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
6724 while ($fmt =~ /(\%[\*\d\.]*p(\w)(\w*))/g) {
6728 if ($extension !~ /[4SsBKRraEehMmIiUDdgVCbGNOxtf]/ ||
6729 ($extension eq "f" &&
6730 defined $qualifier && $qualifier !~ /^w/) ||
6731 ($extension eq "4" &&
6732 defined $qualifier && $qualifier !~ /^cc/)) {
6733 $bad_specifier = $specifier;
6736 if ($extension eq "x" && !defined($stat_real)) {
6737 if (!defined($stat_real)) {
6738 $stat_real = get_stat_real($linenr, $lc);
6740 WARN("VSPRINTF_SPECIFIER_PX",
6741 "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");
6744 if ($bad_specifier ne "") {
6745 my $stat_real = get_stat_real($linenr, $lc);
6746 my $ext_type = "Invalid";
6748 if ($bad_specifier =~ /p[Ff]/) {
6749 $use = " - use %pS instead";
6750 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6753 WARN("VSPRINTF_POINTER_EXTENSION",
6754 "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6759 # Check for misused memsets
6760 if ($perl_version_ok &&
6762 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
6768 if ($ms_size =~ /^(0x|)0$/i) {
6770 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6771 } elsif ($ms_size =~ /^(0x|)1$/i) {
6773 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6777 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6778 # if ($perl_version_ok &&
6780 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6781 # if (WARN("PREFER_ETHER_ADDR_COPY",
6782 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6784 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
6788 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6789 # if ($perl_version_ok &&
6791 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6792 # WARN("PREFER_ETHER_ADDR_EQUAL",
6793 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6796 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6797 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
6798 # if ($perl_version_ok &&
6800 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6804 # if ($ms_val =~ /^(?:0x|)0+$/i) {
6805 # if (WARN("PREFER_ETH_ZERO_ADDR",
6806 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
6808 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
6810 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
6811 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
6812 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
6814 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
6819 # strlcpy uses that should likely be strscpy
6820 if ($line =~ /\bstrlcpy\s*\(/) {
6822 "Prefer strscpy over strlcpy - see: https://lore.kernel.org/r/CAHk-=wgfRnXz0W3D37d01q3JFkr_i_uTL=V6A6G1oUZcprmknw\@mail.gmail.com/\n" . $herecurr);
6825 # typecasts on min/max could be min_t/max_t
6826 if ($perl_version_ok &&
6828 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
6829 if (defined $2 || defined $7) {
6831 my $cast1 = deparenthesize($2);
6833 my $cast2 = deparenthesize($7);
6837 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
6838 $cast = "$cast1 or $cast2";
6839 } elsif ($cast1 ne "") {
6845 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
6849 # check usleep_range arguments
6850 if ($perl_version_ok &&
6852 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
6856 WARN("USLEEP_RANGE",
6857 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6858 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
6860 WARN("USLEEP_RANGE",
6861 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6865 # check for naked sscanf
6866 if ($perl_version_ok &&
6868 $line =~ /\bsscanf\b/ &&
6869 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
6870 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
6871 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
6872 my $lc = $stat =~ tr@\n@@;
6873 $lc = $lc + $linenr;
6874 my $stat_real = get_stat_real($linenr, $lc);
6875 WARN("NAKED_SSCANF",
6876 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
6879 # check for simple sscanf that should be kstrto<foo>
6880 if ($perl_version_ok &&
6882 $line =~ /\bsscanf\b/) {
6883 my $lc = $stat =~ tr@\n@@;
6884 $lc = $lc + $linenr;
6885 my $stat_real = get_stat_real($linenr, $lc);
6886 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
6888 my $count = $format =~ tr@%@%@;
6890 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
6891 WARN("SSCANF_TO_KSTRTO",
6892 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
6897 # check for new externs in .h files.
6898 if ($realfile =~ /\.h$/ &&
6899 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
6900 if (CHK("AVOID_EXTERNS",
6901 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
6903 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
6907 # check for new externs in .c files.
6908 if ($realfile =~ /\.c$/ && defined $stat &&
6909 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
6911 my $function_name = $1;
6912 my $paren_space = $2;
6915 if (defined $cond) {
6916 substr($s, 0, length($cond), '');
6920 WARN("AVOID_EXTERNS",
6921 "externs should be avoided in .c files\n" . $herecurr);
6924 if ($paren_space =~ /\n/) {
6925 WARN("FUNCTION_ARGUMENTS",
6926 "arguments for function declarations should follow identifier\n" . $herecurr);
6929 } elsif ($realfile =~ /\.c$/ && defined $stat &&
6930 $stat =~ /^.\s*extern\s+/)
6932 WARN("AVOID_EXTERNS",
6933 "externs should be avoided in .c files\n" . $herecurr);
6936 # check for function declarations that have arguments without identifier names
6937 if (defined $stat &&
6938 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
6940 my $args = trim($1);
6941 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
6943 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
6944 WARN("FUNCTION_ARGUMENTS",
6945 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
6950 # check for function definitions
6951 if ($perl_version_ok &&
6953 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
6954 $context_function = $1;
6956 # check for multiline function definition with misplaced open brace
6958 my $cnt = statement_rawlines($stat);
6959 my $herectx = $here . "\n";
6960 for (my $n = 0; $n < $cnt; $n++) {
6961 my $rl = raw_line($linenr, $n);
6962 $herectx .= $rl . "\n";
6963 $ok = 1 if ($rl =~ /^[ \+]\{/);
6964 $ok = 1 if ($rl =~ /\{/ && $n == 0);
6965 last if $rl =~ /^[ \+].*\{/;
6969 "open brace '{' following function definitions go on the next line\n" . $herectx);
6973 # checks for new __setup's
6974 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6977 if (!grep(/$name/, @setup_docs)) {
6978 CHK("UNDOCUMENTED_SETUP",
6979 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
6983 # check for pointless casting of alloc functions
6984 if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
6985 WARN("UNNECESSARY_CASTS",
6986 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6990 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6991 if ($perl_version_ok &&
6992 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6993 CHK("ALLOC_SIZEOF_STRUCT",
6994 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6997 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6998 if ($perl_version_ok &&
7000 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
7004 my $newfunc = "kmalloc_array";
7005 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
7008 if ($a1 =~ /^sizeof\s*\S/) {
7012 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
7013 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
7014 my $cnt = statement_rawlines($stat);
7015 my $herectx = get_stat_here($linenr, $cnt, $here);
7017 if (WARN("ALLOC_WITH_MULTIPLY",
7018 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
7021 $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;
7026 # check for krealloc arg reuse
7027 if ($perl_version_ok &&
7028 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*($Lval)\s*,/ &&
7030 WARN("KREALLOC_ARG_REUSE",
7031 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
7034 # check for alloc argument mismatch
7035 if ($line =~ /\b((?:devm_)?(?:kcalloc|kmalloc_array))\s*\(\s*sizeof\b/) {
7036 WARN("ALLOC_ARRAY_ARGS",
7037 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
7040 # check for multiple semicolons
7041 if ($line =~ /;\s*;\s*$/) {
7042 if (WARN("ONE_SEMICOLON",
7043 "Statements terminations use 1 semicolon\n" . $herecurr) &&
7045 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
7049 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
7050 if ($realfile !~ m@^include/uapi/@ &&
7051 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
7053 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
7054 if (CHK("BIT_MACRO",
7055 "Prefer using the BIT$ull macro\n" . $herecurr) &&
7057 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
7061 # check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
7062 if ($rawline =~ /\bIS_ENABLED\s*\(\s*(\w+)\s*\)/ && $1 !~ /^${CONFIG_}/) {
7063 WARN("IS_ENABLED_CONFIG",
7064 "IS_ENABLED($1) is normally used as IS_ENABLED(${CONFIG_}$1)\n" . $herecurr);
7067 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
7068 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(${CONFIG_}[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
7070 if (WARN("PREFER_IS_ENABLED",
7071 "Prefer IS_ENABLED(<FOO>) to ${CONFIG_}<FOO> || ${CONFIG_}<FOO>_MODULE\n" . $herecurr) &&
7073 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
7077 # check for /* fallthrough */ like comment, prefer fallthrough;
7078 my @fallthroughs = (
7081 'lint -fallthrough[ \t]*',
7082 'intentional(?:ly)?[ \t]*fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)',
7083 '(?:else,?\s*)?FALL(?:S | |-)?THR(?:OUGH|U|EW)[ \t.!]*(?:-[^\n\r]*)?',
7084 'Fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7085 'fall(?:s | |-)?thr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7087 if ($raw_comment ne '') {
7088 foreach my $ft (@fallthroughs) {
7089 if ($raw_comment =~ /$ft/) {
7090 my $msg_level = \&WARN;
7091 $msg_level = \&CHK if ($file);
7092 &{$msg_level}("PREFER_FALLTHROUGH",
7093 "Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
7099 # check for switch/default statements without a break;
7100 if ($perl_version_ok &&
7102 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
7103 my $cnt = statement_rawlines($stat);
7104 my $herectx = get_stat_here($linenr, $cnt, $here);
7106 WARN("DEFAULT_NO_BREAK",
7107 "switch default: should use break\n" . $herectx);
7110 # check for gcc specific __FUNCTION__
7111 if ($line =~ /\b__FUNCTION__\b/) {
7112 if (WARN("USE_FUNC",
7113 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
7115 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
7119 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
7120 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
7122 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
7125 # check for use of yield()
7126 if ($line =~ /\byield\s*\(\s*\)/) {
7128 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
7131 # check for comparisons against true and false
7132 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
7140 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
7142 my $type = lc($otype);
7143 if ($type =~ /^(?:true|false)$/) {
7144 if (("$test" eq "==" && "$type" eq "true") ||
7145 ("$test" eq "!=" && "$type" eq "false")) {
7149 CHK("BOOL_COMPARISON",
7150 "Using comparison to $otype is error prone\n" . $herecurr);
7152 ## maybe suggesting a correct construct would better
7153 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
7158 # check for semaphores initialized locked
7159 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
7160 WARN("CONSIDER_COMPLETION",
7161 "consider using a completion\n" . $herecurr);
7164 # recommend kstrto* over simple_strto* and strict_strto*
7165 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
7166 WARN("CONSIDER_KSTRTO",
7167 "$1 is obsolete, use k$3 instead\n" . $herecurr);
7170 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
7171 if ($line =~ /^.\s*__initcall\s*\(/) {
7172 WARN("USE_DEVICE_INITCALL",
7173 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
7176 # check for spin_is_locked(), suggest lockdep instead
7177 if ($line =~ /\bspin_is_locked\(/) {
7179 "Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
7182 # check for deprecated apis
7183 if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
7184 my $deprecated_api = $1;
7185 my $new_api = $deprecated_apis{$deprecated_api};
7186 WARN("DEPRECATED_API",
7187 "Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
7190 # check for various structs that are normally const (ops, kgdb, device_tree)
7191 # and avoid what seem like struct definitions 'struct foo {'
7192 if (defined($const_structs) &&
7193 $line !~ /\bconst\b/ &&
7194 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
7195 WARN("CONST_STRUCT",
7196 "struct $1 should normally be const\n" . $herecurr);
7199 # use of NR_CPUS is usually wrong
7200 # ignore definitions of NR_CPUS and usage to define arrays as likely right
7201 # ignore designated initializers using NR_CPUS
7202 if ($line =~ /\bNR_CPUS\b/ &&
7203 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
7204 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
7205 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
7206 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
7207 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/ &&
7208 $line !~ /^.\s*\.\w+\s*=\s*.*\bNR_CPUS\b/)
7211 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
7214 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
7215 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
7216 ERROR("DEFINE_ARCH_HAS",
7217 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
7220 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
7221 if ($perl_version_ok &&
7222 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
7223 WARN("LIKELY_MISUSE",
7224 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
7227 # return sysfs_emit(foo, fmt, ...) fmt without newline
7228 if ($line =~ /\breturn\s+sysfs_emit\s*\(\s*$FuncArg\s*,\s*($String)/ &&
7229 substr($rawline, $-[6], $+[6] - $-[6]) !~ /\\n"$/) {
7230 my $offset = $+[6] - 1;
7231 if (WARN("SYSFS_EMIT",
7232 "return sysfs_emit(...) formats should include a terminating newline\n" . $herecurr) &&
7234 substr($fixed[$fixlinenr], $offset, 0) = '\\n';
7238 # nested likely/unlikely calls
7239 if ($line =~ /\b(?:(?:un)?likely)\s*\(\s*!?\s*(IS_ERR(?:_OR_NULL|_VALUE)?|WARN)/) {
7240 WARN("LIKELY_MISUSE",
7241 "nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
7244 # whine mightly about in_atomic
7245 if ($line =~ /\bin_atomic\s*\(/) {
7246 if ($realfile =~ m@^drivers/@) {
7248 "do not use in_atomic in drivers\n" . $herecurr);
7249 } elsif ($realfile !~ m@^kernel/@) {
7251 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
7255 # check for lockdep_set_novalidate_class
7256 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
7257 $line =~ /__lockdep_no_validate__\s*\)/ ) {
7258 if ($realfile !~ m@^kernel/lockdep@ &&
7259 $realfile !~ m@^include/linux/lockdep@ &&
7260 $realfile !~ m@^drivers/base/core@) {
7262 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
7266 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
7267 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
7268 WARN("EXPORTED_WORLD_WRITABLE",
7269 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
7272 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
7273 # and whether or not function naming is typical and if
7274 # DEVICE_ATTR permissions uses are unusual too
7275 if ($perl_version_ok &&
7277 $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*\)/) {
7282 my $octal_perms = perms_to_octal($perms);
7283 if ($show =~ /^${var}_show$/ &&
7284 $store =~ /^${var}_store$/ &&
7285 $octal_perms eq "0644") {
7286 if (WARN("DEVICE_ATTR_RW",
7287 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
7289 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
7291 } elsif ($show =~ /^${var}_show$/ &&
7292 $store =~ /^NULL$/ &&
7293 $octal_perms eq "0444") {
7294 if (WARN("DEVICE_ATTR_RO",
7295 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
7297 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
7299 } elsif ($show =~ /^NULL$/ &&
7300 $store =~ /^${var}_store$/ &&
7301 $octal_perms eq "0200") {
7302 if (WARN("DEVICE_ATTR_WO",
7303 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
7305 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
7307 } elsif ($octal_perms eq "0644" ||
7308 $octal_perms eq "0444" ||
7309 $octal_perms eq "0200") {
7310 my $newshow = "$show";
7311 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
7312 my $newstore = $store;
7313 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
7315 if ($show ne $newshow) {
7316 $rename .= " '$show' to '$newshow'";
7318 if ($store ne $newstore) {
7319 $rename .= " '$store' to '$newstore'";
7321 WARN("DEVICE_ATTR_FUNCTIONS",
7322 "Consider renaming function(s)$rename\n" . $herecurr);
7324 WARN("DEVICE_ATTR_PERMS",
7325 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
7329 # Mode permission misuses where it seems decimal should be octal
7330 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
7331 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
7332 # specific definition of not visible in sysfs.
7333 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
7334 # use the default permissions
7335 if ($perl_version_ok &&
7337 $line =~ /$mode_perms_search/) {
7338 foreach my $entry (@mode_permission_funcs) {
7339 my $func = $entry->[0];
7340 my $arg_pos = $entry->[1];
7342 my $lc = $stat =~ tr@\n@@;
7343 $lc = $lc + $linenr;
7344 my $stat_real = get_stat_real($linenr, $lc);
7349 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
7351 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
7352 if ($stat =~ /$test/) {
7354 $val = $6 if ($skip_args ne "");
7355 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
7356 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
7357 ($val =~ /^$Octal$/ && length($val) ne 4))) {
7358 ERROR("NON_OCTAL_PERMISSIONS",
7359 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
7361 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
7362 ERROR("EXPORTED_WORLD_WRITABLE",
7363 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
7369 # check for uses of S_<PERMS> that could be octal for readability
7370 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
7372 my $octal = perms_to_octal($oval);
7373 if (WARN("SYMBOLIC_PERMS",
7374 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
7376 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
7380 # validate content of MODULE_LICENSE against list from include/linux/module.h
7381 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
7382 my $extracted_string = get_quoted_string($line, $rawline);
7383 my $valid_licenses = qr{
7386 GPL\ and\ additional\ rights|
7392 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
7393 WARN("MODULE_LICENSE",
7394 "unknown module license " . $extracted_string . "\n" . $herecurr);
7398 # check for sysctl duplicate constants
7399 if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
7400 WARN("DUPLICATED_SYSCTL_CONST",
7401 "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
7405 # If we have no input at all, then there is nothing to report on
7406 # so just keep quiet.
7407 if ($#rawlines == -1) {
7411 # In mailback mode only produce a report in the negative, for
7412 # things that appear to be patches.
7413 if ($mailback && ($clean == 1 || !$is_patch)) {
7417 # This is not a patch, and we are in 'no-patch' mode so
7419 if (!$chk_patch && !$is_patch) {
7423 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
7424 ERROR("NOT_UNIFIED_DIFF",
7425 "Does not appear to be a unified-diff format patch\n");
7427 if ($is_patch && $has_commit_log && $chk_signoff) {
7428 if ($signoff == 0) {
7429 ERROR("MISSING_SIGN_OFF",
7430 "Missing Signed-off-by: line(s)\n");
7431 } elsif ($authorsignoff != 1) {
7432 # authorsignoff values:
7433 # 0 -> missing sign off
7434 # 1 -> sign off identical
7435 # 2 -> names and addresses match, comments mismatch
7436 # 3 -> addresses match, names different
7437 # 4 -> names match, addresses different
7438 # 5 -> names match, addresses excluding subaddress details (refer RFC 5233) match
7440 my $sob_msg = "'From: $author' != 'Signed-off-by: $author_sob'";
7442 if ($authorsignoff == 0) {
7443 ERROR("NO_AUTHOR_SIGN_OFF",
7444 "Missing Signed-off-by: line by nominal patch author '$author'\n");
7445 } elsif ($authorsignoff == 2) {
7446 CHK("FROM_SIGN_OFF_MISMATCH",
7447 "From:/Signed-off-by: email comments mismatch: $sob_msg\n");
7448 } elsif ($authorsignoff == 3) {
7449 WARN("FROM_SIGN_OFF_MISMATCH",
7450 "From:/Signed-off-by: email name mismatch: $sob_msg\n");
7451 } elsif ($authorsignoff == 4) {
7452 WARN("FROM_SIGN_OFF_MISMATCH",
7453 "From:/Signed-off-by: email address mismatch: $sob_msg\n");
7454 } elsif ($authorsignoff == 5) {
7455 WARN("FROM_SIGN_OFF_MISMATCH",
7456 "From:/Signed-off-by: email subaddress mismatch: $sob_msg\n");
7461 print report_dump();
7462 if ($summary && !($clean == 1 && $quiet == 1)) {
7463 print "$filename " if ($summary_file);
7464 print "total: $cnt_error errors, $cnt_warn warnings, " .
7465 (($check)? "$cnt_chk checks, " : "") .
7466 "$cnt_lines lines checked\n";
7470 # If there were any defects found and not already fixing them
7471 if (!$clean and !$fix) {
7474 NOTE: For some of the reported defects, checkpatch may be able to
7475 mechanically convert to the typical style using --fix or --fix-inplace.
7478 # If there were whitespace errors which cleanpatch can fix
7479 # then suggest that.
7480 if ($rpt_cleaners) {
7484 NOTE: Whitespace errors detected.
7485 You may wish to use scripts/cleanpatch or scripts/cleanfile
7490 if ($clean == 0 && $fix &&
7491 ("@rawlines" ne "@fixed" ||
7492 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
7493 my $newfile = $filename;
7494 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
7498 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
7500 open($f, '>', $newfile)
7501 or die "$P: Can't open $newfile for write\n";
7502 foreach my $fixed_line (@fixed) {
7505 if ($linecount > 3) {
7506 $fixed_line =~ s/^\+//;
7507 print $f $fixed_line . "\n";
7510 print $f $fixed_line . "\n";
7518 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
7520 Do _NOT_ trust the results written to this file.
7521 Do _NOT_ submit these changes without inspecting them for correctness.
7523 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
7524 No warranties, expressed or implied...
7532 print "$vname has no obvious style problems and is ready for submission.\n";
7534 print "$vname has style problems, please review.\n";