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|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@])/gi) {
2719 my $typo_fix = $spelling_fix{lc($typo)};
2720 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2721 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2722 my $msg_type = \&WARN;
2723 $msg_type = \&CHK if ($file);
2724 if (&{$msg_type}("TYPO_SPELLING",
2725 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2727 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2732 # ignore non-hunk lines and lines being removed
2733 next if (!$hunk_line || $line =~ /^-/);
2735 #trailing whitespace
2736 if ($line =~ /^\+.*\015/) {
2737 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2738 if (ERROR("DOS_LINE_ENDINGS",
2739 "DOS line endings\n" . $herevet) &&
2741 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2743 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2744 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2745 if (ERROR("TRAILING_WHITESPACE",
2746 "trailing whitespace\n" . $herevet) &&
2748 $fixed[$fixlinenr] =~ s/\s+$//;
2754 # Check for FSF mailing addresses.
2755 if ($rawline =~ /\bwrite to the Free/i ||
2756 $rawline =~ /\b675\s+Mass\s+Ave/i ||
2757 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2758 $rawline =~ /\b51\s+Franklin\s+St/i) {
2759 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2760 my $msg_type = \&ERROR;
2761 $msg_type = \&CHK if ($file);
2762 &{$msg_type}("FSF_MAILING_ADDRESS",
2763 "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)
2766 # check for Kconfig help text having a real description
2767 # Only applies when adding the entry originally, after that we do not have
2768 # sufficient context to determine whether it is indeed long enough.
2769 if ($realfile =~ /Kconfig/ &&
2770 $line =~ /^\+\s*config\s+/) {
2773 my $ln = $linenr + 1;
2777 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2778 $f = $lines[$ln - 1];
2779 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2780 $is_end = $lines[$ln - 1] =~ /^\+/;
2782 next if ($f =~ /^-/);
2783 last if (!$file && $f =~ /^\@\@/);
2785 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2787 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2794 next if ($f =~ /^$/);
2795 if ($f =~ /^\s*config\s/) {
2801 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2802 WARN("CONFIG_DESCRIPTION",
2803 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2805 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2808 # check for MAINTAINERS entries that don't have the right form
2809 if ($realfile =~ /^MAINTAINERS$/ &&
2810 $rawline =~ /^\+[A-Z]:/ &&
2811 $rawline !~ /^\+[A-Z]:\t\S/) {
2812 if (WARN("MAINTAINERS_STYLE",
2813 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
2815 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
2819 # discourage the use of boolean for type definition attributes of Kconfig options
2820 if ($realfile =~ /Kconfig/ &&
2821 $line =~ /^\+\s*\bboolean\b/) {
2822 WARN("CONFIG_TYPE_BOOLEAN",
2823 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2826 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2827 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2830 'EXTRA_AFLAGS' => 'asflags-y',
2831 'EXTRA_CFLAGS' => 'ccflags-y',
2832 'EXTRA_CPPFLAGS' => 'cppflags-y',
2833 'EXTRA_LDFLAGS' => 'ldflags-y',
2836 WARN("DEPRECATED_VARIABLE",
2837 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2840 # check for DT compatible documentation
2841 if (defined $root &&
2842 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2843 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2845 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2847 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2848 my $vp_file = $dt_path . "vendor-prefixes.txt";
2850 foreach my $compat (@compats) {
2851 my $compat2 = $compat;
2852 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2853 my $compat3 = $compat;
2854 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2855 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2857 WARN("UNDOCUMENTED_DT_STRING",
2858 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2861 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2863 `grep -Eq "^$vendor\\b" $vp_file`;
2865 WARN("UNDOCUMENTED_DT_STRING",
2866 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2871 # check we are in a valid source file if not then ignore this hunk
2872 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
2874 # line length limit (with some exclusions)
2876 # There are a few types of lines that may extend beyond $max_line_length:
2877 # logging functions like pr_info that end in a string
2878 # lines with a single string
2879 # #defines that are a single string
2881 # There are 3 different line length message types:
2882 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2883 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2884 # LONG_LINE all other lines longer than $max_line_length
2886 # if LONG_LINE is ignored, the other 2 types are also ignored
2889 if ($line =~ /^\+/ && $length > $max_line_length) {
2890 my $msg_type = "LONG_LINE";
2892 # Check the allowed long line types first
2894 # logging functions that end in a string that starts
2895 # before $max_line_length
2896 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2897 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2900 # lines with only strings (w/ possible termination)
2901 # #defines with only strings
2902 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2903 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2906 # EFI_GUID is another special case
2907 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/) {
2910 # Otherwise set the alternate message types
2912 # a comment starts before $max_line_length
2913 } elsif ($line =~ /($;[\s$;]*)$/ &&
2914 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2915 $msg_type = "LONG_LINE_COMMENT"
2917 # a quoted string starts before $max_line_length
2918 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2919 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2920 $msg_type = "LONG_LINE_STRING"
2923 if ($msg_type ne "" &&
2924 (show_type("LONG_LINE") || show_type($msg_type))) {
2926 "line over $max_line_length characters\n" . $herecurr);
2930 # check for adding lines without a newline.
2931 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2932 WARN("MISSING_EOF_NEWLINE",
2933 "adding a line without newline at end of file\n" . $herecurr);
2936 # Blackfin: use hi/lo macros
2937 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2938 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2939 my $herevet = "$here\n" . cat_vet($line) . "\n";
2941 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2943 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2944 my $herevet = "$here\n" . cat_vet($line) . "\n";
2946 "use the HI() macro, not (... >> 16)\n" . $herevet);
2950 # check we are in a valid source file C or perl if not then ignore this hunk
2951 next if ($realfile !~ /\.(h|c|pl|dtsi|dts|sh)$/);
2953 # at the beginning of a line any tabs must come first and anything
2954 # more than 8 must use tabs.
2955 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2956 $rawline =~ /^\+\s* \s*/) {
2957 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2959 if (ERROR("CODE_INDENT",
2960 "code indent should use tabs where possible\n" . $herevet) &&
2962 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2966 # check for space before tabs.
2967 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2968 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2969 if (WARN("SPACE_BEFORE_TAB",
2970 "please, no space before tabs\n" . $herevet) &&
2972 while ($fixed[$fixlinenr] =~
2973 s/(^\+.*) {8,8}\t/$1\t\t/) {}
2974 while ($fixed[$fixlinenr] =~
2975 s/(^\+.*) +\t/$1\t/) {}
2979 # check for && or || at the start of a line
2980 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2981 CHK("LOGICAL_CONTINUATIONS",
2982 "Logical continuations should be on the previous line\n" . $hereprev);
2985 # check indentation starts on a tab stop
2986 if ($^V && $^V ge 5.10.0 &&
2987 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2988 my $indent = length($1);
2991 "Statements should start on a tabstop\n" . $herecurr) &&
2993 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2998 # check multi-line statement indentation matches previous line
2999 if ($^V && $^V ge 5.10.0 &&
3000 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3001 $prevline =~ /^\+(\t*)(.*)$/;
3005 my $pos = pos_last_openparen($rest);
3007 $line =~ /^(\+| )([ \t]*)/;
3010 my $goodtabindent = $oldindent .
3013 my $goodspaceindent = $oldindent . " " x $pos;
3015 if ($newindent ne $goodtabindent &&
3016 $newindent ne $goodspaceindent) {
3018 if (CHK("PARENTHESIS_ALIGNMENT",
3019 "Alignment should match open parenthesis\n" . $hereprev) &&
3020 $fix && $line =~ /^\+/) {
3021 $fixed[$fixlinenr] =~
3022 s/^\+[ \t]*/\+$goodtabindent/;
3028 # check for space after cast like "(int) foo" or "(struct foo) bar"
3029 # avoid checking a few false positives:
3030 # "sizeof(<type>)" or "__alignof__(<type>)"
3031 # function pointer declarations like "(*foo)(int) = bar;"
3032 # structure definitions like "(struct foo) { 0 };"
3033 # multiline macros that define functions
3034 # known attributes or the __attribute__ keyword
3035 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3036 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3038 "No space is necessary after a cast\n" . $herecurr) &&
3040 $fixed[$fixlinenr] =~
3041 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3045 # Block comment styles
3046 # Networking with an initial /*
3047 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3048 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3049 $rawline =~ /^\+[ \t]*\*/ &&
3051 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3052 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3055 # Block comments use * on subsequent lines
3056 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3057 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
3058 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3059 $rawline =~ /^\+/ && #line is new
3060 $rawline !~ /^\+[ \t]*\*/) { #no leading *
3061 WARN("BLOCK_COMMENT_STYLE",
3062 "Block comments use * on subsequent lines\n" . $hereprev);
3065 # Block comments use */ on trailing lines
3066 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
3067 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3068 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3069 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
3070 WARN("BLOCK_COMMENT_STYLE",
3071 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3074 # Block comment * alignment
3075 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3076 $line =~ /^\+[ \t]*$;/ && #leading comment
3077 $rawline =~ /^\+[ \t]*\*/ && #leading *
3078 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
3079 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3080 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3082 $prevrawline =~ m@^\+([ \t]*/?)\*@;
3084 $oldindent = expand_tabs($1);
3086 $prevrawline =~ m@^\+(.*/?)\*@;
3087 $oldindent = expand_tabs($1);
3089 $rawline =~ m@^\+([ \t]*)\*@;
3091 $newindent = expand_tabs($newindent);
3092 if (length($oldindent) ne length($newindent)) {
3093 WARN("BLOCK_COMMENT_STYLE",
3094 "Block comments should align the * on each line\n" . $hereprev);
3098 # check for missing blank lines after struct/union declarations
3099 # with exceptions for various attributes and macros
3100 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3102 !($line =~ /^\+\s*$/ ||
3103 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3104 $line =~ /^\+\s*MODULE_/i ||
3105 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3106 $line =~ /^\+[a-z_]*init/ ||
3107 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3108 $line =~ /^\+\s*DECLARE/ ||
3109 $line =~ /^\+\s*__setup/)) {
3110 if (CHK("LINE_SPACING",
3111 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3113 fix_insert_line($fixlinenr, "\+");
3117 # check for multiple consecutive blank lines
3118 if ($prevline =~ /^[\+ ]\s*$/ &&
3119 $line =~ /^\+\s*$/ &&
3120 $last_blank_line != ($linenr - 1)) {
3121 if (CHK("LINE_SPACING",
3122 "Please don't use multiple blank lines\n" . $hereprev) &&
3124 fix_delete_line($fixlinenr, $rawline);
3127 $last_blank_line = $linenr;
3130 # check for missing blank lines after declarations
3131 if ($sline =~ /^\+\s+\S/ && #Not at char 1
3132 # actual declarations
3133 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3134 # function pointer declarations
3135 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3136 # foo bar; where foo is some local typedef or #define
3137 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3138 # known declaration macros
3139 $prevline =~ /^\+\s+$declaration_macros/) &&
3140 # for "else if" which can look like "$Ident $Ident"
3141 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3142 # other possible extensions of declaration lines
3143 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3144 # not starting a section or a macro "\" extended line
3145 $prevline =~ /(?:\{\s*|\\)$/) &&
3146 # looks like a declaration
3147 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3148 # function pointer declarations
3149 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3150 # foo bar; where foo is some local typedef or #define
3151 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3152 # known declaration macros
3153 $sline =~ /^\+\s+$declaration_macros/ ||
3154 # start of struct or union or enum
3155 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3156 # start or end of block or continuation of declaration
3157 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3158 # bitfield continuation
3159 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3160 # other possible extensions of declaration lines
3161 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3162 # indentation of previous and current line are the same
3163 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3164 if (WARN("LINE_SPACING",
3165 "Missing a blank line after declarations\n" . $hereprev) &&
3167 fix_insert_line($fixlinenr, "\+");
3171 # check for spaces at the beginning of a line.
3173 # 1) within comments
3174 # 2) indented preprocessor commands
3176 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3177 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3178 if (WARN("LEADING_SPACE",
3179 "please, no spaces at the start of a line\n" . $herevet) &&
3181 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3185 # check we are in a valid C source file if not then ignore this hunk
3186 next if ($realfile !~ /\.(h|c)$/);
3188 # check if this appears to be the start function declaration, save the name
3189 if ($sline =~ /^\+\{\s*$/ &&
3190 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3191 $context_function = $1;
3194 # check if this appears to be the end of function declaration
3195 if ($sline =~ /^\+\}\s*$/) {
3196 undef $context_function;
3199 # check indentation of any line with a bare else
3200 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3201 # if the previous line is a break or return and is indented 1 tab more...
3202 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3203 my $tabs = length($1) + 1;
3204 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3205 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3206 defined $lines[$linenr] &&
3207 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3208 WARN("UNNECESSARY_ELSE",
3209 "else is not generally useful after a break or return\n" . $hereprev);
3213 # check indentation of a line with a break;
3214 # if the previous line is a goto or return and is indented the same # of tabs
3215 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3217 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3218 WARN("UNNECESSARY_BREAK",
3219 "break is not useful after a goto or return\n" . $hereprev);
3223 # check for RCS/CVS revision markers
3224 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3226 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3229 # Blackfin: don't use __builtin_bfin_[cs]sync
3230 if ($line =~ /__builtin_bfin_csync/) {
3231 my $herevet = "$here\n" . cat_vet($line) . "\n";
3233 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
3235 if ($line =~ /__builtin_bfin_ssync/) {
3236 my $herevet = "$here\n" . cat_vet($line) . "\n";
3238 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
3241 # check for old HOTPLUG __dev<foo> section markings
3242 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3243 WARN("HOTPLUG_SECTION",
3244 "Using $1 is unnecessary\n" . $herecurr);
3247 # Check for potential 'bare' types
3248 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3250 #print "LINE<$line>\n";
3251 if ($linenr > $suppress_statement &&
3252 $realcnt && $sline =~ /.\s*\S/) {
3253 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3254 ctx_statement_block($linenr, $realcnt, 0);
3255 $stat =~ s/\n./\n /g;
3256 $cond =~ s/\n./\n /g;
3258 #print "linenr<$linenr> <$stat>\n";
3259 # If this statement has no statement boundaries within
3260 # it there is no point in retrying a statement scan
3261 # until we hit end of it.
3262 my $frag = $stat; $frag =~ s/;+\s*$//;
3263 if ($frag !~ /(?:{|;)/) {
3264 #print "skip<$line_nr_next>\n";
3265 $suppress_statement = $line_nr_next;
3268 # Find the real next line.
3269 $realline_next = $line_nr_next;
3270 if (defined $realline_next &&
3271 (!defined $lines[$realline_next - 1] ||
3272 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3279 # Ignore goto labels.
3280 if ($s =~ /$Ident:\*$/s) {
3282 # Ignore functions being called
3283 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3285 } elsif ($s =~ /^.\s*else\b/s) {
3287 # declarations always start with types
3288 } 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) {
3291 possible($type, "A:" . $s);
3293 # definitions in global scope can only start with types
3294 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3295 possible($1, "B:" . $s);
3298 # any (foo ... *) is a pointer cast, and foo is a type
3299 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3300 possible($1, "C:" . $s);
3303 # Check for any sort of function declaration.
3304 # int foo(something bar, other baz);
3305 # void (*store_gdt)(x86_descr_ptr *);
3306 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3307 my ($name_len) = length($1);
3310 substr($ctx, 0, $name_len + 1, '');
3311 $ctx =~ s/\)[^\)]*$//;
3313 for my $arg (split(/\s*,\s*/, $ctx)) {
3314 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3316 possible($1, "D:" . $s);
3324 # Checks which may be anchored in the context.
3327 # Check for switch () and associated case and default
3328 # statements should be at the same indent.
3329 if ($line=~/\bswitch\s*\(.*\)/) {
3332 my @ctx = ctx_block_outer($linenr, $realcnt);
3334 for my $ctx (@ctx) {
3335 my ($clen, $cindent) = line_stats($ctx);
3336 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3337 $indent != $cindent) {
3338 $err .= "$sep$ctx\n";
3345 ERROR("SWITCH_CASE_INDENT_LEVEL",
3346 "switch and case should be at the same indent\n$hereline$err");
3350 # if/while/etc brace do not go on next line, unless defining a do while loop,
3351 # or if that brace on the next line is for something else
3352 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3353 my $pre_ctx = "$1$2";
3355 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3357 if ($line =~ /^\+\t{6,}/) {
3358 WARN("DEEP_INDENTATION",
3359 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3362 my $ctx_cnt = $realcnt - $#ctx - 1;
3363 my $ctx = join("\n", @ctx);
3365 my $ctx_ln = $linenr;
3366 my $ctx_skip = $realcnt;
3368 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3369 defined $lines[$ctx_ln - 1] &&
3370 $lines[$ctx_ln - 1] =~ /^-/)) {
3371 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3372 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3376 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3377 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3379 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3381 "that open brace { should be on the previous line\n" .
3382 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3384 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3385 $ctx =~ /\)\s*\;\s*$/ &&
3386 defined $lines[$ctx_ln - 1])
3388 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3389 if ($nindent > $indent) {
3390 WARN("TRAILING_SEMICOLON",
3391 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3392 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3397 # Check relative indent for conditionals and blocks.
3398 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3399 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3400 ctx_statement_block($linenr, $realcnt, 0)
3401 if (!defined $stat);
3402 my ($s, $c) = ($stat, $cond);
3404 substr($s, 0, length($c), '');
3406 # remove inline comments
3410 # Find out how long the conditional actually is.
3411 my @newlines = ($c =~ /\n/gs);
3412 my $cond_lines = 1 + $#newlines;
3414 # Make sure we remove the line prefixes as we have
3415 # none on the first line, and are going to readd them
3418 while ($s =~ /\n\s+\\\n/) {
3419 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3422 # We want to check the first line inside the block
3423 # starting at the end of the conditional, so remove:
3424 # 1) any blank line termination
3425 # 2) any opening brace { on end of the line
3427 my $continuation = 0;
3429 $s =~ s/^.*\bdo\b//;
3431 if ($s =~ s/^\s*\\//) {
3434 if ($s =~ s/^\s*?\n//) {
3439 # Also ignore a loop construct at the end of a
3440 # preprocessor statement.
3441 if (($prevline =~ /^.\s*#\s*define\s/ ||
3442 $prevline =~ /\\\s*$/) && $continuation == 0) {
3448 while ($cond_ptr != $cond_lines) {
3449 $cond_ptr = $cond_lines;
3451 # If we see an #else/#elif then the code
3453 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3458 # 1) blank lines, they should be at 0,
3459 # 2) preprocessor lines, and
3461 if ($continuation ||
3463 $s =~ /^\s*#\s*?/ ||
3464 $s =~ /^\s*$Ident\s*:/) {
3465 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3466 if ($s =~ s/^.*?\n//) {
3472 my (undef, $sindent) = line_stats("+" . $s);
3473 my $stat_real = raw_line($linenr, $cond_lines);
3475 # Check if either of these lines are modified, else
3476 # this is not this patch's fault.
3477 if (!defined($stat_real) ||
3478 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3481 if (defined($stat_real) && $cond_lines > 1) {
3482 $stat_real = "[...]\n$stat_real";
3485 #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";
3487 if ($check && $s ne '' &&
3488 (($sindent % 8) != 0 ||
3489 ($sindent < $indent) ||
3490 ($sindent == $indent &&
3491 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
3492 ($sindent > $indent + 8))) {
3493 WARN("SUSPECT_CODE_INDENT",
3494 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3498 # Track the 'values' across context and added lines.
3499 my $opline = $line; $opline =~ s/^./ /;
3500 my ($curr_values, $curr_vars) =
3501 annotate_values($opline . "\n", $prev_values);
3502 $curr_values = $prev_values . $curr_values;
3504 my $outline = $opline; $outline =~ s/\t/ /g;
3505 print "$linenr > .$outline\n";
3506 print "$linenr > $curr_values\n";
3507 print "$linenr > $curr_vars\n";
3509 $prev_values = substr($curr_values, -1);
3511 #ignore lines not being added
3512 next if ($line =~ /^[^\+]/);
3514 # check for dereferences that span multiple lines
3515 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3516 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3517 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3519 $line =~ /^.\s*($Lval)/;
3522 WARN("MULTILINE_DEREFERENCE",
3523 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3526 # check for declarations of signed or unsigned without int
3527 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3530 $var = "" if (!defined $var);
3531 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3535 $pointer = "" if (!defined $pointer);
3537 if (WARN("UNSPECIFIED_INT",
3538 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3540 my $decl = trim($sign) . " int ";
3541 my $comp_pointer = $pointer;
3542 $comp_pointer =~ s/\s//g;
3543 $decl .= $comp_pointer;
3544 $decl = rtrim($decl) if ($var eq "");
3545 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3550 # TEST: allow direct testing of the type matcher.
3552 if ($line =~ /^.\s*$Declare\s*$/) {
3554 "TEST: is type\n" . $herecurr);
3555 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3556 ERROR("TEST_NOT_TYPE",
3557 "TEST: is not type ($1 is)\n". $herecurr);
3561 # TEST: allow direct testing of the attribute matcher.
3563 if ($line =~ /^.\s*$Modifier\s*$/) {
3565 "TEST: is attr\n" . $herecurr);
3566 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3567 ERROR("TEST_NOT_ATTR",
3568 "TEST: is not attr ($1 is)\n". $herecurr);
3573 # check for initialisation to aggregates open brace on the next line
3574 if ($line =~ /^.\s*{/ &&
3575 $prevline =~ /(?:^|[^=])=\s*$/) {
3576 if (ERROR("OPEN_BRACE",
3577 "that open brace { should be on the previous line\n" . $hereprev) &&
3578 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3579 fix_delete_line($fixlinenr - 1, $prevrawline);
3580 fix_delete_line($fixlinenr, $rawline);
3581 my $fixedline = $prevrawline;
3582 $fixedline =~ s/\s*=\s*$/ = {/;
3583 fix_insert_line($fixlinenr, $fixedline);
3585 $fixedline =~ s/^(.\s*)\{\s*/$1/;
3586 fix_insert_line($fixlinenr, $fixedline);
3591 # Checks which are anchored on the added line.
3594 # check for malformed paths in #include statements (uses RAW line)
3595 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3597 if ($path =~ m{//}) {
3598 ERROR("MALFORMED_INCLUDE",
3599 "malformed #include filename\n" . $herecurr);
3601 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3602 ERROR("UAPI_INCLUDE",
3603 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3607 # no C99 // comments
3608 if ($line =~ m{//}) {
3609 if (ERROR("C99_COMMENTS",
3610 "do not use C99 // comments\n" . $herecurr) &&
3612 my $line = $fixed[$fixlinenr];
3613 if ($line =~ /\/\/(.*)$/) {
3614 my $comment = trim($1);
3615 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3619 # Remove C99 comments.
3621 $opline =~ s@//.*@@;
3623 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3624 # the whole statement.
3625 #print "APW <$lines[$realline_next - 1]>\n";
3626 if (defined $realline_next &&
3627 exists $lines[$realline_next - 1] &&
3628 !defined $suppress_export{$realline_next} &&
3629 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3630 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3631 # Handle definitions which produce identifiers with
3634 # EXPORT_SYMBOL(something_foo);
3636 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3637 $name =~ /^${Ident}_$2/) {
3638 #print "FOO C name<$name>\n";
3639 $suppress_export{$realline_next} = 1;
3641 } elsif ($stat !~ /(?:
3643 ^.DEFINE_$Ident\(\Q$name\E\)|
3644 ^.DECLARE_$Ident\(\Q$name\E\)|
3645 ^.LIST_HEAD\(\Q$name\E\)|
3646 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3647 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3649 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3650 $suppress_export{$realline_next} = 2;
3652 $suppress_export{$realline_next} = 1;
3655 if (!defined $suppress_export{$linenr} &&
3656 $prevline =~ /^.\s*$/ &&
3657 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3658 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3659 #print "FOO B <$lines[$linenr - 1]>\n";
3660 $suppress_export{$linenr} = 2;
3662 if (defined $suppress_export{$linenr} &&
3663 $suppress_export{$linenr} == 2) {
3664 WARN("EXPORT_SYMBOL",
3665 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3668 # check for global initialisers.
3669 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3670 if (ERROR("GLOBAL_INITIALISERS",
3671 "do not initialise globals to $1\n" . $herecurr) &&
3673 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3676 # check for static initialisers.
3677 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3678 if (ERROR("INITIALISED_STATIC",
3679 "do not initialise statics to $1\n" .
3682 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3686 # check for misordered declarations of char/short/int/long with signed/unsigned
3687 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3689 WARN("MISORDERED_TYPE",
3690 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3693 # check for static const char * arrays.
3694 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3695 WARN("STATIC_CONST_CHAR_ARRAY",
3696 "static const char * array should probably be static const char * const\n" .
3700 # check for static char foo[] = "bar" declarations.
3701 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3702 WARN("STATIC_CONST_CHAR_ARRAY",
3703 "static char array declaration should probably be static const char\n" .
3707 # check for const <foo> const where <foo> is not a pointer or array type
3708 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3710 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3712 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3713 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3715 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3719 # check for non-global char *foo[] = {"bar", ...} declarations.
3720 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3721 WARN("STATIC_CONST_CHAR_ARRAY",
3722 "char * array declaration might be better as static const\n" .
3726 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3727 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3729 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3731 if (WARN("ARRAY_SIZE",
3732 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3734 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3739 # check for function declarations without arguments like "int foo()"
3740 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3741 if (ERROR("FUNCTION_WITHOUT_ARGS",
3742 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3744 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3748 # check for new typedefs, only function parameters and sparse annotations
3750 if ($line =~ /\btypedef\s/ &&
3751 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3752 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3753 $line !~ /\b$typeTypedefs\b/ &&
3754 $line !~ /\b__bitwise\b/) {
3755 WARN("NEW_TYPEDEFS",
3756 "do not add new typedefs\n" . $herecurr);
3759 # * goes on variable not on type
3761 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3763 my ($ident, $from, $to) = ($1, $2, $2);
3765 # Should start with a space.
3766 $to =~ s/^(\S)/ $1/;
3767 # Should not end with a space.
3769 # '*'s should not have spaces between.
3770 while ($to =~ s/\*\s+\*/\*\*/) {
3773 ## print "1: from<$from> to<$to> ident<$ident>\n";
3775 if (ERROR("POINTER_LOCATION",
3776 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3778 my $sub_from = $ident;
3779 my $sub_to = $ident;
3780 $sub_to =~ s/\Q$from\E/$to/;
3781 $fixed[$fixlinenr] =~
3782 s@\Q$sub_from\E@$sub_to@;
3786 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3788 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3790 # Should start with a space.
3791 $to =~ s/^(\S)/ $1/;
3792 # Should not end with a space.
3794 # '*'s should not have spaces between.
3795 while ($to =~ s/\*\s+\*/\*\*/) {
3797 # Modifiers should have spaces.
3798 $to =~ s/(\b$Modifier$)/$1 /;
3800 ## print "2: from<$from> to<$to> ident<$ident>\n";
3801 if ($from ne $to && $ident !~ /^$Modifier$/) {
3802 if (ERROR("POINTER_LOCATION",
3803 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3806 my $sub_from = $match;
3807 my $sub_to = $match;
3808 $sub_to =~ s/\Q$from\E/$to/;
3809 $fixed[$fixlinenr] =~
3810 s@\Q$sub_from\E@$sub_to@;
3815 # avoid BUG() or BUG_ON()
3816 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3817 my $msg_type = \&WARN;
3818 $msg_type = \&CHK if ($file);
3819 &{$msg_type}("AVOID_BUG",
3820 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3823 # avoid LINUX_VERSION_CODE
3824 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3825 WARN("LINUX_VERSION_CODE",
3826 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3829 # check for uses of printk_ratelimit
3830 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3831 WARN("PRINTK_RATELIMITED",
3832 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3835 # printk should use KERN_* levels. Note that follow on printk's on the
3836 # same line do not need a level, so we use the current block context
3837 # to try and find and validate the current printk. In summary the current
3838 # printk includes all preceding printk's which have no newline on the end.
3839 # we assume the first bad printk is the one to report.
3840 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3842 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3843 #print "CHECK<$lines[$ln - 1]\n";
3844 # we have a preceding printk if it ends
3845 # with "\n" ignore it, else it is to blame
3846 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3847 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3854 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3855 "printk() should include KERN_ facility level\n" . $herecurr);
3859 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3861 my $level = lc($orig);
3862 $level = "warn" if ($level eq "warning");
3863 my $level2 = $level;
3864 $level2 = "dbg" if ($level eq "debug");
3865 WARN("PREFER_PR_LEVEL",
3866 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3869 if ($line =~ /\bpr_warning\s*\(/) {
3870 if (WARN("PREFER_PR_LEVEL",
3871 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3873 $fixed[$fixlinenr] =~
3874 s/\bpr_warning\b/pr_warn/;
3878 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3880 my $level = lc($orig);
3881 $level = "warn" if ($level eq "warning");
3882 $level = "dbg" if ($level eq "debug");
3883 WARN("PREFER_DEV_LEVEL",
3884 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3887 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
3888 # number of false positives, but assembly files are not checked, so at
3889 # least the arch entry code will not trigger this warning.
3890 if ($line =~ /\bENOSYS\b/) {
3892 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3895 # function brace can't be on same line, except for #defines of do while,
3896 # or if closed on same line
3897 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3898 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3899 if (ERROR("OPEN_BRACE",
3900 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3902 fix_delete_line($fixlinenr, $rawline);
3903 my $fixed_line = $rawline;
3904 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3907 fix_insert_line($fixlinenr, ltrim($line1));
3908 fix_insert_line($fixlinenr, "\+{");
3909 if ($line2 !~ /^\s*$/) {
3910 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3915 # open braces for enum, union and struct go on the same line.
3916 if ($line =~ /^.\s*{/ &&
3917 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3918 if (ERROR("OPEN_BRACE",
3919 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3920 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3921 fix_delete_line($fixlinenr - 1, $prevrawline);
3922 fix_delete_line($fixlinenr, $rawline);
3923 my $fixedline = rtrim($prevrawline) . " {";
3924 fix_insert_line($fixlinenr, $fixedline);
3925 $fixedline = $rawline;
3926 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
3927 if ($fixedline !~ /^\+\s*$/) {
3928 fix_insert_line($fixlinenr, $fixedline);
3933 # missing space after union, struct or enum definition
3934 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3936 "missing space after $1 definition\n" . $herecurr) &&
3938 $fixed[$fixlinenr] =~
3939 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3943 # Function pointer declarations
3944 # check spacing between type, funcptr, and args
3945 # canonical declaration is "type (*funcptr)(args...)"
3946 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3948 my $pre_pointer_space = $2;
3949 my $post_pointer_space = $3;
3951 my $post_funcname_space = $5;
3952 my $pre_args_space = $6;
3954 # the $Declare variable will capture all spaces after the type
3955 # so check it for a missing trailing missing space but pointer return types
3956 # don't need a space so don't warn for those.
3957 my $post_declare_space = "";
3958 if ($declare =~ /(\s+)$/) {
3959 $post_declare_space = $1;
3960 $declare = rtrim($declare);
3962 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3964 "missing space after return type\n" . $herecurr);
3965 $post_declare_space = " ";
3968 # unnecessary space "type (*funcptr)(args...)"
3969 # This test is not currently implemented because these declarations are
3971 # int foo(int bar, ...)
3972 # and this is form shouldn't/doesn't generate a checkpatch warning.
3974 # elsif ($declare =~ /\s{2,}$/) {
3976 # "Multiple spaces after return type\n" . $herecurr);
3979 # unnecessary space "type ( *funcptr)(args...)"
3980 if (defined $pre_pointer_space &&
3981 $pre_pointer_space =~ /^\s/) {
3983 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3986 # unnecessary space "type (* funcptr)(args...)"
3987 if (defined $post_pointer_space &&
3988 $post_pointer_space =~ /^\s/) {
3990 "Unnecessary space before function pointer name\n" . $herecurr);
3993 # unnecessary space "type (*funcptr )(args...)"
3994 if (defined $post_funcname_space &&
3995 $post_funcname_space =~ /^\s/) {
3997 "Unnecessary space after function pointer name\n" . $herecurr);
4000 # unnecessary space "type (*funcptr) (args...)"
4001 if (defined $pre_args_space &&
4002 $pre_args_space =~ /^\s/) {
4004 "Unnecessary space before function pointer arguments\n" . $herecurr);
4007 if (show_type("SPACING") && $fix) {
4008 $fixed[$fixlinenr] =~
4009 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4013 # check for spacing round square brackets; allowed:
4014 # 1. with a type on the left -- int [] a;
4015 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4016 # 3. inside a curly brace -- = { [0...10] = 5 }
4017 while ($line =~ /(.*?\s)\[/g) {
4018 my ($where, $prefix) = ($-[1], $1);
4019 if ($prefix !~ /$Type\s+$/ &&
4020 ($where != 0 || $prefix !~ /^.\s+$/) &&
4021 $prefix !~ /[{,]\s+$/) {
4022 if (ERROR("BRACKET_SPACE",
4023 "space prohibited before open square bracket '['\n" . $herecurr) &&
4025 $fixed[$fixlinenr] =~
4026 s/^(\+.*?)\s+\[/$1\[/;
4031 # check for spaces between functions and their parentheses.
4032 while ($line =~ /($Ident)\s+\(/g) {
4034 my $ctx_before = substr($line, 0, $-[1]);
4035 my $ctx = "$ctx_before$name";
4037 # Ignore those directives where spaces _are_ permitted.
4039 if|for|while|switch|return|case|
4040 volatile|__volatile__|
4041 __attribute__|format|__extension__|
4044 # cpp #define statements have non-optional spaces, ie
4045 # if there is a space between the name and the open
4046 # parenthesis it is simply not a parameter group.
4047 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4049 # cpp #elif statement condition may start with a (
4050 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4052 # If this whole things ends with a type its most
4053 # likely a typedef for a function.
4054 } elsif ($ctx =~ /$Type$/) {
4058 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4060 $fixed[$fixlinenr] =~
4061 s/\b$name\s+\(/$name\(/;
4066 # Check operator spacing.
4067 if (!($line=~/\#\s*include/)) {
4068 my $fixed_line = "";
4072 <<=|>>=|<=|>=|==|!=|
4073 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4074 =>|->|<<|>>|<|>|=|!|~|
4075 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4078 my @elements = split(/($ops|;)/, $opline);
4080 ## print("element count: <" . $#elements . ">\n");
4081 ## foreach my $el (@elements) {
4082 ## print("el: <$el>\n");
4085 my @fix_elements = ();
4088 foreach my $el (@elements) {
4089 push(@fix_elements, substr($rawline, $off, length($el)));
4090 $off += length($el);
4095 my $blank = copy_spacing($opline);
4096 my $last_after = -1;
4098 for (my $n = 0; $n < $#elements; $n += 2) {
4100 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4102 ## print("n: <$n> good: <$good>\n");
4104 $off += length($elements[$n]);
4106 # Pick up the preceding and succeeding characters.
4107 my $ca = substr($opline, 0, $off);
4109 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4110 $cc = substr($opline, $off + length($elements[$n + 1]));
4112 my $cb = "$ca$;$cc";
4115 $a = 'V' if ($elements[$n] ne '');
4116 $a = 'W' if ($elements[$n] =~ /\s$/);
4117 $a = 'C' if ($elements[$n] =~ /$;$/);
4118 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4119 $a = 'O' if ($elements[$n] eq '');
4120 $a = 'E' if ($ca =~ /^\s*$/);
4122 my $op = $elements[$n + 1];
4125 if (defined $elements[$n + 2]) {
4126 $c = 'V' if ($elements[$n + 2] ne '');
4127 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4128 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4129 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4130 $c = 'O' if ($elements[$n + 2] eq '');
4131 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4136 my $ctx = "${a}x${c}";
4138 my $at = "(ctx:$ctx)";
4140 my $ptr = substr($blank, 0, $off) . "^";
4141 my $hereptr = "$hereline$ptr\n";
4143 # Pull out the value of this operator.
4144 my $op_type = substr($curr_values, $off + 1, 1);
4146 # Get the full operator variant.
4147 my $opv = $op . substr($curr_vars, $off, 1);
4149 # Ignore operators passed as parameters.
4150 if ($op_type ne 'V' &&
4151 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4154 # } elsif ($op =~ /^$;+$/) {
4156 # ; should have either the end of line or a space or \ after it
4157 } elsif ($op eq ';') {
4158 if ($ctx !~ /.x[WEBC]/ &&
4159 $cc !~ /^\\/ && $cc !~ /^;/) {
4160 if (ERROR("SPACING",
4161 "space required after that '$op' $at\n" . $hereptr)) {
4162 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4168 } elsif ($op eq '//') {
4170 # : when part of a bitfield
4171 } elsif ($opv eq ':B') {
4172 # skip the bitfield test for now
4176 } elsif ($op eq '->') {
4177 if ($ctx =~ /Wx.|.xW/) {
4178 if (ERROR("SPACING",
4179 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4180 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4181 if (defined $fix_elements[$n + 2]) {
4182 $fix_elements[$n + 2] =~ s/^\s+//;
4188 # , must not have a space before and must have a space on the right.
4189 } elsif ($op eq ',') {
4190 my $rtrim_before = 0;
4191 my $space_after = 0;
4192 if ($ctx =~ /Wx./) {
4193 if (ERROR("SPACING",
4194 "space prohibited before that '$op' $at\n" . $hereptr)) {
4199 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4200 if (ERROR("SPACING",
4201 "space required after that '$op' $at\n" . $hereptr)) {
4207 if ($rtrim_before || $space_after) {
4208 if ($rtrim_before) {
4209 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4211 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4218 # '*' as part of a type definition -- reported already.
4219 } elsif ($opv eq '*_') {
4220 #warn "'*' is part of type\n";
4222 # unary operators should have a space before and
4223 # none after. May be left adjacent to another
4224 # unary operator, or a cast
4225 } elsif ($op eq '!' || $op eq '~' ||
4226 $opv eq '*U' || $opv eq '-U' ||
4227 $opv eq '&U' || $opv eq '&&U') {
4228 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4229 if (ERROR("SPACING",
4230 "space required before that '$op' $at\n" . $hereptr)) {
4231 if ($n != $last_after + 2) {
4232 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4237 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4238 # A unary '*' may be const
4240 } elsif ($ctx =~ /.xW/) {
4241 if (ERROR("SPACING",
4242 "space prohibited after that '$op' $at\n" . $hereptr)) {
4243 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4244 if (defined $fix_elements[$n + 2]) {
4245 $fix_elements[$n + 2] =~ s/^\s+//;
4251 # unary ++ and unary -- are allowed no space on one side.
4252 } elsif ($op eq '++' or $op eq '--') {
4253 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4254 if (ERROR("SPACING",
4255 "space required one side of that '$op' $at\n" . $hereptr)) {
4256 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4260 if ($ctx =~ /Wx[BE]/ ||
4261 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4262 if (ERROR("SPACING",
4263 "space prohibited before that '$op' $at\n" . $hereptr)) {
4264 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4268 if ($ctx =~ /ExW/) {
4269 if (ERROR("SPACING",
4270 "space prohibited after that '$op' $at\n" . $hereptr)) {
4271 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4272 if (defined $fix_elements[$n + 2]) {
4273 $fix_elements[$n + 2] =~ s/^\s+//;
4279 # << and >> may either have or not have spaces both sides
4280 } elsif ($op eq '<<' or $op eq '>>' or
4281 $op eq '&' or $op eq '^' or $op eq '|' or
4282 $op eq '+' or $op eq '-' or
4283 $op eq '*' or $op eq '/' or
4287 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4289 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4290 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4291 $fix_elements[$n + 2] =~ s/^\s+//;
4294 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4296 "space preferred before that '$op' $at\n" . $hereptr)) {
4297 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4301 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4302 if (ERROR("SPACING",
4303 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4304 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4305 if (defined $fix_elements[$n + 2]) {
4306 $fix_elements[$n + 2] =~ s/^\s+//;
4312 # A colon needs no spaces before when it is
4313 # terminating a case value or a label.
4314 } elsif ($opv eq ':C' || $opv eq ':L') {
4315 if ($ctx =~ /Wx./) {
4316 if (ERROR("SPACING",
4317 "space prohibited before that '$op' $at\n" . $hereptr)) {
4318 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4323 # All the others need spaces both sides.
4324 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4327 # Ignore email addresses <foo@bar>
4329 $cc =~ /^\S+\@\S+>/) ||
4331 $ca =~ /<\S+\@\S+$/))
4336 # for asm volatile statements
4337 # ignore a colon with another
4338 # colon immediately before or after
4340 ($ca =~ /:$/ || $cc =~ /^:/)) {
4344 # messages are ERROR, but ?: are CHK
4346 my $msg_type = \&ERROR;
4347 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4349 if (&{$msg_type}("SPACING",
4350 "spaces required around that '$op' $at\n" . $hereptr)) {
4351 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4352 if (defined $fix_elements[$n + 2]) {
4353 $fix_elements[$n + 2] =~ s/^\s+//;
4359 $off += length($elements[$n + 1]);
4361 ## print("n: <$n> GOOD: <$good>\n");
4363 $fixed_line = $fixed_line . $good;
4366 if (($#elements % 2) == 0) {
4367 $fixed_line = $fixed_line . $fix_elements[$#elements];
4370 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4371 $fixed[$fixlinenr] = $fixed_line;
4377 # check for whitespace before a non-naked semicolon
4378 if ($line =~ /^\+.*\S\s+;\s*$/) {
4380 "space prohibited before semicolon\n" . $herecurr) &&
4382 1 while $fixed[$fixlinenr] =~
4383 s/^(\+.*\S)\s+;/$1;/;
4387 # check for multiple assignments
4388 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4389 CHK("MULTIPLE_ASSIGNMENTS",
4390 "multiple assignments should be avoided\n" . $herecurr);
4393 ## # check for multiple declarations, allowing for a function declaration
4395 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4396 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4398 ## # Remove any bracketed sections to ensure we do not
4399 ## # falsly report the parameters of functions.
4401 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4403 ## if ($ln =~ /,/) {
4404 ## WARN("MULTIPLE_DECLARATION",
4405 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4409 #need space before brace following if, while, etc
4410 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4412 if (ERROR("SPACING",
4413 "space required before the open brace '{'\n" . $herecurr) &&
4415 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
4419 ## # check for blank lines before declarations
4420 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4421 ## $prevrawline =~ /^.\s*$/) {
4423 ## "No blank lines before declarations\n" . $hereprev);
4427 # closing brace should have a space following it when it has anything
4429 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4430 if (ERROR("SPACING",
4431 "space required after that close brace '}'\n" . $herecurr) &&
4433 $fixed[$fixlinenr] =~
4434 s/}((?!(?:,|;|\)))\S)/} $1/;
4438 # check spacing on square brackets
4439 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4440 if (ERROR("SPACING",
4441 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4443 $fixed[$fixlinenr] =~
4447 if ($line =~ /\s\]/) {
4448 if (ERROR("SPACING",
4449 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4451 $fixed[$fixlinenr] =~
4456 # check spacing on parentheses
4457 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4458 $line !~ /for\s*\(\s+;/) {
4459 if (ERROR("SPACING",
4460 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4462 $fixed[$fixlinenr] =~
4466 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4467 $line !~ /for\s*\(.*;\s+\)/ &&
4468 $line !~ /:\s+\)/) {
4469 if (ERROR("SPACING",
4470 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4472 $fixed[$fixlinenr] =~
4477 # check unnecessary parentheses around addressof/dereference single $Lvals
4478 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4480 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4482 if (CHK("UNNECESSARY_PARENTHESES",
4483 "Unnecessary parentheses around $var\n" . $herecurr) &&
4485 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4489 # check for unnecessary parentheses around function pointer uses
4490 # ie: (foo->bar)(); should be foo->bar();
4491 # but not "if (foo->bar) (" to avoid some false positives
4492 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4494 if (CHK("UNNECESSARY_PARENTHESES",
4495 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4497 my $var2 = deparenthesize($var);
4499 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4503 #goto labels aren't indented, allow a single space however
4504 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4505 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4506 if (WARN("INDENTED_LABEL",
4507 "labels should not be indented\n" . $herecurr) &&
4509 $fixed[$fixlinenr] =~
4514 # return is not a function
4515 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4517 if ($^V && $^V ge 5.10.0 &&
4518 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4520 $value = deparenthesize($value);
4521 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4522 ERROR("RETURN_PARENTHESES",
4523 "return is not a function, parentheses are not required\n" . $herecurr);
4525 } elsif ($spacing !~ /\s+/) {
4527 "space required before the open parenthesis '('\n" . $herecurr);
4531 # unnecessary return in a void function
4532 # at end-of-function, with the previous line a single leading tab, then return;
4533 # and the line before that not a goto label target like "out:"
4534 if ($sline =~ /^[ \+]}\s*$/ &&
4535 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4537 $lines[$linenr - 3] =~ /^[ +]/ &&
4538 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4540 "void function return statements are not generally useful\n" . $hereprev);
4543 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4544 if ($^V && $^V ge 5.10.0 &&
4545 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4546 my $openparens = $1;
4547 my $count = $openparens =~ tr@\(@\(@;
4549 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4550 my $comp = $4; #Not $1 because of $LvalOrFunc
4551 $msg = " - maybe == should be = ?" if ($comp eq "==");
4552 WARN("UNNECESSARY_PARENTHESES",
4553 "Unnecessary parentheses$msg\n" . $herecurr);
4557 # comparisons with a constant or upper case identifier on the left
4558 # avoid cases like "foo + BAR < baz"
4559 # only fix matches surrounded by parentheses to avoid incorrect
4560 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4561 if ($^V && $^V ge 5.10.0 &&
4562 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4567 my $newcomp = $comp;
4568 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4569 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4570 WARN("CONSTANT_COMPARISON",
4571 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4575 } elsif ($comp eq "<=") {
4577 } elsif ($comp eq ">") {
4579 } elsif ($comp eq ">=") {
4582 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4586 # Return of what appears to be an errno should normally be negative
4587 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4589 if ($name ne 'EOF' && $name ne 'ERROR') {
4590 WARN("USE_NEGATIVE_ERRNO",
4591 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4595 # Need a space before open parenthesis after if, while etc
4596 if ($line =~ /\b(if|while|for|switch)\(/) {
4597 if (ERROR("SPACING",
4598 "space required before the open parenthesis '('\n" . $herecurr) &&
4600 $fixed[$fixlinenr] =~
4601 s/\b(if|while|for|switch)\(/$1 \(/;
4605 # Check for illegal assignment in if conditional -- and check for trailing
4606 # statements after the conditional.
4607 if ($line =~ /do\s*(?!{)/) {
4608 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4609 ctx_statement_block($linenr, $realcnt, 0)
4610 if (!defined $stat);
4611 my ($stat_next) = ctx_statement_block($line_nr_next,
4612 $remain_next, $off_next);
4613 $stat_next =~ s/\n./\n /g;
4614 ##print "stat<$stat> stat_next<$stat_next>\n";
4616 if ($stat_next =~ /^\s*while\b/) {
4617 # If the statement carries leading newlines,
4618 # then count those as offsets.
4620 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4622 statement_rawlines($whitespace) - 1;
4624 $suppress_whiletrailers{$line_nr_next +
4628 if (!defined $suppress_whiletrailers{$linenr} &&
4629 defined($stat) && defined($cond) &&
4630 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4631 my ($s, $c) = ($stat, $cond);
4633 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4634 ERROR("ASSIGN_IN_IF",
4635 "do not use assignment in if condition\n" . $herecurr);
4638 # Find out what is on the end of the line after the
4640 substr($s, 0, length($c), '');
4642 $s =~ s/$;//g; # Remove any comments
4643 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4644 $c !~ /}\s*while\s*/)
4646 # Find out how long the conditional actually is.
4647 my @newlines = ($c =~ /\n/gs);
4648 my $cond_lines = 1 + $#newlines;
4651 $stat_real = raw_line($linenr, $cond_lines)
4652 . "\n" if ($cond_lines);
4653 if (defined($stat_real) && $cond_lines > 1) {
4654 $stat_real = "[...]\n$stat_real";
4657 ERROR("TRAILING_STATEMENTS",
4658 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4662 # Check for bitwise tests written as boolean
4674 WARN("HEXADECIMAL_BOOLEAN_TEST",
4675 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4678 # if and else should not have general statements after it
4679 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4681 $s =~ s/$;//g; # Remove any comments
4682 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4683 ERROR("TRAILING_STATEMENTS",
4684 "trailing statements should be on next line\n" . $herecurr);
4687 # if should not continue a brace
4688 if ($line =~ /}\s*if\b/) {
4689 ERROR("TRAILING_STATEMENTS",
4690 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4693 # case and default should not have general statements after them
4694 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4696 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4700 ERROR("TRAILING_STATEMENTS",
4701 "trailing statements should be on next line\n" . $herecurr);
4704 # Check for }<nl>else {, these must be at the same
4705 # indent level to be relevant to each other.
4706 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4707 $previndent == $indent) {
4708 if (ERROR("ELSE_AFTER_BRACE",
4709 "else should follow close brace '}'\n" . $hereprev) &&
4710 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4711 fix_delete_line($fixlinenr - 1, $prevrawline);
4712 fix_delete_line($fixlinenr, $rawline);
4713 my $fixedline = $prevrawline;
4714 $fixedline =~ s/}\s*$//;
4715 if ($fixedline !~ /^\+\s*$/) {
4716 fix_insert_line($fixlinenr, $fixedline);
4718 $fixedline = $rawline;
4719 $fixedline =~ s/^(.\s*)else/$1} else/;
4720 fix_insert_line($fixlinenr, $fixedline);
4724 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4725 $previndent == $indent) {
4726 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4728 # Find out what is on the end of the line after the
4730 substr($s, 0, length($c), '');
4733 if ($s =~ /^\s*;/) {
4734 if (ERROR("WHILE_AFTER_BRACE",
4735 "while should follow close brace '}'\n" . $hereprev) &&
4736 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4737 fix_delete_line($fixlinenr - 1, $prevrawline);
4738 fix_delete_line($fixlinenr, $rawline);
4739 my $fixedline = $prevrawline;
4740 my $trailing = $rawline;
4741 $trailing =~ s/^\+//;
4742 $trailing = trim($trailing);
4743 $fixedline =~ s/}\s*$/} $trailing/;
4744 fix_insert_line($fixlinenr, $fixedline);
4749 #Specific variable tests
4750 while ($line =~ m{($Constant|$Lval)}g) {
4753 #gcc binary extension
4754 if ($var =~ /^$Binary$/) {
4755 if (WARN("GCC_BINARY_CONSTANT",
4756 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4758 my $hexval = sprintf("0x%x", oct($var));
4759 $fixed[$fixlinenr] =~
4760 s/\b$var\b/$hexval/;
4765 if ($var !~ /^$Constant$/ &&
4766 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4767 #Ignore Page<foo> variants
4768 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4769 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4770 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4771 #Ignore some three character SI units explicitly, like MiB and KHz
4772 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4773 while ($var =~ m{($Ident)}g) {
4775 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4777 seed_camelcase_includes();
4778 if (!$file && !$camelcase_file_seeded) {
4779 seed_camelcase_file($realfile);
4780 $camelcase_file_seeded = 1;
4783 if (!defined $camelcase{$word}) {
4784 $camelcase{$word} = 1;
4786 "Avoid CamelCase: <$word>\n" . $herecurr);
4792 #no spaces allowed after \ in define
4793 if ($line =~ /\#\s*define.*\\\s+$/) {
4794 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4795 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4797 $fixed[$fixlinenr] =~ s/\s+$//;
4801 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4802 # itself <asm/foo.h> (uses RAW line)
4803 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4805 my $checkfile = "include/linux/$file";
4806 if (-f "$root/$checkfile" &&
4807 $realfile ne $checkfile &&
4808 $1 !~ /$allowed_asm_includes/)
4810 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4811 if ($asminclude > 0) {
4812 if ($realfile =~ m{^arch/}) {
4813 CHK("ARCH_INCLUDE_LINUX",
4814 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4816 WARN("INCLUDE_LINUX",
4817 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4823 # multi-statement macros should be enclosed in a do while loop, grab the
4824 # first statement and ensure its the whole macro if its not enclosed
4825 # in a known good container
4826 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4827 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4830 my ($off, $dstat, $dcond, $rest);
4832 my $has_flow_statement = 0;
4833 my $has_arg_concat = 0;
4834 ($dstat, $dcond, $ln, $cnt, $off) =
4835 ctx_statement_block($linenr, $realcnt, 0);
4837 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4838 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4840 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4841 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4843 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4844 my $define_args = $1;
4845 my $define_stmt = $dstat;
4848 if (defined $define_args && $define_args ne "") {
4849 $define_args = substr($define_args, 1, length($define_args) - 2);
4850 $define_args =~ s/\s*//g;
4851 @def_args = split(",", $define_args);
4855 $dstat =~ s/\\\n.//g;
4856 $dstat =~ s/^\s*//s;
4857 $dstat =~ s/\s*$//s;
4859 # Flatten any parentheses and braces
4860 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4861 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4862 $dstat =~ s/.\[[^\[\]]*\]/1/)
4866 # Flatten any obvious string concatentation.
4867 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4868 $dstat =~ s/$Ident\s*($String)/$1/)
4872 # Make asm volatile uses seem like a generic function
4873 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4875 my $exceptions = qr{
4888 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4891 my $herectx = $here . "\n";
4892 my $stmt_cnt = statement_rawlines($ctx);
4894 for (my $n = 0; $n < $stmt_cnt; $n++) {
4895 $herectx .= raw_line($linenr, $n) . "\n";
4899 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4900 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4901 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4902 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4903 $dstat !~ /$exceptions/ &&
4904 $dstat !~ /^\.$Ident\s*=/ && # .foo =
4905 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4906 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4907 $dstat !~ /^for\s*$Constant$/ && # for (...)
4908 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4909 $dstat !~ /^do\s*{/ && # do {...
4910 $dstat !~ /^\(\{/ && # ({...
4911 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4913 if ($dstat =~ /^\s*if\b/) {
4914 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4915 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
4916 } elsif ($dstat =~ /;/) {
4917 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4918 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4920 ERROR("COMPLEX_MACRO",
4921 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4926 # Make $define_stmt single line, comment-free, etc
4927 my @stmt_array = split('\n', $define_stmt);
4930 foreach my $l (@stmt_array) {
4935 } elsif ($l =~ /^[\+ ]/) {
4936 $define_stmt .= substr($l, 1);
4939 $define_stmt =~ s/$;//g;
4940 $define_stmt =~ s/\s+/ /g;
4941 $define_stmt = trim($define_stmt);
4943 # check if any macro arguments are reused (ignore '...' and 'type')
4944 foreach my $arg (@def_args) {
4945 next if ($arg =~ /\.\.\./);
4946 next if ($arg =~ /^type$/i);
4947 my $tmp_stmt = $define_stmt;
4948 $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
4949 $tmp_stmt =~ s/\#+\s*$arg\b//g;
4950 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
4951 my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
4953 CHK("MACRO_ARG_REUSE",
4954 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
4956 # check if any macro arguments may have other precedence issues
4957 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
4958 ((defined($1) && $1 ne ',') ||
4959 (defined($2) && $2 ne ','))) {
4960 CHK("MACRO_ARG_PRECEDENCE",
4961 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
4965 # check for macros with flow control, but without ## concatenation
4966 # ## concatenation is commonly a macro that defines a function so ignore those
4967 if ($has_flow_statement && !$has_arg_concat) {
4968 my $herectx = $here . "\n";
4969 my $cnt = statement_rawlines($ctx);
4971 for (my $n = 0; $n < $cnt; $n++) {
4972 $herectx .= raw_line($linenr, $n) . "\n";
4974 WARN("MACRO_WITH_FLOW_CONTROL",
4975 "Macros with flow control statements should be avoided\n" . "$herectx");
4978 # check for line continuations outside of #defines, preprocessor #, and asm
4981 if ($prevline !~ /^..*\\$/ &&
4982 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4983 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
4984 $line =~ /^\+.*\\$/) {
4985 WARN("LINE_CONTINUATIONS",
4986 "Avoid unnecessary line continuations\n" . $herecurr);
4990 # do {} while (0) macro tests:
4991 # single-statement macros do not need to be enclosed in do while (0) loop,
4992 # macro should not end with a semicolon
4993 if ($^V && $^V ge 5.10.0 &&
4994 $realfile !~ m@/vmlinux.lds.h$@ &&
4995 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4998 my ($off, $dstat, $dcond, $rest);
5000 ($dstat, $dcond, $ln, $cnt, $off) =
5001 ctx_statement_block($linenr, $realcnt, 0);
5004 $dstat =~ s/\\\n.//g;
5007 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5012 my $cnt = statement_rawlines($ctx);
5013 my $herectx = $here . "\n";
5015 for (my $n = 0; $n < $cnt; $n++) {
5016 $herectx .= raw_line($linenr, $n) . "\n";
5019 if (($stmts =~ tr/;/;/) == 1 &&
5020 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5021 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5022 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5024 if (defined $semis && $semis ne "") {
5025 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5026 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5028 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5030 my $cnt = statement_rawlines($ctx);
5031 my $herectx = $here . "\n";
5033 for (my $n = 0; $n < $cnt; $n++) {
5034 $herectx .= raw_line($linenr, $n) . "\n";
5037 WARN("TRAILING_SEMICOLON",
5038 "macros should not use a trailing semicolon\n" . "$herectx");
5042 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
5043 # all assignments may have only one of the following with an assignment:
5046 # VMLINUX_SYMBOL(...)
5047 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
5048 WARN("MISSING_VMLINUX_SYMBOL",
5049 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
5052 # check for redundant bracing round if etc
5053 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5054 my ($level, $endln, @chunks) =
5055 ctx_statement_full($linenr, $realcnt, 1);
5056 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5057 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5058 if ($#chunks > 0 && $level == 0) {
5062 my $herectx = $here . "\n";
5063 my $ln = $linenr - 1;
5064 for my $chunk (@chunks) {
5065 my ($cond, $block) = @{$chunk};
5067 # If the condition carries leading newlines, then count those as offsets.
5068 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5069 my $offset = statement_rawlines($whitespace) - 1;
5071 $allowed[$allow] = 0;
5072 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5074 # We have looked at and allowed this specific line.
5075 $suppress_ifbraces{$ln + $offset} = 1;
5077 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5078 $ln += statement_rawlines($block) - 1;
5080 substr($block, 0, length($cond), '');
5082 $seen++ if ($block =~ /^\s*{/);
5084 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5085 if (statement_lines($cond) > 1) {
5086 #print "APW: ALLOWED: cond<$cond>\n";
5087 $allowed[$allow] = 1;
5089 if ($block =~/\b(?:if|for|while)\b/) {
5090 #print "APW: ALLOWED: block<$block>\n";
5091 $allowed[$allow] = 1;
5093 if (statement_block_size($block) > 1) {
5094 #print "APW: ALLOWED: lines block<$block>\n";
5095 $allowed[$allow] = 1;
5100 my $sum_allowed = 0;
5101 foreach (@allowed) {
5104 if ($sum_allowed == 0) {
5106 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5107 } elsif ($sum_allowed != $allow &&
5110 "braces {} should be used on all arms of this statement\n" . $herectx);
5115 if (!defined $suppress_ifbraces{$linenr - 1} &&
5116 $line =~ /\b(if|while|for|else)\b/) {
5119 # Check the pre-context.
5120 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5121 #print "APW: ALLOWED: pre<$1>\n";
5125 my ($level, $endln, @chunks) =
5126 ctx_statement_full($linenr, $realcnt, $-[0]);
5128 # Check the condition.
5129 my ($cond, $block) = @{$chunks[0]};
5130 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5131 if (defined $cond) {
5132 substr($block, 0, length($cond), '');
5134 if (statement_lines($cond) > 1) {
5135 #print "APW: ALLOWED: cond<$cond>\n";
5138 if ($block =~/\b(?:if|for|while)\b/) {
5139 #print "APW: ALLOWED: block<$block>\n";
5142 if (statement_block_size($block) > 1) {
5143 #print "APW: ALLOWED: lines block<$block>\n";
5146 # Check the post-context.
5147 if (defined $chunks[1]) {
5148 my ($cond, $block) = @{$chunks[1]};
5149 if (defined $cond) {
5150 substr($block, 0, length($cond), '');
5152 if ($block =~ /^\s*\{/) {
5153 #print "APW: ALLOWED: chunk-1 block<$block>\n";
5157 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5158 my $herectx = $here . "\n";
5159 my $cnt = statement_rawlines($block);
5161 for (my $n = 0; $n < $cnt; $n++) {
5162 $herectx .= raw_line($linenr, $n) . "\n";
5166 "braces {} are not necessary for single statement blocks\n" . $herectx);
5170 # try to replace assertions with error handling
5171 if ($line =~ /\bLASSERTF?\s*\(/) {
5173 "try to replace assertions with error handling\n" .
5177 # avoid new console messages
5178 if ($line =~ /\bLCONSOLE[A-Z_]*\s*\(/) {
5180 "avoid adding new console messages\n" .
5184 # minimize new CERROR messages
5185 if ($line =~ /\bC(EMERG|ERROR|NETERR|WARN)\s*\(/) {
5187 "think hard when adding new CERROR messages\n" .
5191 # don't allow GPLv3 license files
5192 if ($rawline =~ /version 3/) {
5194 "using GPLv3 is usually wrong\n" . $herecurr);
5197 # check for single line unbalanced braces
5198 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5199 $sline =~ /^.\s*else\s*\{\s*$/) {
5200 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5203 # check for unnecessary blank lines around braces
5204 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5206 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5207 $fix && $prevrawline =~ /^\+/) {
5208 fix_delete_line($fixlinenr - 1, $prevrawline);
5211 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5213 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5215 fix_delete_line($fixlinenr, $rawline);
5219 # no volatiles please
5220 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5221 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5223 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5226 # Check for user-visible strings broken across lines, which breaks the ability
5227 # to grep for the string. Make exceptions when the previous string ends in a
5228 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5229 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5230 if ($line =~ /^\+\s*$String/ &&
5231 $prevline =~ /"\s*$/ &&
5232 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5233 if (WARN("SPLIT_STRING",
5234 "quoted string split across lines\n" . $hereprev) &&
5236 $prevrawline =~ /^\+.*"\s*$/ &&
5237 $last_coalesced_string_linenr != $linenr - 1) {
5238 my $extracted_string = get_quoted_string($line, $rawline);
5239 my $comma_close = "";
5240 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5244 fix_delete_line($fixlinenr - 1, $prevrawline);
5245 fix_delete_line($fixlinenr, $rawline);
5246 my $fixedline = $prevrawline;
5247 $fixedline =~ s/"\s*$//;
5248 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5249 fix_insert_line($fixlinenr - 1, $fixedline);
5250 $fixedline = $rawline;
5251 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5252 if ($fixedline !~ /\+\s*$/) {
5253 fix_insert_line($fixlinenr, $fixedline);
5255 $last_coalesced_string_linenr = $linenr;
5259 # check for missing a space in a string concatenation
5260 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5261 WARN('MISSING_SPACE',
5262 "break quoted strings at a space character\n" . $hereprev);
5265 # check for an embedded function name in a string when the function is known
5266 # This does not work very well for -f --file checking as it depends on patch
5267 # context providing the function name or a single line form for in-file
5268 # function declarations
5269 if ($line =~ /^\+.*$String/ &&
5270 defined($context_function) &&
5271 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
5272 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
5273 WARN("EMBEDDED_FUNCTION_NAME",
5274 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
5277 # check for spaces before a quoted newline
5278 if ($rawline =~ /^.*\".*\s\\n/) {
5279 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5280 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5282 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5287 # concatenated string without spaces between elements
5288 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5289 CHK("CONCATENATED_STRING",
5290 "Concatenated strings should use spaces between elements\n" . $herecurr);
5293 # uncoalesced string fragments
5294 if ($line =~ /$String\s*"/) {
5295 WARN("STRING_FRAGMENTS",
5296 "Consecutive strings are generally better as a single string\n" . $herecurr);
5299 # check for non-standard and hex prefixed decimal printf formats
5300 my $show_L = 1; #don't show the same defect twice
5302 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5303 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
5304 $string =~ s/%%/__/g;
5306 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
5308 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
5312 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
5314 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
5317 # check for 0x<decimal>
5318 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
5319 ERROR("PRINTF_0XDECIMAL",
5320 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5324 # check for line continuations in quoted strings with odd counts of "
5325 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
5326 WARN("LINE_CONTINUATIONS",
5327 "Avoid line continuations in quoted strings\n" . $herecurr);
5331 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5332 CHK("REDUNDANT_CODE",
5333 "if this code is redundant consider removing it\n" .
5337 # check for needless "if (<foo>) fn(<foo>)" uses
5338 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5339 my $tested = quotemeta($1);
5340 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5341 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5343 if (WARN('NEEDLESS_IF',
5344 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5347 my $leading_tabs = "";
5348 my $new_leading_tabs = "";
5349 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5354 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5355 $new_leading_tabs = $1;
5356 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5363 fix_delete_line($fixlinenr - 1, $prevrawline);
5364 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5370 # check for unnecessary "Out of Memory" messages
5371 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5372 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5373 (defined $1 || defined $3) &&
5376 my $testline = $lines[$linenr - 3];
5378 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5379 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5381 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)/) {
5383 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5387 # check for logging functions with KERN_<LEVEL>
5388 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5389 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5391 if (WARN("UNNECESSARY_KERN_LEVEL",
5392 "Possible unnecessary $level\n" . $herecurr) &&
5394 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5398 # check for logging continuations
5399 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
5400 WARN("LOGGING_CONTINUATION",
5401 "Avoid logging continuation uses where feasible\n" . $herecurr);
5404 # check for mask then right shift without a parentheses
5405 if ($^V && $^V ge 5.10.0 &&
5406 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5407 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5408 WARN("MASK_THEN_SHIFT",
5409 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5412 # check for pointer comparisons to NULL
5413 if ($^V && $^V ge 5.10.0) {
5414 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5417 $equal = "" if ($4 eq "!=");
5418 if (CHK("COMPARISON_TO_NULL",
5419 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5421 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5426 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5427 if ($line =~ /(\b$InitAttribute\b)/) {
5429 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5432 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5433 ERROR("MISPLACED_INIT",
5434 "$attr should be placed after $var\n" . $herecurr)) ||
5435 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5436 WARN("MISPLACED_INIT",
5437 "$attr should be placed after $var\n" . $herecurr))) &&
5439 $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;
5444 # check for $InitAttributeData (ie: __initdata) with const
5445 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5447 $attr =~ /($InitAttributePrefix)(.*)/;
5448 my $attr_prefix = $1;
5450 if (ERROR("INIT_ATTRIBUTE",
5451 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5453 $fixed[$fixlinenr] =~
5454 s/$InitAttributeData/${attr_prefix}initconst/;
5458 # check for $InitAttributeConst (ie: __initconst) without const
5459 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5461 if (ERROR("INIT_ATTRIBUTE",
5462 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5464 my $lead = $fixed[$fixlinenr] =~
5465 /(^\+\s*(?:static\s+))/;
5467 $lead = "$lead " if ($lead !~ /^\+$/);
5468 $lead = "${lead}const ";
5469 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5473 # check for __read_mostly with const non-pointer (should just be const)
5474 if ($line =~ /\b__read_mostly\b/ &&
5475 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5476 if (ERROR("CONST_READ_MOSTLY",
5477 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5479 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5483 # don't use __constant_<foo> functions outside of include/uapi/
5484 if ($realfile !~ m@^include/uapi/@ &&
5485 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5486 my $constant_func = $1;
5487 my $func = $constant_func;
5488 $func =~ s/^__constant_//;
5489 if (WARN("CONSTANT_CONVERSION",
5490 "$constant_func should be $func\n" . $herecurr) &&
5492 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5496 # prefer usleep_range over udelay
5497 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5499 # ignore udelay's < 10, however
5500 if (! ($delay < 10) ) {
5502 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5504 if ($delay > 2000) {
5506 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5510 # warn about unexpectedly long msleep's
5511 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5514 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5518 # check for comparisons of jiffies
5519 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5520 WARN("JIFFIES_COMPARISON",
5521 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5524 # check for comparisons of get_jiffies_64()
5525 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5526 WARN("JIFFIES_COMPARISON",
5527 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5530 # warn about #ifdefs in C files
5531 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5532 # print "#ifdef in C files should be avoided\n";
5533 # print "$herecurr";
5537 # warn about spacing in #ifdefs
5538 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5539 if (ERROR("SPACING",
5540 "exactly one space required after that #$1\n" . $herecurr) &&
5542 $fixed[$fixlinenr] =~
5543 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5548 # check for spinlock_t definitions without a comment.
5549 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5550 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5552 if (!ctx_has_comment($first_line, $linenr)) {
5553 CHK("UNCOMMENTED_DEFINITION",
5554 "$1 definition without comment\n" . $herecurr);
5557 # check for memory barriers without a comment.
5563 read_barrier_depends
5565 my $barrier_stems = qr{
5573 my $all_barriers = qr{
5575 smp_(?:$barrier_stems)|
5576 virt_(?:$barrier_stems)
5579 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5580 if (!ctx_has_comment($first_line, $linenr)) {
5581 WARN("MEMORY_BARRIER",
5582 "memory barrier without comment\n" . $herecurr);
5586 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5588 if ($realfile !~ m@^include/asm-generic/@ &&
5589 $realfile !~ m@/barrier\.h$@ &&
5590 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5591 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5592 WARN("MEMORY_BARRIER",
5593 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5596 # check for waitqueue_active without a comment.
5597 if ($line =~ /\bwaitqueue_active\s*\(/) {
5598 if (!ctx_has_comment($first_line, $linenr)) {
5599 WARN("WAITQUEUE_ACTIVE",
5600 "waitqueue_active without comment\n" . $herecurr);
5604 # check of hardware specific defines
5605 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5607 "architecture specific defines should be avoided\n" . $herecurr);
5610 # check that the storage class is not after a type
5611 if ($line =~ /\b($Type)\s+($Storage)\b/) {
5612 WARN("STORAGE_CLASS",
5613 "storage class '$2' should be located before type '$1'\n" . $herecurr);
5615 # Check that the storage class is at the beginning of a declaration
5616 if ($line =~ /\b$Storage\b/ &&
5617 $line !~ /^.\s*$Storage/ &&
5618 $line =~ /^.\s*(.+?)\$Storage\s/ &&
5619 $1 !~ /[\,\)]\s*$/) {
5620 WARN("STORAGE_CLASS",
5621 "storage class should be at the beginning of the declaration\n" . $herecurr);
5624 # check the location of the inline attribute, that it is between
5625 # storage class and type.
5626 if ($line =~ /\b$Type\s+$Inline\b/ ||
5627 $line =~ /\b$Inline\s+$Storage\b/) {
5628 ERROR("INLINE_LOCATION",
5629 "inline keyword should sit between storage class and type\n" . $herecurr);
5632 # Check for __inline__ and __inline, prefer inline
5633 if ($realfile !~ m@\binclude/uapi/@ &&
5634 $line =~ /\b(__inline__|__inline)\b/) {
5636 "plain inline is preferred over $1\n" . $herecurr) &&
5638 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5643 # Check for __attribute__ packed, prefer __packed
5644 if ($realfile !~ m@\binclude/uapi/@ &&
5645 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5646 WARN("PREFER_PACKED",
5647 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5650 # Check for __attribute__ aligned, prefer __aligned
5651 if ($realfile !~ m@\binclude/uapi/@ &&
5652 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5653 WARN("PREFER_ALIGNED",
5654 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5657 # Check for __attribute__ format(printf, prefer __printf
5658 if ($realfile !~ m@\binclude/uapi/@ &&
5659 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5660 if (WARN("PREFER_PRINTF",
5661 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5663 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5668 # Check for __attribute__ format(scanf, prefer __scanf
5669 if ($realfile !~ m@\binclude/uapi/@ &&
5670 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5671 if (WARN("PREFER_SCANF",
5672 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5674 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5678 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5679 if ($^V && $^V ge 5.10.0 &&
5680 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5681 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5682 $line =~ /\b__weak\b/)) {
5683 ERROR("WEAK_DECLARATION",
5684 "Using weak declarations can have unintended link defects\n" . $herecurr);
5687 # check for c99 types like uint8_t used outside of uapi/ and tools/
5688 if ($realfile !~ m@\binclude/uapi/@ &&
5689 $realfile !~ m@\btools/@ &&
5690 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5692 if ($type =~ /\b($typeC99Typedefs)\b/) {
5694 my $kernel_type = 'u';
5695 $kernel_type = 's' if ($type =~ /^_*[si]/);
5698 if (CHK("PREFER_KERNEL_TYPES",
5699 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5701 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5706 # check for cast of C90 native int or longer types constants
5707 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5710 if (WARN("TYPECAST_INT_CONSTANT",
5711 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5714 my $newconst = $const;
5715 $newconst =~ s/${Int_type}$//;
5716 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5717 if ($cast =~ /\blong\s+long\b/) {
5719 } elsif ($cast =~ /\blong\b/) {
5722 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5726 # check for sizeof(&)
5727 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5728 WARN("SIZEOF_ADDRESS",
5729 "sizeof(& should be avoided\n" . $herecurr);
5732 # check for sizeof without parenthesis
5733 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5734 if (WARN("SIZEOF_PARENTHESIS",
5735 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5737 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5741 # check for struct spinlock declarations
5742 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5743 WARN("USE_SPINLOCK_T",
5744 "struct spinlock should be spinlock_t\n" . $herecurr);
5747 # check for seq_printf uses that could be seq_puts
5748 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5749 my $fmt = get_quoted_string($line, $rawline);
5752 if (WARN("PREFER_SEQ_PUTS",
5753 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5755 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5760 # check for vsprintf extension %p<foo> misuses
5761 if ($^V && $^V ge 5.10.0 &&
5763 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
5764 $1 !~ /^_*volatile_*$/) {
5765 my $bad_extension = "";
5766 my $lc = $stat =~ tr@\n@@;
5767 $lc = $lc + $linenr;
5768 for (my $count = $linenr; $count <= $lc; $count++) {
5769 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
5771 if ($fmt =~ /(\%[\*\d\.]*p(?![\WFfSsBKRraEhMmIiUDdgVCbGNO]).)/) {
5772 $bad_extension = $1;
5776 if ($bad_extension ne "") {
5777 my $stat_real = raw_line($linenr, 0);
5778 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5779 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5781 WARN("VSPRINTF_POINTER_EXTENSION",
5782 "Invalid vsprintf pointer extension '$bad_extension'\n" . "$here\n$stat_real\n");
5786 # Check for misused memsets
5787 if ($^V && $^V ge 5.10.0 &&
5789 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5795 if ($ms_size =~ /^(0x|)0$/i) {
5797 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5798 } elsif ($ms_size =~ /^(0x|)1$/i) {
5800 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5804 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5805 # if ($^V && $^V ge 5.10.0 &&
5807 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5808 # if (WARN("PREFER_ETHER_ADDR_COPY",
5809 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5811 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5815 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5816 # if ($^V && $^V ge 5.10.0 &&
5818 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5819 # WARN("PREFER_ETHER_ADDR_EQUAL",
5820 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5823 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5824 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5825 # if ($^V && $^V ge 5.10.0 &&
5827 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5831 # if ($ms_val =~ /^(?:0x|)0+$/i) {
5832 # if (WARN("PREFER_ETH_ZERO_ADDR",
5833 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5835 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5837 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5838 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
5839 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5841 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5846 # typecasts on min/max could be min_t/max_t
5847 if ($^V && $^V ge 5.10.0 &&
5849 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5850 if (defined $2 || defined $7) {
5852 my $cast1 = deparenthesize($2);
5854 my $cast2 = deparenthesize($7);
5858 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5859 $cast = "$cast1 or $cast2";
5860 } elsif ($cast1 ne "") {
5866 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5870 # check usleep_range arguments
5871 if ($^V && $^V ge 5.10.0 &&
5873 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5877 WARN("USLEEP_RANGE",
5878 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5879 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5881 WARN("USLEEP_RANGE",
5882 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5886 # check for naked sscanf
5887 if ($^V && $^V ge 5.10.0 &&
5889 $line =~ /\bsscanf\b/ &&
5890 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5891 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5892 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5893 my $lc = $stat =~ tr@\n@@;
5894 $lc = $lc + $linenr;
5895 my $stat_real = raw_line($linenr, 0);
5896 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5897 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5899 WARN("NAKED_SSCANF",
5900 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5903 # check for simple sscanf that should be kstrto<foo>
5904 if ($^V && $^V ge 5.10.0 &&
5906 $line =~ /\bsscanf\b/) {
5907 my $lc = $stat =~ tr@\n@@;
5908 $lc = $lc + $linenr;
5909 my $stat_real = raw_line($linenr, 0);
5910 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5911 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5913 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5915 my $count = $format =~ tr@%@%@;
5917 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5918 WARN("SSCANF_TO_KSTRTO",
5919 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5924 # check for new externs in .h files.
5925 if ($realfile =~ /\.h$/ &&
5926 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5927 if (CHK("AVOID_EXTERNS",
5928 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5930 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5934 # check for new externs in .c files.
5935 if ($realfile =~ /\.c$/ && defined $stat &&
5936 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5938 my $function_name = $1;
5939 my $paren_space = $2;
5942 if (defined $cond) {
5943 substr($s, 0, length($cond), '');
5945 if ($s =~ /^\s*;/ &&
5946 $function_name ne 'uninitialized_var')
5948 WARN("AVOID_EXTERNS",
5949 "externs should be avoided in .c files\n" . $herecurr);
5952 if ($paren_space =~ /\n/) {
5953 WARN("FUNCTION_ARGUMENTS",
5954 "arguments for function declarations should follow identifier\n" . $herecurr);
5957 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5958 $stat =~ /^.\s*extern\s+/)
5960 WARN("AVOID_EXTERNS",
5961 "externs should be avoided in .c files\n" . $herecurr);
5964 # check for function declarations that have arguments without identifier names
5965 if (defined $stat &&
5966 $stat =~ /^.\s*(?:extern\s+)?$Type\s*$Ident\s*\(\s*([^{]+)\s*\)\s*;/s &&
5968 my $args = trim($1);
5969 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
5971 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
5972 WARN("FUNCTION_ARGUMENTS",
5973 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
5978 # check for function definitions
5979 if ($^V && $^V ge 5.10.0 &&
5981 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
5982 $context_function = $1;
5984 # check for multiline function definition with misplaced open brace
5986 my $cnt = statement_rawlines($stat);
5987 my $herectx = $here . "\n";
5988 for (my $n = 0; $n < $cnt; $n++) {
5989 my $rl = raw_line($linenr, $n);
5990 $herectx .= $rl . "\n";
5991 $ok = 1 if ($rl =~ /^[ \+]\{/);
5992 $ok = 1 if ($rl =~ /\{/ && $n == 0);
5993 last if $rl =~ /^[ \+].*\{/;
5997 "open brace '{' following function definitions go on the next line\n" . $herectx);
6001 # checks for new __setup's
6002 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6005 if (!grep(/$name/, @setup_docs)) {
6006 CHK("UNDOCUMENTED_SETUP",
6007 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
6011 # check for pointless casting of kmalloc return
6012 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
6013 WARN("UNNECESSARY_CASTS",
6014 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6018 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6019 if ($^V && $^V ge 5.10.0 &&
6020 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6021 CHK("ALLOC_SIZEOF_STRUCT",
6022 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6025 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6026 if ($^V && $^V ge 5.10.0 &&
6028 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6032 my $newfunc = "kmalloc_array";
6033 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6036 if ($a1 =~ /^sizeof\s*\S/) {
6040 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6041 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6043 my $herectx = $here . "\n";
6044 my $cnt = statement_rawlines($stat);
6045 for (my $n = 0; $n < $cnt; $n++) {
6046 $herectx .= raw_line($linenr, $n) . "\n";
6048 if (WARN("ALLOC_WITH_MULTIPLY",
6049 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6052 $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;
6057 # check for krealloc arg reuse
6058 if ($^V && $^V ge 5.10.0 &&
6059 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
6060 WARN("KREALLOC_ARG_REUSE",
6061 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6064 # check for alloc argument mismatch
6065 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6066 WARN("ALLOC_ARRAY_ARGS",
6067 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6070 # check for multiple semicolons
6071 if ($line =~ /;\s*;\s*$/) {
6072 if (WARN("ONE_SEMICOLON",
6073 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6075 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6079 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6080 if ($realfile !~ m@^include/uapi/@ &&
6081 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6083 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6084 if (CHK("BIT_MACRO",
6085 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6087 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6091 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6092 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6094 if (WARN("PREFER_IS_ENABLED",
6095 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6097 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6101 # check for case / default statements not preceded by break/fallthrough/switch
6102 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
6104 my $has_statement = 0;
6106 my $prevline = $linenr;
6107 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
6109 my $rline = $rawlines[$prevline - 1];
6110 my $fline = $lines[$prevline - 1];
6111 last if ($fline =~ /^\@\@/);
6112 next if ($fline =~ /^\-/);
6113 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
6114 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
6115 next if ($fline =~ /^.[\s$;]*$/);
6118 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
6120 if (!$has_break && $has_statement) {
6121 WARN("MISSING_BREAK",
6122 "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
6126 # check for switch/default statements without a break;
6127 if ($^V && $^V ge 5.10.0 &&
6129 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6131 my $herectx = $here . "\n";
6132 my $cnt = statement_rawlines($stat);
6133 for (my $n = 0; $n < $cnt; $n++) {
6134 $herectx .= raw_line($linenr, $n) . "\n";
6136 WARN("DEFAULT_NO_BREAK",
6137 "switch default: should use break\n" . $herectx);
6140 # check for gcc specific __FUNCTION__
6141 if ($line =~ /\b__FUNCTION__\b/) {
6142 if (WARN("USE_FUNC",
6143 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
6145 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
6149 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
6150 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6152 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6155 # check for use of yield()
6156 if ($line =~ /\byield\s*\(\s*\)/) {
6158 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
6161 # check for comparisons against true and false
6162 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6170 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6172 my $type = lc($otype);
6173 if ($type =~ /^(?:true|false)$/) {
6174 if (("$test" eq "==" && "$type" eq "true") ||
6175 ("$test" eq "!=" && "$type" eq "false")) {
6179 CHK("BOOL_COMPARISON",
6180 "Using comparison to $otype is error prone\n" . $herecurr);
6182 ## maybe suggesting a correct construct would better
6183 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6188 # check for semaphores initialized locked
6189 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6190 WARN("CONSIDER_COMPLETION",
6191 "consider using a completion\n" . $herecurr);
6194 # recommend kstrto* over simple_strto* and strict_strto*
6195 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6196 WARN("CONSIDER_KSTRTO",
6197 "$1 is obsolete, use k$3 instead\n" . $herecurr);
6200 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
6201 if ($line =~ /^.\s*__initcall\s*\(/) {
6202 WARN("USE_DEVICE_INITCALL",
6203 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6206 # check for various structs that are normally const (ops, kgdb, device_tree)
6207 # and avoid what seem like struct definitions 'struct foo {'
6208 if ($line !~ /\bconst\b/ &&
6209 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
6210 WARN("CONST_STRUCT",
6211 "struct $1 should normally be const\n" . $herecurr);
6214 # use of NR_CPUS is usually wrong
6215 # ignore definitions of NR_CPUS and usage to define arrays as likely right
6216 if ($line =~ /\bNR_CPUS\b/ &&
6217 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6218 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6219 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6220 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6221 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6224 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6227 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6228 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6229 ERROR("DEFINE_ARCH_HAS",
6230 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6233 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
6234 if ($^V && $^V ge 5.10.0 &&
6235 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6236 WARN("LIKELY_MISUSE",
6237 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6240 # whine mightly about in_atomic
6241 if ($line =~ /\bin_atomic\s*\(/) {
6242 if ($realfile =~ m@^drivers/@) {
6244 "do not use in_atomic in drivers\n" . $herecurr);
6245 } elsif ($realfile !~ m@^kernel/@) {
6247 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6251 # whine about ACCESS_ONCE
6252 if ($^V && $^V ge 5.10.0 &&
6253 $line =~ /\bACCESS_ONCE\s*$balanced_parens\s*(=(?!=))?\s*($FuncArg)?/) {
6257 $par =~ s/^\(\s*(.*)\s*\)$/$1/;
6259 if (WARN("PREFER_WRITE_ONCE",
6260 "Prefer WRITE_ONCE(<FOO>, <BAR>) over ACCESS_ONCE(<FOO>) = <BAR>\n" . $herecurr) &&
6262 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)\s*$eq\s*\Q$fun\E/WRITE_ONCE($par, $fun)/;
6265 if (WARN("PREFER_READ_ONCE",
6266 "Prefer READ_ONCE(<FOO>) over ACCESS_ONCE(<FOO>)\n" . $herecurr) &&
6268 $fixed[$fixlinenr] =~ s/\bACCESS_ONCE\s*\(\s*\Q$par\E\s*\)/READ_ONCE($par)/;
6273 # check for mutex_trylock_recursive usage
6274 if ($line =~ /mutex_trylock_recursive/) {
6276 "recursive locking is bad, do not use this ever.\n" . $herecurr);
6279 # check for lockdep_set_novalidate_class
6280 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6281 $line =~ /__lockdep_no_validate__\s*\)/ ) {
6282 if ($realfile !~ m@^kernel/lockdep@ &&
6283 $realfile !~ m@^include/linux/lockdep@ &&
6284 $realfile !~ m@^drivers/base/core@) {
6286 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6290 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6291 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6292 WARN("EXPORTED_WORLD_WRITABLE",
6293 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6296 # Mode permission misuses where it seems decimal should be octal
6297 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6298 if ($^V && $^V ge 5.10.0 &&
6300 $line =~ /$mode_perms_search/) {
6301 foreach my $entry (@mode_permission_funcs) {
6302 my $func = $entry->[0];
6303 my $arg_pos = $entry->[1];
6305 my $lc = $stat =~ tr@\n@@;
6306 $lc = $lc + $linenr;
6307 my $stat_real = raw_line($linenr, 0);
6308 for (my $count = $linenr + 1; $count <= $lc; $count++) {
6309 $stat_real = $stat_real . "\n" . raw_line($count, 0);
6315 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6317 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6318 if ($stat =~ /$test/) {
6320 $val = $6 if ($skip_args ne "");
6321 if (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6322 ($val =~ /^$Octal$/ && length($val) ne 4)) {
6323 ERROR("NON_OCTAL_PERMISSIONS",
6324 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6326 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6327 ERROR("EXPORTED_WORLD_WRITABLE",
6328 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6334 # check for uses of S_<PERMS> that could be octal for readability
6335 if ($line =~ /\b$mode_perms_string_search\b/) {
6341 while ($line =~ /\b(($mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
6342 $curpos = pos($line);
6345 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
6347 $to |= $mode_permission_string_types{$match};
6348 $val .= '\s*\|\s*' if ($val ne "");
6352 $oval =~ s/^\s*\|\s*//;
6353 $oval =~ s/\s*\|\s*$//;
6354 my $octal = sprintf("%04o", $to);
6355 if (WARN("SYMBOLIC_PERMS",
6356 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6358 $fixed[$fixlinenr] =~ s/$val/$octal/;
6362 # validate content of MODULE_LICENSE against list from include/linux/module.h
6363 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6364 my $extracted_string = get_quoted_string($line, $rawline);
6365 my $valid_licenses = qr{
6368 GPL\ and\ additional\ rights|
6374 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6375 WARN("MODULE_LICENSE",
6376 "unknown module license " . $extracted_string . "\n" . $herecurr);
6381 # If we have no input at all, then there is nothing to report on
6382 # so just keep quiet.
6383 if ($#rawlines == -1) {
6387 # In mailback mode only produce a report in the negative, for
6388 # things that appear to be patches.
6389 if ($mailback && ($clean == 1 || !$is_patch)) {
6393 # This is not a patch, and we are are in 'no-patch' mode so
6395 if (!$chk_patch && !$is_patch) {
6399 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
6400 ERROR("NOT_UNIFIED_DIFF",
6401 "Does not appear to be a unified-diff format patch\n");
6403 if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6404 ERROR("MISSING_SIGN_OFF",
6405 "Missing Signed-off-by: line(s)\n");
6408 print report_dump();
6409 if ($summary && !($clean == 1 && $quiet == 1)) {
6410 print "$filename " if ($summary_file);
6411 print "total: $cnt_error errors, $cnt_warn warnings, " .
6412 (($check)? "$cnt_chk checks, " : "") .
6413 "$cnt_lines lines checked\n";
6417 # If there were any defects found and not already fixing them
6418 if (!$clean and !$fix) {
6421 NOTE: For some of the reported defects, checkpatch may be able to
6422 mechanically convert to the typical style using --fix or --fix-inplace.
6425 # If there were whitespace errors which cleanpatch can fix
6426 # then suggest that.
6427 if ($rpt_cleaners) {
6431 NOTE: Whitespace errors detected.
6432 You may wish to use scripts/cleanpatch or scripts/cleanfile
6437 if ($clean == 0 && $fix &&
6438 ("@rawlines" ne "@fixed" ||
6439 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6440 my $newfile = $filename;
6441 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6445 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6447 open($f, '>', $newfile)
6448 or die "$P: Can't open $newfile for write\n";
6449 foreach my $fixed_line (@fixed) {
6452 if ($linecount > 3) {
6453 $fixed_line =~ s/^\+//;
6454 print $f $fixed_line . "\n";
6457 print $f $fixed_line . "\n";
6465 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6467 Do _NOT_ trust the results written to this file.
6468 Do _NOT_ submit these changes without inspecting them for correctness.
6470 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6471 No warranties, expressed or implied...
6479 print "$vname has no obvious style problems and is ready for submission.\n";
6481 print "$vname has style problems, please review.\n";