2 # (c) 2001, Dave Jones. (the file handling bit)
3 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
5 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
6 # Licensed under the terms of the GNU GPL License version 2
8 # Based on linux/scripts/checkpatch.pl v4.12-11743-g96d0d83 with
9 # some additional Lustre-specific checks.
16 use Term::ANSIColor qw(:constants);
19 my $D = dirname(abs_path($P));
23 use Getopt::Long qw(:config no_auto_abbrev);
53 my $configuration_file = ".checkpatch.conf";
54 my $max_line_length = 80;
55 my $ignore_perl_version = 0;
56 my $minimum_perl_version = 5.10.0;
57 my $min_conf_desc_length = 4;
58 my $spelling_file = "$D/spelling.txt";
60 my $codespellfile = "/usr/share/codespell/dictionary.txt";
61 my $conststructsfile = "$D/const_structs.checkpatch";
62 my $typedefsfile = "";
64 my $allow_c99_comments = 1;
70 Usage: $P [OPTION]... [FILE]...
75 --no-tree run without a kernel tree
76 --no-signoff do not check for 'Signed-off-by' line
77 --patch treat FILE as patchfile (default)
78 --emacs emacs compile window format
79 --terse one line per report
80 --showfile emit diffed file position, not input file position
81 -g, --git treat FILE as a single commit or git revision range
82 single git commit with:
86 multiple git commits with:
90 git merges are ignored
91 -f, --file treat FILE as regular source file
92 --subjective, --strict enable more subjective tests
93 --list-types list the possible message types
94 --types TYPE(,TYPE2...) show only these comma separated message types
95 --ignore TYPE(,TYPE2...) ignore various comma separated message types
96 --show-types show the specific message type in the output
97 --max-line-length=n set the maximum line length, if exceeded, warn
98 --min-conf-desc-length=n set the min description length, if shorter, warn
99 --root=PATH PATH to the kernel tree root
100 --no-summary suppress the per-file summary
101 --mailback only produce a report in case of warnings/errors
102 --summary-file include the filename in summary
103 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
104 'values', 'possible', 'type', and 'attr' (default
106 --test-only=WORD report only warnings/errors containing WORD
108 --fix EXPERIMENTAL - may create horrible results
109 If correctable single-line errors exist, create
110 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
111 with potential errors corrected to the preferred
113 --fix-inplace EXPERIMENTAL - may create horrible results
114 Is the same as --fix, but overwrites the input
115 file. It's your fault if there's no backup or git
116 --ignore-perl-version override checking of perl version. expect
118 --codespell Use the codespell dictionary for spelling/typos
119 (default:/usr/share/codespell/dictionary.txt)
120 --codespellfile Use this codespell dictionary
121 --typedefsfile Read additional types from this file
122 --color[=WHEN] Use colors 'always', 'never', or only when output
123 is a terminal ('auto'). Default is 'auto'.
124 -h, --help, --version display this help and exit
126 When FILE is - read standard input.
134 return grep { !$seen{$_}++ } @_;
144 open(my $script, '<', abs_path($P)) or
145 die "$P: Can't read '$P' $!\n";
147 my $text = <$script>;
151 for ($text =~ /\b(?:(?:CHK|WARN|ERROR)\s*\(\s*"([^"]+)")/g) {
154 @types = sort(uniq(@types));
155 print("#\tMessage type\n\n");
156 foreach my $type (@types) {
157 print(++$count . "\t" . $type . "\n");
163 my $conf = which_conf($configuration_file);
166 open(my $conffile, '<', "$conf")
167 or warn "$P: Can't find a readable $configuration_file file $!\n";
169 while (<$conffile>) {
172 $line =~ s/\s*\n?$//g;
176 next if ($line =~ m/^\s*#/);
177 next if ($line =~ m/^\s*$/);
179 my @words = split(" ", $line);
180 foreach my $word (@words) {
181 last if ($word =~ m/^#/);
182 push (@conf_args, $word);
186 unshift(@ARGV, @conf_args) if @conf_args;
189 # Perl's Getopt::Long allows options to take optional arguments after a space.
190 # Prevent --color by itself from consuming other arguments
192 if ($_ eq "--color" || $_ eq "-color") {
193 $_ = "--color=$color";
198 'q|quiet+' => \$quiet,
200 'signoff!' => \$chk_signoff,
201 'patch!' => \$chk_patch,
204 'showfile!' => \$showfile,
207 'subjective!' => \$check,
208 'strict!' => \$check,
209 'ignore=s' => \@ignore,
211 'show-types!' => \$show_types,
212 'list-types!' => \$list_types,
213 'max-line-length=i' => \$max_line_length,
214 'min-conf-desc-length=i' => \$min_conf_desc_length,
216 'summary!' => \$summary,
217 'mailback!' => \$mailback,
218 'summary-file!' => \$summary_file,
220 'fix-inplace!' => \$fix_inplace,
221 'ignore-perl-version!' => \$ignore_perl_version,
222 'debug=s' => \%debug,
223 'test-only=s' => \$tst_only,
224 'codespell!' => \$codespell,
225 'codespellfile=s' => \$codespellfile,
226 'typedefsfile=s' => \$typedefsfile,
227 'color=s' => \$color,
228 'no-color' => \$color, #keep old behaviors of -nocolor
229 'nocolor' => \$color, #keep old behaviors of -nocolor
236 list_types(0) if ($list_types);
238 $fix = 1 if ($fix_inplace);
239 $check_orig = $check;
243 if ($^V && $^V lt $minimum_perl_version) {
244 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
245 if (!$ignore_perl_version) {
250 #if no filenames are given, push '-' to read patch from stdin
255 if ($color =~ /^[01]$/) {
257 } elsif ($color =~ /^always$/i) {
259 } elsif ($color =~ /^never$/i) {
261 } elsif ($color =~ /^auto$/i) {
262 $color = (-t STDOUT);
264 die "Invalid color mode: $color\n";
267 sub hash_save_array_words {
268 my ($hashRef, $arrayRef) = @_;
270 my @array = split(/,/, join(',', @$arrayRef));
271 foreach my $word (@array) {
272 $word =~ s/\s*\n?$//g;
275 $word =~ tr/[a-z]/[A-Z]/;
277 next if ($word =~ m/^\s*#/);
278 next if ($word =~ m/^\s*$/);
284 sub hash_show_words {
285 my ($hashRef, $prefix) = @_;
287 if (keys %$hashRef) {
288 print "\nNOTE: $prefix message types:";
289 foreach my $word (sort keys %$hashRef) {
296 hash_save_array_words(\%ignore_type, \@ignore);
297 hash_save_array_words(\%use_type, \@use);
300 my $dbg_possible = 0;
303 for my $key (keys %debug) {
305 eval "\${dbg_$key} = '$debug{$key}';";
309 my $rpt_cleaners = 0;
318 if (!top_of_kernel_tree($root)) {
319 die "$P: $root: --root does not point at a valid tree\n";
322 if (top_of_kernel_tree('.')) {
324 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
325 top_of_kernel_tree($1)) {
330 if (!defined $root) {
331 print "Must be run from the top-level dir. of a kernel tree\n";
336 my $emitted_corrupt = 0;
339 [A-Za-z_][A-Za-z\d_]*
340 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
342 our $Storage = qr{extern|static|asmlinkage};
355 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
356 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
357 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
358 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
359 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
361 # Notes to $Attribute:
362 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
383 ____cacheline_aligned|
384 ____cacheline_aligned_in_smp|
385 ____cacheline_internodealigned_in_smp|
389 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
390 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
391 our $Lval = qr{$Ident(?:$Member)*};
393 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
394 our $Binary = qr{(?i)0b[01]+$Int_type?};
395 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
396 our $Int = qr{[0-9]+$Int_type?};
397 our $Octal = qr{0[0-7]+$Int_type?};
398 our $String = qr{"[X\t]*"};
399 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
400 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
401 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
402 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
403 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
404 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
405 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
406 our $Arithmetic = qr{\+|-|\*|\/|%};
410 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
413 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
417 our $NonptrTypeMisordered;
418 our $NonptrTypeWithAttr;
422 our $DeclareMisordered;
424 our $NON_ASCII_UTF8 = qr{
425 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
426 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
427 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
428 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
429 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
430 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
431 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
435 [\x09\x0A\x0D\x20-\x7E] # ASCII
439 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
440 our $typeOtherOSTypedefs = qr{(?x:
441 u_(?:char|short|int|long) | # bsd
442 u(?:nchar|short|int|long) # sysv
444 our $typeKernelTypedefs = qr{(?x:
445 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
448 our $typeTypedefs = qr{(?x:
450 $typeOtherOSTypedefs\b|
451 $typeKernelTypedefs\b
454 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
456 our $logFunctions = qr{(?x:
457 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
458 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
459 WARN(?:_RATELIMIT|_ONCE|)|
460 CDEBUG|CERROR|CNETERR|CEMERG|CL_LOCK_DEBUG|CWARN|DEBUG_REQ|LCONSOLE_[A-Z]*|
463 seq_vprintf|seq_printf|seq_puts
466 our $signature_tags = qr{(?xi:
477 our @typeListMisordered = (
478 qr{char\s+(?:un)?signed},
479 qr{int\s+(?:(?:un)?signed\s+)?short\s},
480 qr{int\s+short(?:\s+(?:un)?signed)},
481 qr{short\s+int(?:\s+(?:un)?signed)},
482 qr{(?:un)?signed\s+int\s+short},
483 qr{short\s+(?:un)?signed},
484 qr{long\s+int\s+(?:un)?signed},
485 qr{int\s+long\s+(?:un)?signed},
486 qr{long\s+(?:un)?signed\s+int},
487 qr{int\s+(?:un)?signed\s+long},
488 qr{int\s+(?:un)?signed},
489 qr{int\s+long\s+long\s+(?:un)?signed},
490 qr{long\s+long\s+int\s+(?:un)?signed},
491 qr{long\s+long\s+(?:un)?signed\s+int},
492 qr{long\s+long\s+(?:un)?signed},
493 qr{long\s+(?:un)?signed},
498 qr{(?:(?:un)?signed\s+)?char},
499 qr{(?:(?:un)?signed\s+)?short\s+int},
500 qr{(?:(?:un)?signed\s+)?short},
501 qr{(?:(?:un)?signed\s+)?int},
502 qr{(?:(?:un)?signed\s+)?long\s+int},
503 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
504 qr{(?:(?:un)?signed\s+)?long\s+long},
505 qr{(?:(?:un)?signed\s+)?long},
514 qr{${Ident}_handler},
515 qr{${Ident}_handler_fn},
519 our $C90_int_types = qr{(?x:
520 long\s+long\s+int\s+(?:un)?signed|
521 long\s+long\s+(?:un)?signed\s+int|
522 long\s+long\s+(?:un)?signed|
523 (?:(?:un)?signed\s+)?long\s+long\s+int|
524 (?:(?:un)?signed\s+)?long\s+long|
525 int\s+long\s+long\s+(?:un)?signed|
526 int\s+(?:(?:un)?signed\s+)?long\s+long|
528 long\s+int\s+(?:un)?signed|
529 long\s+(?:un)?signed\s+int|
530 long\s+(?:un)?signed|
531 (?:(?:un)?signed\s+)?long\s+int|
532 (?:(?:un)?signed\s+)?long|
533 int\s+long\s+(?:un)?signed|
534 int\s+(?:(?:un)?signed\s+)?long|
537 (?:(?:un)?signed\s+)?int
540 our @typeListFile = ();
541 our @typeListWithAttr = (
543 qr{struct\s+$InitAttribute\s+$Ident},
544 qr{union\s+$InitAttribute\s+$Ident},
547 our @modifierList = (
550 our @modifierListFile = ();
552 our @mode_permission_funcs = (
554 ["module_param_(?:array|named|string)", 4],
555 ["module_param_array_named", 5],
556 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
557 ["proc_create(?:_data|)", 2],
558 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
559 ["IIO_DEV_ATTR_[A-Z_]+", 1],
560 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
561 ["SENSOR_TEMPLATE(?:_2|)", 3],
565 #Create a search pattern for all these functions to speed up a loop below
566 our $mode_perms_search = "";
567 foreach my $entry (@mode_permission_funcs) {
568 $mode_perms_search .= '|' if ($mode_perms_search ne "");
569 $mode_perms_search .= $entry->[0];
572 our $mode_perms_world_writable = qr{
580 our %mode_permission_string_types = (
599 #Create a search pattern for all these strings to speed up a loop below
600 our $mode_perms_string_search = "";
601 foreach my $entry (keys %mode_permission_string_types) {
602 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
603 $mode_perms_string_search .= $entry;
606 our $allowed_asm_includes = qr{(?x:
612 # memory.h: ARM has a custom one
614 # Load common spelling mistakes and build regular expression list.
618 if (open(my $spelling, '<', $spelling_file)) {
619 while (<$spelling>) {
622 $line =~ s/\s*\n?$//g;
625 next if ($line =~ m/^\s*#/);
626 next if ($line =~ m/^\s*$/);
628 my ($suspect, $fix) = split(/\|\|/, $line);
630 $spelling_fix{$suspect} = $fix;
634 warn "No typos will be found - file '$spelling_file': $!\n";
638 if (open(my $spelling, '<', $codespellfile)) {
639 while (<$spelling>) {
642 $line =~ s/\s*\n?$//g;
645 next if ($line =~ m/^\s*#/);
646 next if ($line =~ m/^\s*$/);
647 next if ($line =~ m/, disabled/i);
651 my ($suspect, $fix) = split(/->/, $line);
653 $spelling_fix{$suspect} = $fix;
657 warn "No codespell typos will be found - file '$codespellfile': $!\n";
661 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
664 my ($wordsRef, $file) = @_;
666 if (open(my $words, '<', $file)) {
670 $line =~ s/\s*\n?$//g;
673 next if ($line =~ m/^\s*#/);
674 next if ($line =~ m/^\s*$/);
676 print("$file: '$line' invalid - ignored\n");
680 $$wordsRef .= '|' if ($$wordsRef ne "");
690 my $const_structs = "";
691 read_words(\$const_structs, $conststructsfile)
692 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
694 my $typeOtherTypedefs = "";
695 if (length($typedefsfile)) {
696 read_words(\$typeOtherTypedefs, $typedefsfile)
697 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
699 $typeTypedefs .= '|' . $typeOtherTypedefs if ($typeOtherTypedefs ne "");
702 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
703 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
704 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
705 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
706 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
712 (?:$Modifier\s+|const\s+)*
714 (?:typeof|__typeof__)\s*\([^\)]*\)|
718 (?:\s+$Modifier|\s+const)*
720 $NonptrTypeMisordered = qr{
721 (?:$Modifier\s+|const\s+)*
725 (?:\s+$Modifier|\s+const)*
727 $NonptrTypeWithAttr = qr{
728 (?:$Modifier\s+|const\s+)*
730 (?:typeof|__typeof__)\s*\([^\)]*\)|
734 (?:\s+$Modifier|\s+const)*
738 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
739 (?:\s+$Inline|\s+$Modifier)*
741 $TypeMisordered = qr{
742 $NonptrTypeMisordered
743 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
744 (?:\s+$Inline|\s+$Modifier)*
746 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
747 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
751 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
753 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
754 # requires at least perl version v5.10.0
755 # Any use must be runtime checked with $^V
757 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
758 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
759 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
761 our $declaration_macros = qr{(?x:
762 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
763 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
764 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
769 return "" if (!defined($string));
771 while ($string =~ /^\s*\(.*\)\s*$/) {
772 $string =~ s@^\s*\(\s*@@;
773 $string =~ s@\s*\)\s*$@@;
776 $string =~ s@\s+@ @g;
781 sub seed_camelcase_file {
784 return if (!(-f $file));
788 open(my $include_file, '<', "$file")
789 or warn "$P: Can't read '$file' $!\n";
790 my $text = <$include_file>;
791 close($include_file);
793 my @lines = split('\n', $text);
795 foreach my $line (@lines) {
796 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
797 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
799 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
801 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
807 sub is_maintained_obsolete {
810 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
812 my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
814 return $status =~ /obsolete/i;
817 my $camelcase_seeded = 0;
818 sub seed_camelcase_includes {
819 return if ($camelcase_seeded);
822 my $camelcase_cache = "";
823 my @include_files = ();
825 $camelcase_seeded = 1;
828 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
829 chomp $git_last_include_commit;
830 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
832 my $last_mod_date = 0;
833 $files = `find $root/include -name "*.h"`;
834 @include_files = split('\n', $files);
835 foreach my $file (@include_files) {
836 my $date = POSIX::strftime("%Y%m%d%H%M",
837 localtime((stat $file)[9]));
838 $last_mod_date = $date if ($last_mod_date < $date);
840 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
843 if ($camelcase_cache ne "" && -f $camelcase_cache) {
844 open(my $camelcase_file, '<', "$camelcase_cache")
845 or warn "$P: Can't read '$camelcase_cache' $!\n";
846 while (<$camelcase_file>) {
850 close($camelcase_file);
856 $files = `git ls-files "include/*.h"`;
857 @include_files = split('\n', $files);
860 foreach my $file (@include_files) {
861 seed_camelcase_file($file);
864 if ($camelcase_cache ne "") {
865 unlink glob ".checkpatch-camelcase.*";
866 open(my $camelcase_file, '>', "$camelcase_cache")
867 or warn "$P: Can't write '$camelcase_cache' $!\n";
868 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
869 print $camelcase_file ("$_\n");
871 close($camelcase_file);
875 sub git_commit_info {
876 my ($commit, $id, $desc) = @_;
878 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
880 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
881 $output =~ s/^\s*//gm;
882 my @lines = split("\n", $output);
884 return ($id, $desc) if ($#lines < 0);
886 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
887 # Maybe one day convert this block of bash into something that returns
888 # all matching commit ids, but it's very slow...
890 # echo "checking commits $1..."
891 # git rev-list --remotes | grep -i "^$1" |
892 # while read line ; do
893 # git log --format='%H %s' -1 $line |
894 # echo "commit $(cut -c 1-12,41-)"
896 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
899 $id = substr($lines[0], 0, 12);
900 $desc = substr($lines[0], 41);
906 $chk_signoff = 0 if ($file);
911 my @fixed_inserted = ();
912 my @fixed_deleted = ();
915 # If input is git commits, extract all commits from the commit expressions.
916 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
917 die "$P: No git repository found\n" if ($git && !-e ".git");
921 foreach my $commit_expr (@ARGV) {
923 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
924 $git_range = "-$2 $1";
925 } elsif ($commit_expr =~ m/\.\./) {
926 $git_range = "$commit_expr";
928 $git_range = "-1 $commit_expr";
930 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
931 foreach my $line (split(/\n/, $lines)) {
932 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
933 next if (!defined($1) || !defined($2));
936 unshift(@commits, $sha1);
937 $git_commits{$sha1} = $subject;
940 die "$P: no git commits after extraction!\n" if (@commits == 0);
945 for my $filename (@ARGV) {
948 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
949 die "$P: $filename: git format-patch failed - $!\n";
951 open($FILE, '-|', "diff -u /dev/null $filename") ||
952 die "$P: $filename: diff failed - $!\n";
953 } elsif ($filename eq '-') {
954 open($FILE, '<&STDIN');
956 open($FILE, '<', "$filename") ||
957 die "$P: $filename: open failed - $!\n";
959 if ($filename eq '-') {
960 $vname = 'Your patch';
962 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
972 if ($#ARGV > 0 && $quiet == 0) {
973 print '-' x length($vname) . "\n";
975 print '-' x length($vname) . "\n";
978 if (!process($filename)) {
984 @fixed_inserted = ();
987 @modifierListFile = ();
993 hash_show_words(\%use_type, "Used");
994 hash_show_words(\%ignore_type, "Ignored");
999 NOTE: perl $^V is not modern enough to detect all possible issues.
1000 An upgrade to at least perl v5.10.0 is suggested.
1006 NOTE: If any of the errors are false positives, please report
1007 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1014 sub top_of_kernel_tree {
1018 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1019 "README", "Documentation", "arch", "include", "drivers",
1020 "fs", "init", "ipc", "kernel", "lib", "scripts",
1023 foreach my $check (@tree_check) {
1024 if (! -e $root . '/' . $check) {
1032 my ($formatted_email) = @_;
1038 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1041 $comment = $3 if defined $3;
1042 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1044 $comment = $2 if defined $2;
1045 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1047 $comment = $2 if defined $2;
1048 $formatted_email =~ s/$address.*$//;
1049 $name = $formatted_email;
1050 $name = trim($name);
1051 $name =~ s/^\"|\"$//g;
1052 # If there's a name left after stripping spaces and
1053 # leading quotes, and the address doesn't have both
1054 # leading and trailing angle brackets, the address
1056 # "joe smith joe@smith.com" bad
1057 # "joe smith <joe@smith.com" bad
1058 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1065 $name = trim($name);
1066 $name =~ s/^\"|\"$//g;
1067 $address = trim($address);
1068 $address =~ s/^\<|\>$//g;
1070 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1071 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1072 $name = "\"$name\"";
1075 return ($name, $address, $comment);
1079 my ($name, $address) = @_;
1081 my $formatted_email;
1083 $name = trim($name);
1084 $name =~ s/^\"|\"$//g;
1085 $address = trim($address);
1087 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1088 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1089 $name = "\"$name\"";
1092 if ("$name" eq "") {
1093 $formatted_email = "$address";
1095 $formatted_email = "$name <$address>";
1098 return $formatted_email;
1104 foreach my $path (split(/:/, $ENV{PATH})) {
1105 if (-e "$path/$bin") {
1106 return "$path/$bin";
1116 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1117 if (-e "$path/$conf") {
1118 return "$path/$conf";
1130 for my $c (split(//, $str)) {
1134 for (; ($n % 8) != 0; $n++) {
1146 (my $res = shift) =~ tr/\t/ /c;
1153 # Drop the diff line leader and expand tabs
1155 $line = expand_tabs($line);
1157 # Pick the indent from the front of the line.
1158 my ($white) = ($line =~ /^(\s*)/);
1160 return (length($line), length($white));
1163 my $sanitise_quote = '';
1165 sub sanitise_line_reset {
1166 my ($in_comment) = @_;
1169 $sanitise_quote = '*/';
1171 $sanitise_quote = '';
1184 # Always copy over the diff marker.
1185 $res = substr($line, 0, 1);
1187 for ($off = 1; $off < length($line); $off++) {
1188 $c = substr($line, $off, 1);
1190 # Comments we are wacking completly including the begin
1191 # and end, all to $;.
1192 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1193 $sanitise_quote = '*/';
1195 substr($res, $off, 2, "$;$;");
1199 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1200 $sanitise_quote = '';
1201 substr($res, $off, 2, "$;$;");
1205 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1206 $sanitise_quote = '//';
1208 substr($res, $off, 2, $sanitise_quote);
1213 # A \ in a string means ignore the next character.
1214 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1216 substr($res, $off, 2, 'XX');
1221 if ($c eq "'" || $c eq '"') {
1222 if ($sanitise_quote eq '') {
1223 $sanitise_quote = $c;
1225 substr($res, $off, 1, $c);
1227 } elsif ($sanitise_quote eq $c) {
1228 $sanitise_quote = '';
1232 #print "c<$c> SQ<$sanitise_quote>\n";
1233 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1234 substr($res, $off, 1, $;);
1235 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1236 substr($res, $off, 1, $;);
1237 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1238 substr($res, $off, 1, 'X');
1240 substr($res, $off, 1, $c);
1244 if ($sanitise_quote eq '//') {
1245 $sanitise_quote = '';
1248 # The pathname on a #include may be surrounded by '<' and '>'.
1249 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1250 my $clean = 'X' x length($1);
1251 $res =~ s@\<.*\>@<$clean>@;
1253 # The whole of a #error is a string.
1254 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1255 my $clean = 'X' x length($1);
1256 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1259 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1261 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1267 sub get_quoted_string {
1268 my ($line, $rawline) = @_;
1270 return "" if ($line !~ m/($String)/g);
1271 return substr($rawline, $-[0], $+[0] - $-[0]);
1274 sub ctx_statement_block {
1275 my ($linenr, $remain, $off) = @_;
1276 my $line = $linenr - 1;
1279 my $coff = $off - 1;
1293 @stack = (['', 0]) if ($#stack == -1);
1295 #warn "CSB: blk<$blk> remain<$remain>\n";
1296 # If we are about to drop off the end, pull in more
1299 for (; $remain > 0; $line++) {
1300 last if (!defined $lines[$line]);
1301 next if ($lines[$line] =~ /^-/);
1304 $blk .= $lines[$line] . "\n";
1305 $len = length($blk);
1309 # Bail if there is no further context.
1310 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1314 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1320 $c = substr($blk, $off, 1);
1321 $remainder = substr($blk, $off);
1323 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1325 # Handle nested #if/#else.
1326 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1327 push(@stack, [ $type, $level ]);
1328 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1329 ($type, $level) = @{$stack[$#stack - 1]};
1330 } elsif ($remainder =~ /^#\s*endif\b/) {
1331 ($type, $level) = @{pop(@stack)};
1334 # Statement ends at the ';' or a close '}' at the
1336 if ($level == 0 && $c eq ';') {
1340 # An else is really a conditional as long as its not else if
1341 if ($level == 0 && $coff_set == 0 &&
1342 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1343 $remainder =~ /^(else)(?:\s|{)/ &&
1344 $remainder !~ /^else\s+if\b/) {
1345 $coff = $off + length($1) - 1;
1347 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1348 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1351 if (($type eq '' || $type eq '(') && $c eq '(') {
1355 if ($type eq '(' && $c eq ')') {
1357 $type = ($level != 0)? '(' : '';
1359 if ($level == 0 && $coff < $soff) {
1362 #warn "CSB: mark coff<$coff>\n";
1365 if (($type eq '' || $type eq '{') && $c eq '{') {
1369 if ($type eq '{' && $c eq '}') {
1371 $type = ($level != 0)? '{' : '';
1374 if (substr($blk, $off + 1, 1) eq ';') {
1380 # Preprocessor commands end at the newline unless escaped.
1381 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1389 # We are truly at the end, so shuffle to the next line.
1396 my $statement = substr($blk, $soff, $off - $soff + 1);
1397 my $condition = substr($blk, $soff, $coff - $soff + 1);
1399 #warn "STATEMENT<$statement>\n";
1400 #warn "CONDITION<$condition>\n";
1402 #print "coff<$coff> soff<$off> loff<$loff>\n";
1404 return ($statement, $condition,
1405 $line, $remain + 1, $off - $loff + 1, $level);
1408 sub statement_lines {
1411 # Strip the diff line prefixes and rip blank lines at start and end.
1412 $stmt =~ s/(^|\n)./$1/g;
1416 my @stmt_lines = ($stmt =~ /\n/g);
1418 return $#stmt_lines + 2;
1421 sub statement_rawlines {
1424 my @stmt_lines = ($stmt =~ /\n/g);
1426 return $#stmt_lines + 2;
1429 sub statement_block_size {
1432 $stmt =~ s/(^|\n)./$1/g;
1438 my @stmt_lines = ($stmt =~ /\n/g);
1439 my @stmt_statements = ($stmt =~ /;/g);
1441 my $stmt_lines = $#stmt_lines + 2;
1442 my $stmt_statements = $#stmt_statements + 1;
1444 if ($stmt_lines > $stmt_statements) {
1447 return $stmt_statements;
1451 sub ctx_statement_full {
1452 my ($linenr, $remain, $off) = @_;
1453 my ($statement, $condition, $level);
1457 # Grab the first conditional/block pair.
1458 ($statement, $condition, $linenr, $remain, $off, $level) =
1459 ctx_statement_block($linenr, $remain, $off);
1460 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1461 push(@chunks, [ $condition, $statement ]);
1462 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1463 return ($level, $linenr, @chunks);
1466 # Pull in the following conditional/block pairs and see if they
1467 # could continue the statement.
1469 ($statement, $condition, $linenr, $remain, $off, $level) =
1470 ctx_statement_block($linenr, $remain, $off);
1471 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1472 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1474 push(@chunks, [ $condition, $statement ]);
1477 return ($level, $linenr, @chunks);
1481 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1483 my $start = $linenr - 1;
1490 my @stack = ($level);
1491 for ($line = $start; $remain > 0; $line++) {
1492 next if ($rawlines[$line] =~ /^-/);
1495 $blk .= $rawlines[$line];
1497 # Handle nested #if/#else.
1498 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1499 push(@stack, $level);
1500 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1501 $level = $stack[$#stack - 1];
1502 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1503 $level = pop(@stack);
1506 foreach my $c (split(//, $lines[$line])) {
1507 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1513 if ($c eq $close && $level > 0) {
1515 last if ($level == 0);
1516 } elsif ($c eq $open) {
1521 if (!$outer || $level <= 1) {
1522 push(@res, $rawlines[$line]);
1525 last if ($level == 0);
1528 return ($level, @res);
1530 sub ctx_block_outer {
1531 my ($linenr, $remain) = @_;
1533 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1537 my ($linenr, $remain) = @_;
1539 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1543 my ($linenr, $remain, $off) = @_;
1545 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1548 sub ctx_block_level {
1549 my ($linenr, $remain) = @_;
1551 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1553 sub ctx_statement_level {
1554 my ($linenr, $remain, $off) = @_;
1556 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1559 sub ctx_locate_comment {
1560 my ($first_line, $end_line) = @_;
1562 # Catch a comment on the end of the line itself.
1563 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1564 return $current_comment if (defined $current_comment);
1566 # Look through the context and try and figure out if there is a
1569 $current_comment = '';
1570 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1571 my $line = $rawlines[$linenr - 1];
1573 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1576 if ($line =~ m@/\*@) {
1579 if (!$in_comment && $current_comment ne '') {
1580 $current_comment = '';
1582 $current_comment .= $line . "\n" if ($in_comment);
1583 if ($line =~ m@\*/@) {
1588 chomp($current_comment);
1589 return($current_comment);
1591 sub ctx_has_comment {
1592 my ($first_line, $end_line) = @_;
1593 my $cmt = ctx_locate_comment($first_line, $end_line);
1595 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1596 ##print "CMMT: $cmt\n";
1598 return ($cmt ne '');
1602 my ($linenr, $cnt) = @_;
1604 my $offset = $linenr - 1;
1609 $line = $rawlines[$offset++];
1610 next if (defined($line) && $line =~ /^-/);
1622 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1625 $coded = sprintf("^%c", unpack('C', $2) + 64);
1634 my $av_preprocessor = 0;
1639 sub annotate_reset {
1640 $av_preprocessor = 0;
1642 @av_paren_type = ('E');
1643 $av_pend_colon = 'O';
1646 sub annotate_values {
1647 my ($stream, $type) = @_;
1650 my $var = '_' x length($stream);
1653 print "$stream\n" if ($dbg_values > 1);
1655 while (length($cur)) {
1656 @av_paren_type = ('E') if ($#av_paren_type < 0);
1657 print " <" . join('', @av_paren_type) .
1658 "> <$type> <$av_pending>" if ($dbg_values > 1);
1659 if ($cur =~ /^(\s+)/o) {
1660 print "WS($1)\n" if ($dbg_values > 1);
1661 if ($1 =~ /\n/ && $av_preprocessor) {
1662 $type = pop(@av_paren_type);
1663 $av_preprocessor = 0;
1666 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1667 print "CAST($1)\n" if ($dbg_values > 1);
1668 push(@av_paren_type, $type);
1671 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1672 print "DECLARE($1)\n" if ($dbg_values > 1);
1675 } elsif ($cur =~ /^($Modifier)\s*/) {
1676 print "MODIFIER($1)\n" if ($dbg_values > 1);
1679 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1680 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1681 $av_preprocessor = 1;
1682 push(@av_paren_type, $type);
1688 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1689 print "UNDEF($1)\n" if ($dbg_values > 1);
1690 $av_preprocessor = 1;
1691 push(@av_paren_type, $type);
1693 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1694 print "PRE_START($1)\n" if ($dbg_values > 1);
1695 $av_preprocessor = 1;
1697 push(@av_paren_type, $type);
1698 push(@av_paren_type, $type);
1701 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1702 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1703 $av_preprocessor = 1;
1705 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1709 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1710 print "PRE_END($1)\n" if ($dbg_values > 1);
1712 $av_preprocessor = 1;
1714 # Assume all arms of the conditional end as this
1715 # one does, and continue as if the #endif was not here.
1716 pop(@av_paren_type);
1717 push(@av_paren_type, $type);
1720 } elsif ($cur =~ /^(\\\n)/o) {
1721 print "PRECONT($1)\n" if ($dbg_values > 1);
1723 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1724 print "ATTR($1)\n" if ($dbg_values > 1);
1725 $av_pending = $type;
1728 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1729 print "SIZEOF($1)\n" if ($dbg_values > 1);
1735 } elsif ($cur =~ /^(if|while|for)\b/o) {
1736 print "COND($1)\n" if ($dbg_values > 1);
1740 } elsif ($cur =~/^(case)/o) {
1741 print "CASE($1)\n" if ($dbg_values > 1);
1742 $av_pend_colon = 'C';
1745 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1746 print "KEYWORD($1)\n" if ($dbg_values > 1);
1749 } elsif ($cur =~ /^(\()/o) {
1750 print "PAREN('$1')\n" if ($dbg_values > 1);
1751 push(@av_paren_type, $av_pending);
1755 } elsif ($cur =~ /^(\))/o) {
1756 my $new_type = pop(@av_paren_type);
1757 if ($new_type ne '_') {
1759 print "PAREN('$1') -> $type\n"
1760 if ($dbg_values > 1);
1762 print "PAREN('$1')\n" if ($dbg_values > 1);
1765 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1766 print "FUNC($1)\n" if ($dbg_values > 1);
1770 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1771 if (defined $2 && $type eq 'C' || $type eq 'T') {
1772 $av_pend_colon = 'B';
1773 } elsif ($type eq 'E') {
1774 $av_pend_colon = 'L';
1776 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1779 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1780 print "IDENT($1)\n" if ($dbg_values > 1);
1783 } elsif ($cur =~ /^($Assignment)/o) {
1784 print "ASSIGN($1)\n" if ($dbg_values > 1);
1787 } elsif ($cur =~/^(;|{|})/) {
1788 print "END($1)\n" if ($dbg_values > 1);
1790 $av_pend_colon = 'O';
1792 } elsif ($cur =~/^(,)/) {
1793 print "COMMA($1)\n" if ($dbg_values > 1);
1796 } elsif ($cur =~ /^(\?)/o) {
1797 print "QUESTION($1)\n" if ($dbg_values > 1);
1800 } elsif ($cur =~ /^(:)/o) {
1801 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1803 substr($var, length($res), 1, $av_pend_colon);
1804 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1809 $av_pend_colon = 'O';
1811 } elsif ($cur =~ /^(\[)/o) {
1812 print "CLOSE($1)\n" if ($dbg_values > 1);
1815 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1818 print "OPV($1)\n" if ($dbg_values > 1);
1825 substr($var, length($res), 1, $variant);
1828 } elsif ($cur =~ /^($Operators)/o) {
1829 print "OP($1)\n" if ($dbg_values > 1);
1830 if ($1 ne '++' && $1 ne '--') {
1834 } elsif ($cur =~ /(^.)/o) {
1835 print "C($1)\n" if ($dbg_values > 1);
1838 $cur = substr($cur, length($1));
1839 $res .= $type x length($1);
1843 return ($res, $var);
1847 my ($possible, $line) = @_;
1848 my $notPermitted = qr{(?:
1865 ^(?:typedef|struct|enum)\b
1867 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1868 if ($possible !~ $notPermitted) {
1869 # Check for modifiers.
1870 $possible =~ s/\s*$Storage\s*//g;
1871 $possible =~ s/\s*$Sparse\s*//g;
1872 if ($possible =~ /^\s*$/) {
1874 } elsif ($possible =~ /\s/) {
1875 $possible =~ s/\s*$Type\s*//g;
1876 for my $modifier (split(' ', $possible)) {
1877 if ($modifier !~ $notPermitted) {
1878 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1879 push(@modifierListFile, $modifier);
1884 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1885 push(@typeListFile, $possible);
1889 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1898 $type =~ tr/[a-z]/[A-Z]/;
1900 return defined $use_type{$type} if (scalar keys %use_type > 0);
1902 return !defined $ignore_type{$type};
1906 my ($level, $type, $msg) = @_;
1908 if (!show_type($type) ||
1909 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1914 if ($level eq 'ERROR') {
1916 } elsif ($level eq 'WARNING') {
1922 $output .= $prefix . $level . ':';
1924 $output .= BLUE if ($color);
1925 $output .= "$type:";
1927 $output .= RESET if ($color);
1928 $output .= ' ' . $msg . "\n";
1931 my @lines = split("\n", $output, -1);
1932 splice(@lines, 1, 1);
1933 $output = join("\n", @lines);
1935 $output = (split('\n', $output))[0] . "\n" if ($terse);
1937 push(our @report, $output);
1946 sub fixup_current_range {
1947 my ($lineRef, $offset, $length) = @_;
1949 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1952 my $no = $o + $offset;
1953 my $nl = $l + $length;
1954 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1958 sub fix_inserted_deleted_lines {
1959 my ($linesRef, $insertedRef, $deletedRef) = @_;
1961 my $range_last_linenr = 0;
1962 my $delta_offset = 0;
1967 my $next_insert = 0;
1968 my $next_delete = 0;
1972 my $inserted = @{$insertedRef}[$next_insert++];
1973 my $deleted = @{$deletedRef}[$next_delete++];
1975 foreach my $old_line (@{$linesRef}) {
1977 my $line = $old_line; #don't modify the array
1978 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
1980 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1981 $range_last_linenr = $new_linenr;
1982 fixup_current_range(\$line, $delta_offset, 0);
1985 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1986 $deleted = @{$deletedRef}[$next_delete++];
1988 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1991 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1992 push(@lines, ${$inserted}{'LINE'});
1993 $inserted = @{$insertedRef}[$next_insert++];
1995 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1999 push(@lines, $line);
2009 sub fix_insert_line {
2010 my ($linenr, $line) = @_;
2016 push(@fixed_inserted, $inserted);
2019 sub fix_delete_line {
2020 my ($linenr, $line) = @_;
2027 push(@fixed_deleted, $deleted);
2031 my ($type, $msg) = @_;
2033 if (report("ERROR", $type, $msg)) {
2041 my ($type, $msg) = @_;
2043 if (report("WARNING", $type, $msg)) {
2051 my ($type, $msg) = @_;
2053 if ($check && report("CHECK", $type, $msg)) {
2061 sub check_absolute_file {
2062 my ($absolute, $herecurr) = @_;
2063 my $file = $absolute;
2065 ##print "absolute<$absolute>\n";
2067 # See if any suffix of this path is a path within the tree.
2068 while ($file =~ s@^[^/]*/@@) {
2069 if (-f "$root/$file") {
2070 ##print "file<$file>\n";
2078 # It is, so see if the prefix is acceptable.
2079 my $prefix = $absolute;
2080 substr($prefix, -length($file)) = '';
2082 ##print "prefix<$prefix>\n";
2083 if ($prefix ne ".../") {
2084 WARN("USE_RELATIVE_PATH",
2085 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2092 $string =~ s/^\s+|\s+$//g;
2100 $string =~ s/^\s+//;
2108 $string =~ s/\s+$//;
2113 sub string_find_replace {
2114 my ($string, $find, $replace) = @_;
2116 $string =~ s/$find/$replace/g;
2124 my $source_indent = 8;
2125 my $max_spaces_before_tab = $source_indent - 1;
2126 my $spaces_to_tab = " " x $source_indent;
2128 #convert leading spaces to tabs
2129 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2130 #Remove spaces before a tab
2131 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2136 sub pos_last_openparen {
2141 my $opens = $line =~ tr/\(/\(/;
2142 my $closes = $line =~ tr/\)/\)/;
2144 my $last_openparen = 0;
2146 if (($opens == 0) || ($closes >= $opens)) {
2150 my $len = length($line);
2152 for ($pos = 0; $pos < $len; $pos++) {
2153 my $string = substr($line, $pos);
2154 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2155 $pos += length($1) - 1;
2156 } elsif (substr($line, $pos, 1) eq '(') {
2157 $last_openparen = $pos;
2158 } elsif (index($string, '(') == -1) {
2163 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2167 my $filename = shift;
2173 my $stashrawline="";
2183 my $in_header_lines = $file ? 0 : 1;
2184 my $in_commit_log = 0; #Scanning lines before patch
2185 my $has_commit_log = 0; #Encountered lines before patch
2186 my $commit_log_possible_stack_dump = 0;
2187 my $commit_log_long_line = 0;
2188 my $commit_log_has_diff = 0;
2189 my $reported_maintainer_file = 0;
2190 my $non_utf8_charset = 0;
2192 my $last_blank_line = 0;
2193 my $last_coalesced_string_linenr = -1;
2201 # Trace the real file/line as we go.
2206 my $context_function; #undef'd unless there's a known function
2208 my $comment_edge = 0;
2212 my $prev_values = 'E';
2215 my %suppress_ifbraces;
2216 my %suppress_whiletrailers;
2217 my %suppress_export;
2218 my $suppress_statement = 0;
2220 my %signatures = ();
2222 # Pre-scan the patch sanitizing the lines.
2223 # Pre-scan the patch looking for any __setup documentation.
2225 my @setup_docs = ();
2228 my $camelcase_file_seeded = 0;
2230 sanitise_line_reset();
2232 foreach my $rawline (@rawlines) {
2236 push(@fixed, $rawline) if ($fix);
2238 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2240 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
2245 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2254 # Guestimate if this is a continuing comment. Run
2255 # the context looking for a comment "edge". If this
2256 # edge is a close comment then we must be in a comment
2260 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2261 next if (defined $rawlines[$ln - 1] &&
2262 $rawlines[$ln - 1] =~ /^-/);
2264 #print "RAW<$rawlines[$ln - 1]>\n";
2265 last if (!defined $rawlines[$ln - 1]);
2266 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2267 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2272 if (defined $edge && $edge eq '*/') {
2276 # Guestimate if this is a continuing comment. If this
2277 # is the start of a diff block and this line starts
2278 # ' *' then it is very likely a comment.
2279 if (!defined $edge &&
2280 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2285 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2286 sanitise_line_reset($in_comment);
2288 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2289 # Standardise the strings and chars within the input to
2290 # simplify matching -- only bother with positive lines.
2291 $line = sanitise_line($rawline);
2293 push(@lines, $line);
2296 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2301 #print "==>$rawline\n";
2302 #print "-->$line\n";
2304 if ($setup_docs && $line =~ /^\+/) {
2305 push(@setup_docs, $line);
2314 foreach my $line (@lines) {
2317 my $sline = $line; #copy of $line
2318 $sline =~ s/$;/ /g; #with comments as spaces
2320 my $rawline = $rawlines[$linenr - 1];
2322 #extract the line range in the file after the patch is applied
2323 if (!$in_commit_log &&
2324 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2327 $first_line = $linenr + 1;
2337 %suppress_ifbraces = ();
2338 %suppress_whiletrailers = ();
2339 %suppress_export = ();
2340 $suppress_statement = 0;
2341 if ($context =~ /\b(\w+)\s*\(/) {
2342 $context_function = $1;
2344 undef $context_function;
2348 # track the line number as we move through the hunk, note that
2349 # new versions of GNU diff omit the leading space on completely
2350 # blank context lines so we need to count that too.
2351 } elsif ($line =~ /^( |\+|$)/) {
2353 $realcnt-- if ($realcnt != 0);
2355 # Measure the line length and indent.
2356 ($length, $indent) = line_stats($rawline);
2358 # Track the previous line.
2359 ($prevline, $stashline) = ($stashline, $line);
2360 ($previndent, $stashindent) = ($stashindent, $indent);
2361 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2363 #warn "line<$line>\n";
2365 } elsif ($realcnt == 1) {
2369 my $hunk_line = ($realcnt != 0);
2371 $here = "#$linenr: " if (!$file);
2372 $here = "#$realline: " if ($file);
2375 # extract the filename as it passes
2376 if ($line =~ /^diff --git.*?(\S+)$/) {
2378 $realfile =~ s@^([^/]*)/@@ if (!$file);
2381 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2383 $realfile =~ s@^([^/]*)/@@ if (!$file);
2387 if (!$file && $tree && $p1_prefix ne '' &&
2388 -e "$root/$p1_prefix") {
2389 WARN("PATCH_PREFIX",
2390 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2393 if ($realfile =~ m@^include/asm/@) {
2394 ERROR("MODIFIED_INCLUDE_ASM",
2395 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2400 #make up the handle for any error we report on this line
2402 $prefix = "$realfile:$realline: "
2405 $prefix = "$filename:$realline: ";
2407 $prefix = "$filename:$linenr: ";
2412 if (is_maintained_obsolete($realfile)) {
2414 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2416 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2419 $check = $check_orig;
2424 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2426 my $hereline = "$here\n$rawline\n";
2427 my $herecurr = "$here\n$rawline\n";
2428 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2430 $cnt_lines++ if ($realcnt != 0);
2432 # Check if the commit log has what seems like a diff which can confuse patch
2433 if ($in_commit_log && !$commit_log_has_diff &&
2434 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2435 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2436 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2437 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2438 ERROR("DIFF_IN_COMMIT_MSG",
2439 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2440 $commit_log_has_diff = 1;
2443 # Check for incorrect file permissions
2444 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2445 my $permhere = $here . "FILE: $realfile\n";
2446 if ($realfile !~ m@scripts/@ &&
2447 $realfile !~ /\.(py|pl|awk|sh)$/) {
2448 ERROR("EXECUTE_PERMISSIONS",
2449 "do not set execute permissions for source files\n" . $permhere);
2453 # Check the patch for a signoff:
2454 if ($line =~ /^\s*signed-off-by:/i) {
2459 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2460 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2461 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2462 $reported_maintainer_file = 1;
2465 # Check signature styles
2466 if (!$in_header_lines &&
2467 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2468 my $space_before = $1;
2470 my $space_after = $3;
2472 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2474 if ($sign_off !~ /$signature_tags/) {
2475 WARN("BAD_SIGN_OFF",
2476 "Non-standard signature: $sign_off\n" . $herecurr);
2478 if (defined $space_before && $space_before ne "") {
2479 if (WARN("BAD_SIGN_OFF",
2480 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2482 $fixed[$fixlinenr] =
2483 "$ucfirst_sign_off $email";
2486 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2487 if (WARN("BAD_SIGN_OFF",
2488 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2490 $fixed[$fixlinenr] =
2491 "$ucfirst_sign_off $email";
2495 if (!defined $space_after || $space_after ne " ") {
2496 if (WARN("BAD_SIGN_OFF",
2497 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2499 $fixed[$fixlinenr] =
2500 "$ucfirst_sign_off $email";
2504 my ($email_name, $email_address, $comment) = parse_email($email);
2505 my $suggested_email = format_email(($email_name, $email_address));
2506 if ($suggested_email eq "") {
2507 ERROR("BAD_SIGN_OFF",
2508 "Unrecognized email address: '$email'\n" . $herecurr);
2510 my $dequoted = $suggested_email;
2511 $dequoted =~ s/^"//;
2512 $dequoted =~ s/" </ </;
2513 # Don't force email to have quotes
2514 # Allow just an angle bracketed address
2515 if ("$dequoted$comment" ne $email &&
2516 "<$email_address>$comment" ne $email &&
2517 "$suggested_email$comment" ne $email) {
2518 WARN("BAD_SIGN_OFF",
2519 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2523 # Check for duplicate signatures
2524 my $sig_nospace = $line;
2525 $sig_nospace =~ s/\s//g;
2526 $sig_nospace = lc($sig_nospace);
2527 if (defined $signatures{$sig_nospace}) {
2528 WARN("BAD_SIGN_OFF",
2529 "Duplicate signature\n" . $herecurr);
2531 $signatures{$sig_nospace} = 1;
2535 # Check email subject for common tools that don't need to be mentioned
2536 if ($in_header_lines &&
2537 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2538 WARN("EMAIL_SUBJECT",
2539 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2542 # Check for old stable address
2543 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2544 ERROR("STABLE_ADDRESS",
2545 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2548 # Check for unwanted Gerrit info
2549 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2550 ERROR("GERRIT_CHANGE_ID",
2551 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2554 # Check if the commit log is in a possible stack dump
2555 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2556 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2557 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2559 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2560 # stack dump address
2561 $commit_log_possible_stack_dump = 1;
2564 # Check for line lengths > 75 in commit log, warn once
2565 if ($in_commit_log && !$commit_log_long_line &&
2566 length($line) > 75 &&
2567 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2568 # file delta changes
2569 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2571 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2572 # A Fixes: or Link: line
2573 $commit_log_possible_stack_dump)) {
2574 WARN("COMMIT_LOG_LONG_LINE",
2575 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2576 $commit_log_long_line = 1;
2579 # Reset possible stack dump if a blank line is found
2580 if ($in_commit_log && $commit_log_possible_stack_dump &&
2582 $commit_log_possible_stack_dump = 0;
2585 # Check for git id commit length and improperly formed commit descriptions
2586 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2587 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
2588 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
2589 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2590 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2591 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2592 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2593 my $init_char = "c";
2594 my $orig_commit = "";
2601 my $id = '0123456789ab';
2602 my $orig_desc = "commit description";
2603 my $description = "";
2605 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2607 $orig_commit = lc($2);
2608 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2609 $orig_commit = lc($1);
2612 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2613 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2614 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2615 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2616 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2619 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2620 defined $rawlines[$linenr] &&
2621 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2624 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2625 defined $rawlines[$linenr] &&
2626 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2627 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2629 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2630 $orig_desc .= " " . $1;
2634 ($id, $description) = git_commit_info($orig_commit,
2638 ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
2639 ERROR("GIT_COMMIT_ID",
2640 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2644 # Check for added, moved or deleted files
2645 if (!$reported_maintainer_file && !$in_commit_log &&
2646 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2647 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2648 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2649 (defined($1) || defined($2))))) {
2651 $reported_maintainer_file = 1;
2652 WARN("FILE_PATH_CHANGES",
2653 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2656 # Check for wrappage within a valid hunk of the file
2657 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2658 ERROR("CORRUPTED_PATCH",
2659 "patch seems to be corrupt (line wrapped?)\n" .
2660 $herecurr) if (!$emitted_corrupt++);
2663 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2664 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2665 $rawline !~ m/^$UTF8*$/) {
2666 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2668 my $blank = copy_spacing($rawline);
2669 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2670 my $hereptr = "$hereline$ptr\n";
2673 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2676 # Check if it's the start of a commit log
2677 # (not a header line and we haven't seen the patch filename)
2678 if ($in_header_lines && $realfile =~ /^$/ &&
2679 !($rawline =~ /^\s+(?:\S|$)/ ||
2680 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
2681 $in_header_lines = 0;
2683 $has_commit_log = 1;
2686 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2687 # declined it, i.e defined some charset where it is missing.
2688 if ($in_header_lines &&
2689 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2691 $non_utf8_charset = 1;
2694 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2695 $rawline =~ /$NON_ASCII_UTF8/) {
2696 WARN("UTF8_BEFORE_PATCH",
2697 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2700 # Check for absolute kernel paths in commit message
2701 if ($tree && $in_commit_log) {
2702 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2705 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2706 check_absolute_file($1, $herecurr)) {
2709 check_absolute_file($file, $herecurr);
2714 # Check for various typo / spelling mistakes
2715 if (defined($misspellings) &&
2716 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2717 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/g) {
2719 my $typo_fix = $spelling_fix{$typo};
2720 my $msg_type = \&WARN;
2721 $msg_type = \&CHK if ($file);
2722 if (&{$msg_type}("TYPO_SPELLING",
2723 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2725 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2730 # ignore non-hunk lines and lines being removed
2731 next if (!$hunk_line || $line =~ /^-/);
2733 #trailing whitespace
2734 if ($line =~ /^\+.*\015/) {
2735 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2736 if (ERROR("DOS_LINE_ENDINGS",
2737 "DOS line endings\n" . $herevet) &&
2739 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2741 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2742 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2743 if (ERROR("TRAILING_WHITESPACE",
2744 "trailing whitespace\n" . $herevet) &&
2746 $fixed[$fixlinenr] =~ s/\s+$//;
2752 # Check for FSF mailing addresses.
2753 if ($rawline =~ /\bwrite to the Free/i ||
2754 $rawline =~ /\b675\s+Mass\s+Ave/i ||
2755 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2756 $rawline =~ /\b51\s+Franklin\s+St/i) {
2757 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2758 my $msg_type = \&ERROR;
2759 $msg_type = \&CHK if ($file);
2760 &{$msg_type}("FSF_MAILING_ADDRESS",
2761 "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)
2764 # check for Kconfig help text having a real description
2765 # Only applies when adding the entry originally, after that we do not have
2766 # sufficient context to determine whether it is indeed long enough.
2767 if ($realfile =~ /Kconfig/ &&
2768 $line =~ /^\+\s*config\s+/) {
2771 my $ln = $linenr + 1;
2775 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2776 $f = $lines[$ln - 1];
2777 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2778 $is_end = $lines[$ln - 1] =~ /^\+/;
2780 next if ($f =~ /^-/);
2781 last if (!$file && $f =~ /^\@\@/);
2783 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2785 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2792 next if ($f =~ /^$/);
2793 if ($f =~ /^\s*config\s/) {
2799 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2800 WARN("CONFIG_DESCRIPTION",
2801 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2803 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2806 # check for MAINTAINERS entries that don't have the right form
2807 if ($realfile =~ /^MAINTAINERS$/ &&
2808 $rawline =~ /^\+[A-Z]:/ &&
2809 $rawline !~ /^\+[A-Z]:\t\S/) {
2810 if (WARN("MAINTAINERS_STYLE",
2811 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
2813 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
2817 # discourage the use of boolean for type definition attributes of Kconfig options
2818 if ($realfile =~ /Kconfig/ &&
2819 $line =~ /^\+\s*\bboolean\b/) {
2820 WARN("CONFIG_TYPE_BOOLEAN",
2821 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2824 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2825 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2828 'EXTRA_AFLAGS' => 'asflags-y',
2829 'EXTRA_CFLAGS' => 'ccflags-y',
2830 'EXTRA_CPPFLAGS' => 'cppflags-y',
2831 'EXTRA_LDFLAGS' => 'ldflags-y',
2834 WARN("DEPRECATED_VARIABLE",
2835 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2838 # check for DT compatible documentation
2839 if (defined $root &&
2840 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2841 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2843 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2845 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2846 my $vp_file = $dt_path . "vendor-prefixes.txt";
2848 foreach my $compat (@compats) {
2849 my $compat2 = $compat;
2850 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2851 my $compat3 = $compat;
2852 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2853 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2855 WARN("UNDOCUMENTED_DT_STRING",
2856 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2859 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2861 `grep -Eq "^$vendor\\b" $vp_file`;
2863 WARN("UNDOCUMENTED_DT_STRING",
2864 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2869 # check we are in a valid source file if not then ignore this hunk
2870 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
2872 # line length limit (with some exclusions)
2874 # There are a few types of lines that may extend beyond $max_line_length:
2875 # logging functions like pr_info that end in a string
2876 # lines with a single string
2877 # #defines that are a single string
2879 # There are 3 different line length message types:
2880 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2881 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2882 # LONG_LINE all other lines longer than $max_line_length
2884 # if LONG_LINE is ignored, the other 2 types are also ignored
2887 if ($line =~ /^\+/ && $length > $max_line_length) {
2888 my $msg_type = "LONG_LINE";
2890 # Check the allowed long line types first
2892 # logging functions that end in a string that starts
2893 # before $max_line_length
2894 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2895 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2898 # lines with only strings (w/ possible termination)
2899 # #defines with only strings
2900 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2901 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2904 # EFI_GUID is another special case
2905 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/) {
2908 # Otherwise set the alternate message types
2910 # a comment starts before $max_line_length
2911 } elsif ($line =~ /($;[\s$;]*)$/ &&
2912 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2913 $msg_type = "LONG_LINE_COMMENT"
2915 # a quoted string starts before $max_line_length
2916 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2917 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2918 $msg_type = "LONG_LINE_STRING"
2921 if ($msg_type ne "" &&
2922 (show_type("LONG_LINE") || show_type($msg_type))) {
2924 "line over $max_line_length characters\n" . $herecurr);
2928 # check for adding lines without a newline.
2929 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2930 WARN("MISSING_EOF_NEWLINE",
2931 "adding a line without newline at end of file\n" . $herecurr);
2934 # Blackfin: use hi/lo macros
2935 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2936 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2937 my $herevet = "$here\n" . cat_vet($line) . "\n";
2939 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2941 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2942 my $herevet = "$here\n" . cat_vet($line) . "\n";
2944 "use the HI() macro, not (... >> 16)\n" . $herevet);
2948 # check we are in a valid source file C or perl if not then ignore this hunk
2949 next if ($realfile !~ /\.(h|c|pl|dtsi|dts|sh)$/);
2951 # at the beginning of a line any tabs must come first and anything
2952 # more than 8 must use tabs.
2953 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2954 $rawline =~ /^\+\s* \s*/) {
2955 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2957 if (ERROR("CODE_INDENT",
2958 "code indent should use tabs where possible\n" . $herevet) &&
2960 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2964 # check for space before tabs.
2965 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2966 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2967 if (WARN("SPACE_BEFORE_TAB",
2968 "please, no space before tabs\n" . $herevet) &&
2970 while ($fixed[$fixlinenr] =~
2971 s/(^\+.*) {8,8}\t/$1\t\t/) {}
2972 while ($fixed[$fixlinenr] =~
2973 s/(^\+.*) +\t/$1\t/) {}
2977 # check for && or || at the start of a line
2978 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2979 CHK("LOGICAL_CONTINUATIONS",
2980 "Logical continuations should be on the previous line\n" . $hereprev);
2983 # check indentation starts on a tab stop
2984 if ($^V && $^V ge 5.10.0 &&
2985 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2986 my $indent = length($1);
2989 "Statements should start on a tabstop\n" . $herecurr) &&
2991 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2996 # check multi-line statement indentation matches previous line
2997 if ($^V && $^V ge 5.10.0 &&
2998 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2999 $prevline =~ /^\+(\t*)(.*)$/;
3003 my $pos = pos_last_openparen($rest);
3005 $line =~ /^(\+| )([ \t]*)/;
3008 my $goodtabindent = $oldindent .
3011 my $goodspaceindent = $oldindent . " " x $pos;
3013 if ($newindent ne $goodtabindent &&
3014 $newindent ne $goodspaceindent) {
3016 if (CHK("PARENTHESIS_ALIGNMENT",
3017 "Alignment should match open parenthesis\n" . $hereprev) &&
3018 $fix && $line =~ /^\+/) {
3019 $fixed[$fixlinenr] =~
3020 s/^\+[ \t]*/\+$goodtabindent/;
3026 # check for space after cast like "(int) foo" or "(struct foo) bar"
3027 # avoid checking a few false positives:
3028 # "sizeof(<type>)" or "__alignof__(<type>)"
3029 # function pointer declarations like "(*foo)(int) = bar;"
3030 # structure definitions like "(struct foo) { 0 };"
3031 # multiline macros that define functions
3032 # known attributes or the __attribute__ keyword
3033 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3034 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3036 "No space is necessary after a cast\n" . $herecurr) &&
3038 $fixed[$fixlinenr] =~
3039 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3043 # Block comment styles
3044 # Networking with an initial /*
3045 if ($realfile =~ m@^(drivers/net/|net/|lnet)@ &&
3046 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3047 $rawline =~ /^\+[ \t]*\*/ &&
3049 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3050 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3053 # Block comments use * on subsequent lines
3054 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3055 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
3056 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3057 $rawline =~ /^\+/ && #line is new
3058 $rawline !~ /^\+[ \t]*\*/) { #no leading *
3059 WARN("BLOCK_COMMENT_STYLE",
3060 "Block comments use * on subsequent lines\n" . $hereprev);
3063 # Block comments use */ on trailing lines
3064 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
3065 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3066 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3067 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
3068 WARN("BLOCK_COMMENT_STYLE",
3069 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3072 # Block comment * alignment
3073 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3074 $line =~ /^\+[ \t]*$;/ && #leading comment
3075 $rawline =~ /^\+[ \t]*\*/ && #leading *
3076 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
3077 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3078 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3080 $prevrawline =~ m@^\+([ \t]*/?)\*@;
3082 $oldindent = expand_tabs($1);
3084 $prevrawline =~ m@^\+(.*/?)\*@;
3085 $oldindent = expand_tabs($1);
3087 $rawline =~ m@^\+([ \t]*)\*@;
3089 $newindent = expand_tabs($newindent);
3090 if (length($oldindent) ne length($newindent)) {
3091 WARN("BLOCK_COMMENT_STYLE",
3092 "Block comments should align the * on each line\n" . $hereprev);
3096 # check for missing blank lines after struct/union declarations
3097 # with exceptions for various attributes and macros
3098 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3100 !($line =~ /^\+\s*$/ ||
3101 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3102 $line =~ /^\+\s*MODULE_/i ||
3103 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3104 $line =~ /^\+[a-z_]*init/ ||
3105 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3106 $line =~ /^\+\s*DECLARE/ ||
3107 $line =~ /^\+\s*__setup/)) {
3108 if (CHK("LINE_SPACING",
3109 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3111 fix_insert_line($fixlinenr, "\+");
3115 # check for multiple consecutive blank lines
3116 if ($prevline =~ /^[\+ ]\s*$/ &&
3117 $line =~ /^\+\s*$/ &&
3118 $last_blank_line != ($linenr - 1)) {
3119 if (CHK("LINE_SPACING",
3120 "Please don't use multiple blank lines\n" . $hereprev) &&
3122 fix_delete_line($fixlinenr, $rawline);
3125 $last_blank_line = $linenr;
3128 # check for missing blank lines after declarations
3129 if ($sline =~ /^\+\s+\S/ && #Not at char 1
3130 # actual declarations
3131 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3132 # function pointer declarations
3133 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3134 # foo bar; where foo is some local typedef or #define
3135 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3136 # known declaration macros
3137 $prevline =~ /^\+\s+$declaration_macros/) &&
3138 # for "else if" which can look like "$Ident $Ident"
3139 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3140 # other possible extensions of declaration lines
3141 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3142 # not starting a section or a macro "\" extended line
3143 $prevline =~ /(?:\{\s*|\\)$/) &&
3144 # looks like a declaration
3145 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3146 # function pointer declarations
3147 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3148 # foo bar; where foo is some local typedef or #define
3149 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3150 # known declaration macros
3151 $sline =~ /^\+\s+$declaration_macros/ ||
3152 # start of struct or union or enum
3153 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3154 # start or end of block or continuation of declaration
3155 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3156 # bitfield continuation
3157 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3158 # other possible extensions of declaration lines
3159 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3160 # indentation of previous and current line are the same
3161 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3162 if (WARN("LINE_SPACING",
3163 "Missing a blank line after declarations\n" . $hereprev) &&
3165 fix_insert_line($fixlinenr, "\+");
3169 # check for spaces at the beginning of a line.
3171 # 1) within comments
3172 # 2) indented preprocessor commands
3174 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3175 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3176 if (WARN("LEADING_SPACE",
3177 "please, no spaces at the start of a line\n" . $herevet) &&
3179 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3183 # check we are in a valid C source file if not then ignore this hunk
3184 next if ($realfile !~ /\.(h|c)$/);
3186 # check if this appears to be the start function declaration, save the name
3187 if ($sline =~ /^\+\{\s*$/ &&
3188 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3189 $context_function = $1;
3192 # check if this appears to be the end of function declaration
3193 if ($sline =~ /^\+\}\s*$/) {
3194 undef $context_function;
3197 # check indentation of any line with a bare else
3198 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3199 # if the previous line is a break or return and is indented 1 tab more...
3200 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3201 my $tabs = length($1) + 1;
3202 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3203 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3204 defined $lines[$linenr] &&
3205 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3206 WARN("UNNECESSARY_ELSE",
3207 "else is not generally useful after a break or return\n" . $hereprev);
3211 # check indentation of a line with a break;
3212 # if the previous line is a goto or return and is indented the same # of tabs
3213 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3215 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3216 WARN("UNNECESSARY_BREAK",
3217 "break is not useful after a goto or return\n" . $hereprev);
3221 # check for RCS/CVS revision markers
3222 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3224 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3227 # Blackfin: don't use __builtin_bfin_[cs]sync
3228 if ($line =~ /__builtin_bfin_csync/) {
3229 my $herevet = "$here\n" . cat_vet($line) . "\n";
3231 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3233 if ($line =~ /__builtin_bfin_ssync/) {
3234 my $herevet = "$here\n" . cat_vet($line) . "\n";
3236 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3239 # check for old HOTPLUG __dev<foo> section markings
3240 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3241 WARN("HOTPLUG_SECTION",
3242 "Using $1 is unnecessary\n" . $herecurr);
3245 # Check for potential 'bare' types
3246 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3248 #print "LINE<$line>\n";
3249 if ($linenr > $suppress_statement &&
3250 $realcnt && $sline =~ /.\s*\S/) {
3251 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3252 ctx_statement_block($linenr, $realcnt, 0);
3253 $stat =~ s/\n./\n /g;
3254 $cond =~ s/\n./\n /g;
3256 #print "linenr<$linenr> <$stat>\n";
3257 # If this statement has no statement boundaries within
3258 # it there is no point in retrying a statement scan
3259 # until we hit end of it.
3260 my $frag = $stat; $frag =~ s/;+\s*$//;
3261 if ($frag !~ /(?:{|;)/) {
3262 #print "skip<$line_nr_next>\n";
3263 $suppress_statement = $line_nr_next;
3266 # Find the real next line.
3267 $realline_next = $line_nr_next;
3268 if (defined $realline_next &&
3269 (!defined $lines[$realline_next - 1] ||
3270 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3277 # Ignore goto labels.
3278 if ($s =~ /$Ident:\*$/s) {
3280 # Ignore functions being called
3281 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3283 } elsif ($s =~ /^.\s*else\b/s) {
3285 # declarations always start with types
3286 } 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) {
3289 possible($type, "A:" . $s);
3291 # definitions in global scope can only start with types
3292 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3293 possible($1, "B:" . $s);
3296 # any (foo ... *) is a pointer cast, and foo is a type
3297 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3298 possible($1, "C:" . $s);
3301 # Check for any sort of function declaration.
3302 # int foo(something bar, other baz);
3303 # void (*store_gdt)(x86_descr_ptr *);
3304 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3305 my ($name_len) = length($1);
3308 substr($ctx, 0, $name_len + 1, '');
3309 $ctx =~ s/\)[^\)]*$//;
3311 for my $arg (split(/\s*,\s*/, $ctx)) {
3312 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3314 possible($1, "D:" . $s);
3322 # Checks which may be anchored in the context.
3325 # Check for switch () and associated case and default
3326 # statements should be at the same indent.
3327 if ($line=~/\bswitch\s*\(.*\)/) {
3330 my @ctx = ctx_block_outer($linenr, $realcnt);
3332 for my $ctx (@ctx) {
3333 my ($clen, $cindent) = line_stats($ctx);
3334 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3335 $indent != $cindent) {
3336 $err .= "$sep$ctx\n";
3343 ERROR("SWITCH_CASE_INDENT_LEVEL",
3344 "switch and case should be at the same indent\n$hereline$err");
3348 # if/while/etc brace do not go on next line, unless defining a do while loop,
3349 # or if that brace on the next line is for something else
3350 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3351 my $pre_ctx = "$1$2";
3353 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3355 if ($line =~ /^\+\t{6,}/) {
3356 WARN("DEEP_INDENTATION",
3357 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3360 my $ctx_cnt = $realcnt - $#ctx - 1;
3361 my $ctx = join("\n", @ctx);
3363 my $ctx_ln = $linenr;
3364 my $ctx_skip = $realcnt;
3366 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3367 defined $lines[$ctx_ln - 1] &&
3368 $lines[$ctx_ln - 1] =~ /^-/)) {
3369 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3370 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3374 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3375 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3377 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3379 "that open brace { should be on the previous line\n" .
3380 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3382 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3383 $ctx =~ /\)\s*\;\s*$/ &&
3384 defined $lines[$ctx_ln - 1])
3386 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3387 if ($nindent > $indent) {
3388 WARN("TRAILING_SEMICOLON",
3389 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3390 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3395 # Check relative indent for conditionals and blocks.
3396 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3397 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3398 ctx_statement_block($linenr, $realcnt, 0)
3399 if (!defined $stat);
3400 my ($s, $c) = ($stat, $cond);
3402 substr($s, 0, length($c), '');
3404 # remove inline comments
3408 # Find out how long the conditional actually is.
3409 my @newlines = ($c =~ /\n/gs);
3410 my $cond_lines = 1 + $#newlines;
3412 # Make sure we remove the line prefixes as we have
3413 # none on the first line, and are going to readd them
3416 while ($s =~ /\n\s+\\\n/) {
3417 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3420 # We want to check the first line inside the block
3421 # starting at the end of the conditional, so remove:
3422 # 1) any blank line termination
3423 # 2) any opening brace { on end of the line
3425 my $continuation = 0;
3427 $s =~ s/^.*\bdo\b//;
3429 if ($s =~ s/^\s*\\//) {
3432 if ($s =~ s/^\s*?\n//) {
3437 # Also ignore a loop construct at the end of a
3438 # preprocessor statement.
3439 if (($prevline =~ /^.\s*#\s*define\s/ ||
3440 $prevline =~ /\\\s*$/) && $continuation == 0) {
3446 while ($cond_ptr != $cond_lines) {
3447 $cond_ptr = $cond_lines;
3449 # If we see an #else/#elif then the code
3451 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3456 # 1) blank lines, they should be at 0,
3457 # 2) preprocessor lines, and
3459 if ($continuation ||
3461 $s =~ /^\s*#\s*?/ ||
3462 $s =~ /^\s*$Ident\s*:/) {
3463 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3464 if ($s =~ s/^.*?\n//) {
3470 my (undef, $sindent) = line_stats("+" . $s);
3471 my $stat_real = raw_line($linenr, $cond_lines);
3473 # Check if either of these lines are modified, else
3474 # this is not this patch's fault.
3475 if (!defined($stat_real) ||
3476 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3479 if (defined($stat_real) && $cond_lines > 1) {
3480 $stat_real = "[...]\n$stat_real";
3483 #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";
3485 if ($check && $s ne '' &&
3486 (($sindent % 8) != 0 ||
3487 ($sindent < $indent) ||
3488 ($sindent == $indent &&
3489 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
3490 ($sindent > $indent + 8))) {
3491 WARN("SUSPECT_CODE_INDENT",
3492 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3496 # Track the 'values' across context and added lines.
3497 my $opline = $line; $opline =~ s/^./ /;
3498 my ($curr_values, $curr_vars) =
3499 annotate_values($opline . "\n", $prev_values);
3500 $curr_values = $prev_values . $curr_values;
3502 my $outline = $opline; $outline =~ s/\t/ /g;
3503 print "$linenr > .$outline\n";
3504 print "$linenr > $curr_values\n";
3505 print "$linenr > $curr_vars\n";
3507 $prev_values = substr($curr_values, -1);
3509 #ignore lines not being added
3510 next if ($line =~ /^[^\+]/);
3512 # check for dereferences that span multiple lines
3513 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3514 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3515 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3517 $line =~ /^.\s*($Lval)/;
3520 WARN("MULTILINE_DEREFERENCE",
3521 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3524 # check for declarations of signed or unsigned without int
3525 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3528 $var = "" if (!defined $var);
3529 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3533 $pointer = "" if (!defined $pointer);
3535 if (WARN("UNSPECIFIED_INT",
3536 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3538 my $decl = trim($sign) . " int ";
3539 my $comp_pointer = $pointer;
3540 $comp_pointer =~ s/\s//g;
3541 $decl .= $comp_pointer;
3542 $decl = rtrim($decl) if ($var eq "");
3543 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3548 # TEST: allow direct testing of the type matcher.
3550 if ($line =~ /^.\s*$Declare\s*$/) {
3552 "TEST: is type\n" . $herecurr);
3553 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3554 ERROR("TEST_NOT_TYPE",
3555 "TEST: is not type ($1 is)\n". $herecurr);
3559 # TEST: allow direct testing of the attribute matcher.
3561 if ($line =~ /^.\s*$Modifier\s*$/) {
3563 "TEST: is attr\n" . $herecurr);
3564 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3565 ERROR("TEST_NOT_ATTR",
3566 "TEST: is not attr ($1 is)\n". $herecurr);
3571 # check for initialisation to aggregates open brace on the next line
3572 if ($line =~ /^.\s*{/ &&
3573 $prevline =~ /(?:^|[^=])=\s*$/) {
3574 if (ERROR("OPEN_BRACE",
3575 "that open brace { should be on the previous line\n" . $hereprev) &&
3576 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3577 fix_delete_line($fixlinenr - 1, $prevrawline);
3578 fix_delete_line($fixlinenr, $rawline);
3579 my $fixedline = $prevrawline;
3580 $fixedline =~ s/\s*=\s*$/ = {/;
3581 fix_insert_line($fixlinenr, $fixedline);
3583 $fixedline =~ s/^(.\s*)\{\s*/$1/;
3584 fix_insert_line($fixlinenr, $fixedline);
3589 # Checks which are anchored on the added line.
3592 # check for malformed paths in #include statements (uses RAW line)
3593 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3595 if ($path =~ m{//}) {
3596 ERROR("MALFORMED_INCLUDE",
3597 "malformed #include filename\n" . $herecurr);
3599 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3600 ERROR("UAPI_INCLUDE",
3601 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3605 # no C99 // comments
3606 if ($line =~ m{//}) {
3607 if (ERROR("C99_COMMENTS",
3608 "do not use C99 // comments\n" . $herecurr) &&
3610 my $line = $fixed[$fixlinenr];
3611 if ($line =~ /\/\/(.*)$/) {
3612 my $comment = trim($1);
3613 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3617 # Remove C99 comments.
3619 $opline =~ s@//.*@@;
3621 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3622 # the whole statement.
3623 #print "APW <$lines[$realline_next - 1]>\n";
3624 if (defined $realline_next &&
3625 exists $lines[$realline_next - 1] &&
3626 !defined $suppress_export{$realline_next} &&
3627 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3628 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3629 # Handle definitions which produce identifiers with
3632 # EXPORT_SYMBOL(something_foo);
3634 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3635 $name =~ /^${Ident}_$2/) {
3636 #print "FOO C name<$name>\n";
3637 $suppress_export{$realline_next} = 1;
3639 } elsif ($stat !~ /(?:
3641 ^.DEFINE_$Ident\(\Q$name\E\)|
3642 ^.DECLARE_$Ident\(\Q$name\E\)|
3643 ^.LIST_HEAD\(\Q$name\E\)|
3644 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3645 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3647 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3648 $suppress_export{$realline_next} = 2;
3650 $suppress_export{$realline_next} = 1;
3653 if (!defined $suppress_export{$linenr} &&
3654 $prevline =~ /^.\s*$/ &&
3655 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3656 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3657 #print "FOO B <$lines[$linenr - 1]>\n";
3658 $suppress_export{$linenr} = 2;
3660 if (defined $suppress_export{$linenr} &&
3661 $suppress_export{$linenr} == 2) {
3662 WARN("EXPORT_SYMBOL",
3663 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3666 # check for global initialisers.
3667 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3668 if (ERROR("GLOBAL_INITIALISERS",
3669 "do not initialise globals to $1\n" . $herecurr) &&
3671 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3674 # check for static initialisers.
3675 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3676 if (ERROR("INITIALISED_STATIC",
3677 "do not initialise statics to $1\n" .
3680 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3684 # check for misordered declarations of char/short/int/long with signed/unsigned
3685 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3687 WARN("MISORDERED_TYPE",
3688 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3691 # check for static const char * arrays.
3692 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3693 WARN("STATIC_CONST_CHAR_ARRAY",
3694 "static const char * array should probably be static const char * const\n" .
3698 # check for static char foo[] = "bar" declarations.
3699 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3700 WARN("STATIC_CONST_CHAR_ARRAY",
3701 "static char array declaration should probably be static const char\n" .
3705 # check for const <foo> const where <foo> is not a pointer or array type
3706 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3708 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3710 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3711 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3713 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3717 # check for non-global char *foo[] = {"bar", ...} declarations.
3718 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3719 WARN("STATIC_CONST_CHAR_ARRAY",
3720 "char * array declaration might be better as static const\n" .
3724 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3725 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3727 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3729 if (WARN("ARRAY_SIZE",
3730 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3732 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3737 # check for function declarations without arguments like "int foo()"
3738 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3739 if (ERROR("FUNCTION_WITHOUT_ARGS",
3740 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3742 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3746 # check for new typedefs, only function parameters and sparse annotations
3748 if ($line =~ /\btypedef\s/ &&
3749 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3750 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3751 $line !~ /\b$typeTypedefs\b/ &&
3752 $line !~ /\b__bitwise\b/) {
3753 WARN("NEW_TYPEDEFS",
3754 "do not add new typedefs\n" . $herecurr);
3757 # * goes on variable not on type
3759 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3761 my ($ident, $from, $to) = ($1, $2, $2);
3763 # Should start with a space.
3764 $to =~ s/^(\S)/ $1/;
3765 # Should not end with a space.
3767 # '*'s should not have spaces between.
3768 while ($to =~ s/\*\s+\*/\*\*/) {
3771 ## print "1: from<$from> to<$to> ident<$ident>\n";
3773 if (ERROR("POINTER_LOCATION",
3774 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3776 my $sub_from = $ident;
3777 my $sub_to = $ident;
3778 $sub_to =~ s/\Q$from\E/$to/;
3779 $fixed[$fixlinenr] =~
3780 s@\Q$sub_from\E@$sub_to@;
3784 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3786 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3788 # Should start with a space.
3789 $to =~ s/^(\S)/ $1/;
3790 # Should not end with a space.
3792 # '*'s should not have spaces between.
3793 while ($to =~ s/\*\s+\*/\*\*/) {
3795 # Modifiers should have spaces.
3796 $to =~ s/(\b$Modifier$)/$1 /;
3798 ## print "2: from<$from> to<$to> ident<$ident>\n";
3799 if ($from ne $to && $ident !~ /^$Modifier$/) {
3800 if (ERROR("POINTER_LOCATION",
3801 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3804 my $sub_from = $match;
3805 my $sub_to = $match;
3806 $sub_to =~ s/\Q$from\E/$to/;
3807 $fixed[$fixlinenr] =~
3808 s@\Q$sub_from\E@$sub_to@;
3813 # avoid BUG() or BUG_ON()
3814 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3815 my $msg_type = \&WARN;
3816 $msg_type = \&CHK if ($file);
3817 &{$msg_type}("AVOID_BUG",
3818 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3821 # avoid LINUX_VERSION_CODE
3822 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3823 WARN("LINUX_VERSION_CODE",
3824 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3827 # check for uses of printk_ratelimit
3828 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3829 WARN("PRINTK_RATELIMITED",
3830 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3833 # printk should use KERN_* levels. Note that follow on printk's on the
3834 # same line do not need a level, so we use the current block context
3835 # to try and find and validate the current printk. In summary the current
3836 # printk includes all preceding printk's which have no newline on the end.
3837 # we assume the first bad printk is the one to report.
3838 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3840 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3841 #print "CHECK<$lines[$ln - 1]\n";
3842 # we have a preceding printk if it ends
3843 # with "\n" ignore it, else it is to blame
3844 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3845 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3852 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3853 "printk() should include KERN_ facility level\n" . $herecurr);
3857 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3859 my $level = lc($orig);
3860 $level = "warn" if ($level eq "warning");
3861 my $level2 = $level;
3862 $level2 = "dbg" if ($level eq "debug");
3863 WARN("PREFER_PR_LEVEL",
3864 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3867 if ($line =~ /\bpr_warning\s*\(/) {
3868 if (WARN("PREFER_PR_LEVEL",
3869 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3871 $fixed[$fixlinenr] =~
3872 s/\bpr_warning\b/pr_warn/;
3876 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3878 my $level = lc($orig);
3879 $level = "warn" if ($level eq "warning");
3880 $level = "dbg" if ($level eq "debug");
3881 WARN("PREFER_DEV_LEVEL",
3882 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3885 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
3886 # number of false positives, but assembly files are not checked, so at
3887 # least the arch entry code will not trigger this warning.
3888 if ($line =~ /\bENOSYS\b/) {
3890 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3893 # function brace can't be on same line, except for #defines of do while,
3894 # or if closed on same line
3895 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3896 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3897 if (ERROR("OPEN_BRACE",
3898 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3900 fix_delete_line($fixlinenr, $rawline);
3901 my $fixed_line = $rawline;
3902 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3905 fix_insert_line($fixlinenr, ltrim($line1));
3906 fix_insert_line($fixlinenr, "\+{");
3907 if ($line2 !~ /^\s*$/) {
3908 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3913 # open braces for enum, union and struct go on the same line.
3914 if ($line =~ /^.\s*{/ &&
3915 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3916 if (ERROR("OPEN_BRACE",
3917 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3918 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3919 fix_delete_line($fixlinenr - 1, $prevrawline);
3920 fix_delete_line($fixlinenr, $rawline);
3921 my $fixedline = rtrim($prevrawline) . " {";
3922 fix_insert_line($fixlinenr, $fixedline);
3923 $fixedline = $rawline;
3924 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
3925 if ($fixedline !~ /^\+\s*$/) {
3926 fix_insert_line($fixlinenr, $fixedline);
3931 # missing space after union, struct or enum definition
3932 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3934 "missing space after $1 definition\n" . $herecurr) &&
3936 $fixed[$fixlinenr] =~
3937 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3941 # Function pointer declarations
3942 # check spacing between type, funcptr, and args
3943 # canonical declaration is "type (*funcptr)(args...)"
3944 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3946 my $pre_pointer_space = $2;
3947 my $post_pointer_space = $3;
3949 my $post_funcname_space = $5;
3950 my $pre_args_space = $6;
3952 # the $Declare variable will capture all spaces after the type
3953 # so check it for a missing trailing missing space but pointer return types
3954 # don't need a space so don't warn for those.
3955 my $post_declare_space = "";
3956 if ($declare =~ /(\s+)$/) {
3957 $post_declare_space = $1;
3958 $declare = rtrim($declare);
3960 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3962 "missing space after return type\n" . $herecurr);
3963 $post_declare_space = " ";
3966 # unnecessary space "type (*funcptr)(args...)"
3967 # This test is not currently implemented because these declarations are
3969 # int foo(int bar, ...)
3970 # and this is form shouldn't/doesn't generate a checkpatch warning.
3972 # elsif ($declare =~ /\s{2,}$/) {
3974 # "Multiple spaces after return type\n" . $herecurr);
3977 # unnecessary space "type ( *funcptr)(args...)"
3978 if (defined $pre_pointer_space &&
3979 $pre_pointer_space =~ /^\s/) {
3981 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3984 # unnecessary space "type (* funcptr)(args...)"
3985 if (defined $post_pointer_space &&
3986 $post_pointer_space =~ /^\s/) {
3988 "Unnecessary space before function pointer name\n" . $herecurr);
3991 # unnecessary space "type (*funcptr )(args...)"
3992 if (defined $post_funcname_space &&
3993 $post_funcname_space =~ /^\s/) {
3995 "Unnecessary space after function pointer name\n" . $herecurr);
3998 # unnecessary space "type (*funcptr) (args...)"
3999 if (defined $pre_args_space &&
4000 $pre_args_space =~ /^\s/) {
4002 "Unnecessary space before function pointer arguments\n" . $herecurr);
4005 if (show_type("SPACING") && $fix) {
4006 $fixed[$fixlinenr] =~
4007 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4011 # check for spacing round square brackets; allowed:
4012 # 1. with a type on the left -- int [] a;
4013 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4014 # 3. inside a curly brace -- = { [0...10] = 5 }
4015 while ($line =~ /(.*?\s)\[/g) {
4016 my ($where, $prefix) = ($-[1], $1);
4017 if ($prefix !~ /$Type\s+$/ &&
4018 ($where != 0 || $prefix !~ /^.\s+$/) &&
4019 $prefix !~ /[{,]\s+$/) {
4020 if (ERROR("BRACKET_SPACE",
4021 "space prohibited before open square bracket '['\n" . $herecurr) &&
4023 $fixed[$fixlinenr] =~
4024 s/^(\+.*?)\s+\[/$1\[/;
4029 # check for spaces between functions and their parentheses.
4030 while ($line =~ /($Ident)\s+\(/g) {
4032 my $ctx_before = substr($line, 0, $-[1]);
4033 my $ctx = "$ctx_before$name";
4035 # Ignore those directives where spaces _are_ permitted.
4037 if|for|while|switch|return|case|
4038 volatile|__volatile__|
4039 __attribute__|format|__extension__|
4042 # cpp #define statements have non-optional spaces, ie
4043 # if there is a space between the name and the open
4044 # parenthesis it is simply not a parameter group.
4045 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4047 # cpp #elif statement condition may start with a (
4048 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4050 # If this whole things ends with a type its most
4051 # likely a typedef for a function.
4052 } elsif ($ctx =~ /$Type$/) {
4056 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4058 $fixed[$fixlinenr] =~
4059 s/\b$name\s+\(/$name\(/;
4064 # Check operator spacing.
4065 if (!($line=~/\#\s*include/)) {
4066 my $fixed_line = "";
4070 <<=|>>=|<=|>=|==|!=|
4071 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4072 =>|->|<<|>>|<|>|=|!|~|
4073 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4076 my @elements = split(/($ops|;)/, $opline);
4078 ## print("element count: <" . $#elements . ">\n");
4079 ## foreach my $el (@elements) {
4080 ## print("el: <$el>\n");
4083 my @fix_elements = ();
4086 foreach my $el (@elements) {
4087 push(@fix_elements, substr($rawline, $off, length($el)));
4088 $off += length($el);
4093 my $blank = copy_spacing($opline);
4094 my $last_after = -1;
4096 for (my $n = 0; $n < $#elements; $n += 2) {
4098 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4100 ## print("n: <$n> good: <$good>\n");
4102 $off += length($elements[$n]);
4104 # Pick up the preceding and succeeding characters.
4105 my $ca = substr($opline, 0, $off);
4107 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4108 $cc = substr($opline, $off + length($elements[$n + 1]));
4110 my $cb = "$ca$;$cc";
4113 $a = 'V' if ($elements[$n] ne '');
4114 $a = 'W' if ($elements[$n] =~ /\s$/);
4115 $a = 'C' if ($elements[$n] =~ /$;$/);
4116 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4117 $a = 'O' if ($elements[$n] eq '');
4118 $a = 'E' if ($ca =~ /^\s*$/);
4120 my $op = $elements[$n + 1];
4123 if (defined $elements[$n + 2]) {
4124 $c = 'V' if ($elements[$n + 2] ne '');
4125 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4126 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4127 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4128 $c = 'O' if ($elements[$n + 2] eq '');
4129 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4134 my $ctx = "${a}x${c}";
4136 my $at = "(ctx:$ctx)";
4138 my $ptr = substr($blank, 0, $off) . "^";
4139 my $hereptr = "$hereline$ptr\n";
4141 # Pull out the value of this operator.
4142 my $op_type = substr($curr_values, $off + 1, 1);
4144 # Get the full operator variant.
4145 my $opv = $op . substr($curr_vars, $off, 1);
4147 # Ignore operators passed as parameters.
4148 if ($op_type ne 'V' &&
4149 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4152 # } elsif ($op =~ /^$;+$/) {
4154 # ; should have either the end of line or a space or \ after it
4155 } elsif ($op eq ';') {
4156 if ($ctx !~ /.x[WEBC]/ &&
4157 $cc !~ /^\\/ && $cc !~ /^;/) {
4158 if (ERROR("SPACING",
4159 "space required after that '$op' $at\n" . $hereptr)) {
4160 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4166 } elsif ($op eq '//') {
4168 # : when part of a bitfield
4169 } elsif ($opv eq ':B') {
4170 # skip the bitfield test for now
4174 } elsif ($op eq '->') {
4175 if ($ctx =~ /Wx.|.xW/) {
4176 if (ERROR("SPACING",
4177 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4178 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4179 if (defined $fix_elements[$n + 2]) {
4180 $fix_elements[$n + 2] =~ s/^\s+//;
4186 # , must not have a space before and must have a space on the right.
4187 } elsif ($op eq ',') {
4188 my $rtrim_before = 0;
4189 my $space_after = 0;
4190 if ($ctx =~ /Wx./) {
4191 if (ERROR("SPACING",
4192 "space prohibited before that '$op' $at\n" . $hereptr)) {
4197 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4198 if (ERROR("SPACING",
4199 "space required after that '$op' $at\n" . $hereptr)) {
4205 if ($rtrim_before || $space_after) {
4206 if ($rtrim_before) {
4207 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4209 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4216 # '*' as part of a type definition -- reported already.
4217 } elsif ($opv eq '*_') {
4218 #warn "'*' is part of type\n";
4220 # unary operators should have a space before and
4221 # none after. May be left adjacent to another
4222 # unary operator, or a cast
4223 } elsif ($op eq '!' || $op eq '~' ||
4224 $opv eq '*U' || $opv eq '-U' ||
4225 $opv eq '&U' || $opv eq '&&U') {
4226 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4227 if (ERROR("SPACING",
4228 "space required before that '$op' $at\n" . $hereptr)) {
4229 if ($n != $last_after + 2) {
4230 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4235 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4236 # A unary '*' may be const
4238 } elsif ($ctx =~ /.xW/) {
4239 if (ERROR("SPACING",
4240 "space prohibited after that '$op' $at\n" . $hereptr)) {
4241 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4242 if (defined $fix_elements[$n + 2]) {
4243 $fix_elements[$n + 2] =~ s/^\s+//;
4249 # unary ++ and unary -- are allowed no space on one side.
4250 } elsif ($op eq '++' or $op eq '--') {
4251 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4252 if (ERROR("SPACING",
4253 "space required one side of that '$op' $at\n" . $hereptr)) {
4254 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4258 if ($ctx =~ /Wx[BE]/ ||
4259 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4260 if (ERROR("SPACING",
4261 "space prohibited before that '$op' $at\n" . $hereptr)) {
4262 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4266 if ($ctx =~ /ExW/) {
4267 if (ERROR("SPACING",
4268 "space prohibited after that '$op' $at\n" . $hereptr)) {
4269 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4270 if (defined $fix_elements[$n + 2]) {
4271 $fix_elements[$n + 2] =~ s/^\s+//;
4277 # << and >> may either have or not have spaces both sides
4278 } elsif ($op eq '<<' or $op eq '>>' or
4279 $op eq '&' or $op eq '^' or $op eq '|' or
4280 $op eq '+' or $op eq '-' or
4281 $op eq '*' or $op eq '/' or
4285 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4287 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4288 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4289 $fix_elements[$n + 2] =~ s/^\s+//;
4292 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4294 "space preferred before that '$op' $at\n" . $hereptr)) {
4295 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4299 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4300 if (ERROR("SPACING",
4301 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4302 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4303 if (defined $fix_elements[$n + 2]) {
4304 $fix_elements[$n + 2] =~ s/^\s+//;
4310 # A colon needs no spaces before when it is
4311 # terminating a case value or a label.
4312 } elsif ($opv eq ':C' || $opv eq ':L') {
4313 if ($ctx =~ /Wx./) {
4314 if (ERROR("SPACING",
4315 "space prohibited before that '$op' $at\n" . $hereptr)) {
4316 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4321 # All the others need spaces both sides.
4322 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4325 # Ignore email addresses <foo@bar>
4327 $cc =~ /^\S+\@\S+>/) ||
4329 $ca =~ /<\S+\@\S+$/))
4334 # for asm volatile statements
4335 # ignore a colon with another
4336 # colon immediately before or after
4338 ($ca =~ /:$/ || $cc =~ /^:/)) {
4342 # messages are ERROR, but ?: are CHK
4344 my $msg_type = \&ERROR;
4345 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4347 if (&{$msg_type}("SPACING",
4348 "spaces required around that '$op' $at\n" . $hereptr)) {
4349 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4350 if (defined $fix_elements[$n + 2]) {
4351 $fix_elements[$n + 2] =~ s/^\s+//;
4357 $off += length($elements[$n + 1]);
4359 ## print("n: <$n> GOOD: <$good>\n");
4361 $fixed_line = $fixed_line . $good;
4364 if (($#elements % 2) == 0) {
4365 $fixed_line = $fixed_line . $fix_elements[$#elements];
4368 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4369 $fixed[$fixlinenr] = $fixed_line;
4375 # check for whitespace before a non-naked semicolon
4376 if ($line =~ /^\+.*\S\s+;\s*$/) {
4378 "space prohibited before semicolon\n" . $herecurr) &&
4380 1 while $fixed[$fixlinenr] =~
4381 s/^(\+.*\S)\s+;/$1;/;
4385 # check for multiple assignments
4386 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4387 CHK("MULTIPLE_ASSIGNMENTS",
4388 "multiple assignments should be avoided\n" . $herecurr);
4391 ## # check for multiple declarations, allowing for a function declaration
4393 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4394 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4396 ## # Remove any bracketed sections to ensure we do not
4397 ## # falsly report the parameters of functions.
4399 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4401 ## if ($ln =~ /,/) {
4402 ## WARN("MULTIPLE_DECLARATION",
4403 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4407 #need space before brace following if, while, etc
4408 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4410 if (ERROR("SPACING",
4411 "space required before the open brace '{'\n" . $herecurr) &&
4413 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
4417 ## # check for blank lines before declarations
4418 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4419 ## $prevrawline =~ /^.\s*$/) {
4421 ## "No blank lines before declarations\n" . $hereprev);
4425 # closing brace should have a space following it when it has anything
4427 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4428 if (ERROR("SPACING",
4429 "space required after that close brace '}'\n" . $herecurr) &&
4431 $fixed[$fixlinenr] =~
4432 s/}((?!(?:,|;|\)))\S)/} $1/;
4436 # check spacing on square brackets
4437 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4438 if (ERROR("SPACING",
4439 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4441 $fixed[$fixlinenr] =~
4445 if ($line =~ /\s\]/) {
4446 if (ERROR("SPACING",
4447 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4449 $fixed[$fixlinenr] =~
4454 # check spacing on parentheses
4455 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4456 $line !~ /for\s*\(\s+;/) {
4457 if (ERROR("SPACING",
4458 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4460 $fixed[$fixlinenr] =~
4464 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4465 $line !~ /for\s*\(.*;\s+\)/ &&
4466 $line !~ /:\s+\)/) {
4467 if (ERROR("SPACING",
4468 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4470 $fixed[$fixlinenr] =~
4475 # check unnecessary parentheses around addressof/dereference single $Lvals
4476 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4478 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4480 if (CHK("UNNECESSARY_PARENTHESES",
4481 "Unnecessary parentheses around $var\n" . $herecurr) &&
4483 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4487 # check for unnecessary parentheses around function pointer uses
4488 # ie: (foo->bar)(); should be foo->bar();
4489 # but not "if (foo->bar) (" to avoid some false positives
4490 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4492 if (CHK("UNNECESSARY_PARENTHESES",
4493 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4495 my $var2 = deparenthesize($var);
4497 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4501 #goto labels aren't indented, allow a single space however
4502 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4503 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4504 if (WARN("INDENTED_LABEL",
4505 "labels should not be indented\n" . $herecurr) &&
4507 $fixed[$fixlinenr] =~
4512 # return is not a function
4513 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4515 if ($^V && $^V ge 5.10.0 &&
4516 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4518 $value = deparenthesize($value);
4519 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4520 ERROR("RETURN_PARENTHESES",
4521 "return is not a function, parentheses are not required\n" . $herecurr);
4523 } elsif ($spacing !~ /\s+/) {
4525 "space required before the open parenthesis '('\n" . $herecurr);
4529 # unnecessary return in a void function
4530 # at end-of-function, with the previous line a single leading tab, then return;
4531 # and the line before that not a goto label target like "out:"
4532 if ($sline =~ /^[ \+]}\s*$/ &&
4533 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4535 $lines[$linenr - 3] =~ /^[ +]/ &&
4536 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4538 "void function return statements are not generally useful\n" . $hereprev);
4541 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4542 if ($^V && $^V ge 5.10.0 &&
4543 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4544 my $openparens = $1;
4545 my $count = $openparens =~ tr@\(@\(@;
4547 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4548 my $comp = $4; #Not $1 because of $LvalOrFunc
4549 $msg = " - maybe == should be = ?" if ($comp eq "==");
4550 WARN("UNNECESSARY_PARENTHESES",
4551 "Unnecessary parentheses$msg\n" . $herecurr);
4555 # comparisons with a constant or upper case identifier on the left
4556 # avoid cases like "foo + BAR < baz"
4557 # only fix matches surrounded by parentheses to avoid incorrect
4558 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4559 if ($^V && $^V ge 5.10.0 &&
4560 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4565 my $newcomp = $comp;
4566 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4567 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4568 WARN("CONSTANT_COMPARISON",
4569 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4573 } elsif ($comp eq "<=") {
4575 } elsif ($comp eq ">") {
4577 } elsif ($comp eq ">=") {
4580 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4584 # Return of what appears to be an errno should normally be negative
4585 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4587 if ($name ne 'EOF' && $name ne 'ERROR') {
4588 WARN("USE_NEGATIVE_ERRNO",
4589 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4593 # Need a space before open parenthesis after if, while etc
4594 if ($line =~ /\b(if|while|for|switch)\(/) {
4595 if (ERROR("SPACING",
4596 "space required before the open parenthesis '('\n" . $herecurr) &&
4598 $fixed[$fixlinenr] =~
4599 s/\b(if|while|for|switch)\(/$1 \(/;
4603 # Check for illegal assignment in if conditional -- and check for trailing
4604 # statements after the conditional.
4605 if ($line =~ /do\s*(?!{)/) {
4606 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4607 ctx_statement_block($linenr, $realcnt, 0)
4608 if (!defined $stat);
4609 my ($stat_next) = ctx_statement_block($line_nr_next,
4610 $remain_next, $off_next);
4611 $stat_next =~ s/\n./\n /g;
4612 ##print "stat<$stat> stat_next<$stat_next>\n";
4614 if ($stat_next =~ /^\s*while\b/) {
4615 # If the statement carries leading newlines,
4616 # then count those as offsets.
4618 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4620 statement_rawlines($whitespace) - 1;
4622 $suppress_whiletrailers{$line_nr_next +
4626 if (!defined $suppress_whiletrailers{$linenr} &&
4627 defined($stat) && defined($cond) &&
4628 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4629 my ($s, $c) = ($stat, $cond);
4631 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4632 ERROR("ASSIGN_IN_IF",
4633 "do not use assignment in if condition\n" . $herecurr);
4636 # Find out what is on the end of the line after the
4638 substr($s, 0, length($c), '');
4640 $s =~ s/$;//g; # Remove any comments
4641 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4642 $c !~ /}\s*while\s*/)
4644 # Find out how long the conditional actually is.
4645 my @newlines = ($c =~ /\n/gs);
4646 my $cond_lines = 1 + $#newlines;
4649 $stat_real = raw_line($linenr, $cond_lines)
4650 . "\n" if ($cond_lines);
4651 if (defined($stat_real) && $cond_lines > 1) {
4652 $stat_real = "[...]\n$stat_real";
4655 ERROR("TRAILING_STATEMENTS",
4656 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4660 # Check for bitwise tests written as boolean
4672 WARN("HEXADECIMAL_BOOLEAN_TEST",
4673 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4676 # if and else should not have general statements after it
4677 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4679 $s =~ s/$;//g; # Remove any comments
4680 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4681 ERROR("TRAILING_STATEMENTS",
4682 "trailing statements should be on next line\n" . $herecurr);
4685 # if should not continue a brace
4686 if ($line =~ /}\s*if\b/) {
4687 ERROR("TRAILING_STATEMENTS",
4688 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4691 # case and default should not have general statements after them
4692 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4694 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4698 ERROR("TRAILING_STATEMENTS",
4699 "trailing statements should be on next line\n" . $herecurr);
4702 # Check for }<nl>else {, these must be at the same
4703 # indent level to be relevant to each other.
4704 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4705 $previndent == $indent) {
4706 if (ERROR("ELSE_AFTER_BRACE",
4707 "else should follow close brace '}'\n" . $hereprev) &&
4708 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4709 fix_delete_line($fixlinenr - 1, $prevrawline);
4710 fix_delete_line($fixlinenr, $rawline);
4711 my $fixedline = $prevrawline;
4712 $fixedline =~ s/}\s*$//;
4713 if ($fixedline !~ /^\+\s*$/) {
4714 fix_insert_line($fixlinenr, $fixedline);
4716 $fixedline = $rawline;
4717 $fixedline =~ s/^(.\s*)else/$1} else/;
4718 fix_insert_line($fixlinenr, $fixedline);
4722 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4723 $previndent == $indent) {
4724 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4726 # Find out what is on the end of the line after the
4728 substr($s, 0, length($c), '');
4731 if ($s =~ /^\s*;/) {
4732 if (ERROR("WHILE_AFTER_BRACE",
4733 "while should follow close brace '}'\n" . $hereprev) &&
4734 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4735 fix_delete_line($fixlinenr - 1, $prevrawline);
4736 fix_delete_line($fixlinenr, $rawline);
4737 my $fixedline = $prevrawline;
4738 my $trailing = $rawline;
4739 $trailing =~ s/^\+//;
4740 $trailing = trim($trailing);
4741 $fixedline =~ s/}\s*$/} $trailing/;
4742 fix_insert_line($fixlinenr, $fixedline);
4747 #Specific variable tests
4748 while ($line =~ m{($Constant|$Lval)}g) {
4751 #gcc binary extension
4752 if ($var =~ /^$Binary$/) {
4753 if (WARN("GCC_BINARY_CONSTANT",
4754 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4756 my $hexval = sprintf("0x%x", oct($var));
4757 $fixed[$fixlinenr] =~
4758 s/\b$var\b/$hexval/;
4763 if ($var !~ /^$Constant$/ &&
4764 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4765 #Ignore Page<foo> variants
4766 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4767 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4768 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4769 #Ignore some three character SI units explicitly, like MiB and KHz
4770 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4771 while ($var =~ m{($Ident)}g) {
4773 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4775 seed_camelcase_includes();
4776 if (!$file && !$camelcase_file_seeded) {
4777 seed_camelcase_file($realfile);
4778 $camelcase_file_seeded = 1;
4781 if (!defined $camelcase{$word}) {
4782 $camelcase{$word} = 1;
4784 "Avoid CamelCase: <$word>\n" . $herecurr);
4790 #no spaces allowed after \ in define
4791 if ($line =~ /\#\s*define.*\\\s+$/) {
4792 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4793 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4795 $fixed[$fixlinenr] =~ s/\s+$//;
4799 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4800 # itself <asm/foo.h> (uses RAW line)
4801 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4803 my $checkfile = "include/linux/$file";
4804 if (-f "$root/$checkfile" &&
4805 $realfile ne $checkfile &&
4806 $1 !~ /$allowed_asm_includes/)
4808 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4809 if ($asminclude > 0) {
4810 if ($realfile =~ m{^arch/}) {
4811 CHK("ARCH_INCLUDE_LINUX",
4812 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4814 WARN("INCLUDE_LINUX",
4815 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4821 # multi-statement macros should be enclosed in a do while loop, grab the
4822 # first statement and ensure its the whole macro if its not enclosed
4823 # in a known good container
4824 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4825 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4828 my ($off, $dstat, $dcond, $rest);
4830 my $has_flow_statement = 0;
4831 my $has_arg_concat = 0;
4832 ($dstat, $dcond, $ln, $cnt, $off) =
4833 ctx_statement_block($linenr, $realcnt, 0);
4835 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4836 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4838 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4839 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4841 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4842 my $define_args = $1;
4843 my $define_stmt = $dstat;
4846 if (defined $define_args && $define_args ne "") {
4847 $define_args = substr($define_args, 1, length($define_args) - 2);
4848 $define_args =~ s/\s*//g;
4849 @def_args = split(",", $define_args);
4853 $dstat =~ s/\\\n.//g;
4854 $dstat =~ s/^\s*//s;
4855 $dstat =~ s/\s*$//s;
4857 # Flatten any parentheses and braces
4858 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4859 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4860 $dstat =~ s/.\[[^\[\]]*\]/1/)
4864 # Flatten any obvious string concatentation.
4865 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4866 $dstat =~ s/$Ident\s*($String)/$1/)
4870 # Make asm volatile uses seem like a generic function
4871 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4873 my $exceptions = qr{
4886 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4889 my $herectx = $here . "\n";
4890 my $stmt_cnt = statement_rawlines($ctx);
4892 for (my $n = 0; $n < $stmt_cnt; $n++) {
4893 $herectx .= raw_line($linenr, $n) . "\n";
4897 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4898 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4899 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4900 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4901 $dstat !~ /$exceptions/ &&
4902 $dstat !~ /^\.$Ident\s*=/ && # .foo =
4903 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4904 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4905 $dstat !~ /^for\s*$Constant$/ && # for (...)
4906 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4907 $dstat !~ /^do\s*{/ && # do {...
4908 $dstat !~ /^\(\{/ && # ({...
4909 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4911 if ($dstat =~ /^\s*if\b/) {
4912 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4913 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
4914 } elsif ($dstat =~ /;/) {
4915 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4916 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4918 ERROR("COMPLEX_MACRO",
4919 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4924 # Make $define_stmt single line, comment-free, etc
4925 my @stmt_array = split('\n', $define_stmt);
4928 foreach my $l (@stmt_array) {
4933 } elsif ($l =~ /^[\+ ]/) {
4934 $define_stmt .= substr($l, 1);
4937 $define_stmt =~ s/$;//g;
4938 $define_stmt =~ s/\s+/ /g;
4939 $define_stmt = trim($define_stmt);
4941 # check if any macro arguments are reused (ignore '...' and 'type')
4942 foreach my $arg (@def_args) {
4943 next if ($arg =~ /\.\.\./);
4944 next if ($arg =~ /^type$/i);
4945 my $tmp_stmt = $define_stmt;
4946 $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
4947 $tmp_stmt =~ s/\#+\s*$arg\b//g;
4948 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
4949 my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
4951 CHK("MACRO_ARG_REUSE",
4952 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
4954 # check if any macro arguments may have other precedence issues
4955 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
4956 ((defined($1) && $1 ne ',') ||
4957 (defined($2) && $2 ne ','))) {
4958 CHK("MACRO_ARG_PRECEDENCE",
4959 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
4963 # check for macros with flow control, but without ## concatenation
4964 # ## concatenation is commonly a macro that defines a function so ignore those
4965 if ($has_flow_statement && !$has_arg_concat) {
4966 my $herectx = $here . "\n";
4967 my $cnt = statement_rawlines($ctx);
4969 for (my $n = 0; $n < $cnt; $n++) {
4970 $herectx .= raw_line($linenr, $n) . "\n";
4972 WARN("MACRO_WITH_FLOW_CONTROL",
4973 "Macros with flow control statements should be avoided\n" . "$herectx");
4976 # check for line continuations outside of #defines, preprocessor #, and asm
4979 if ($prevline !~ /^..*\\$/ &&
4980 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4981 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
4982 $line =~ /^\+.*\\$/) {
4983 WARN("LINE_CONTINUATIONS",
4984 "Avoid unnecessary line continuations\n" . $herecurr);
4988 # do {} while (0) macro tests:
4989 # single-statement macros do not need to be enclosed in do while (0) loop,
4990 # macro should not end with a semicolon
4991 if ($^V && $^V ge 5.10.0 &&
4992 $realfile !~ m@/vmlinux.lds.h$@ &&
4993 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4996 my ($off, $dstat, $dcond, $rest);
4998 ($dstat, $dcond, $ln, $cnt, $off) =
4999 ctx_statement_block($linenr, $realcnt, 0);
5002 $dstat =~ s/\\\n.//g;
5005 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5010 my $cnt = statement_rawlines($ctx);
5011 my $herectx = $here . "\n";
5013 for (my $n = 0; $n < $cnt; $n++) {
5014 $herectx .= raw_line($linenr, $n) . "\n";
5017 if (($stmts =~ tr/;/;/) == 1 &&
5018 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5019 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5020 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5022 if (defined $semis && $semis ne "") {
5023 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5024 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5026 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5028 my $cnt = statement_rawlines($ctx);
5029 my $herectx = $here . "\n";
5031 for (my $n = 0; $n < $cnt; $n++) {
5032 $herectx .= raw_line($linenr, $n) . "\n";
5035 WARN("TRAILING_SEMICOLON",
5036 "macros should not use a trailing semicolon\n" . "$herectx");
5040 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
5041 # all assignments may have only one of the following with an assignment:
5044 # VMLINUX_SYMBOL(...)
5045 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
5046 WARN("MISSING_VMLINUX_SYMBOL",
5047 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
5050 # check for redundant bracing round if etc
5051 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5052 my ($level, $endln, @chunks) =
5053 ctx_statement_full($linenr, $realcnt, 1);
5054 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5055 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5056 if ($#chunks > 0 && $level == 0) {
5060 my $herectx = $here . "\n";
5061 my $ln = $linenr - 1;
5062 for my $chunk (@chunks) {
5063 my ($cond, $block) = @{$chunk};
5065 # If the condition carries leading newlines, then count those as offsets.
5066 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5067 my $offset = statement_rawlines($whitespace) - 1;
5069 $allowed[$allow] = 0;
5070 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5072 # We have looked at and allowed this specific line.
5073 $suppress_ifbraces{$ln + $offset} = 1;
5075 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5076 $ln += statement_rawlines($block) - 1;
5078 substr($block, 0, length($cond), '');
5080 $seen++ if ($block =~ /^\s*{/);
5082 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5083 if (statement_lines($cond) > 1) {
5084 #print "APW: ALLOWED: cond<$cond>\n";
5085 $allowed[$allow] = 1;
5087 if ($block =~/\b(?:if|for|while)\b/) {
5088 #print "APW: ALLOWED: block<$block>\n";
5089 $allowed[$allow] = 1;
5091 if (statement_block_size($block) > 1) {
5092 #print "APW: ALLOWED: lines block<$block>\n";
5093 $allowed[$allow] = 1;
5098 my $sum_allowed = 0;
5099 foreach (@allowed) {
5102 if ($sum_allowed == 0) {
5104 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5105 } elsif ($sum_allowed != $allow &&
5108 "braces {} should be used on all arms of this statement\n" . $herectx);
5113 if (!defined $suppress_ifbraces{$linenr - 1} &&
5114 $line =~ /\b(if|while|for|else)\b/) {
5117 # Check the pre-context.
5118 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5119 #print "APW: ALLOWED: pre<$1>\n";
5123 my ($level, $endln, @chunks) =
5124 ctx_statement_full($linenr, $realcnt, $-[0]);
5126 # Check the condition.
5127 my ($cond, $block) = @{$chunks[0]};
5128 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5129 if (defined $cond) {
5130 substr($block, 0, length($cond), '');
5132 if (statement_lines($cond) > 1) {
5133 #print "APW: ALLOWED: cond<$cond>\n";
5136 if ($block =~/\b(?:if|for|while)\b/) {
5137 #print "APW: ALLOWED: block<$block>\n";
5140 if (statement_block_size($block) > 1) {
5141 #print "APW: ALLOWED: lines block<$block>\n";
5144 # Check the post-context.
5145 if (defined $chunks[1]) {
5146 my ($cond, $block) = @{$chunks[1]};
5147 if (defined $cond) {
5148 substr($block, 0, length($cond), '');
5150 if ($block =~ /^\s*\{/) {
5151 #print "APW: ALLOWED: chunk-1 block<$block>\n";
5155 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5156 my $herectx = $here . "\n";
5157 my $cnt = statement_rawlines($block);
5159 for (my $n = 0; $n < $cnt; $n++) {
5160 $herectx .= raw_line($linenr, $n) . "\n";
5164 "braces {} are not necessary for single statement blocks\n" . $herectx);
5168 # try to replace assertions with error handling
5169 if ($line =~ /\bLASSERTF?\s*\(/) {
5171 "try to replace assertions with error handling\n" .
5175 # avoid new console messages
5176 if ($line =~ /\bLCONSOLE[A-Z_]*\s*\(/) {
5178 "avoid adding new console messages\n" .
5182 # minimize new CERROR messages
5183 if ($line =~ /\bC(EMERG|ERROR|NETERR|WARN)\s*\(/) {
5185 "think hard when adding new CERROR messages\n" .
5189 # don't allow GPLv3 license files
5190 if ($rawline =~ /version 3/) {
5192 "using GPLv3 is usually wrong\n" . $herecurr);
5195 # check for single line unbalanced braces
5196 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5197 $sline =~ /^.\s*else\s*\{\s*$/) {
5198 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5201 # check for unnecessary blank lines around braces
5202 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5204 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5205 $fix && $prevrawline =~ /^\+/) {
5206 fix_delete_line($fixlinenr - 1, $prevrawline);
5209 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5211 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5213 fix_delete_line($fixlinenr, $rawline);
5217 # no volatiles please
5218 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5219 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5221 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5224 # Check for user-visible strings broken across lines, which breaks the ability
5225 # to grep for the string. Make exceptions when the previous string ends in a
5226 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5227 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5228 if ($line =~ /^\+\s*$String/ &&
5229 $prevline =~ /"\s*$/ &&
5230 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5231 if (WARN("SPLIT_STRING",
5232 "quoted string split across lines\n" . $hereprev) &&
5234 $prevrawline =~ /^\+.*"\s*$/ &&
5235 $last_coalesced_string_linenr != $linenr - 1) {
5236 my $extracted_string = get_quoted_string($line, $rawline);
5237 my $comma_close = "";
5238 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5242 fix_delete_line($fixlinenr - 1, $prevrawline);
5243 fix_delete_line($fixlinenr, $rawline);
5244 my $fixedline = $prevrawline;
5245 $fixedline =~ s/"\s*$//;
5246 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5247 fix_insert_line($fixlinenr - 1, $fixedline);
5248 $fixedline = $rawline;
5249 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5250 if ($fixedline !~ /\+\s*$/) {
5251 fix_insert_line($fixlinenr, $fixedline);
5253 $last_coalesced_string_linenr = $linenr;
5257 # check for missing a space in a string concatenation
5258 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5259 WARN('MISSING_SPACE',
5260 "break quoted strings at a space character\n" . $hereprev);
5263 # check for an embedded function name in a string when the function is known
5264 # This does not work very well for -f --file checking as it depends on patch
5265 # context providing the function name or a single line form for in-file
5266 # function declarations
5267 if ($line =~ /^\+.*$String/ &&
5268 defined($context_function) &&
5269 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
5270 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
5271 WARN("EMBEDDED_FUNCTION_NAME",
5272 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
5275 # check for spaces before a quoted newline
5276 if ($rawline =~ /^.*\".*\s\\n/) {
5277 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5278 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5280 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5285 # concatenated string without spaces between elements
5286 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5287 CHK("CONCATENATED_STRING",
5288 "Concatenated strings should use spaces between elements\n" . $herecurr);
5291 # uncoalesced string fragments
5292 if ($line =~ /$String\s*"/) {
5293 WARN("STRING_FRAGMENTS",
5294 "Consecutive strings are generally better as a single string\n" . $herecurr);
5297 # check for non-standard and hex prefixed decimal printf formats
5298 my $show_L = 1; #don't show the same defect twice
5300 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5301 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
5302 $string =~ s/%%/__/g;
5304 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
5306 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
5310 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
5312 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
5315 # check for 0x<decimal>
5316 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
5317 ERROR("PRINTF_0XDECIMAL",
5318 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5322 # check for line continuations in quoted strings with odd counts of "
5323 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5324 WARN("LINE_CONTINUATIONS",
5325 "Avoid line continuations in quoted strings\n" . $herecurr);
5329 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5330 CHK("REDUNDANT_CODE",
5331 "if this code is redundant consider removing it\n" .
5335 # check for needless "if (<foo>) fn(<foo>)" uses
5336 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5337 my $tested = quotemeta($1);
5338 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5339 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5341 if (WARN('NEEDLESS_IF',
5342 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5345 my $leading_tabs = "";
5346 my $new_leading_tabs = "";
5347 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5352 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5353 $new_leading_tabs = $1;
5354 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5361 fix_delete_line($fixlinenr - 1, $prevrawline);
5362 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5368 # check for unnecessary "Out of Memory" messages
5369 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5370 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5371 (defined $1 || defined $3) &&
5374 my $testline = $lines[$linenr - 3];
5376 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5377 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5379 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|kmemdup|(?:dev_)?alloc_skb)/) {
5381 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5385 # check for logging functions with KERN_<LEVEL>
5386 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5387 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5389 if (WARN("UNNECESSARY_KERN_LEVEL",
5390 "Possible unnecessary $level\n" . $herecurr) &&
5392 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5396 # check for logging continuations
5397 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
5398 WARN("LOGGING_CONTINUATION",
5399 "Avoid logging continuation uses where feasible\n" . $herecurr);
5402 # check for mask then right shift without a parentheses
5403 if ($^V && $^V ge 5.10.0 &&
5404 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5405 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5406 WARN("MASK_THEN_SHIFT",
5407 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5410 # check for pointer comparisons to NULL
5411 if ($^V && $^V ge 5.10.0) {
5412 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5415 $equal = "" if ($4 eq "!=");
5416 if (CHK("COMPARISON_TO_NULL",
5417 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5419 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5424 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5425 if ($line =~ /(\b$InitAttribute\b)/) {
5427 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5430 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5431 ERROR("MISPLACED_INIT",
5432 "$attr should be placed after $var\n" . $herecurr)) ||
5433 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5434 WARN("MISPLACED_INIT",
5435 "$attr should be placed after $var\n" . $herecurr))) &&
5437 $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;
5442 # check for $InitAttributeData (ie: __initdata) with const
5443 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5445 $attr =~ /($InitAttributePrefix)(.*)/;
5446 my $attr_prefix = $1;
5448 if (ERROR("INIT_ATTRIBUTE",
5449 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5451 $fixed[$fixlinenr] =~
5452 s/$InitAttributeData/${attr_prefix}initconst/;
5456 # check for $InitAttributeConst (ie: __initconst) without const
5457 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5459 if (ERROR("INIT_ATTRIBUTE",
5460 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5462 my $lead = $fixed[$fixlinenr] =~
5463 /(^\+\s*(?:static\s+))/;
5465 $lead = "$lead " if ($lead !~ /^\+$/);
5466 $lead = "${lead}const ";
5467 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5471 # check for __read_mostly with const non-pointer (should just be const)
5472 if ($line =~ /\b__read_mostly\b/ &&
5473 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5474 if (ERROR("CONST_READ_MOSTLY",
5475 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5477 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5481 # don't use __constant_<foo> functions outside of include/uapi/
5482 if ($realfile !~ m@^include/uapi/@ &&
5483 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5484 my $constant_func = $1;
5485 my $func = $constant_func;
5486 $func =~ s/^__constant_//;
5487 if (WARN("CONSTANT_CONVERSION",
5488 "$constant_func should be $func\n" . $herecurr) &&
5490 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5494 # prefer usleep_range over udelay
5495 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5497 # ignore udelay's < 10, however
5498 if (! ($delay < 10) ) {
5500 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5502 if ($delay > 2000) {
5504 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5508 # warn about unexpectedly long msleep's
5509 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5512 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5516 # check for comparisons of jiffies
5517 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5518 WARN("JIFFIES_COMPARISON",
5519 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5522 # check for comparisons of get_jiffies_64()
5523 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5524 WARN("JIFFIES_COMPARISON",
5525 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5528 # warn about #ifdefs in C files
5529 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5530 # print "#ifdef in C files should be avoided\n";
5531 # print "$herecurr";
5535 # warn about spacing in #ifdefs
5536 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5537 if (ERROR("SPACING",
5538 "exactly one space required after that #$1\n" . $herecurr) &&
5540 $fixed[$fixlinenr] =~
5541 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5546 # check for spinlock_t definitions without a comment.
5547 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5548 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5550 if (!ctx_has_comment($first_line, $linenr)) {
5551 CHK("UNCOMMENTED_DEFINITION",
5552 "$1 definition without comment\n" . $herecurr);
5555 # check for memory barriers without a comment.
5561 read_barrier_depends
5563 my $barrier_stems = qr{
5571 my $all_barriers = qr{
5573 smp_(?:$barrier_stems)|
5574 virt_(?:$barrier_stems)
5577 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5578 if (!ctx_has_comment($first_line, $linenr)) {
5579 WARN("MEMORY_BARRIER",
5580 "memory barrier without comment\n" . $herecurr);
5584 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5586 if ($realfile !~ m@^include/asm-generic/@ &&
5587 $realfile !~ m@/barrier\.h$@ &&
5588 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5589 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5590 WARN("MEMORY_BARRIER",
5591 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5594 # check for waitqueue_active without a comment.
5595 if ($line =~ /\bwaitqueue_active\s*\(/) {
5596 if (!ctx_has_comment($first_line, $linenr)) {
5597 WARN("WAITQUEUE_ACTIVE",
5598 "waitqueue_active without comment\n" . $herecurr);
5602 # check of hardware specific defines
5603 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5605 "architecture specific defines should be avoided\n" . $herecurr);
5608 # check that the storage class is not after a type
5609 if ($line =~ /\b($Type)\s+($Storage)\b/) {
5610 WARN("STORAGE_CLASS",
5611 "storage class '$2' should be located before type '$1'\n" . $herecurr);
5613 # Check that the storage class is at the beginning of a declaration
5614 if ($line =~ /\b$Storage\b/ &&
5615 $line !~ /^.\s*$Storage/ &&
5616 $line =~ /^.\s*(.+?)\$Storage\s/ &&
5617 $1 !~ /[\,\)]\s*$/) {
5618 WARN("STORAGE_CLASS",
5619 "storage class should be at the beginning of the declaration\n" . $herecurr);
5622 # check the location of the inline attribute, that it is between
5623 # storage class and type.
5624 if ($line =~ /\b$Type\s+$Inline\b/ ||
5625 $line =~ /\b$Inline\s+$Storage\b/) {
5626 ERROR("INLINE_LOCATION",
5627 "inline keyword should sit between storage class and type\n" . $herecurr);
5630 # Check for __inline__ and __inline, prefer inline
5631 if ($realfile !~ m@\binclude/uapi/@ &&
5632 $line =~ /\b(__inline__|__inline)\b/) {
5634 "plain inline is preferred over $1\n" . $herecurr) &&
5636 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5641 # Check for __packed, prefer __attribute__ packed
5642 if ($realfile !~ m@\binclude/uapi/@ &&
5643 $line =~ /\b__packed\b/) {
5644 WARN("PREFER_PACKED",
5645 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5648 # Check for __aligned, prefer __attribute__ aligned
5649 if ($realfile !~ m@\binclude/uapi/@ &&
5650 $line =~ /\b__aligned\b/) {
5651 WARN("PREFER_ALIGNED",
5652 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5655 # Check for __attribute__ format(printf, prefer __printf
5656 if ($realfile !~ m@\binclude/uapi/@ &&
5657 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5658 if (WARN("PREFER_PRINTF",
5659 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5661 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5666 # Check for __attribute__ format(scanf, prefer __scanf
5667 if ($realfile !~ m@\binclude/uapi/@ &&
5668 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5669 if (WARN("PREFER_SCANF",
5670 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5672 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5676 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5677 if ($^V && $^V ge 5.10.0 &&
5678 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5679 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5680 $line =~ /\b__weak\b/)) {
5681 ERROR("WEAK_DECLARATION",
5682 "Using weak declarations can have unintended link defects\n" . $herecurr);
5685 # check for c99 types like uint8_t used outside of uapi/ and tools/
5686 if ($realfile !~ m@\binclude/uapi/@ &&
5687 $realfile !~ m@\btools/@ &&
5688 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5690 if ($type =~ /\b($typeC99Typedefs)\b/) {
5692 my $kernel_type = 'u';
5693 $kernel_type = 's' if ($type =~ /^_*[si]/);
5696 if (CHK("PREFER_KERNEL_TYPES",
5697 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5699 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5704 # check for cast of C90 native int or longer types constants
5705 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5708 if (WARN("TYPECAST_INT_CONSTANT",
5709 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5712 my $newconst = $const;
5713 $newconst =~ s/${Int_type}$//;
5714 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5715 if ($cast =~ /\blong\s+long\b/) {
5717 } elsif ($cast =~ /\blong\b/) {
5720 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5724 # check for sizeof(&)
5725 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5726 WARN("SIZEOF_ADDRESS",
5727 "sizeof(& should be avoided\n" . $herecurr);
5730 # check for sizeof without parenthesis
5731 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5732 if (WARN("SIZEOF_PARENTHESIS",
5733 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5735 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5739 # check for struct spinlock declarations
5740 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5741 WARN("USE_SPINLOCK_T",
5742 "struct spinlock should be spinlock_t\n" . $herecurr);
5745 # check for seq_printf uses that could be seq_puts
5746 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5747 my $fmt = get_quoted_string($line, $rawline);
5750 if (WARN("PREFER_SEQ_PUTS",
5751 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5753 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5758 # check for vsprintf extension %p<foo> misuses
5759 if ($^V && $^V ge 5.10.0 &&
5761 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
5762 $1 !~ /^_*volatile_*$/) {
5763 my $bad_extension = "";
5764 my $lc = $stat =~ tr@\n@@;
5765 $lc = $lc + $linenr;
5766 for (my $count = $linenr; $count <= $lc; $count++) {
5767 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
5769 if ($fmt =~ /(\%[\*\d\.]*p(?![\WFfSsBKRraEhMmIiUDdgVCbGNO]).)/) {
5770 $bad_extension = $1;
5774 if ($bad_extension ne "") {
5775 my $stat_real = raw_line($linenr, 0);
5776 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5777 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5779 WARN("VSPRINTF_POINTER_EXTENSION",
5780 "Invalid vsprintf pointer extension '$bad_extension'\n" . "$here\n$stat_real\n");
5784 # Check for misused memsets
5785 if ($^V && $^V ge 5.10.0 &&
5787 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5793 if ($ms_size =~ /^(0x|)0$/i) {
5795 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5796 } elsif ($ms_size =~ /^(0x|)1$/i) {
5798 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5802 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5803 # if ($^V && $^V ge 5.10.0 &&
5805 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5806 # if (WARN("PREFER_ETHER_ADDR_COPY",
5807 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5809 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5813 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5814 # if ($^V && $^V ge 5.10.0 &&
5816 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5817 # WARN("PREFER_ETHER_ADDR_EQUAL",
5818 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5821 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5822 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5823 # if ($^V && $^V ge 5.10.0 &&
5825 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5829 # if ($ms_val =~ /^(?:0x|)0+$/i) {
5830 # if (WARN("PREFER_ETH_ZERO_ADDR",
5831 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5833 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5835 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5836 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
5837 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5839 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5844 # typecasts on min/max could be min_t/max_t
5845 if ($^V && $^V ge 5.10.0 &&
5847 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5848 if (defined $2 || defined $7) {
5850 my $cast1 = deparenthesize($2);
5852 my $cast2 = deparenthesize($7);
5856 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5857 $cast = "$cast1 or $cast2";
5858 } elsif ($cast1 ne "") {
5864 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5868 # check usleep_range arguments
5869 if ($^V && $^V ge 5.10.0 &&
5871 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5875 WARN("USLEEP_RANGE",
5876 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5877 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5879 WARN("USLEEP_RANGE",
5880 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5884 # check for naked sscanf
5885 if ($^V && $^V ge 5.10.0 &&
5887 $line =~ /\bsscanf\b/ &&
5888 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5889 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5890 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5891 my $lc = $stat =~ tr@\n@@;
5892 $lc = $lc + $linenr;
5893 my $stat_real = raw_line($linenr, 0);
5894 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5895 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5897 WARN("NAKED_SSCANF",
5898 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5901 # check for simple sscanf that should be kstrto<foo>
5902 if ($^V && $^V ge 5.10.0 &&
5904 $line =~ /\bsscanf\b/) {
5905 my $lc = $stat =~ tr@\n@@;
5906 $lc = $lc + $linenr;
5907 my $stat_real = raw_line($linenr, 0);
5908 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5909 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5911 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5913 my $count = $format =~ tr@%@%@;
5915 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5916 WARN("SSCANF_TO_KSTRTO",
5917 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5922 # check for new externs in .h files.
5923 if ($realfile =~ /\.h$/ &&
5924 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5925 if (CHK("AVOID_EXTERNS",
5926 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5928 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5932 # check for new externs in .c files.
5933 if ($realfile =~ /\.c$/ && defined $stat &&
5934 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5936 my $function_name = $1;
5937 my $paren_space = $2;
5940 if (defined $cond) {
5941 substr($s, 0, length($cond), '');
5943 if ($s =~ /^\s*;/ &&
5944 $function_name ne 'uninitialized_var')
5946 WARN("AVOID_EXTERNS",
5947 "externs should be avoided in .c files\n" . $herecurr);
5950 if ($paren_space =~ /\n/) {
5951 WARN("FUNCTION_ARGUMENTS",
5952 "arguments for function declarations should follow identifier\n" . $herecurr);
5955 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5956 $stat =~ /^.\s*extern\s+/)
5958 WARN("AVOID_EXTERNS",
5959 "externs should be avoided in .c files\n" . $herecurr);
5962 # check for function declarations that have arguments without identifier names
5963 if (defined $stat &&
5964 $stat =~ /^.\s*(?:extern\s+)?$Type\s*$Ident\s*\(\s*([^{]+)\s*\)\s*;/s &&
5966 my $args = trim($1);
5967 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
5969 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
5970 WARN("FUNCTION_ARGUMENTS",
5971 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
5976 # check for function definitions
5977 if ($^V && $^V ge 5.10.0 &&
5979 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
5980 $context_function = $1;
5982 # check for multiline function definition with misplaced open brace
5984 my $cnt = statement_rawlines($stat);
5985 my $herectx = $here . "\n";
5986 for (my $n = 0; $n < $cnt; $n++) {
5987 my $rl = raw_line($linenr, $n);
5988 $herectx .= $rl . "\n";
5989 $ok = 1 if ($rl =~ /^[ \+]\{/);
5990 $ok = 1 if ($rl =~ /\{/ && $n == 0);
5991 last if $rl =~ /^[ \+].*\{/;
5995 "open brace '{' following function definitions go on the next line\n" . $herectx);
5999 # checks for new __setup's
6000 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6003 if (!grep(/$name/, @setup_docs)) {
6004 CHK("UNDOCUMENTED_SETUP",
6005 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
6009 # check for pointless casting of kmalloc return
6010 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
6011 WARN("UNNECESSARY_CASTS",
6012 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6016 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6017 if ($^V && $^V ge 5.10.0 &&
6018 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6019 CHK("ALLOC_SIZEOF_STRUCT",
6020 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6023 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6024 if ($^V && $^V ge 5.10.0 &&
6026 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6030 my $newfunc = "kmalloc_array";
6031 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6034 if ($a1 =~ /^sizeof\s*\S/) {
6038 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6039 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6041 my $herectx = $here . "\n";
6042 my $cnt = statement_rawlines($stat);
6043 for (my $n = 0; $n < $cnt; $n++) {
6044 $herectx .= raw_line($linenr, $n) . "\n";
6046 if (WARN("ALLOC_WITH_MULTIPLY",
6047 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6050 $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;
6055 # check for krealloc arg reuse
6056 if ($^V && $^V ge 5.10.0 &&
6057 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
6058 WARN("KREALLOC_ARG_REUSE",
6059 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6062 # check for alloc argument mismatch
6063 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6064 WARN("ALLOC_ARRAY_ARGS",
6065 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6068 # check for multiple semicolons
6069 if ($line =~ /;\s*;\s*$/) {
6070 if (WARN("ONE_SEMICOLON",
6071 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6073 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6077 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6078 if ($realfile !~ m@^include/uapi/@ &&
6079 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6081 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6082 if (CHK("BIT_MACRO",
6083 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6085 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6089 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6090 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6092 if (WARN("PREFER_IS_ENABLED",
6093 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6095 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6099 # check for case / default statements not preceded by break/fallthrough/switch
6100 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
6102 my $has_statement = 0;
6104 my $prevline = $linenr;
6105 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
6107 my $rline = $rawlines[$prevline - 1];
6108 my $fline = $lines[$prevline - 1];
6109 last if ($fline =~ /^\@\@/);
6110 next if ($fline =~ /^\-/);
6111 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
6112 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
6113 next if ($fline =~ /^.[\s$;]*$/);
6116 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
6118 if (!$has_break && $has_statement) {
6119 WARN("MISSING_BREAK",
6120 "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
6124 # check for switch/default statements without a break;
6125 if ($^V && $^V ge 5.10.0 &&
6127 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6129 my $herectx = $here . "\n";
6130 my $cnt = statement_rawlines($stat);
6131 for (my $n = 0; $n < $cnt; $n++) {
6132 $herectx .= raw_line($linenr, $n) . "\n";
6134 WARN("DEFAULT_NO_BREAK",
6135 "switch default: should use break\n" . $herectx);
6138 # check for gcc specific __FUNCTION__
6139 if ($line =~ /\b__FUNCTION__\b/) {
6140 if (WARN("USE_FUNC",
6141 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
6143 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
6147 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
6148 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6150 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6153 # check for use of yield()
6154 if ($line =~ /\byield\s*\(\s*\)/) {
6156 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
6159 # check for comparisons against true and false
6160 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6168 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6170 my $type = lc($otype);
6171 if ($type =~ /^(?:true|false)$/) {
6172 if (("$test" eq "==" && "$type" eq "true") ||
6173 ("$test" eq "!=" && "$type" eq "false")) {
6177 CHK("BOOL_COMPARISON",
6178 "Using comparison to $otype is error prone\n" . $herecurr);
6180 ## maybe suggesting a correct construct would better
6181 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6186 # check for semaphores initialized locked
6187 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6188 WARN("CONSIDER_COMPLETION",
6189 "consider using a completion\n" . $herecurr);
6192 # recommend kstrto* over simple_strto* and strict_strto*
6193 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6194 WARN("CONSIDER_KSTRTO",
6195 "$1 is obsolete, use k$3 instead\n" . $herecurr);
6198 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
6199 if ($line =~ /^.\s*__initcall\s*\(/) {
6200 WARN("USE_DEVICE_INITCALL",
6201 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6204 # check for various structs that are normally const (ops, kgdb, device_tree)
6205 # and avoid what seem like struct definitions 'struct foo {'
6206 if ($line !~ /\bconst\b/ &&
6207 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
6208 WARN("CONST_STRUCT",
6209 "struct $1 should normally be const\n" . $herecurr);
6212 # use of NR_CPUS is usually wrong
6213 # ignore definitions of NR_CPUS and usage to define arrays as likely right
6214 if ($line =~ /\bNR_CPUS\b/ &&
6215 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6216 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6217 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6218 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6219 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6222 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6225 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6226 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6227 ERROR("DEFINE_ARCH_HAS",
6228 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6231 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
6232 if ($^V && $^V ge 5.10.0 &&
6233 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6234 WARN("LIKELY_MISUSE",
6235 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6238 # whine mightly about in_atomic
6239 if ($line =~ /\bin_atomic\s*\(/) {
6240 if ($realfile =~ m@^drivers/@) {
6242 "do not use in_atomic in drivers\n" . $herecurr);
6243 } elsif ($realfile !~ m@^kernel/@) {
6245 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6249 # whine about ACCESS_ONCE
6250 if ($^V && $^V ge 5.10.0 &&
6251 $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
6255 $par =~ s/^\(\s*(.*)\s*\)$/$1/;
6257 if (WARN("PREFER_WRITE_ONCE",
6258 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
6260 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
6263 if (WARN("PREFER_READ_ONCE",
6264 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
6266 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
6271 # check for mutex_trylock_recursive usage
6272 if ($line =~ /mutex_trylock_recursive/) {
6274 "recursive locking is bad, do not use this ever.\n" . $herecurr);
6277 # check for lockdep_set_novalidate_class
6278 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6279 $line =~ /__lockdep_no_validate__\s*\)/ ) {
6280 if ($realfile !~ m@^kernel/lockdep@ &&
6281 $realfile !~ m@^include/linux/lockdep@ &&
6282 $realfile !~ m@^drivers/base/core@) {
6284 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6288 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6289 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6290 WARN("EXPORTED_WORLD_WRITABLE",
6291 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6294 # Mode permission misuses where it seems decimal should be octal
6295 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6296 if ($^V && $^V ge 5.10.0 &&
6298 $line =~ /$mode_perms_search/) {
6299 foreach my $entry (@mode_permission_funcs) {
6300 my $func = $entry->[0];
6301 my $arg_pos = $entry->[1];
6303 my $lc = $stat =~ tr@\n@@;
6304 $lc = $lc + $linenr;
6305 my $stat_real = raw_line($linenr, 0);
6306 for (my $count = $linenr + 1; $count <= $lc; $count++) {
6307 $stat_real = $stat_real . "\n" . raw_line($count, 0);
6313 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6315 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6316 if ($stat =~ /$test/) {
6318 $val = $6 if ($skip_args ne "");
6319 if (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6320 ($val =~ /^$Octal$/ && length($val) ne 4)) {
6321 ERROR("NON_OCTAL_PERMISSIONS",
6322 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6324 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6325 ERROR("EXPORTED_WORLD_WRITABLE",
6326 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6332 # check for uses of S_<PERMS> that could be octal for readability
6333 if ($line =~ /\b$mode_perms_string_search\b/) {
6339 while ($line =~ /\b(($mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
6340 $curpos = pos($line);
6343 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
6345 $to |= $mode_permission_string_types{$match};
6346 $val .= '\s*\|\s*' if ($val ne "");
6350 $oval =~ s/^\s*\|\s*//;
6351 $oval =~ s/\s*\|\s*$//;
6352 my $octal = sprintf("%04o", $to);
6353 if (WARN("SYMBOLIC_PERMS",
6354 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6356 $fixed[$fixlinenr] =~ s/$val/$octal/;
6360 # validate content of MODULE_LICENSE against list from include/linux/module.h
6361 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6362 my $extracted_string = get_quoted_string($line, $rawline);
6363 my $valid_licenses = qr{
6366 GPL\ and\ additional\ rights|
6372 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6373 WARN("MODULE_LICENSE",
6374 "unknown module license " . $extracted_string . "\n" . $herecurr);
6379 # If we have no input at all, then there is nothing to report on
6380 # so just keep quiet.
6381 if ($#rawlines == -1) {
6385 # In mailback mode only produce a report in the negative, for
6386 # things that appear to be patches.
6387 if ($mailback && ($clean == 1 || !$is_patch)) {
6391 # This is not a patch, and we are are in 'no-patch' mode so
6393 if (!$chk_patch && !$is_patch) {
6397 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
6398 ERROR("NOT_UNIFIED_DIFF",
6399 "Does not appear to be a unified-diff format patch\n");
6401 if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6402 ERROR("MISSING_SIGN_OFF",
6403 "Missing Signed-off-by: line(s)\n");
6406 print report_dump();
6407 if ($summary && !($clean == 1 && $quiet == 1)) {
6408 print "$filename " if ($summary_file);
6409 print "total: $cnt_error errors, $cnt_warn warnings, " .
6410 (($check)? "$cnt_chk checks, " : "") .
6411 "$cnt_lines lines checked\n";
6415 # If there were any defects found and not already fixing them
6416 if (!$clean and !$fix) {
6419 NOTE: For some of the reported defects, checkpatch may be able to
6420 mechanically convert to the typical style using --fix or --fix-inplace.
6423 # If there were whitespace errors which cleanpatch can fix
6424 # then suggest that.
6425 if ($rpt_cleaners) {
6429 NOTE: Whitespace errors detected.
6430 You may wish to use scripts/cleanpatch or scripts/cleanfile
6435 if ($clean == 0 && $fix &&
6436 ("@rawlines" ne "@fixed" ||
6437 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6438 my $newfile = $filename;
6439 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6443 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6445 open($f, '>', $newfile)
6446 or die "$P: Can't open $newfile for write\n";
6447 foreach my $fixed_line (@fixed) {
6450 if ($linecount > 3) {
6451 $fixed_line =~ s/^\+//;
6452 print $f $fixed_line . "\n";
6455 print $f $fixed_line . "\n";
6463 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6465 Do _NOT_ trust the results written to this file.
6466 Do _NOT_ submit these changes without inspecting them for correctness.
6468 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6469 No warranties, expressed or implied...
6477 print "$vname has no obvious style problems and is ready for submission.\n";
6479 print "$vname has style problems, please review.\n";