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
13 use Term::ANSIColor qw(:constants);
16 my $D = dirname(abs_path($P));
20 use Getopt::Long qw(:config no_auto_abbrev);
50 my $configuration_file = ".checkpatch.conf";
51 my $max_line_length = 80;
52 my $ignore_perl_version = 0;
53 my $minimum_perl_version = 5.10.0;
54 my $min_conf_desc_length = 4;
55 my $spelling_file = "$D/spelling.txt";
57 my $codespellfile = "/usr/share/codespell/dictionary.txt";
58 my $conststructsfile = "$D/const_structs.checkpatch";
59 my $typedefsfile = "";
61 my $allow_c99_comments = 1;
67 Usage: $P [OPTION]... [FILE]...
72 --no-tree run without a kernel tree
73 --no-signoff do not check for 'Signed-off-by' line
74 --patch treat FILE as patchfile (default)
75 --emacs emacs compile window format
76 --terse one line per report
77 --showfile emit diffed file position, not input file position
78 -g, --git treat FILE as a single commit or git revision range
79 single git commit with:
83 multiple git commits with:
87 git merges are ignored
88 -f, --file treat FILE as regular source file
89 --subjective, --strict enable more subjective tests
90 --list-types list the possible message types
91 --types TYPE(,TYPE2...) show only these comma separated message types
92 --ignore TYPE(,TYPE2...) ignore various comma separated message types
93 --show-types show the specific message type in the output
94 --max-line-length=n set the maximum line length, if exceeded, warn
95 --min-conf-desc-length=n set the min description length, if shorter, warn
96 --root=PATH PATH to the kernel tree root
97 --no-summary suppress the per-file summary
98 --mailback only produce a report in case of warnings/errors
99 --summary-file include the filename in summary
100 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
101 'values', 'possible', 'type', and 'attr' (default
103 --test-only=WORD report only warnings/errors containing WORD
105 --fix EXPERIMENTAL - may create horrible results
106 If correctable single-line errors exist, create
107 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
108 with potential errors corrected to the preferred
110 --fix-inplace EXPERIMENTAL - may create horrible results
111 Is the same as --fix, but overwrites the input
112 file. It's your fault if there's no backup or git
113 --ignore-perl-version override checking of perl version. expect
115 --codespell Use the codespell dictionary for spelling/typos
116 (default:/usr/share/codespell/dictionary.txt)
117 --codespellfile Use this codespell dictionary
118 --typedefsfile Read additional types from this file
119 --color[=WHEN] Use colors 'always', 'never', or only when output
120 is a terminal ('auto'). Default is 'auto'.
121 -h, --help, --version display this help and exit
123 When FILE is - read standard input.
131 return grep { !$seen{$_}++ } @_;
141 open(my $script, '<', abs_path($P)) or
142 die "$P: Can't read '$P' $!\n";
144 my $text = <$script>;
148 # Also catch when type or level is passed through a variable
149 for ($text =~ /(?:(?:\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
152 @types = sort(uniq(@types));
153 print("#\tMessage type\n\n");
154 foreach my $type (@types) {
155 print(++$count . "\t" . $type . "\n");
161 my $conf = which_conf($configuration_file);
164 open(my $conffile, '<', "$conf")
165 or warn "$P: Can't find a readable $configuration_file file $!\n";
167 while (<$conffile>) {
170 $line =~ s/\s*\n?$//g;
174 next if ($line =~ m/^\s*#/);
175 next if ($line =~ m/^\s*$/);
177 my @words = split(" ", $line);
178 foreach my $word (@words) {
179 last if ($word =~ m/^#/);
180 push (@conf_args, $word);
184 unshift(@ARGV, @conf_args) if @conf_args;
187 # Perl's Getopt::Long allows options to take optional arguments after a space.
188 # Prevent --color by itself from consuming other arguments
190 if ($_ eq "--color" || $_ eq "-color") {
191 $_ = "--color=$color";
196 'q|quiet+' => \$quiet,
198 'signoff!' => \$chk_signoff,
199 'patch!' => \$chk_patch,
202 'showfile!' => \$showfile,
205 'subjective!' => \$check,
206 'strict!' => \$check,
207 'ignore=s' => \@ignore,
209 'show-types!' => \$show_types,
210 'list-types!' => \$list_types,
211 'max-line-length=i' => \$max_line_length,
212 'min-conf-desc-length=i' => \$min_conf_desc_length,
214 'summary!' => \$summary,
215 'mailback!' => \$mailback,
216 'summary-file!' => \$summary_file,
218 'fix-inplace!' => \$fix_inplace,
219 'ignore-perl-version!' => \$ignore_perl_version,
220 'debug=s' => \%debug,
221 'test-only=s' => \$tst_only,
222 'codespell!' => \$codespell,
223 'codespellfile=s' => \$codespellfile,
224 'typedefsfile=s' => \$typedefsfile,
225 'color=s' => \$color,
226 'no-color' => \$color, #keep old behaviors of -nocolor
227 'nocolor' => \$color, #keep old behaviors of -nocolor
234 list_types(0) if ($list_types);
236 $fix = 1 if ($fix_inplace);
237 $check_orig = $check;
241 if ($^V && $^V lt $minimum_perl_version) {
242 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
243 if (!$ignore_perl_version) {
248 #if no filenames are given, push '-' to read patch from stdin
253 if ($color =~ /^[01]$/) {
255 } elsif ($color =~ /^always$/i) {
257 } elsif ($color =~ /^never$/i) {
259 } elsif ($color =~ /^auto$/i) {
260 $color = (-t STDOUT);
262 die "Invalid color mode: $color\n";
265 sub hash_save_array_words {
266 my ($hashRef, $arrayRef) = @_;
268 my @array = split(/,/, join(',', @$arrayRef));
269 foreach my $word (@array) {
270 $word =~ s/\s*\n?$//g;
273 $word =~ tr/[a-z]/[A-Z]/;
275 next if ($word =~ m/^\s*#/);
276 next if ($word =~ m/^\s*$/);
282 sub hash_show_words {
283 my ($hashRef, $prefix) = @_;
285 if (keys %$hashRef) {
286 print "\nNOTE: $prefix message types:";
287 foreach my $word (sort keys %$hashRef) {
294 hash_save_array_words(\%ignore_type, \@ignore);
295 hash_save_array_words(\%use_type, \@use);
298 my $dbg_possible = 0;
301 for my $key (keys %debug) {
303 eval "\${dbg_$key} = '$debug{$key}';";
307 my $rpt_cleaners = 0;
316 if (!top_of_kernel_tree($root)) {
317 die "$P: $root: --root does not point at a valid tree\n";
320 if (top_of_kernel_tree('.')) {
322 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
323 top_of_kernel_tree($1)) {
328 if (!defined $root) {
329 print "Must be run from the top-level dir. of a kernel tree\n";
334 my $emitted_corrupt = 0;
337 [A-Za-z_][A-Za-z\d_]*
338 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
340 our $Storage = qr{extern|static|asmlinkage};
353 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
354 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
355 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
356 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
357 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
359 # Notes to $Attribute:
360 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
381 ____cacheline_aligned|
382 ____cacheline_aligned_in_smp|
383 ____cacheline_internodealigned_in_smp|
387 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
388 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
389 our $Lval = qr{$Ident(?:$Member)*};
391 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
392 our $Binary = qr{(?i)0b[01]+$Int_type?};
393 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
394 our $Int = qr{[0-9]+$Int_type?};
395 our $Octal = qr{0[0-7]+$Int_type?};
396 our $String = qr{"[X\t]*"};
397 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
398 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
399 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
400 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
401 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
402 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
403 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
404 our $Arithmetic = qr{\+|-|\*|\/|%};
408 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
411 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
415 our $NonptrTypeMisordered;
416 our $NonptrTypeWithAttr;
420 our $DeclareMisordered;
422 our $NON_ASCII_UTF8 = qr{
423 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
424 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
425 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
426 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
427 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
428 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
429 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
433 [\x09\x0A\x0D\x20-\x7E] # ASCII
437 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
438 our $typeOtherOSTypedefs = qr{(?x:
439 u_(?:char|short|int|long) | # bsd
440 u(?:nchar|short|int|long) # sysv
442 our $typeKernelTypedefs = qr{(?x:
443 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
446 our $typeTypedefs = qr{(?x:
448 $typeOtherOSTypedefs\b|
449 $typeKernelTypedefs\b
452 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
454 our $logFunctions = qr{(?x:
455 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
456 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
458 WARN(?:_RATELIMIT|_ONCE|)|
461 seq_vprintf|seq_printf|seq_puts
464 our $signature_tags = qr{(?xi:
475 our @typeListMisordered = (
476 qr{char\s+(?:un)?signed},
477 qr{int\s+(?:(?:un)?signed\s+)?short\s},
478 qr{int\s+short(?:\s+(?:un)?signed)},
479 qr{short\s+int(?:\s+(?:un)?signed)},
480 qr{(?:un)?signed\s+int\s+short},
481 qr{short\s+(?:un)?signed},
482 qr{long\s+int\s+(?:un)?signed},
483 qr{int\s+long\s+(?:un)?signed},
484 qr{long\s+(?:un)?signed\s+int},
485 qr{int\s+(?:un)?signed\s+long},
486 qr{int\s+(?:un)?signed},
487 qr{int\s+long\s+long\s+(?:un)?signed},
488 qr{long\s+long\s+int\s+(?:un)?signed},
489 qr{long\s+long\s+(?:un)?signed\s+int},
490 qr{long\s+long\s+(?:un)?signed},
491 qr{long\s+(?:un)?signed},
496 qr{(?:(?:un)?signed\s+)?char},
497 qr{(?:(?:un)?signed\s+)?short\s+int},
498 qr{(?:(?:un)?signed\s+)?short},
499 qr{(?:(?:un)?signed\s+)?int},
500 qr{(?:(?:un)?signed\s+)?long\s+int},
501 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
502 qr{(?:(?:un)?signed\s+)?long\s+long},
503 qr{(?:(?:un)?signed\s+)?long},
512 qr{${Ident}_handler},
513 qr{${Ident}_handler_fn},
517 our $C90_int_types = qr{(?x:
518 long\s+long\s+int\s+(?:un)?signed|
519 long\s+long\s+(?:un)?signed\s+int|
520 long\s+long\s+(?:un)?signed|
521 (?:(?:un)?signed\s+)?long\s+long\s+int|
522 (?:(?:un)?signed\s+)?long\s+long|
523 int\s+long\s+long\s+(?:un)?signed|
524 int\s+(?:(?:un)?signed\s+)?long\s+long|
526 long\s+int\s+(?:un)?signed|
527 long\s+(?:un)?signed\s+int|
528 long\s+(?:un)?signed|
529 (?:(?:un)?signed\s+)?long\s+int|
530 (?:(?:un)?signed\s+)?long|
531 int\s+long\s+(?:un)?signed|
532 int\s+(?:(?:un)?signed\s+)?long|
535 (?:(?:un)?signed\s+)?int
538 our @typeListFile = ();
539 our @typeListWithAttr = (
541 qr{struct\s+$InitAttribute\s+$Ident},
542 qr{union\s+$InitAttribute\s+$Ident},
545 our @modifierList = (
548 our @modifierListFile = ();
550 our @mode_permission_funcs = (
552 ["module_param_(?:array|named|string)", 4],
553 ["module_param_array_named", 5],
554 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
555 ["proc_create(?:_data|)", 2],
556 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
557 ["IIO_DEV_ATTR_[A-Z_]+", 1],
558 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
559 ["SENSOR_TEMPLATE(?:_2|)", 3],
563 #Create a search pattern for all these functions to speed up a loop below
564 our $mode_perms_search = "";
565 foreach my $entry (@mode_permission_funcs) {
566 $mode_perms_search .= '|' if ($mode_perms_search ne "");
567 $mode_perms_search .= $entry->[0];
569 $mode_perms_search = "(?:${mode_perms_search})";
571 our $mode_perms_world_writable = qr{
579 our %mode_permission_string_types = (
598 #Create a search pattern for all these strings to speed up a loop below
599 our $mode_perms_string_search = "";
600 foreach my $entry (keys %mode_permission_string_types) {
601 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
602 $mode_perms_string_search .= $entry;
604 our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
605 our $multi_mode_perms_string_search = qr{
606 ${single_mode_perms_string_search}
607 (?:\s*\|\s*${single_mode_perms_string_search})*
613 return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
620 while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
621 $curpos = pos($string);
624 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
626 $to |= $mode_permission_string_types{$match};
627 $val .= '\s*\|\s*' if ($val ne "");
631 $oval =~ s/^\s*\|\s*//;
632 $oval =~ s/\s*\|\s*$//;
633 return sprintf("%04o", $to);
636 our $allowed_asm_includes = qr{(?x:
642 # memory.h: ARM has a custom one
644 # Load common spelling mistakes and build regular expression list.
648 if (open(my $spelling, '<', $spelling_file)) {
649 while (<$spelling>) {
652 $line =~ s/\s*\n?$//g;
655 next if ($line =~ m/^\s*#/);
656 next if ($line =~ m/^\s*$/);
658 my ($suspect, $fix) = split(/\|\|/, $line);
660 $spelling_fix{$suspect} = $fix;
664 warn "No typos will be found - file '$spelling_file': $!\n";
668 if (open(my $spelling, '<', $codespellfile)) {
669 while (<$spelling>) {
672 $line =~ s/\s*\n?$//g;
675 next if ($line =~ m/^\s*#/);
676 next if ($line =~ m/^\s*$/);
677 next if ($line =~ m/, disabled/i);
681 my ($suspect, $fix) = split(/->/, $line);
683 $spelling_fix{$suspect} = $fix;
687 warn "No codespell typos will be found - file '$codespellfile': $!\n";
691 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
694 my ($wordsRef, $file) = @_;
696 if (open(my $words, '<', $file)) {
700 $line =~ s/\s*\n?$//g;
703 next if ($line =~ m/^\s*#/);
704 next if ($line =~ m/^\s*$/);
706 print("$file: '$line' invalid - ignored\n");
710 $$wordsRef .= '|' if ($$wordsRef ne "");
720 my $const_structs = "";
721 read_words(\$const_structs, $conststructsfile)
722 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
724 my $typeOtherTypedefs = "";
725 if (length($typedefsfile)) {
726 read_words(\$typeOtherTypedefs, $typedefsfile)
727 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
729 $typeTypedefs .= '|' . $typeOtherTypedefs if ($typeOtherTypedefs ne "");
732 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
733 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
734 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
735 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
736 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
742 (?:$Modifier\s+|const\s+)*
744 (?:typeof|__typeof__)\s*\([^\)]*\)|
748 (?:\s+$Modifier|\s+const)*
750 $NonptrTypeMisordered = qr{
751 (?:$Modifier\s+|const\s+)*
755 (?:\s+$Modifier|\s+const)*
757 $NonptrTypeWithAttr = qr{
758 (?:$Modifier\s+|const\s+)*
760 (?:typeof|__typeof__)\s*\([^\)]*\)|
764 (?:\s+$Modifier|\s+const)*
768 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
769 (?:\s+$Inline|\s+$Modifier)*
771 $TypeMisordered = qr{
772 $NonptrTypeMisordered
773 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
774 (?:\s+$Inline|\s+$Modifier)*
776 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
777 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
781 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
783 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
784 # requires at least perl version v5.10.0
785 # Any use must be runtime checked with $^V
787 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
788 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
789 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
791 our $declaration_macros = qr{(?x:
792 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
793 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
794 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
799 return "" if (!defined($string));
801 while ($string =~ /^\s*\(.*\)\s*$/) {
802 $string =~ s@^\s*\(\s*@@;
803 $string =~ s@\s*\)\s*$@@;
806 $string =~ s@\s+@ @g;
811 sub seed_camelcase_file {
814 return if (!(-f $file));
818 open(my $include_file, '<', "$file")
819 or warn "$P: Can't read '$file' $!\n";
820 my $text = <$include_file>;
821 close($include_file);
823 my @lines = split('\n', $text);
825 foreach my $line (@lines) {
826 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
827 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
829 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
831 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
837 sub is_maintained_obsolete {
840 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
842 my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
844 return $status =~ /obsolete/i;
847 my $camelcase_seeded = 0;
848 sub seed_camelcase_includes {
849 return if ($camelcase_seeded);
852 my $camelcase_cache = "";
853 my @include_files = ();
855 $camelcase_seeded = 1;
858 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
859 chomp $git_last_include_commit;
860 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
862 my $last_mod_date = 0;
863 $files = `find $root/include -name "*.h"`;
864 @include_files = split('\n', $files);
865 foreach my $file (@include_files) {
866 my $date = POSIX::strftime("%Y%m%d%H%M",
867 localtime((stat $file)[9]));
868 $last_mod_date = $date if ($last_mod_date < $date);
870 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
873 if ($camelcase_cache ne "" && -f $camelcase_cache) {
874 open(my $camelcase_file, '<', "$camelcase_cache")
875 or warn "$P: Can't read '$camelcase_cache' $!\n";
876 while (<$camelcase_file>) {
880 close($camelcase_file);
886 $files = `git ls-files "include/*.h"`;
887 @include_files = split('\n', $files);
890 foreach my $file (@include_files) {
891 seed_camelcase_file($file);
894 if ($camelcase_cache ne "") {
895 unlink glob ".checkpatch-camelcase.*";
896 open(my $camelcase_file, '>', "$camelcase_cache")
897 or warn "$P: Can't write '$camelcase_cache' $!\n";
898 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
899 print $camelcase_file ("$_\n");
901 close($camelcase_file);
905 sub git_commit_info {
906 my ($commit, $id, $desc) = @_;
908 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
910 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
911 $output =~ s/^\s*//gm;
912 my @lines = split("\n", $output);
914 return ($id, $desc) if ($#lines < 0);
916 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
917 # Maybe one day convert this block of bash into something that returns
918 # all matching commit ids, but it's very slow...
920 # echo "checking commits $1..."
921 # git rev-list --remotes | grep -i "^$1" |
922 # while read line ; do
923 # git log --format='%H %s' -1 $line |
924 # echo "commit $(cut -c 1-12,41-)"
926 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
929 $id = substr($lines[0], 0, 12);
930 $desc = substr($lines[0], 41);
936 $chk_signoff = 0 if ($file);
941 my @fixed_inserted = ();
942 my @fixed_deleted = ();
945 # If input is git commits, extract all commits from the commit expressions.
946 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
947 die "$P: No git repository found\n" if ($git && !-e ".git");
951 foreach my $commit_expr (@ARGV) {
953 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
954 $git_range = "-$2 $1";
955 } elsif ($commit_expr =~ m/\.\./) {
956 $git_range = "$commit_expr";
958 $git_range = "-1 $commit_expr";
960 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
961 foreach my $line (split(/\n/, $lines)) {
962 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
963 next if (!defined($1) || !defined($2));
966 unshift(@commits, $sha1);
967 $git_commits{$sha1} = $subject;
970 die "$P: no git commits after extraction!\n" if (@commits == 0);
975 for my $filename (@ARGV) {
978 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
979 die "$P: $filename: git format-patch failed - $!\n";
981 open($FILE, '-|', "diff -u /dev/null $filename") ||
982 die "$P: $filename: diff failed - $!\n";
983 } elsif ($filename eq '-') {
984 open($FILE, '<&STDIN');
986 open($FILE, '<', "$filename") ||
987 die "$P: $filename: open failed - $!\n";
989 if ($filename eq '-') {
990 $vname = 'Your patch';
992 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1002 if ($#ARGV > 0 && $quiet == 0) {
1003 print '-' x length($vname) . "\n";
1005 print '-' x length($vname) . "\n";
1008 if (!process($filename)) {
1014 @fixed_inserted = ();
1015 @fixed_deleted = ();
1017 @modifierListFile = ();
1023 hash_show_words(\%use_type, "Used");
1024 hash_show_words(\%ignore_type, "Ignored");
1026 if ($^V lt 5.10.0) {
1029 NOTE: perl $^V is not modern enough to detect all possible issues.
1030 An upgrade to at least perl v5.10.0 is suggested.
1036 NOTE: If any of the errors are false positives, please report
1037 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1044 sub top_of_kernel_tree {
1048 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1049 "README", "Documentation", "arch", "include", "drivers",
1050 "fs", "init", "ipc", "kernel", "lib", "scripts",
1053 foreach my $check (@tree_check) {
1054 if (! -e $root . '/' . $check) {
1062 my ($formatted_email) = @_;
1068 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1071 $comment = $3 if defined $3;
1072 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1074 $comment = $2 if defined $2;
1075 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1077 $comment = $2 if defined $2;
1078 $formatted_email =~ s/$address.*$//;
1079 $name = $formatted_email;
1080 $name = trim($name);
1081 $name =~ s/^\"|\"$//g;
1082 # If there's a name left after stripping spaces and
1083 # leading quotes, and the address doesn't have both
1084 # leading and trailing angle brackets, the address
1086 # "joe smith joe@smith.com" bad
1087 # "joe smith <joe@smith.com" bad
1088 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1095 $name = trim($name);
1096 $name =~ s/^\"|\"$//g;
1097 $address = trim($address);
1098 $address =~ s/^\<|\>$//g;
1100 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1101 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1102 $name = "\"$name\"";
1105 return ($name, $address, $comment);
1109 my ($name, $address) = @_;
1111 my $formatted_email;
1113 $name = trim($name);
1114 $name =~ s/^\"|\"$//g;
1115 $address = trim($address);
1117 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1118 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1119 $name = "\"$name\"";
1122 if ("$name" eq "") {
1123 $formatted_email = "$address";
1125 $formatted_email = "$name <$address>";
1128 return $formatted_email;
1134 foreach my $path (split(/:/, $ENV{PATH})) {
1135 if (-e "$path/$bin") {
1136 return "$path/$bin";
1146 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1147 if (-e "$path/$conf") {
1148 return "$path/$conf";
1160 for my $c (split(//, $str)) {
1164 for (; ($n % 8) != 0; $n++) {
1176 (my $res = shift) =~ tr/\t/ /c;
1183 # Drop the diff line leader and expand tabs
1185 $line = expand_tabs($line);
1187 # Pick the indent from the front of the line.
1188 my ($white) = ($line =~ /^(\s*)/);
1190 return (length($line), length($white));
1193 my $sanitise_quote = '';
1195 sub sanitise_line_reset {
1196 my ($in_comment) = @_;
1199 $sanitise_quote = '*/';
1201 $sanitise_quote = '';
1214 # Always copy over the diff marker.
1215 $res = substr($line, 0, 1);
1217 for ($off = 1; $off < length($line); $off++) {
1218 $c = substr($line, $off, 1);
1220 # Comments we are wacking completly including the begin
1221 # and end, all to $;.
1222 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1223 $sanitise_quote = '*/';
1225 substr($res, $off, 2, "$;$;");
1229 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1230 $sanitise_quote = '';
1231 substr($res, $off, 2, "$;$;");
1235 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1236 $sanitise_quote = '//';
1238 substr($res, $off, 2, $sanitise_quote);
1243 # A \ in a string means ignore the next character.
1244 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1246 substr($res, $off, 2, 'XX');
1251 if ($c eq "'" || $c eq '"') {
1252 if ($sanitise_quote eq '') {
1253 $sanitise_quote = $c;
1255 substr($res, $off, 1, $c);
1257 } elsif ($sanitise_quote eq $c) {
1258 $sanitise_quote = '';
1262 #print "c<$c> SQ<$sanitise_quote>\n";
1263 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1264 substr($res, $off, 1, $;);
1265 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1266 substr($res, $off, 1, $;);
1267 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1268 substr($res, $off, 1, 'X');
1270 substr($res, $off, 1, $c);
1274 if ($sanitise_quote eq '//') {
1275 $sanitise_quote = '';
1278 # The pathname on a #include may be surrounded by '<' and '>'.
1279 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1280 my $clean = 'X' x length($1);
1281 $res =~ s@\<.*\>@<$clean>@;
1283 # The whole of a #error is a string.
1284 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1285 my $clean = 'X' x length($1);
1286 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1289 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1291 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1297 sub get_quoted_string {
1298 my ($line, $rawline) = @_;
1300 return "" if ($line !~ m/($String)/g);
1301 return substr($rawline, $-[0], $+[0] - $-[0]);
1304 sub ctx_statement_block {
1305 my ($linenr, $remain, $off) = @_;
1306 my $line = $linenr - 1;
1309 my $coff = $off - 1;
1323 @stack = (['', 0]) if ($#stack == -1);
1325 #warn "CSB: blk<$blk> remain<$remain>\n";
1326 # If we are about to drop off the end, pull in more
1329 for (; $remain > 0; $line++) {
1330 last if (!defined $lines[$line]);
1331 next if ($lines[$line] =~ /^-/);
1334 $blk .= $lines[$line] . "\n";
1335 $len = length($blk);
1339 # Bail if there is no further context.
1340 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1344 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1350 $c = substr($blk, $off, 1);
1351 $remainder = substr($blk, $off);
1353 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1355 # Handle nested #if/#else.
1356 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1357 push(@stack, [ $type, $level ]);
1358 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1359 ($type, $level) = @{$stack[$#stack - 1]};
1360 } elsif ($remainder =~ /^#\s*endif\b/) {
1361 ($type, $level) = @{pop(@stack)};
1364 # Statement ends at the ';' or a close '}' at the
1366 if ($level == 0 && $c eq ';') {
1370 # An else is really a conditional as long as its not else if
1371 if ($level == 0 && $coff_set == 0 &&
1372 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1373 $remainder =~ /^(else)(?:\s|{)/ &&
1374 $remainder !~ /^else\s+if\b/) {
1375 $coff = $off + length($1) - 1;
1377 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1378 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1381 if (($type eq '' || $type eq '(') && $c eq '(') {
1385 if ($type eq '(' && $c eq ')') {
1387 $type = ($level != 0)? '(' : '';
1389 if ($level == 0 && $coff < $soff) {
1392 #warn "CSB: mark coff<$coff>\n";
1395 if (($type eq '' || $type eq '{') && $c eq '{') {
1399 if ($type eq '{' && $c eq '}') {
1401 $type = ($level != 0)? '{' : '';
1404 if (substr($blk, $off + 1, 1) eq ';') {
1410 # Preprocessor commands end at the newline unless escaped.
1411 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1419 # We are truly at the end, so shuffle to the next line.
1426 my $statement = substr($blk, $soff, $off - $soff + 1);
1427 my $condition = substr($blk, $soff, $coff - $soff + 1);
1429 #warn "STATEMENT<$statement>\n";
1430 #warn "CONDITION<$condition>\n";
1432 #print "coff<$coff> soff<$off> loff<$loff>\n";
1434 return ($statement, $condition,
1435 $line, $remain + 1, $off - $loff + 1, $level);
1438 sub statement_lines {
1441 # Strip the diff line prefixes and rip blank lines at start and end.
1442 $stmt =~ s/(^|\n)./$1/g;
1446 my @stmt_lines = ($stmt =~ /\n/g);
1448 return $#stmt_lines + 2;
1451 sub statement_rawlines {
1454 my @stmt_lines = ($stmt =~ /\n/g);
1456 return $#stmt_lines + 2;
1459 sub statement_block_size {
1462 $stmt =~ s/(^|\n)./$1/g;
1468 my @stmt_lines = ($stmt =~ /\n/g);
1469 my @stmt_statements = ($stmt =~ /;/g);
1471 my $stmt_lines = $#stmt_lines + 2;
1472 my $stmt_statements = $#stmt_statements + 1;
1474 if ($stmt_lines > $stmt_statements) {
1477 return $stmt_statements;
1481 sub ctx_statement_full {
1482 my ($linenr, $remain, $off) = @_;
1483 my ($statement, $condition, $level);
1487 # Grab the first conditional/block pair.
1488 ($statement, $condition, $linenr, $remain, $off, $level) =
1489 ctx_statement_block($linenr, $remain, $off);
1490 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1491 push(@chunks, [ $condition, $statement ]);
1492 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1493 return ($level, $linenr, @chunks);
1496 # Pull in the following conditional/block pairs and see if they
1497 # could continue the statement.
1499 ($statement, $condition, $linenr, $remain, $off, $level) =
1500 ctx_statement_block($linenr, $remain, $off);
1501 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1502 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1504 push(@chunks, [ $condition, $statement ]);
1507 return ($level, $linenr, @chunks);
1511 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1513 my $start = $linenr - 1;
1520 my @stack = ($level);
1521 for ($line = $start; $remain > 0; $line++) {
1522 next if ($rawlines[$line] =~ /^-/);
1525 $blk .= $rawlines[$line];
1527 # Handle nested #if/#else.
1528 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1529 push(@stack, $level);
1530 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1531 $level = $stack[$#stack - 1];
1532 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1533 $level = pop(@stack);
1536 foreach my $c (split(//, $lines[$line])) {
1537 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1543 if ($c eq $close && $level > 0) {
1545 last if ($level == 0);
1546 } elsif ($c eq $open) {
1551 if (!$outer || $level <= 1) {
1552 push(@res, $rawlines[$line]);
1555 last if ($level == 0);
1558 return ($level, @res);
1560 sub ctx_block_outer {
1561 my ($linenr, $remain) = @_;
1563 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1567 my ($linenr, $remain) = @_;
1569 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1573 my ($linenr, $remain, $off) = @_;
1575 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1578 sub ctx_block_level {
1579 my ($linenr, $remain) = @_;
1581 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1583 sub ctx_statement_level {
1584 my ($linenr, $remain, $off) = @_;
1586 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1589 sub ctx_locate_comment {
1590 my ($first_line, $end_line) = @_;
1592 # Catch a comment on the end of the line itself.
1593 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1594 return $current_comment if (defined $current_comment);
1596 # Look through the context and try and figure out if there is a
1599 $current_comment = '';
1600 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1601 my $line = $rawlines[$linenr - 1];
1603 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1606 if ($line =~ m@/\*@) {
1609 if (!$in_comment && $current_comment ne '') {
1610 $current_comment = '';
1612 $current_comment .= $line . "\n" if ($in_comment);
1613 if ($line =~ m@\*/@) {
1618 chomp($current_comment);
1619 return($current_comment);
1621 sub ctx_has_comment {
1622 my ($first_line, $end_line) = @_;
1623 my $cmt = ctx_locate_comment($first_line, $end_line);
1625 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1626 ##print "CMMT: $cmt\n";
1628 return ($cmt ne '');
1632 my ($linenr, $cnt) = @_;
1634 my $offset = $linenr - 1;
1639 $line = $rawlines[$offset++];
1640 next if (defined($line) && $line =~ /^-/);
1652 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1655 $coded = sprintf("^%c", unpack('C', $2) + 64);
1664 my $av_preprocessor = 0;
1669 sub annotate_reset {
1670 $av_preprocessor = 0;
1672 @av_paren_type = ('E');
1673 $av_pend_colon = 'O';
1676 sub annotate_values {
1677 my ($stream, $type) = @_;
1680 my $var = '_' x length($stream);
1683 print "$stream\n" if ($dbg_values > 1);
1685 while (length($cur)) {
1686 @av_paren_type = ('E') if ($#av_paren_type < 0);
1687 print " <" . join('', @av_paren_type) .
1688 "> <$type> <$av_pending>" if ($dbg_values > 1);
1689 if ($cur =~ /^(\s+)/o) {
1690 print "WS($1)\n" if ($dbg_values > 1);
1691 if ($1 =~ /\n/ && $av_preprocessor) {
1692 $type = pop(@av_paren_type);
1693 $av_preprocessor = 0;
1696 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1697 print "CAST($1)\n" if ($dbg_values > 1);
1698 push(@av_paren_type, $type);
1701 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1702 print "DECLARE($1)\n" if ($dbg_values > 1);
1705 } elsif ($cur =~ /^($Modifier)\s*/) {
1706 print "MODIFIER($1)\n" if ($dbg_values > 1);
1709 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1710 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1711 $av_preprocessor = 1;
1712 push(@av_paren_type, $type);
1718 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1719 print "UNDEF($1)\n" if ($dbg_values > 1);
1720 $av_preprocessor = 1;
1721 push(@av_paren_type, $type);
1723 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1724 print "PRE_START($1)\n" if ($dbg_values > 1);
1725 $av_preprocessor = 1;
1727 push(@av_paren_type, $type);
1728 push(@av_paren_type, $type);
1731 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1732 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1733 $av_preprocessor = 1;
1735 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1739 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1740 print "PRE_END($1)\n" if ($dbg_values > 1);
1742 $av_preprocessor = 1;
1744 # Assume all arms of the conditional end as this
1745 # one does, and continue as if the #endif was not here.
1746 pop(@av_paren_type);
1747 push(@av_paren_type, $type);
1750 } elsif ($cur =~ /^(\\\n)/o) {
1751 print "PRECONT($1)\n" if ($dbg_values > 1);
1753 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1754 print "ATTR($1)\n" if ($dbg_values > 1);
1755 $av_pending = $type;
1758 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1759 print "SIZEOF($1)\n" if ($dbg_values > 1);
1765 } elsif ($cur =~ /^(if|while|for)\b/o) {
1766 print "COND($1)\n" if ($dbg_values > 1);
1770 } elsif ($cur =~/^(case)/o) {
1771 print "CASE($1)\n" if ($dbg_values > 1);
1772 $av_pend_colon = 'C';
1775 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1776 print "KEYWORD($1)\n" if ($dbg_values > 1);
1779 } elsif ($cur =~ /^(\()/o) {
1780 print "PAREN('$1')\n" if ($dbg_values > 1);
1781 push(@av_paren_type, $av_pending);
1785 } elsif ($cur =~ /^(\))/o) {
1786 my $new_type = pop(@av_paren_type);
1787 if ($new_type ne '_') {
1789 print "PAREN('$1') -> $type\n"
1790 if ($dbg_values > 1);
1792 print "PAREN('$1')\n" if ($dbg_values > 1);
1795 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1796 print "FUNC($1)\n" if ($dbg_values > 1);
1800 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1801 if (defined $2 && $type eq 'C' || $type eq 'T') {
1802 $av_pend_colon = 'B';
1803 } elsif ($type eq 'E') {
1804 $av_pend_colon = 'L';
1806 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1809 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1810 print "IDENT($1)\n" if ($dbg_values > 1);
1813 } elsif ($cur =~ /^($Assignment)/o) {
1814 print "ASSIGN($1)\n" if ($dbg_values > 1);
1817 } elsif ($cur =~/^(;|{|})/) {
1818 print "END($1)\n" if ($dbg_values > 1);
1820 $av_pend_colon = 'O';
1822 } elsif ($cur =~/^(,)/) {
1823 print "COMMA($1)\n" if ($dbg_values > 1);
1826 } elsif ($cur =~ /^(\?)/o) {
1827 print "QUESTION($1)\n" if ($dbg_values > 1);
1830 } elsif ($cur =~ /^(:)/o) {
1831 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1833 substr($var, length($res), 1, $av_pend_colon);
1834 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1839 $av_pend_colon = 'O';
1841 } elsif ($cur =~ /^(\[)/o) {
1842 print "CLOSE($1)\n" if ($dbg_values > 1);
1845 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1848 print "OPV($1)\n" if ($dbg_values > 1);
1855 substr($var, length($res), 1, $variant);
1858 } elsif ($cur =~ /^($Operators)/o) {
1859 print "OP($1)\n" if ($dbg_values > 1);
1860 if ($1 ne '++' && $1 ne '--') {
1864 } elsif ($cur =~ /(^.)/o) {
1865 print "C($1)\n" if ($dbg_values > 1);
1868 $cur = substr($cur, length($1));
1869 $res .= $type x length($1);
1873 return ($res, $var);
1877 my ($possible, $line) = @_;
1878 my $notPermitted = qr{(?:
1895 ^(?:typedef|struct|enum)\b
1897 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1898 if ($possible !~ $notPermitted) {
1899 # Check for modifiers.
1900 $possible =~ s/\s*$Storage\s*//g;
1901 $possible =~ s/\s*$Sparse\s*//g;
1902 if ($possible =~ /^\s*$/) {
1904 } elsif ($possible =~ /\s/) {
1905 $possible =~ s/\s*$Type\s*//g;
1906 for my $modifier (split(' ', $possible)) {
1907 if ($modifier !~ $notPermitted) {
1908 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1909 push(@modifierListFile, $modifier);
1914 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1915 push(@typeListFile, $possible);
1919 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1928 $type =~ tr/[a-z]/[A-Z]/;
1930 return defined $use_type{$type} if (scalar keys %use_type > 0);
1932 return !defined $ignore_type{$type};
1936 my ($level, $type, $msg) = @_;
1938 if (!show_type($type) ||
1939 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1944 if ($level eq 'ERROR') {
1946 } elsif ($level eq 'WARNING') {
1952 $output .= $prefix . $level . ':';
1954 $output .= BLUE if ($color);
1955 $output .= "$type:";
1957 $output .= RESET if ($color);
1958 $output .= ' ' . $msg . "\n";
1961 my @lines = split("\n", $output, -1);
1962 splice(@lines, 1, 1);
1963 $output = join("\n", @lines);
1965 $output = (split('\n', $output))[0] . "\n" if ($terse);
1967 push(our @report, $output);
1976 sub fixup_current_range {
1977 my ($lineRef, $offset, $length) = @_;
1979 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1982 my $no = $o + $offset;
1983 my $nl = $l + $length;
1984 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1988 sub fix_inserted_deleted_lines {
1989 my ($linesRef, $insertedRef, $deletedRef) = @_;
1991 my $range_last_linenr = 0;
1992 my $delta_offset = 0;
1997 my $next_insert = 0;
1998 my $next_delete = 0;
2002 my $inserted = @{$insertedRef}[$next_insert++];
2003 my $deleted = @{$deletedRef}[$next_delete++];
2005 foreach my $old_line (@{$linesRef}) {
2007 my $line = $old_line; #don't modify the array
2008 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
2010 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2011 $range_last_linenr = $new_linenr;
2012 fixup_current_range(\$line, $delta_offset, 0);
2015 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2016 $deleted = @{$deletedRef}[$next_delete++];
2018 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2021 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2022 push(@lines, ${$inserted}{'LINE'});
2023 $inserted = @{$insertedRef}[$next_insert++];
2025 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2029 push(@lines, $line);
2039 sub fix_insert_line {
2040 my ($linenr, $line) = @_;
2046 push(@fixed_inserted, $inserted);
2049 sub fix_delete_line {
2050 my ($linenr, $line) = @_;
2057 push(@fixed_deleted, $deleted);
2061 my ($type, $msg) = @_;
2063 if (report("ERROR", $type, $msg)) {
2071 my ($type, $msg) = @_;
2073 if (report("WARNING", $type, $msg)) {
2081 my ($type, $msg) = @_;
2083 if ($check && report("CHECK", $type, $msg)) {
2091 sub check_absolute_file {
2092 my ($absolute, $herecurr) = @_;
2093 my $file = $absolute;
2095 ##print "absolute<$absolute>\n";
2097 # See if any suffix of this path is a path within the tree.
2098 while ($file =~ s@^[^/]*/@@) {
2099 if (-f "$root/$file") {
2100 ##print "file<$file>\n";
2108 # It is, so see if the prefix is acceptable.
2109 my $prefix = $absolute;
2110 substr($prefix, -length($file)) = '';
2112 ##print "prefix<$prefix>\n";
2113 if ($prefix ne ".../") {
2114 WARN("USE_RELATIVE_PATH",
2115 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2122 $string =~ s/^\s+|\s+$//g;
2130 $string =~ s/^\s+//;
2138 $string =~ s/\s+$//;
2143 sub string_find_replace {
2144 my ($string, $find, $replace) = @_;
2146 $string =~ s/$find/$replace/g;
2154 my $source_indent = 8;
2155 my $max_spaces_before_tab = $source_indent - 1;
2156 my $spaces_to_tab = " " x $source_indent;
2158 #convert leading spaces to tabs
2159 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2160 #Remove spaces before a tab
2161 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2166 sub pos_last_openparen {
2171 my $opens = $line =~ tr/\(/\(/;
2172 my $closes = $line =~ tr/\)/\)/;
2174 my $last_openparen = 0;
2176 if (($opens == 0) || ($closes >= $opens)) {
2180 my $len = length($line);
2182 for ($pos = 0; $pos < $len; $pos++) {
2183 my $string = substr($line, $pos);
2184 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2185 $pos += length($1) - 1;
2186 } elsif (substr($line, $pos, 1) eq '(') {
2187 $last_openparen = $pos;
2188 } elsif (index($string, '(') == -1) {
2193 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2197 my $filename = shift;
2203 my $stashrawline="";
2213 my $in_header_lines = $file ? 0 : 1;
2214 my $in_commit_log = 0; #Scanning lines before patch
2215 my $has_commit_log = 0; #Encountered lines before patch
2216 my $commit_log_possible_stack_dump = 0;
2217 my $commit_log_long_line = 0;
2218 my $commit_log_has_diff = 0;
2219 my $reported_maintainer_file = 0;
2220 my $non_utf8_charset = 0;
2222 my $last_blank_line = 0;
2223 my $last_coalesced_string_linenr = -1;
2231 # Trace the real file/line as we go.
2236 my $context_function; #undef'd unless there's a known function
2238 my $comment_edge = 0;
2242 my $prev_values = 'E';
2245 my %suppress_ifbraces;
2246 my %suppress_whiletrailers;
2247 my %suppress_export;
2248 my $suppress_statement = 0;
2250 my %signatures = ();
2252 # Pre-scan the patch sanitizing the lines.
2253 # Pre-scan the patch looking for any __setup documentation.
2255 my @setup_docs = ();
2258 my $camelcase_file_seeded = 0;
2260 sanitise_line_reset();
2262 foreach my $rawline (@rawlines) {
2266 push(@fixed, $rawline) if ($fix);
2268 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2270 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
2275 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2284 # Guestimate if this is a continuing comment. Run
2285 # the context looking for a comment "edge". If this
2286 # edge is a close comment then we must be in a comment
2290 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2291 next if (defined $rawlines[$ln - 1] &&
2292 $rawlines[$ln - 1] =~ /^-/);
2294 #print "RAW<$rawlines[$ln - 1]>\n";
2295 last if (!defined $rawlines[$ln - 1]);
2296 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2297 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2302 if (defined $edge && $edge eq '*/') {
2306 # Guestimate if this is a continuing comment. If this
2307 # is the start of a diff block and this line starts
2308 # ' *' then it is very likely a comment.
2309 if (!defined $edge &&
2310 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2315 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2316 sanitise_line_reset($in_comment);
2318 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2319 # Standardise the strings and chars within the input to
2320 # simplify matching -- only bother with positive lines.
2321 $line = sanitise_line($rawline);
2323 push(@lines, $line);
2326 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2331 #print "==>$rawline\n";
2332 #print "-->$line\n";
2334 if ($setup_docs && $line =~ /^\+/) {
2335 push(@setup_docs, $line);
2344 foreach my $line (@lines) {
2347 my $sline = $line; #copy of $line
2348 $sline =~ s/$;/ /g; #with comments as spaces
2350 my $rawline = $rawlines[$linenr - 1];
2352 #extract the line range in the file after the patch is applied
2353 if (!$in_commit_log &&
2354 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2357 $first_line = $linenr + 1;
2367 %suppress_ifbraces = ();
2368 %suppress_whiletrailers = ();
2369 %suppress_export = ();
2370 $suppress_statement = 0;
2371 if ($context =~ /\b(\w+)\s*\(/) {
2372 $context_function = $1;
2374 undef $context_function;
2378 # track the line number as we move through the hunk, note that
2379 # new versions of GNU diff omit the leading space on completely
2380 # blank context lines so we need to count that too.
2381 } elsif ($line =~ /^( |\+|$)/) {
2383 $realcnt-- if ($realcnt != 0);
2385 # Measure the line length and indent.
2386 ($length, $indent) = line_stats($rawline);
2388 # Track the previous line.
2389 ($prevline, $stashline) = ($stashline, $line);
2390 ($previndent, $stashindent) = ($stashindent, $indent);
2391 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2393 #warn "line<$line>\n";
2395 } elsif ($realcnt == 1) {
2399 my $hunk_line = ($realcnt != 0);
2401 $here = "#$linenr: " if (!$file);
2402 $here = "#$realline: " if ($file);
2405 # extract the filename as it passes
2406 if ($line =~ /^diff --git.*?(\S+)$/) {
2408 $realfile =~ s@^([^/]*)/@@ if (!$file);
2411 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2413 $realfile =~ s@^([^/]*)/@@ if (!$file);
2417 if (!$file && $tree && $p1_prefix ne '' &&
2418 -e "$root/$p1_prefix") {
2419 WARN("PATCH_PREFIX",
2420 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2423 if ($realfile =~ m@^include/asm/@) {
2424 ERROR("MODIFIED_INCLUDE_ASM",
2425 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2430 #make up the handle for any error we report on this line
2432 $prefix = "$realfile:$realline: "
2435 $prefix = "$filename:$realline: ";
2437 $prefix = "$filename:$linenr: ";
2442 if (is_maintained_obsolete($realfile)) {
2444 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2446 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2449 $check = $check_orig;
2454 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2456 my $hereline = "$here\n$rawline\n";
2457 my $herecurr = "$here\n$rawline\n";
2458 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2460 $cnt_lines++ if ($realcnt != 0);
2462 # Check if the commit log has what seems like a diff which can confuse patch
2463 if ($in_commit_log && !$commit_log_has_diff &&
2464 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2465 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2466 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2467 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2468 ERROR("DIFF_IN_COMMIT_MSG",
2469 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2470 $commit_log_has_diff = 1;
2473 # Check for incorrect file permissions
2474 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2475 my $permhere = $here . "FILE: $realfile\n";
2476 if ($realfile !~ m@scripts/@ &&
2477 $realfile !~ /\.(py|pl|awk|sh)$/) {
2478 ERROR("EXECUTE_PERMISSIONS",
2479 "do not set execute permissions for source files\n" . $permhere);
2483 # Check the patch for a signoff:
2484 if ($line =~ /^\s*signed-off-by:/i) {
2489 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2490 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2491 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2492 $reported_maintainer_file = 1;
2495 # Check signature styles
2496 if (!$in_header_lines &&
2497 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2498 my $space_before = $1;
2500 my $space_after = $3;
2502 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2504 if ($sign_off !~ /$signature_tags/) {
2505 WARN("BAD_SIGN_OFF",
2506 "Non-standard signature: $sign_off\n" . $herecurr);
2508 if (defined $space_before && $space_before ne "") {
2509 if (WARN("BAD_SIGN_OFF",
2510 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2512 $fixed[$fixlinenr] =
2513 "$ucfirst_sign_off $email";
2516 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2517 if (WARN("BAD_SIGN_OFF",
2518 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2520 $fixed[$fixlinenr] =
2521 "$ucfirst_sign_off $email";
2525 if (!defined $space_after || $space_after ne " ") {
2526 if (WARN("BAD_SIGN_OFF",
2527 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2529 $fixed[$fixlinenr] =
2530 "$ucfirst_sign_off $email";
2534 my ($email_name, $email_address, $comment) = parse_email($email);
2535 my $suggested_email = format_email(($email_name, $email_address));
2536 if ($suggested_email eq "") {
2537 ERROR("BAD_SIGN_OFF",
2538 "Unrecognized email address: '$email'\n" . $herecurr);
2540 my $dequoted = $suggested_email;
2541 $dequoted =~ s/^"//;
2542 $dequoted =~ s/" </ </;
2543 # Don't force email to have quotes
2544 # Allow just an angle bracketed address
2545 if ("$dequoted$comment" ne $email &&
2546 "<$email_address>$comment" ne $email &&
2547 "$suggested_email$comment" ne $email) {
2548 WARN("BAD_SIGN_OFF",
2549 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2553 # Check for duplicate signatures
2554 my $sig_nospace = $line;
2555 $sig_nospace =~ s/\s//g;
2556 $sig_nospace = lc($sig_nospace);
2557 if (defined $signatures{$sig_nospace}) {
2558 WARN("BAD_SIGN_OFF",
2559 "Duplicate signature\n" . $herecurr);
2561 $signatures{$sig_nospace} = 1;
2565 # Check email subject for common tools that don't need to be mentioned
2566 if ($in_header_lines &&
2567 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2568 WARN("EMAIL_SUBJECT",
2569 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2572 # Check for old stable address
2573 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2574 ERROR("STABLE_ADDRESS",
2575 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2578 # Check for unwanted Gerrit info
2579 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2580 ERROR("GERRIT_CHANGE_ID",
2581 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2584 # Check if the commit log is in a possible stack dump
2585 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2586 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2587 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2589 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2590 # stack dump address
2591 $commit_log_possible_stack_dump = 1;
2594 # Check for line lengths > 75 in commit log, warn once
2595 if ($in_commit_log && !$commit_log_long_line &&
2596 length($line) > 75 &&
2597 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2598 # file delta changes
2599 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2601 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2602 # A Fixes: or Link: line
2603 $commit_log_possible_stack_dump)) {
2604 WARN("COMMIT_LOG_LONG_LINE",
2605 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2606 $commit_log_long_line = 1;
2609 # Reset possible stack dump if a blank line is found
2610 if ($in_commit_log && $commit_log_possible_stack_dump &&
2612 $commit_log_possible_stack_dump = 0;
2615 # Check for git id commit length and improperly formed commit descriptions
2616 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2617 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
2618 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
2619 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2620 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2621 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2622 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2623 my $init_char = "c";
2624 my $orig_commit = "";
2631 my $id = '0123456789ab';
2632 my $orig_desc = "commit description";
2633 my $description = "";
2635 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2637 $orig_commit = lc($2);
2638 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2639 $orig_commit = lc($1);
2642 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2643 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2644 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2645 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2646 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2649 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2650 defined $rawlines[$linenr] &&
2651 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2654 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2655 defined $rawlines[$linenr] &&
2656 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2657 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2659 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2660 $orig_desc .= " " . $1;
2664 ($id, $description) = git_commit_info($orig_commit,
2668 ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
2669 ERROR("GIT_COMMIT_ID",
2670 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2674 # Check for added, moved or deleted files
2675 if (!$reported_maintainer_file && !$in_commit_log &&
2676 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2677 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2678 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2679 (defined($1) || defined($2))))) {
2681 $reported_maintainer_file = 1;
2682 WARN("FILE_PATH_CHANGES",
2683 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2686 # Check for wrappage within a valid hunk of the file
2687 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2688 ERROR("CORRUPTED_PATCH",
2689 "patch seems to be corrupt (line wrapped?)\n" .
2690 $herecurr) if (!$emitted_corrupt++);
2693 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2694 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2695 $rawline !~ m/^$UTF8*$/) {
2696 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2698 my $blank = copy_spacing($rawline);
2699 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2700 my $hereptr = "$hereline$ptr\n";
2703 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2706 # Check if it's the start of a commit log
2707 # (not a header line and we haven't seen the patch filename)
2708 if ($in_header_lines && $realfile =~ /^$/ &&
2709 !($rawline =~ /^\s+(?:\S|$)/ ||
2710 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
2711 $in_header_lines = 0;
2713 $has_commit_log = 1;
2716 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2717 # declined it, i.e defined some charset where it is missing.
2718 if ($in_header_lines &&
2719 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2721 $non_utf8_charset = 1;
2724 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2725 $rawline =~ /$NON_ASCII_UTF8/) {
2726 WARN("UTF8_BEFORE_PATCH",
2727 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2730 # Check for absolute kernel paths in commit message
2731 if ($tree && $in_commit_log) {
2732 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2735 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2736 check_absolute_file($1, $herecurr)) {
2739 check_absolute_file($file, $herecurr);
2744 # Check for various typo / spelling mistakes
2745 if (defined($misspellings) &&
2746 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2747 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2749 my $typo_fix = $spelling_fix{lc($typo)};
2750 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2751 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2752 my $msg_level = \&WARN;
2753 $msg_level = \&CHK if ($file);
2754 if (&{$msg_level}("TYPO_SPELLING",
2755 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2757 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2762 # ignore non-hunk lines and lines being removed
2763 next if (!$hunk_line || $line =~ /^-/);
2765 #trailing whitespace
2766 if ($line =~ /^\+.*\015/) {
2767 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2768 if (ERROR("DOS_LINE_ENDINGS",
2769 "DOS line endings\n" . $herevet) &&
2771 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2773 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2774 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2775 if (ERROR("TRAILING_WHITESPACE",
2776 "trailing whitespace\n" . $herevet) &&
2778 $fixed[$fixlinenr] =~ s/\s+$//;
2784 # Check for FSF mailing addresses.
2785 if ($rawline =~ /\bwrite to the Free/i ||
2786 $rawline =~ /\b675\s+Mass\s+Ave/i ||
2787 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2788 $rawline =~ /\b51\s+Franklin\s+St/i) {
2789 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2790 my $msg_level = \&ERROR;
2791 $msg_level = \&CHK if ($file);
2792 &{$msg_level}("FSF_MAILING_ADDRESS",
2793 "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)
2796 # check for Kconfig help text having a real description
2797 # Only applies when adding the entry originally, after that we do not have
2798 # sufficient context to determine whether it is indeed long enough.
2799 if ($realfile =~ /Kconfig/ &&
2800 $line =~ /^\+\s*config\s+/) {
2803 my $ln = $linenr + 1;
2807 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2808 $f = $lines[$ln - 1];
2809 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2810 $is_end = $lines[$ln - 1] =~ /^\+/;
2812 next if ($f =~ /^-/);
2813 last if (!$file && $f =~ /^\@\@/);
2815 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2817 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2824 next if ($f =~ /^$/);
2825 if ($f =~ /^\s*config\s/) {
2831 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2832 WARN("CONFIG_DESCRIPTION",
2833 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2835 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2838 # check for MAINTAINERS entries that don't have the right form
2839 if ($realfile =~ /^MAINTAINERS$/ &&
2840 $rawline =~ /^\+[A-Z]:/ &&
2841 $rawline !~ /^\+[A-Z]:\t\S/) {
2842 if (WARN("MAINTAINERS_STYLE",
2843 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
2845 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
2849 # discourage the use of boolean for type definition attributes of Kconfig options
2850 if ($realfile =~ /Kconfig/ &&
2851 $line =~ /^\+\s*\bboolean\b/) {
2852 WARN("CONFIG_TYPE_BOOLEAN",
2853 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2856 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2857 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2860 'EXTRA_AFLAGS' => 'asflags-y',
2861 'EXTRA_CFLAGS' => 'ccflags-y',
2862 'EXTRA_CPPFLAGS' => 'cppflags-y',
2863 'EXTRA_LDFLAGS' => 'ldflags-y',
2866 WARN("DEPRECATED_VARIABLE",
2867 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2870 # check for DT compatible documentation
2871 if (defined $root &&
2872 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2873 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2875 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2877 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2878 my $vp_file = $dt_path . "vendor-prefixes.txt";
2880 foreach my $compat (@compats) {
2881 my $compat2 = $compat;
2882 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2883 my $compat3 = $compat;
2884 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2885 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2887 WARN("UNDOCUMENTED_DT_STRING",
2888 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2891 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2893 `grep -Eq "^$vendor\\b" $vp_file`;
2895 WARN("UNDOCUMENTED_DT_STRING",
2896 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2901 # check we are in a valid source file if not then ignore this hunk
2902 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
2904 # line length limit (with some exclusions)
2906 # There are a few types of lines that may extend beyond $max_line_length:
2907 # logging functions like pr_info that end in a string
2908 # lines with a single string
2909 # #defines that are a single string
2910 # lines with an RFC3986 like URL
2912 # There are 3 different line length message types:
2913 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
2914 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2915 # LONG_LINE all other lines longer than $max_line_length
2917 # if LONG_LINE is ignored, the other 2 types are also ignored
2920 if ($line =~ /^\+/ && $length > $max_line_length) {
2921 my $msg_type = "LONG_LINE";
2923 # Check the allowed long line types first
2925 # logging functions that end in a string that starts
2926 # before $max_line_length
2927 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2928 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2931 # lines with only strings (w/ possible termination)
2932 # #defines with only strings
2933 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2934 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2937 # More special cases
2938 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
2939 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
2942 # URL ($rawline is used in case the URL is in a comment)
2943 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
2946 # Otherwise set the alternate message types
2948 # a comment starts before $max_line_length
2949 } elsif ($line =~ /($;[\s$;]*)$/ &&
2950 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2951 $msg_type = "LONG_LINE_COMMENT"
2953 # a quoted string starts before $max_line_length
2954 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2955 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2956 $msg_type = "LONG_LINE_STRING"
2959 if ($msg_type ne "" &&
2960 (show_type("LONG_LINE") || show_type($msg_type))) {
2962 "line over $max_line_length characters\n" . $herecurr);
2966 # check for adding lines without a newline.
2967 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2968 WARN("MISSING_EOF_NEWLINE",
2969 "adding a line without newline at end of file\n" . $herecurr);
2972 # check we are in a valid source file C or perl if not then ignore this hunk
2973 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2975 # at the beginning of a line any tabs must come first and anything
2976 # more than 8 must use tabs.
2977 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2978 $rawline =~ /^\+\s* \s*/) {
2979 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2981 if (ERROR("CODE_INDENT",
2982 "code indent should use tabs where possible\n" . $herevet) &&
2984 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2988 # check for space before tabs.
2989 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2990 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2991 if (WARN("SPACE_BEFORE_TAB",
2992 "please, no space before tabs\n" . $herevet) &&
2994 while ($fixed[$fixlinenr] =~
2995 s/(^\+.*) {8,8}\t/$1\t\t/) {}
2996 while ($fixed[$fixlinenr] =~
2997 s/(^\+.*) +\t/$1\t/) {}
3001 # check for && or || at the start of a line
3002 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3003 CHK("LOGICAL_CONTINUATIONS",
3004 "Logical continuations should be on the previous line\n" . $hereprev);
3007 # check indentation starts on a tab stop
3008 if ($^V && $^V ge 5.10.0 &&
3009 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3010 my $indent = length($1);
3013 "Statements should start on a tabstop\n" . $herecurr) &&
3015 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
3020 # check multi-line statement indentation matches previous line
3021 if ($^V && $^V ge 5.10.0 &&
3022 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3023 $prevline =~ /^\+(\t*)(.*)$/;
3027 my $pos = pos_last_openparen($rest);
3029 $line =~ /^(\+| )([ \t]*)/;
3032 my $goodtabindent = $oldindent .
3035 my $goodspaceindent = $oldindent . " " x $pos;
3037 if ($newindent ne $goodtabindent &&
3038 $newindent ne $goodspaceindent) {
3040 if (CHK("PARENTHESIS_ALIGNMENT",
3041 "Alignment should match open parenthesis\n" . $hereprev) &&
3042 $fix && $line =~ /^\+/) {
3043 $fixed[$fixlinenr] =~
3044 s/^\+[ \t]*/\+$goodtabindent/;
3050 # check for space after cast like "(int) foo" or "(struct foo) bar"
3051 # avoid checking a few false positives:
3052 # "sizeof(<type>)" or "__alignof__(<type>)"
3053 # function pointer declarations like "(*foo)(int) = bar;"
3054 # structure definitions like "(struct foo) { 0 };"
3055 # multiline macros that define functions
3056 # known attributes or the __attribute__ keyword
3057 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3058 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3060 "No space is necessary after a cast\n" . $herecurr) &&
3062 $fixed[$fixlinenr] =~
3063 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3067 # Block comment styles
3068 # Networking with an initial /*
3069 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3070 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3071 $rawline =~ /^\+[ \t]*\*/ &&
3073 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3074 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3077 # Block comments use * on subsequent lines
3078 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3079 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
3080 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3081 $rawline =~ /^\+/ && #line is new
3082 $rawline !~ /^\+[ \t]*\*/) { #no leading *
3083 WARN("BLOCK_COMMENT_STYLE",
3084 "Block comments use * on subsequent lines\n" . $hereprev);
3087 # Block comments use */ on trailing lines
3088 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
3089 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3090 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3091 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
3092 WARN("BLOCK_COMMENT_STYLE",
3093 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3096 # Block comment * alignment
3097 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3098 $line =~ /^\+[ \t]*$;/ && #leading comment
3099 $rawline =~ /^\+[ \t]*\*/ && #leading *
3100 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
3101 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3102 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3104 $prevrawline =~ m@^\+([ \t]*/?)\*@;
3106 $oldindent = expand_tabs($1);
3108 $prevrawline =~ m@^\+(.*/?)\*@;
3109 $oldindent = expand_tabs($1);
3111 $rawline =~ m@^\+([ \t]*)\*@;
3113 $newindent = expand_tabs($newindent);
3114 if (length($oldindent) ne length($newindent)) {
3115 WARN("BLOCK_COMMENT_STYLE",
3116 "Block comments should align the * on each line\n" . $hereprev);
3120 # check for missing blank lines after struct/union declarations
3121 # with exceptions for various attributes and macros
3122 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3124 !($line =~ /^\+\s*$/ ||
3125 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3126 $line =~ /^\+\s*MODULE_/i ||
3127 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3128 $line =~ /^\+[a-z_]*init/ ||
3129 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3130 $line =~ /^\+\s*DECLARE/ ||
3131 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3132 $line =~ /^\+\s*__setup/)) {
3133 if (CHK("LINE_SPACING",
3134 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3136 fix_insert_line($fixlinenr, "\+");
3140 # check for multiple consecutive blank lines
3141 if ($prevline =~ /^[\+ ]\s*$/ &&
3142 $line =~ /^\+\s*$/ &&
3143 $last_blank_line != ($linenr - 1)) {
3144 if (CHK("LINE_SPACING",
3145 "Please don't use multiple blank lines\n" . $hereprev) &&
3147 fix_delete_line($fixlinenr, $rawline);
3150 $last_blank_line = $linenr;
3153 # check for missing blank lines after declarations
3154 if ($sline =~ /^\+\s+\S/ && #Not at char 1
3155 # actual declarations
3156 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3157 # function pointer declarations
3158 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3159 # foo bar; where foo is some local typedef or #define
3160 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3161 # known declaration macros
3162 $prevline =~ /^\+\s+$declaration_macros/) &&
3163 # for "else if" which can look like "$Ident $Ident"
3164 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3165 # other possible extensions of declaration lines
3166 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3167 # not starting a section or a macro "\" extended line
3168 $prevline =~ /(?:\{\s*|\\)$/) &&
3169 # looks like a declaration
3170 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3171 # function pointer declarations
3172 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3173 # foo bar; where foo is some local typedef or #define
3174 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3175 # known declaration macros
3176 $sline =~ /^\+\s+$declaration_macros/ ||
3177 # start of struct or union or enum
3178 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3179 # start or end of block or continuation of declaration
3180 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3181 # bitfield continuation
3182 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3183 # other possible extensions of declaration lines
3184 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3185 # indentation of previous and current line are the same
3186 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3187 if (WARN("LINE_SPACING",
3188 "Missing a blank line after declarations\n" . $hereprev) &&
3190 fix_insert_line($fixlinenr, "\+");
3194 # check for spaces at the beginning of a line.
3196 # 1) within comments
3197 # 2) indented preprocessor commands
3199 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3200 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3201 if (WARN("LEADING_SPACE",
3202 "please, no spaces at the start of a line\n" . $herevet) &&
3204 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3208 # check we are in a valid C source file if not then ignore this hunk
3209 next if ($realfile !~ /\.(h|c)$/);
3211 # check for unusual line ending [ or (
3212 if ($line =~ /^\+.*([\[\(])\s*$/) {
3213 CHK("OPEN_ENDED_LINE",
3214 "Lines should not end with a '$1'\n" . $herecurr);
3217 # check if this appears to be the start function declaration, save the name
3218 if ($sline =~ /^\+\{\s*$/ &&
3219 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3220 $context_function = $1;
3223 # check if this appears to be the end of function declaration
3224 if ($sline =~ /^\+\}\s*$/) {
3225 undef $context_function;
3228 # check indentation of any line with a bare else
3229 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3230 # if the previous line is a break or return and is indented 1 tab more...
3231 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3232 my $tabs = length($1) + 1;
3233 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3234 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3235 defined $lines[$linenr] &&
3236 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3237 WARN("UNNECESSARY_ELSE",
3238 "else is not generally useful after a break or return\n" . $hereprev);
3242 # check indentation of a line with a break;
3243 # if the previous line is a goto or return and is indented the same # of tabs
3244 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3246 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3247 WARN("UNNECESSARY_BREAK",
3248 "break is not useful after a goto or return\n" . $hereprev);
3252 # check for RCS/CVS revision markers
3253 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3255 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3258 # check for old HOTPLUG __dev<foo> section markings
3259 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3260 WARN("HOTPLUG_SECTION",
3261 "Using $1 is unnecessary\n" . $herecurr);
3264 # Check for potential 'bare' types
3265 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3267 #print "LINE<$line>\n";
3268 if ($linenr > $suppress_statement &&
3269 $realcnt && $sline =~ /.\s*\S/) {
3270 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3271 ctx_statement_block($linenr, $realcnt, 0);
3272 $stat =~ s/\n./\n /g;
3273 $cond =~ s/\n./\n /g;
3275 #print "linenr<$linenr> <$stat>\n";
3276 # If this statement has no statement boundaries within
3277 # it there is no point in retrying a statement scan
3278 # until we hit end of it.
3279 my $frag = $stat; $frag =~ s/;+\s*$//;
3280 if ($frag !~ /(?:{|;)/) {
3281 #print "skip<$line_nr_next>\n";
3282 $suppress_statement = $line_nr_next;
3285 # Find the real next line.
3286 $realline_next = $line_nr_next;
3287 if (defined $realline_next &&
3288 (!defined $lines[$realline_next - 1] ||
3289 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3296 # Ignore goto labels.
3297 if ($s =~ /$Ident:\*$/s) {
3299 # Ignore functions being called
3300 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3302 } elsif ($s =~ /^.\s*else\b/s) {
3304 # declarations always start with types
3305 } 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) {
3308 possible($type, "A:" . $s);
3310 # definitions in global scope can only start with types
3311 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3312 possible($1, "B:" . $s);
3315 # any (foo ... *) is a pointer cast, and foo is a type
3316 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3317 possible($1, "C:" . $s);
3320 # Check for any sort of function declaration.
3321 # int foo(something bar, other baz);
3322 # void (*store_gdt)(x86_descr_ptr *);
3323 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3324 my ($name_len) = length($1);
3327 substr($ctx, 0, $name_len + 1, '');
3328 $ctx =~ s/\)[^\)]*$//;
3330 for my $arg (split(/\s*,\s*/, $ctx)) {
3331 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3333 possible($1, "D:" . $s);
3341 # Checks which may be anchored in the context.
3344 # Check for switch () and associated case and default
3345 # statements should be at the same indent.
3346 if ($line=~/\bswitch\s*\(.*\)/) {
3349 my @ctx = ctx_block_outer($linenr, $realcnt);
3351 for my $ctx (@ctx) {
3352 my ($clen, $cindent) = line_stats($ctx);
3353 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3354 $indent != $cindent) {
3355 $err .= "$sep$ctx\n";
3362 ERROR("SWITCH_CASE_INDENT_LEVEL",
3363 "switch and case should be at the same indent\n$hereline$err");
3367 # if/while/etc brace do not go on next line, unless defining a do while loop,
3368 # or if that brace on the next line is for something else
3369 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3370 my $pre_ctx = "$1$2";
3372 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3374 if ($line =~ /^\+\t{6,}/) {
3375 WARN("DEEP_INDENTATION",
3376 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3379 my $ctx_cnt = $realcnt - $#ctx - 1;
3380 my $ctx = join("\n", @ctx);
3382 my $ctx_ln = $linenr;
3383 my $ctx_skip = $realcnt;
3385 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3386 defined $lines[$ctx_ln - 1] &&
3387 $lines[$ctx_ln - 1] =~ /^-/)) {
3388 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3389 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3393 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3394 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3396 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3398 "that open brace { should be on the previous line\n" .
3399 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3401 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3402 $ctx =~ /\)\s*\;\s*$/ &&
3403 defined $lines[$ctx_ln - 1])
3405 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3406 if ($nindent > $indent) {
3407 WARN("TRAILING_SEMICOLON",
3408 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3409 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3414 # Check relative indent for conditionals and blocks.
3415 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3416 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3417 ctx_statement_block($linenr, $realcnt, 0)
3418 if (!defined $stat);
3419 my ($s, $c) = ($stat, $cond);
3421 substr($s, 0, length($c), '');
3423 # remove inline comments
3427 # Find out how long the conditional actually is.
3428 my @newlines = ($c =~ /\n/gs);
3429 my $cond_lines = 1 + $#newlines;
3431 # Make sure we remove the line prefixes as we have
3432 # none on the first line, and are going to readd them
3435 while ($s =~ /\n\s+\\\n/) {
3436 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3439 # We want to check the first line inside the block
3440 # starting at the end of the conditional, so remove:
3441 # 1) any blank line termination
3442 # 2) any opening brace { on end of the line
3444 my $continuation = 0;
3446 $s =~ s/^.*\bdo\b//;
3448 if ($s =~ s/^\s*\\//) {
3451 if ($s =~ s/^\s*?\n//) {
3456 # Also ignore a loop construct at the end of a
3457 # preprocessor statement.
3458 if (($prevline =~ /^.\s*#\s*define\s/ ||
3459 $prevline =~ /\\\s*$/) && $continuation == 0) {
3465 while ($cond_ptr != $cond_lines) {
3466 $cond_ptr = $cond_lines;
3468 # If we see an #else/#elif then the code
3470 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3475 # 1) blank lines, they should be at 0,
3476 # 2) preprocessor lines, and
3478 if ($continuation ||
3480 $s =~ /^\s*#\s*?/ ||
3481 $s =~ /^\s*$Ident\s*:/) {
3482 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3483 if ($s =~ s/^.*?\n//) {
3489 my (undef, $sindent) = line_stats("+" . $s);
3490 my $stat_real = raw_line($linenr, $cond_lines);
3492 # Check if either of these lines are modified, else
3493 # this is not this patch's fault.
3494 if (!defined($stat_real) ||
3495 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3498 if (defined($stat_real) && $cond_lines > 1) {
3499 $stat_real = "[...]\n$stat_real";
3502 #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";
3504 if ($check && $s ne '' &&
3505 (($sindent % 8) != 0 ||
3506 ($sindent < $indent) ||
3507 ($sindent == $indent &&
3508 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
3509 ($sindent > $indent + 8))) {
3510 WARN("SUSPECT_CODE_INDENT",
3511 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3515 # Track the 'values' across context and added lines.
3516 my $opline = $line; $opline =~ s/^./ /;
3517 my ($curr_values, $curr_vars) =
3518 annotate_values($opline . "\n", $prev_values);
3519 $curr_values = $prev_values . $curr_values;
3521 my $outline = $opline; $outline =~ s/\t/ /g;
3522 print "$linenr > .$outline\n";
3523 print "$linenr > $curr_values\n";
3524 print "$linenr > $curr_vars\n";
3526 $prev_values = substr($curr_values, -1);
3528 #ignore lines not being added
3529 next if ($line =~ /^[^\+]/);
3531 # check for dereferences that span multiple lines
3532 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3533 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3534 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3536 $line =~ /^.\s*($Lval)/;
3539 WARN("MULTILINE_DEREFERENCE",
3540 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3543 # check for declarations of signed or unsigned without int
3544 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3547 $var = "" if (!defined $var);
3548 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3552 $pointer = "" if (!defined $pointer);
3554 if (WARN("UNSPECIFIED_INT",
3555 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3557 my $decl = trim($sign) . " int ";
3558 my $comp_pointer = $pointer;
3559 $comp_pointer =~ s/\s//g;
3560 $decl .= $comp_pointer;
3561 $decl = rtrim($decl) if ($var eq "");
3562 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3567 # TEST: allow direct testing of the type matcher.
3569 if ($line =~ /^.\s*$Declare\s*$/) {
3571 "TEST: is type\n" . $herecurr);
3572 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3573 ERROR("TEST_NOT_TYPE",
3574 "TEST: is not type ($1 is)\n". $herecurr);
3578 # TEST: allow direct testing of the attribute matcher.
3580 if ($line =~ /^.\s*$Modifier\s*$/) {
3582 "TEST: is attr\n" . $herecurr);
3583 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3584 ERROR("TEST_NOT_ATTR",
3585 "TEST: is not attr ($1 is)\n". $herecurr);
3590 # check for initialisation to aggregates open brace on the next line
3591 if ($line =~ /^.\s*{/ &&
3592 $prevline =~ /(?:^|[^=])=\s*$/) {
3593 if (ERROR("OPEN_BRACE",
3594 "that open brace { should be on the previous line\n" . $hereprev) &&
3595 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3596 fix_delete_line($fixlinenr - 1, $prevrawline);
3597 fix_delete_line($fixlinenr, $rawline);
3598 my $fixedline = $prevrawline;
3599 $fixedline =~ s/\s*=\s*$/ = {/;
3600 fix_insert_line($fixlinenr, $fixedline);
3602 $fixedline =~ s/^(.\s*)\{\s*/$1/;
3603 fix_insert_line($fixlinenr, $fixedline);
3608 # Checks which are anchored on the added line.
3611 # check for malformed paths in #include statements (uses RAW line)
3612 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3614 if ($path =~ m{//}) {
3615 ERROR("MALFORMED_INCLUDE",
3616 "malformed #include filename\n" . $herecurr);
3618 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3619 ERROR("UAPI_INCLUDE",
3620 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3624 # no C99 // comments
3625 if ($line =~ m{//}) {
3626 if (ERROR("C99_COMMENTS",
3627 "do not use C99 // comments\n" . $herecurr) &&
3629 my $line = $fixed[$fixlinenr];
3630 if ($line =~ /\/\/(.*)$/) {
3631 my $comment = trim($1);
3632 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3636 # Remove C99 comments.
3638 $opline =~ s@//.*@@;
3640 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3641 # the whole statement.
3642 #print "APW <$lines[$realline_next - 1]>\n";
3643 if (defined $realline_next &&
3644 exists $lines[$realline_next - 1] &&
3645 !defined $suppress_export{$realline_next} &&
3646 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3647 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3648 # Handle definitions which produce identifiers with
3651 # EXPORT_SYMBOL(something_foo);
3653 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3654 $name =~ /^${Ident}_$2/) {
3655 #print "FOO C name<$name>\n";
3656 $suppress_export{$realline_next} = 1;
3658 } elsif ($stat !~ /(?:
3660 ^.DEFINE_$Ident\(\Q$name\E\)|
3661 ^.DECLARE_$Ident\(\Q$name\E\)|
3662 ^.LIST_HEAD\(\Q$name\E\)|
3663 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3664 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3666 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3667 $suppress_export{$realline_next} = 2;
3669 $suppress_export{$realline_next} = 1;
3672 if (!defined $suppress_export{$linenr} &&
3673 $prevline =~ /^.\s*$/ &&
3674 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3675 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3676 #print "FOO B <$lines[$linenr - 1]>\n";
3677 $suppress_export{$linenr} = 2;
3679 if (defined $suppress_export{$linenr} &&
3680 $suppress_export{$linenr} == 2) {
3681 WARN("EXPORT_SYMBOL",
3682 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3685 # check for global initialisers.
3686 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3687 if (ERROR("GLOBAL_INITIALISERS",
3688 "do not initialise globals to $1\n" . $herecurr) &&
3690 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3693 # check for static initialisers.
3694 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3695 if (ERROR("INITIALISED_STATIC",
3696 "do not initialise statics to $1\n" .
3699 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3703 # check for misordered declarations of char/short/int/long with signed/unsigned
3704 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3706 WARN("MISORDERED_TYPE",
3707 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3710 # check for static const char * arrays.
3711 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3712 WARN("STATIC_CONST_CHAR_ARRAY",
3713 "static const char * array should probably be static const char * const\n" .
3717 # check for static char foo[] = "bar" declarations.
3718 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3719 WARN("STATIC_CONST_CHAR_ARRAY",
3720 "static char array declaration should probably be static const char\n" .
3724 # check for const <foo> const where <foo> is not a pointer or array type
3725 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3727 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3729 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3730 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3732 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3736 # check for non-global char *foo[] = {"bar", ...} declarations.
3737 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3738 WARN("STATIC_CONST_CHAR_ARRAY",
3739 "char * array declaration might be better as static const\n" .
3743 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3744 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3746 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3748 if (WARN("ARRAY_SIZE",
3749 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3751 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3756 # check for function declarations without arguments like "int foo()"
3757 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3758 if (ERROR("FUNCTION_WITHOUT_ARGS",
3759 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3761 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3765 # check for new typedefs, only function parameters and sparse annotations
3767 if ($line =~ /\btypedef\s/ &&
3768 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3769 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3770 $line !~ /\b$typeTypedefs\b/ &&
3771 $line !~ /\b__bitwise\b/) {
3772 WARN("NEW_TYPEDEFS",
3773 "do not add new typedefs\n" . $herecurr);
3776 # * goes on variable not on type
3778 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3780 my ($ident, $from, $to) = ($1, $2, $2);
3782 # Should start with a space.
3783 $to =~ s/^(\S)/ $1/;
3784 # Should not end with a space.
3786 # '*'s should not have spaces between.
3787 while ($to =~ s/\*\s+\*/\*\*/) {
3790 ## print "1: from<$from> to<$to> ident<$ident>\n";
3792 if (ERROR("POINTER_LOCATION",
3793 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3795 my $sub_from = $ident;
3796 my $sub_to = $ident;
3797 $sub_to =~ s/\Q$from\E/$to/;
3798 $fixed[$fixlinenr] =~
3799 s@\Q$sub_from\E@$sub_to@;
3803 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3805 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3807 # Should start with a space.
3808 $to =~ s/^(\S)/ $1/;
3809 # Should not end with a space.
3811 # '*'s should not have spaces between.
3812 while ($to =~ s/\*\s+\*/\*\*/) {
3814 # Modifiers should have spaces.
3815 $to =~ s/(\b$Modifier$)/$1 /;
3817 ## print "2: from<$from> to<$to> ident<$ident>\n";
3818 if ($from ne $to && $ident !~ /^$Modifier$/) {
3819 if (ERROR("POINTER_LOCATION",
3820 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3823 my $sub_from = $match;
3824 my $sub_to = $match;
3825 $sub_to =~ s/\Q$from\E/$to/;
3826 $fixed[$fixlinenr] =~
3827 s@\Q$sub_from\E@$sub_to@;
3832 # avoid BUG() or BUG_ON()
3833 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3834 my $msg_level = \&WARN;
3835 $msg_level = \&CHK if ($file);
3836 &{$msg_level}("AVOID_BUG",
3837 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3840 # avoid LINUX_VERSION_CODE
3841 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3842 WARN("LINUX_VERSION_CODE",
3843 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3846 # check for uses of printk_ratelimit
3847 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3848 WARN("PRINTK_RATELIMITED",
3849 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3852 # printk should use KERN_* levels
3853 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
3854 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3855 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
3858 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3860 my $level = lc($orig);
3861 $level = "warn" if ($level eq "warning");
3862 my $level2 = $level;
3863 $level2 = "dbg" if ($level eq "debug");
3864 WARN("PREFER_PR_LEVEL",
3865 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3868 if ($line =~ /\bpr_warning\s*\(/) {
3869 if (WARN("PREFER_PR_LEVEL",
3870 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3872 $fixed[$fixlinenr] =~
3873 s/\bpr_warning\b/pr_warn/;
3877 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3879 my $level = lc($orig);
3880 $level = "warn" if ($level eq "warning");
3881 $level = "dbg" if ($level eq "debug");
3882 WARN("PREFER_DEV_LEVEL",
3883 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3886 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
3887 # number of false positives, but assembly files are not checked, so at
3888 # least the arch entry code will not trigger this warning.
3889 if ($line =~ /\bENOSYS\b/) {
3891 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3894 # function brace can't be on same line, except for #defines of do while,
3895 # or if closed on same line
3896 if ($^V && $^V ge 5.10.0 &&
3897 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
3898 $sline !~ /\#\s*define\b.*do\s*\{/ &&
3900 if (ERROR("OPEN_BRACE",
3901 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
3903 fix_delete_line($fixlinenr, $rawline);
3904 my $fixed_line = $rawline;
3905 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3908 fix_insert_line($fixlinenr, ltrim($line1));
3909 fix_insert_line($fixlinenr, "\+{");
3910 if ($line2 !~ /^\s*$/) {
3911 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3916 # open braces for enum, union and struct go on the same line.
3917 if ($line =~ /^.\s*{/ &&
3918 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3919 if (ERROR("OPEN_BRACE",
3920 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3921 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3922 fix_delete_line($fixlinenr - 1, $prevrawline);
3923 fix_delete_line($fixlinenr, $rawline);
3924 my $fixedline = rtrim($prevrawline) . " {";
3925 fix_insert_line($fixlinenr, $fixedline);
3926 $fixedline = $rawline;
3927 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
3928 if ($fixedline !~ /^\+\s*$/) {
3929 fix_insert_line($fixlinenr, $fixedline);
3934 # missing space after union, struct or enum definition
3935 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3937 "missing space after $1 definition\n" . $herecurr) &&
3939 $fixed[$fixlinenr] =~
3940 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3944 # Function pointer declarations
3945 # check spacing between type, funcptr, and args
3946 # canonical declaration is "type (*funcptr)(args...)"
3947 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3949 my $pre_pointer_space = $2;
3950 my $post_pointer_space = $3;
3952 my $post_funcname_space = $5;
3953 my $pre_args_space = $6;
3955 # the $Declare variable will capture all spaces after the type
3956 # so check it for a missing trailing missing space but pointer return types
3957 # don't need a space so don't warn for those.
3958 my $post_declare_space = "";
3959 if ($declare =~ /(\s+)$/) {
3960 $post_declare_space = $1;
3961 $declare = rtrim($declare);
3963 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3965 "missing space after return type\n" . $herecurr);
3966 $post_declare_space = " ";
3969 # unnecessary space "type (*funcptr)(args...)"
3970 # This test is not currently implemented because these declarations are
3972 # int foo(int bar, ...)
3973 # and this is form shouldn't/doesn't generate a checkpatch warning.
3975 # elsif ($declare =~ /\s{2,}$/) {
3977 # "Multiple spaces after return type\n" . $herecurr);
3980 # unnecessary space "type ( *funcptr)(args...)"
3981 if (defined $pre_pointer_space &&
3982 $pre_pointer_space =~ /^\s/) {
3984 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3987 # unnecessary space "type (* funcptr)(args...)"
3988 if (defined $post_pointer_space &&
3989 $post_pointer_space =~ /^\s/) {
3991 "Unnecessary space before function pointer name\n" . $herecurr);
3994 # unnecessary space "type (*funcptr )(args...)"
3995 if (defined $post_funcname_space &&
3996 $post_funcname_space =~ /^\s/) {
3998 "Unnecessary space after function pointer name\n" . $herecurr);
4001 # unnecessary space "type (*funcptr) (args...)"
4002 if (defined $pre_args_space &&
4003 $pre_args_space =~ /^\s/) {
4005 "Unnecessary space before function pointer arguments\n" . $herecurr);
4008 if (show_type("SPACING") && $fix) {
4009 $fixed[$fixlinenr] =~
4010 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4014 # check for spacing round square brackets; allowed:
4015 # 1. with a type on the left -- int [] a;
4016 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4017 # 3. inside a curly brace -- = { [0...10] = 5 }
4018 while ($line =~ /(.*?\s)\[/g) {
4019 my ($where, $prefix) = ($-[1], $1);
4020 if ($prefix !~ /$Type\s+$/ &&
4021 ($where != 0 || $prefix !~ /^.\s+$/) &&
4022 $prefix !~ /[{,]\s+$/) {
4023 if (ERROR("BRACKET_SPACE",
4024 "space prohibited before open square bracket '['\n" . $herecurr) &&
4026 $fixed[$fixlinenr] =~
4027 s/^(\+.*?)\s+\[/$1\[/;
4032 # check for spaces between functions and their parentheses.
4033 while ($line =~ /($Ident)\s+\(/g) {
4035 my $ctx_before = substr($line, 0, $-[1]);
4036 my $ctx = "$ctx_before$name";
4038 # Ignore those directives where spaces _are_ permitted.
4040 if|for|while|switch|return|case|
4041 volatile|__volatile__|
4042 __attribute__|format|__extension__|
4045 # cpp #define statements have non-optional spaces, ie
4046 # if there is a space between the name and the open
4047 # parenthesis it is simply not a parameter group.
4048 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4050 # cpp #elif statement condition may start with a (
4051 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4053 # If this whole things ends with a type its most
4054 # likely a typedef for a function.
4055 } elsif ($ctx =~ /$Type$/) {
4059 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4061 $fixed[$fixlinenr] =~
4062 s/\b$name\s+\(/$name\(/;
4067 # Check operator spacing.
4068 if (!($line=~/\#\s*include/)) {
4069 my $fixed_line = "";
4073 <<=|>>=|<=|>=|==|!=|
4074 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4075 =>|->|<<|>>|<|>|=|!|~|
4076 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4079 my @elements = split(/($ops|;)/, $opline);
4081 ## print("element count: <" . $#elements . ">\n");
4082 ## foreach my $el (@elements) {
4083 ## print("el: <$el>\n");
4086 my @fix_elements = ();
4089 foreach my $el (@elements) {
4090 push(@fix_elements, substr($rawline, $off, length($el)));
4091 $off += length($el);
4096 my $blank = copy_spacing($opline);
4097 my $last_after = -1;
4099 for (my $n = 0; $n < $#elements; $n += 2) {
4101 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4103 ## print("n: <$n> good: <$good>\n");
4105 $off += length($elements[$n]);
4107 # Pick up the preceding and succeeding characters.
4108 my $ca = substr($opline, 0, $off);
4110 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4111 $cc = substr($opline, $off + length($elements[$n + 1]));
4113 my $cb = "$ca$;$cc";
4116 $a = 'V' if ($elements[$n] ne '');
4117 $a = 'W' if ($elements[$n] =~ /\s$/);
4118 $a = 'C' if ($elements[$n] =~ /$;$/);
4119 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4120 $a = 'O' if ($elements[$n] eq '');
4121 $a = 'E' if ($ca =~ /^\s*$/);
4123 my $op = $elements[$n + 1];
4126 if (defined $elements[$n + 2]) {
4127 $c = 'V' if ($elements[$n + 2] ne '');
4128 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4129 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4130 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4131 $c = 'O' if ($elements[$n + 2] eq '');
4132 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4137 my $ctx = "${a}x${c}";
4139 my $at = "(ctx:$ctx)";
4141 my $ptr = substr($blank, 0, $off) . "^";
4142 my $hereptr = "$hereline$ptr\n";
4144 # Pull out the value of this operator.
4145 my $op_type = substr($curr_values, $off + 1, 1);
4147 # Get the full operator variant.
4148 my $opv = $op . substr($curr_vars, $off, 1);
4150 # Ignore operators passed as parameters.
4151 if ($op_type ne 'V' &&
4152 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4155 # } elsif ($op =~ /^$;+$/) {
4157 # ; should have either the end of line or a space or \ after it
4158 } elsif ($op eq ';') {
4159 if ($ctx !~ /.x[WEBC]/ &&
4160 $cc !~ /^\\/ && $cc !~ /^;/) {
4161 if (ERROR("SPACING",
4162 "space required after that '$op' $at\n" . $hereptr)) {
4163 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4169 } elsif ($op eq '//') {
4171 # : when part of a bitfield
4172 } elsif ($opv eq ':B') {
4173 # skip the bitfield test for now
4177 } elsif ($op eq '->') {
4178 if ($ctx =~ /Wx.|.xW/) {
4179 if (ERROR("SPACING",
4180 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4181 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4182 if (defined $fix_elements[$n + 2]) {
4183 $fix_elements[$n + 2] =~ s/^\s+//;
4189 # , must not have a space before and must have a space on the right.
4190 } elsif ($op eq ',') {
4191 my $rtrim_before = 0;
4192 my $space_after = 0;
4193 if ($ctx =~ /Wx./) {
4194 if (ERROR("SPACING",
4195 "space prohibited before that '$op' $at\n" . $hereptr)) {
4200 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4201 if (ERROR("SPACING",
4202 "space required after that '$op' $at\n" . $hereptr)) {
4208 if ($rtrim_before || $space_after) {
4209 if ($rtrim_before) {
4210 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4212 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4219 # '*' as part of a type definition -- reported already.
4220 } elsif ($opv eq '*_') {
4221 #warn "'*' is part of type\n";
4223 # unary operators should have a space before and
4224 # none after. May be left adjacent to another
4225 # unary operator, or a cast
4226 } elsif ($op eq '!' || $op eq '~' ||
4227 $opv eq '*U' || $opv eq '-U' ||
4228 $opv eq '&U' || $opv eq '&&U') {
4229 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4230 if (ERROR("SPACING",
4231 "space required before that '$op' $at\n" . $hereptr)) {
4232 if ($n != $last_after + 2) {
4233 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4238 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4239 # A unary '*' may be const
4241 } elsif ($ctx =~ /.xW/) {
4242 if (ERROR("SPACING",
4243 "space prohibited after that '$op' $at\n" . $hereptr)) {
4244 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4245 if (defined $fix_elements[$n + 2]) {
4246 $fix_elements[$n + 2] =~ s/^\s+//;
4252 # unary ++ and unary -- are allowed no space on one side.
4253 } elsif ($op eq '++' or $op eq '--') {
4254 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4255 if (ERROR("SPACING",
4256 "space required one side of that '$op' $at\n" . $hereptr)) {
4257 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4261 if ($ctx =~ /Wx[BE]/ ||
4262 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4263 if (ERROR("SPACING",
4264 "space prohibited before that '$op' $at\n" . $hereptr)) {
4265 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4269 if ($ctx =~ /ExW/) {
4270 if (ERROR("SPACING",
4271 "space prohibited after that '$op' $at\n" . $hereptr)) {
4272 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4273 if (defined $fix_elements[$n + 2]) {
4274 $fix_elements[$n + 2] =~ s/^\s+//;
4280 # << and >> may either have or not have spaces both sides
4281 } elsif ($op eq '<<' or $op eq '>>' or
4282 $op eq '&' or $op eq '^' or $op eq '|' or
4283 $op eq '+' or $op eq '-' or
4284 $op eq '*' or $op eq '/' or
4288 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4290 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4291 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4292 $fix_elements[$n + 2] =~ s/^\s+//;
4295 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4297 "space preferred before that '$op' $at\n" . $hereptr)) {
4298 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4302 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4303 if (ERROR("SPACING",
4304 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4305 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4306 if (defined $fix_elements[$n + 2]) {
4307 $fix_elements[$n + 2] =~ s/^\s+//;
4313 # A colon needs no spaces before when it is
4314 # terminating a case value or a label.
4315 } elsif ($opv eq ':C' || $opv eq ':L') {
4316 if ($ctx =~ /Wx./) {
4317 if (ERROR("SPACING",
4318 "space prohibited before that '$op' $at\n" . $hereptr)) {
4319 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4324 # All the others need spaces both sides.
4325 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4328 # Ignore email addresses <foo@bar>
4330 $cc =~ /^\S+\@\S+>/) ||
4332 $ca =~ /<\S+\@\S+$/))
4337 # for asm volatile statements
4338 # ignore a colon with another
4339 # colon immediately before or after
4341 ($ca =~ /:$/ || $cc =~ /^:/)) {
4345 # messages are ERROR, but ?: are CHK
4347 my $msg_level = \&ERROR;
4348 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4350 if (&{$msg_level}("SPACING",
4351 "spaces required around that '$op' $at\n" . $hereptr)) {
4352 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4353 if (defined $fix_elements[$n + 2]) {
4354 $fix_elements[$n + 2] =~ s/^\s+//;
4360 $off += length($elements[$n + 1]);
4362 ## print("n: <$n> GOOD: <$good>\n");
4364 $fixed_line = $fixed_line . $good;
4367 if (($#elements % 2) == 0) {
4368 $fixed_line = $fixed_line . $fix_elements[$#elements];
4371 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4372 $fixed[$fixlinenr] = $fixed_line;
4378 # check for whitespace before a non-naked semicolon
4379 if ($line =~ /^\+.*\S\s+;\s*$/) {
4381 "space prohibited before semicolon\n" . $herecurr) &&
4383 1 while $fixed[$fixlinenr] =~
4384 s/^(\+.*\S)\s+;/$1;/;
4388 # check for multiple assignments
4389 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4390 CHK("MULTIPLE_ASSIGNMENTS",
4391 "multiple assignments should be avoided\n" . $herecurr);
4394 ## # check for multiple declarations, allowing for a function declaration
4396 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4397 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4399 ## # Remove any bracketed sections to ensure we do not
4400 ## # falsly report the parameters of functions.
4402 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4404 ## if ($ln =~ /,/) {
4405 ## WARN("MULTIPLE_DECLARATION",
4406 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4410 #need space before brace following if, while, etc
4411 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4413 if (ERROR("SPACING",
4414 "space required before the open brace '{'\n" . $herecurr) &&
4416 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
4420 ## # check for blank lines before declarations
4421 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4422 ## $prevrawline =~ /^.\s*$/) {
4424 ## "No blank lines before declarations\n" . $hereprev);
4428 # closing brace should have a space following it when it has anything
4430 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4431 if (ERROR("SPACING",
4432 "space required after that close brace '}'\n" . $herecurr) &&
4434 $fixed[$fixlinenr] =~
4435 s/}((?!(?:,|;|\)))\S)/} $1/;
4439 # check spacing on square brackets
4440 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4441 if (ERROR("SPACING",
4442 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4444 $fixed[$fixlinenr] =~
4448 if ($line =~ /\s\]/) {
4449 if (ERROR("SPACING",
4450 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4452 $fixed[$fixlinenr] =~
4457 # check spacing on parentheses
4458 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4459 $line !~ /for\s*\(\s+;/) {
4460 if (ERROR("SPACING",
4461 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4463 $fixed[$fixlinenr] =~
4467 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4468 $line !~ /for\s*\(.*;\s+\)/ &&
4469 $line !~ /:\s+\)/) {
4470 if (ERROR("SPACING",
4471 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4473 $fixed[$fixlinenr] =~
4478 # check unnecessary parentheses around addressof/dereference single $Lvals
4479 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4481 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4483 if (CHK("UNNECESSARY_PARENTHESES",
4484 "Unnecessary parentheses around $var\n" . $herecurr) &&
4486 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4490 # check for unnecessary parentheses around function pointer uses
4491 # ie: (foo->bar)(); should be foo->bar();
4492 # but not "if (foo->bar) (" to avoid some false positives
4493 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4495 if (CHK("UNNECESSARY_PARENTHESES",
4496 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4498 my $var2 = deparenthesize($var);
4500 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4504 # check for unnecessary parentheses around comparisons in if uses
4505 # when !drivers/staging or command-line uses --strict
4506 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
4507 $^V && $^V ge 5.10.0 && defined($stat) &&
4508 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
4510 my $test = substr($2, 1, -1);
4512 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
4514 # avoid parentheses around potential macro args
4515 next if ($match =~ /^\s*\w+\s*$/);
4516 if (!defined($herectx)) {
4517 $herectx = $here . "\n";
4518 my $cnt = statement_rawlines($if_stat);
4519 for (my $n = 0; $n < $cnt; $n++) {
4520 my $rl = raw_line($linenr, $n);
4521 $herectx .= $rl . "\n";
4522 last if $rl =~ /^[ \+].*\{/;
4525 CHK("UNNECESSARY_PARENTHESES",
4526 "Unnecessary parentheses around '$match'\n" . $herectx);
4530 #goto labels aren't indented, allow a single space however
4531 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4532 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4533 if (WARN("INDENTED_LABEL",
4534 "labels should not be indented\n" . $herecurr) &&
4536 $fixed[$fixlinenr] =~
4541 # return is not a function
4542 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4544 if ($^V && $^V ge 5.10.0 &&
4545 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4547 $value = deparenthesize($value);
4548 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4549 ERROR("RETURN_PARENTHESES",
4550 "return is not a function, parentheses are not required\n" . $herecurr);
4552 } elsif ($spacing !~ /\s+/) {
4554 "space required before the open parenthesis '('\n" . $herecurr);
4558 # unnecessary return in a void function
4559 # at end-of-function, with the previous line a single leading tab, then return;
4560 # and the line before that not a goto label target like "out:"
4561 if ($sline =~ /^[ \+]}\s*$/ &&
4562 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4564 $lines[$linenr - 3] =~ /^[ +]/ &&
4565 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4567 "void function return statements are not generally useful\n" . $hereprev);
4570 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4571 if ($^V && $^V ge 5.10.0 &&
4572 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4573 my $openparens = $1;
4574 my $count = $openparens =~ tr@\(@\(@;
4576 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4577 my $comp = $4; #Not $1 because of $LvalOrFunc
4578 $msg = " - maybe == should be = ?" if ($comp eq "==");
4579 WARN("UNNECESSARY_PARENTHESES",
4580 "Unnecessary parentheses$msg\n" . $herecurr);
4584 # comparisons with a constant or upper case identifier on the left
4585 # avoid cases like "foo + BAR < baz"
4586 # only fix matches surrounded by parentheses to avoid incorrect
4587 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4588 if ($^V && $^V ge 5.10.0 &&
4589 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4594 my $newcomp = $comp;
4595 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4596 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4597 WARN("CONSTANT_COMPARISON",
4598 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4602 } elsif ($comp eq "<=") {
4604 } elsif ($comp eq ">") {
4606 } elsif ($comp eq ">=") {
4609 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4613 # Return of what appears to be an errno should normally be negative
4614 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4616 if ($name ne 'EOF' && $name ne 'ERROR') {
4617 WARN("USE_NEGATIVE_ERRNO",
4618 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4622 # Need a space before open parenthesis after if, while etc
4623 if ($line =~ /\b(if|while|for|switch)\(/) {
4624 if (ERROR("SPACING",
4625 "space required before the open parenthesis '('\n" . $herecurr) &&
4627 $fixed[$fixlinenr] =~
4628 s/\b(if|while|for|switch)\(/$1 \(/;
4632 # Check for illegal assignment in if conditional -- and check for trailing
4633 # statements after the conditional.
4634 if ($line =~ /do\s*(?!{)/) {
4635 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4636 ctx_statement_block($linenr, $realcnt, 0)
4637 if (!defined $stat);
4638 my ($stat_next) = ctx_statement_block($line_nr_next,
4639 $remain_next, $off_next);
4640 $stat_next =~ s/\n./\n /g;
4641 ##print "stat<$stat> stat_next<$stat_next>\n";
4643 if ($stat_next =~ /^\s*while\b/) {
4644 # If the statement carries leading newlines,
4645 # then count those as offsets.
4647 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4649 statement_rawlines($whitespace) - 1;
4651 $suppress_whiletrailers{$line_nr_next +
4655 if (!defined $suppress_whiletrailers{$linenr} &&
4656 defined($stat) && defined($cond) &&
4657 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4658 my ($s, $c) = ($stat, $cond);
4660 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4661 ERROR("ASSIGN_IN_IF",
4662 "do not use assignment in if condition\n" . $herecurr);
4665 # Find out what is on the end of the line after the
4667 substr($s, 0, length($c), '');
4669 $s =~ s/$;//g; # Remove any comments
4670 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4671 $c !~ /}\s*while\s*/)
4673 # Find out how long the conditional actually is.
4674 my @newlines = ($c =~ /\n/gs);
4675 my $cond_lines = 1 + $#newlines;
4678 $stat_real = raw_line($linenr, $cond_lines)
4679 . "\n" if ($cond_lines);
4680 if (defined($stat_real) && $cond_lines > 1) {
4681 $stat_real = "[...]\n$stat_real";
4684 ERROR("TRAILING_STATEMENTS",
4685 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4689 # Check for bitwise tests written as boolean
4701 WARN("HEXADECIMAL_BOOLEAN_TEST",
4702 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4705 # if and else should not have general statements after it
4706 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4708 $s =~ s/$;//g; # Remove any comments
4709 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4710 ERROR("TRAILING_STATEMENTS",
4711 "trailing statements should be on next line\n" . $herecurr);
4714 # if should not continue a brace
4715 if ($line =~ /}\s*if\b/) {
4716 ERROR("TRAILING_STATEMENTS",
4717 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4720 # case and default should not have general statements after them
4721 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4723 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4727 ERROR("TRAILING_STATEMENTS",
4728 "trailing statements should be on next line\n" . $herecurr);
4731 # Check for }<nl>else {, these must be at the same
4732 # indent level to be relevant to each other.
4733 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4734 $previndent == $indent) {
4735 if (ERROR("ELSE_AFTER_BRACE",
4736 "else should follow close brace '}'\n" . $hereprev) &&
4737 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4738 fix_delete_line($fixlinenr - 1, $prevrawline);
4739 fix_delete_line($fixlinenr, $rawline);
4740 my $fixedline = $prevrawline;
4741 $fixedline =~ s/}\s*$//;
4742 if ($fixedline !~ /^\+\s*$/) {
4743 fix_insert_line($fixlinenr, $fixedline);
4745 $fixedline = $rawline;
4746 $fixedline =~ s/^(.\s*)else/$1} else/;
4747 fix_insert_line($fixlinenr, $fixedline);
4751 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4752 $previndent == $indent) {
4753 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4755 # Find out what is on the end of the line after the
4757 substr($s, 0, length($c), '');
4760 if ($s =~ /^\s*;/) {
4761 if (ERROR("WHILE_AFTER_BRACE",
4762 "while should follow close brace '}'\n" . $hereprev) &&
4763 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4764 fix_delete_line($fixlinenr - 1, $prevrawline);
4765 fix_delete_line($fixlinenr, $rawline);
4766 my $fixedline = $prevrawline;
4767 my $trailing = $rawline;
4768 $trailing =~ s/^\+//;
4769 $trailing = trim($trailing);
4770 $fixedline =~ s/}\s*$/} $trailing/;
4771 fix_insert_line($fixlinenr, $fixedline);
4776 #Specific variable tests
4777 while ($line =~ m{($Constant|$Lval)}g) {
4780 #gcc binary extension
4781 if ($var =~ /^$Binary$/) {
4782 if (WARN("GCC_BINARY_CONSTANT",
4783 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4785 my $hexval = sprintf("0x%x", oct($var));
4786 $fixed[$fixlinenr] =~
4787 s/\b$var\b/$hexval/;
4792 if ($var !~ /^$Constant$/ &&
4793 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4794 #Ignore Page<foo> variants
4795 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4796 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4797 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4798 #Ignore some three character SI units explicitly, like MiB and KHz
4799 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4800 while ($var =~ m{($Ident)}g) {
4802 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4804 seed_camelcase_includes();
4805 if (!$file && !$camelcase_file_seeded) {
4806 seed_camelcase_file($realfile);
4807 $camelcase_file_seeded = 1;
4810 if (!defined $camelcase{$word}) {
4811 $camelcase{$word} = 1;
4813 "Avoid CamelCase: <$word>\n" . $herecurr);
4819 #no spaces allowed after \ in define
4820 if ($line =~ /\#\s*define.*\\\s+$/) {
4821 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4822 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4824 $fixed[$fixlinenr] =~ s/\s+$//;
4828 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4829 # itself <asm/foo.h> (uses RAW line)
4830 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4832 my $checkfile = "include/linux/$file";
4833 if (-f "$root/$checkfile" &&
4834 $realfile ne $checkfile &&
4835 $1 !~ /$allowed_asm_includes/)
4837 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4838 if ($asminclude > 0) {
4839 if ($realfile =~ m{^arch/}) {
4840 CHK("ARCH_INCLUDE_LINUX",
4841 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4843 WARN("INCLUDE_LINUX",
4844 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4850 # multi-statement macros should be enclosed in a do while loop, grab the
4851 # first statement and ensure its the whole macro if its not enclosed
4852 # in a known good container
4853 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4854 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4857 my ($off, $dstat, $dcond, $rest);
4859 my $has_flow_statement = 0;
4860 my $has_arg_concat = 0;
4861 ($dstat, $dcond, $ln, $cnt, $off) =
4862 ctx_statement_block($linenr, $realcnt, 0);
4864 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4865 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4867 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4868 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4870 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4871 my $define_args = $1;
4872 my $define_stmt = $dstat;
4875 if (defined $define_args && $define_args ne "") {
4876 $define_args = substr($define_args, 1, length($define_args) - 2);
4877 $define_args =~ s/\s*//g;
4878 @def_args = split(",", $define_args);
4882 $dstat =~ s/\\\n.//g;
4883 $dstat =~ s/^\s*//s;
4884 $dstat =~ s/\s*$//s;
4886 # Flatten any parentheses and braces
4887 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4888 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4889 $dstat =~ s/.\[[^\[\]]*\]/1/)
4893 # Flatten any obvious string concatentation.
4894 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4895 $dstat =~ s/$Ident\s*($String)/$1/)
4899 # Make asm volatile uses seem like a generic function
4900 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4902 my $exceptions = qr{
4915 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4918 my $herectx = $here . "\n";
4919 my $stmt_cnt = statement_rawlines($ctx);
4921 for (my $n = 0; $n < $stmt_cnt; $n++) {
4922 $herectx .= raw_line($linenr, $n) . "\n";
4926 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4927 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4928 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4929 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4930 $dstat !~ /$exceptions/ &&
4931 $dstat !~ /^\.$Ident\s*=/ && # .foo =
4932 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4933 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4934 $dstat !~ /^for\s*$Constant$/ && # for (...)
4935 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4936 $dstat !~ /^do\s*{/ && # do {...
4937 $dstat !~ /^\(\{/ && # ({...
4938 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4940 if ($dstat =~ /^\s*if\b/) {
4941 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4942 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
4943 } elsif ($dstat =~ /;/) {
4944 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4945 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4947 ERROR("COMPLEX_MACRO",
4948 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4953 # Make $define_stmt single line, comment-free, etc
4954 my @stmt_array = split('\n', $define_stmt);
4957 foreach my $l (@stmt_array) {
4962 } elsif ($l =~ /^[\+ ]/) {
4963 $define_stmt .= substr($l, 1);
4966 $define_stmt =~ s/$;//g;
4967 $define_stmt =~ s/\s+/ /g;
4968 $define_stmt = trim($define_stmt);
4970 # check if any macro arguments are reused (ignore '...' and 'type')
4971 foreach my $arg (@def_args) {
4972 next if ($arg =~ /\.\.\./);
4973 next if ($arg =~ /^type$/i);
4974 my $tmp_stmt = $define_stmt;
4975 $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
4976 $tmp_stmt =~ s/\#+\s*$arg\b//g;
4977 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
4978 my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
4980 CHK("MACRO_ARG_REUSE",
4981 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
4983 # check if any macro arguments may have other precedence issues
4984 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
4985 ((defined($1) && $1 ne ',') ||
4986 (defined($2) && $2 ne ','))) {
4987 CHK("MACRO_ARG_PRECEDENCE",
4988 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
4992 # check for macros with flow control, but without ## concatenation
4993 # ## concatenation is commonly a macro that defines a function so ignore those
4994 if ($has_flow_statement && !$has_arg_concat) {
4995 my $herectx = $here . "\n";
4996 my $cnt = statement_rawlines($ctx);
4998 for (my $n = 0; $n < $cnt; $n++) {
4999 $herectx .= raw_line($linenr, $n) . "\n";
5001 WARN("MACRO_WITH_FLOW_CONTROL",
5002 "Macros with flow control statements should be avoided\n" . "$herectx");
5005 # check for line continuations outside of #defines, preprocessor #, and asm
5008 if ($prevline !~ /^..*\\$/ &&
5009 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
5010 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
5011 $line =~ /^\+.*\\$/) {
5012 WARN("LINE_CONTINUATIONS",
5013 "Avoid unnecessary line continuations\n" . $herecurr);
5017 # do {} while (0) macro tests:
5018 # single-statement macros do not need to be enclosed in do while (0) loop,
5019 # macro should not end with a semicolon
5020 if ($^V && $^V ge 5.10.0 &&
5021 $realfile !~ m@/vmlinux.lds.h$@ &&
5022 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5025 my ($off, $dstat, $dcond, $rest);
5027 ($dstat, $dcond, $ln, $cnt, $off) =
5028 ctx_statement_block($linenr, $realcnt, 0);
5031 $dstat =~ s/\\\n.//g;
5034 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5039 my $cnt = statement_rawlines($ctx);
5040 my $herectx = $here . "\n";
5042 for (my $n = 0; $n < $cnt; $n++) {
5043 $herectx .= raw_line($linenr, $n) . "\n";
5046 if (($stmts =~ tr/;/;/) == 1 &&
5047 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5048 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5049 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5051 if (defined $semis && $semis ne "") {
5052 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5053 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5055 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5057 my $cnt = statement_rawlines($ctx);
5058 my $herectx = $here . "\n";
5060 for (my $n = 0; $n < $cnt; $n++) {
5061 $herectx .= raw_line($linenr, $n) . "\n";
5064 WARN("TRAILING_SEMICOLON",
5065 "macros should not use a trailing semicolon\n" . "$herectx");
5069 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
5070 # all assignments may have only one of the following with an assignment:
5073 # VMLINUX_SYMBOL(...)
5074 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
5075 WARN("MISSING_VMLINUX_SYMBOL",
5076 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
5079 # check for redundant bracing round if etc
5080 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5081 my ($level, $endln, @chunks) =
5082 ctx_statement_full($linenr, $realcnt, 1);
5083 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5084 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5085 if ($#chunks > 0 && $level == 0) {
5089 my $herectx = $here . "\n";
5090 my $ln = $linenr - 1;
5091 for my $chunk (@chunks) {
5092 my ($cond, $block) = @{$chunk};
5094 # If the condition carries leading newlines, then count those as offsets.
5095 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5096 my $offset = statement_rawlines($whitespace) - 1;
5098 $allowed[$allow] = 0;
5099 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5101 # We have looked at and allowed this specific line.
5102 $suppress_ifbraces{$ln + $offset} = 1;
5104 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5105 $ln += statement_rawlines($block) - 1;
5107 substr($block, 0, length($cond), '');
5109 $seen++ if ($block =~ /^\s*{/);
5111 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5112 if (statement_lines($cond) > 1) {
5113 #print "APW: ALLOWED: cond<$cond>\n";
5114 $allowed[$allow] = 1;
5116 if ($block =~/\b(?:if|for|while)\b/) {
5117 #print "APW: ALLOWED: block<$block>\n";
5118 $allowed[$allow] = 1;
5120 if (statement_block_size($block) > 1) {
5121 #print "APW: ALLOWED: lines block<$block>\n";
5122 $allowed[$allow] = 1;
5127 my $sum_allowed = 0;
5128 foreach (@allowed) {
5131 if ($sum_allowed == 0) {
5133 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5134 } elsif ($sum_allowed != $allow &&
5137 "braces {} should be used on all arms of this statement\n" . $herectx);
5142 if (!defined $suppress_ifbraces{$linenr - 1} &&
5143 $line =~ /\b(if|while|for|else)\b/) {
5146 # Check the pre-context.
5147 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5148 #print "APW: ALLOWED: pre<$1>\n";
5152 my ($level, $endln, @chunks) =
5153 ctx_statement_full($linenr, $realcnt, $-[0]);
5155 # Check the condition.
5156 my ($cond, $block) = @{$chunks[0]};
5157 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5158 if (defined $cond) {
5159 substr($block, 0, length($cond), '');
5161 if (statement_lines($cond) > 1) {
5162 #print "APW: ALLOWED: cond<$cond>\n";
5165 if ($block =~/\b(?:if|for|while)\b/) {
5166 #print "APW: ALLOWED: block<$block>\n";
5169 if (statement_block_size($block) > 1) {
5170 #print "APW: ALLOWED: lines block<$block>\n";
5173 # Check the post-context.
5174 if (defined $chunks[1]) {
5175 my ($cond, $block) = @{$chunks[1]};
5176 if (defined $cond) {
5177 substr($block, 0, length($cond), '');
5179 if ($block =~ /^\s*\{/) {
5180 #print "APW: ALLOWED: chunk-1 block<$block>\n";
5184 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5185 my $herectx = $here . "\n";
5186 my $cnt = statement_rawlines($block);
5188 for (my $n = 0; $n < $cnt; $n++) {
5189 $herectx .= raw_line($linenr, $n) . "\n";
5193 "braces {} are not necessary for single statement blocks\n" . $herectx);
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 =~ /\\$/ && $sline =~ 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 for smp_read_barrier_depends and read_barrier_depends
5605 if (!$file && $line =~ /\b(smp_|)read_barrier_depends\s*\(/) {
5606 WARN("READ_BARRIER_DEPENDS",
5607 "$1read_barrier_depends should only be used in READ_ONCE or DEC Alpha code\n" . $herecurr);
5610 # check of hardware specific defines
5611 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5613 "architecture specific defines should be avoided\n" . $herecurr);
5616 # check that the storage class is not after a type
5617 if ($line =~ /\b($Type)\s+($Storage)\b/) {
5618 WARN("STORAGE_CLASS",
5619 "storage class '$2' should be located before type '$1'\n" . $herecurr);
5621 # Check that the storage class is at the beginning of a declaration
5622 if ($line =~ /\b$Storage\b/ &&
5623 $line !~ /^.\s*$Storage/ &&
5624 $line =~ /^.\s*(.+?)\$Storage\s/ &&
5625 $1 !~ /[\,\)]\s*$/) {
5626 WARN("STORAGE_CLASS",
5627 "storage class should be at the beginning of the declaration\n" . $herecurr);
5630 # check the location of the inline attribute, that it is between
5631 # storage class and type.
5632 if ($line =~ /\b$Type\s+$Inline\b/ ||
5633 $line =~ /\b$Inline\s+$Storage\b/) {
5634 ERROR("INLINE_LOCATION",
5635 "inline keyword should sit between storage class and type\n" . $herecurr);
5638 # Check for __inline__ and __inline, prefer inline
5639 if ($realfile !~ m@\binclude/uapi/@ &&
5640 $line =~ /\b(__inline__|__inline)\b/) {
5642 "plain inline is preferred over $1\n" . $herecurr) &&
5644 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5649 # Check for __attribute__ packed, prefer __packed
5650 if ($realfile !~ m@\binclude/uapi/@ &&
5651 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5652 WARN("PREFER_PACKED",
5653 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5656 # Check for __attribute__ aligned, prefer __aligned
5657 if ($realfile !~ m@\binclude/uapi/@ &&
5658 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5659 WARN("PREFER_ALIGNED",
5660 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5663 # Check for __attribute__ format(printf, prefer __printf
5664 if ($realfile !~ m@\binclude/uapi/@ &&
5665 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5666 if (WARN("PREFER_PRINTF",
5667 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5669 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5674 # Check for __attribute__ format(scanf, prefer __scanf
5675 if ($realfile !~ m@\binclude/uapi/@ &&
5676 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5677 if (WARN("PREFER_SCANF",
5678 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5680 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5684 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5685 if ($^V && $^V ge 5.10.0 &&
5686 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5687 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5688 $line =~ /\b__weak\b/)) {
5689 ERROR("WEAK_DECLARATION",
5690 "Using weak declarations can have unintended link defects\n" . $herecurr);
5693 # check for c99 types like uint8_t used outside of uapi/ and tools/
5694 if ($realfile !~ m@\binclude/uapi/@ &&
5695 $realfile !~ m@\btools/@ &&
5696 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5698 if ($type =~ /\b($typeC99Typedefs)\b/) {
5700 my $kernel_type = 'u';
5701 $kernel_type = 's' if ($type =~ /^_*[si]/);
5704 if (CHK("PREFER_KERNEL_TYPES",
5705 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5707 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5712 # check for cast of C90 native int or longer types constants
5713 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5716 if (WARN("TYPECAST_INT_CONSTANT",
5717 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5720 my $newconst = $const;
5721 $newconst =~ s/${Int_type}$//;
5722 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5723 if ($cast =~ /\blong\s+long\b/) {
5725 } elsif ($cast =~ /\blong\b/) {
5728 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5732 # check for sizeof(&)
5733 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5734 WARN("SIZEOF_ADDRESS",
5735 "sizeof(& should be avoided\n" . $herecurr);
5738 # check for sizeof without parenthesis
5739 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5740 if (WARN("SIZEOF_PARENTHESIS",
5741 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5743 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5747 # check for struct spinlock declarations
5748 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5749 WARN("USE_SPINLOCK_T",
5750 "struct spinlock should be spinlock_t\n" . $herecurr);
5753 # check for seq_printf uses that could be seq_puts
5754 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5755 my $fmt = get_quoted_string($line, $rawline);
5758 if (WARN("PREFER_SEQ_PUTS",
5759 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5761 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5766 # check for vsprintf extension %p<foo> misuses
5767 if ($^V && $^V ge 5.10.0 &&
5769 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
5770 $1 !~ /^_*volatile_*$/) {
5771 my $bad_extension = "";
5772 my $lc = $stat =~ tr@\n@@;
5773 $lc = $lc + $linenr;
5774 for (my $count = $linenr; $count <= $lc; $count++) {
5775 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
5777 if ($fmt =~ /(\%[\*\d\.]*p(?![\WSsBKRraEhMmIiUDdgVCbGNOx]).)/) {
5778 $bad_extension = $1;
5782 if ($bad_extension ne "") {
5783 my $stat_real = raw_line($linenr, 0);
5784 my $ext_type = "Invalid";
5786 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5787 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5789 if ($bad_extension =~ /p[Ff]/) {
5790 $ext_type = "Deprecated";
5791 $use = " - use %pS instead";
5792 $use =~ s/pS/ps/ if ($bad_extension =~ /pf/);
5794 WARN("VSPRINTF_POINTER_EXTENSION",
5795 "$ext_type vsprintf pointer extension '$bad_extension'$use\n" . "$here\n$stat_real\n");
5799 # Check for misused memsets
5800 if ($^V && $^V ge 5.10.0 &&
5802 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5808 if ($ms_size =~ /^(0x|)0$/i) {
5810 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5811 } elsif ($ms_size =~ /^(0x|)1$/i) {
5813 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5817 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5818 # if ($^V && $^V ge 5.10.0 &&
5820 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5821 # if (WARN("PREFER_ETHER_ADDR_COPY",
5822 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5824 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5828 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5829 # if ($^V && $^V ge 5.10.0 &&
5831 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5832 # WARN("PREFER_ETHER_ADDR_EQUAL",
5833 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5836 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5837 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5838 # if ($^V && $^V ge 5.10.0 &&
5840 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5844 # if ($ms_val =~ /^(?:0x|)0+$/i) {
5845 # if (WARN("PREFER_ETH_ZERO_ADDR",
5846 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5848 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5850 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5851 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
5852 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5854 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5859 # typecasts on min/max could be min_t/max_t
5860 if ($^V && $^V ge 5.10.0 &&
5862 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5863 if (defined $2 || defined $7) {
5865 my $cast1 = deparenthesize($2);
5867 my $cast2 = deparenthesize($7);
5871 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5872 $cast = "$cast1 or $cast2";
5873 } elsif ($cast1 ne "") {
5879 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5883 # check usleep_range arguments
5884 if ($^V && $^V ge 5.10.0 &&
5886 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5890 WARN("USLEEP_RANGE",
5891 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5892 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5894 WARN("USLEEP_RANGE",
5895 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5899 # check for naked sscanf
5900 if ($^V && $^V ge 5.10.0 &&
5902 $line =~ /\bsscanf\b/ &&
5903 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5904 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5905 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5906 my $lc = $stat =~ tr@\n@@;
5907 $lc = $lc + $linenr;
5908 my $stat_real = raw_line($linenr, 0);
5909 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5910 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5912 WARN("NAKED_SSCANF",
5913 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5916 # check for simple sscanf that should be kstrto<foo>
5917 if ($^V && $^V ge 5.10.0 &&
5919 $line =~ /\bsscanf\b/) {
5920 my $lc = $stat =~ tr@\n@@;
5921 $lc = $lc + $linenr;
5922 my $stat_real = raw_line($linenr, 0);
5923 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5924 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5926 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5928 my $count = $format =~ tr@%@%@;
5930 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5931 WARN("SSCANF_TO_KSTRTO",
5932 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5937 # check for new externs in .h files.
5938 if ($realfile =~ /\.h$/ &&
5939 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5940 if (CHK("AVOID_EXTERNS",
5941 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5943 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5947 # check for new externs in .c files.
5948 if ($realfile =~ /\.c$/ && defined $stat &&
5949 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5951 my $function_name = $1;
5952 my $paren_space = $2;
5955 if (defined $cond) {
5956 substr($s, 0, length($cond), '');
5958 if ($s =~ /^\s*;/ &&
5959 $function_name ne 'uninitialized_var')
5961 WARN("AVOID_EXTERNS",
5962 "externs should be avoided in .c files\n" . $herecurr);
5965 if ($paren_space =~ /\n/) {
5966 WARN("FUNCTION_ARGUMENTS",
5967 "arguments for function declarations should follow identifier\n" . $herecurr);
5970 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5971 $stat =~ /^.\s*extern\s+/)
5973 WARN("AVOID_EXTERNS",
5974 "externs should be avoided in .c files\n" . $herecurr);
5977 # check for function declarations that have arguments without identifier names
5978 if (defined $stat &&
5979 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
5981 my $args = trim($1);
5982 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
5984 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
5985 WARN("FUNCTION_ARGUMENTS",
5986 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
5991 # check for function definitions
5992 if ($^V && $^V ge 5.10.0 &&
5994 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
5995 $context_function = $1;
5997 # check for multiline function definition with misplaced open brace
5999 my $cnt = statement_rawlines($stat);
6000 my $herectx = $here . "\n";
6001 for (my $n = 0; $n < $cnt; $n++) {
6002 my $rl = raw_line($linenr, $n);
6003 $herectx .= $rl . "\n";
6004 $ok = 1 if ($rl =~ /^[ \+]\{/);
6005 $ok = 1 if ($rl =~ /\{/ && $n == 0);
6006 last if $rl =~ /^[ \+].*\{/;
6010 "open brace '{' following function definitions go on the next line\n" . $herectx);
6014 # checks for new __setup's
6015 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6018 if (!grep(/$name/, @setup_docs)) {
6019 CHK("UNDOCUMENTED_SETUP",
6020 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
6024 # check for pointless casting of kmalloc return
6025 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
6026 WARN("UNNECESSARY_CASTS",
6027 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6031 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6032 if ($^V && $^V ge 5.10.0 &&
6033 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6034 CHK("ALLOC_SIZEOF_STRUCT",
6035 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6038 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6039 if ($^V && $^V ge 5.10.0 &&
6041 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6045 my $newfunc = "kmalloc_array";
6046 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6049 if ($a1 =~ /^sizeof\s*\S/) {
6053 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6054 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6056 my $herectx = $here . "\n";
6057 my $cnt = statement_rawlines($stat);
6058 for (my $n = 0; $n < $cnt; $n++) {
6059 $herectx .= raw_line($linenr, $n) . "\n";
6061 if (WARN("ALLOC_WITH_MULTIPLY",
6062 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6065 $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;
6070 # check for krealloc arg reuse
6071 if ($^V && $^V ge 5.10.0 &&
6072 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
6073 WARN("KREALLOC_ARG_REUSE",
6074 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6077 # check for alloc argument mismatch
6078 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6079 WARN("ALLOC_ARRAY_ARGS",
6080 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6083 # check for multiple semicolons
6084 if ($line =~ /;\s*;\s*$/) {
6085 if (WARN("ONE_SEMICOLON",
6086 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6088 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6092 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6093 if ($realfile !~ m@^include/uapi/@ &&
6094 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6096 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6097 if (CHK("BIT_MACRO",
6098 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6100 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6104 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6105 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6107 if (WARN("PREFER_IS_ENABLED",
6108 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6110 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6114 # check for case / default statements not preceded by break/fallthrough/switch
6115 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
6117 my $has_statement = 0;
6119 my $prevline = $linenr;
6120 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
6122 my $rline = $rawlines[$prevline - 1];
6123 my $fline = $lines[$prevline - 1];
6124 last if ($fline =~ /^\@\@/);
6125 next if ($fline =~ /^\-/);
6126 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
6127 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
6128 next if ($fline =~ /^.[\s$;]*$/);
6131 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|exit\s*\(\b|return\b|goto\b|continue\b)/);
6133 if (!$has_break && $has_statement) {
6134 WARN("MISSING_BREAK",
6135 "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
6139 # check for switch/default statements without a break;
6140 if ($^V && $^V ge 5.10.0 &&
6142 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6144 my $herectx = $here . "\n";
6145 my $cnt = statement_rawlines($stat);
6146 for (my $n = 0; $n < $cnt; $n++) {
6147 $herectx .= raw_line($linenr, $n) . "\n";
6149 WARN("DEFAULT_NO_BREAK",
6150 "switch default: should use break\n" . $herectx);
6153 # check for gcc specific __FUNCTION__
6154 if ($line =~ /\b__FUNCTION__\b/) {
6155 if (WARN("USE_FUNC",
6156 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
6158 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
6162 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
6163 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6165 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6168 # check for use of yield()
6169 if ($line =~ /\byield\s*\(\s*\)/) {
6171 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
6174 # check for comparisons against true and false
6175 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6183 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6185 my $type = lc($otype);
6186 if ($type =~ /^(?:true|false)$/) {
6187 if (("$test" eq "==" && "$type" eq "true") ||
6188 ("$test" eq "!=" && "$type" eq "false")) {
6192 CHK("BOOL_COMPARISON",
6193 "Using comparison to $otype is error prone\n" . $herecurr);
6195 ## maybe suggesting a correct construct would better
6196 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6201 # check for semaphores initialized locked
6202 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6203 WARN("CONSIDER_COMPLETION",
6204 "consider using a completion\n" . $herecurr);
6207 # recommend kstrto* over simple_strto* and strict_strto*
6208 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6209 WARN("CONSIDER_KSTRTO",
6210 "$1 is obsolete, use k$3 instead\n" . $herecurr);
6213 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
6214 if ($line =~ /^.\s*__initcall\s*\(/) {
6215 WARN("USE_DEVICE_INITCALL",
6216 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6219 # check for various structs that are normally const (ops, kgdb, device_tree)
6220 # and avoid what seem like struct definitions 'struct foo {'
6221 if ($line !~ /\bconst\b/ &&
6222 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
6223 WARN("CONST_STRUCT",
6224 "struct $1 should normally be const\n" . $herecurr);
6227 # use of NR_CPUS is usually wrong
6228 # ignore definitions of NR_CPUS and usage to define arrays as likely right
6229 if ($line =~ /\bNR_CPUS\b/ &&
6230 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6231 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6232 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6233 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6234 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6237 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6240 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6241 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6242 ERROR("DEFINE_ARCH_HAS",
6243 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6246 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
6247 if ($^V && $^V ge 5.10.0 &&
6248 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6249 WARN("LIKELY_MISUSE",
6250 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6253 # whine mightly about in_atomic
6254 if ($line =~ /\bin_atomic\s*\(/) {
6255 if ($realfile =~ m@^drivers/@) {
6257 "do not use in_atomic in drivers\n" . $herecurr);
6258 } elsif ($realfile !~ m@^kernel/@) {
6260 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6264 # check for mutex_trylock_recursive usage
6265 if ($line =~ /mutex_trylock_recursive/) {
6267 "recursive locking is bad, do not use this ever.\n" . $herecurr);
6270 # check for lockdep_set_novalidate_class
6271 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6272 $line =~ /__lockdep_no_validate__\s*\)/ ) {
6273 if ($realfile !~ m@^kernel/lockdep@ &&
6274 $realfile !~ m@^include/linux/lockdep@ &&
6275 $realfile !~ m@^drivers/base/core@) {
6277 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6281 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6282 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6283 WARN("EXPORTED_WORLD_WRITABLE",
6284 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6287 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
6288 # and whether or not function naming is typical and if
6289 # DEVICE_ATTR permissions uses are unusual too
6290 if ($^V && $^V ge 5.10.0 &&
6292 $stat =~ /\bDEVICE_ATTR\s*\(\s*(\w+)\s*,\s*\(?\s*(\s*(?:${multi_mode_perms_string_search}|0[0-7]{3,3})\s*)\s*\)?\s*,\s*(\w+)\s*,\s*(\w+)\s*\)/) {
6297 my $octal_perms = perms_to_octal($perms);
6298 if ($show =~ /^${var}_show$/ &&
6299 $store =~ /^${var}_store$/ &&
6300 $octal_perms eq "0644") {
6301 if (WARN("DEVICE_ATTR_RW",
6302 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
6304 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
6306 } elsif ($show =~ /^${var}_show$/ &&
6307 $store =~ /^NULL$/ &&
6308 $octal_perms eq "0444") {
6309 if (WARN("DEVICE_ATTR_RO",
6310 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
6312 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
6314 } elsif ($show =~ /^NULL$/ &&
6315 $store =~ /^${var}_store$/ &&
6316 $octal_perms eq "0200") {
6317 if (WARN("DEVICE_ATTR_WO",
6318 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
6320 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
6322 } elsif ($octal_perms eq "0644" ||
6323 $octal_perms eq "0444" ||
6324 $octal_perms eq "0200") {
6325 my $newshow = "$show";
6326 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
6327 my $newstore = $store;
6328 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
6330 if ($show ne $newshow) {
6331 $rename .= " '$show' to '$newshow'";
6333 if ($store ne $newstore) {
6334 $rename .= " '$store' to '$newstore'";
6336 WARN("DEVICE_ATTR_FUNCTIONS",
6337 "Consider renaming function(s)$rename\n" . $herecurr);
6339 WARN("DEVICE_ATTR_PERMS",
6340 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
6344 # Mode permission misuses where it seems decimal should be octal
6345 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6346 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
6347 # specific definition of not visible in sysfs.
6348 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
6349 # use the default permissions
6350 if ($^V && $^V ge 5.10.0 &&
6352 $line =~ /$mode_perms_search/) {
6353 foreach my $entry (@mode_permission_funcs) {
6354 my $func = $entry->[0];
6355 my $arg_pos = $entry->[1];
6357 my $lc = $stat =~ tr@\n@@;
6358 $lc = $lc + $linenr;
6359 my $stat_real = raw_line($linenr, 0);
6360 for (my $count = $linenr + 1; $count <= $lc; $count++) {
6361 $stat_real = $stat_real . "\n" . raw_line($count, 0);
6367 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6369 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6370 if ($stat =~ /$test/) {
6372 $val = $6 if ($skip_args ne "");
6373 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
6374 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6375 ($val =~ /^$Octal$/ && length($val) ne 4))) {
6376 ERROR("NON_OCTAL_PERMISSIONS",
6377 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6379 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6380 ERROR("EXPORTED_WORLD_WRITABLE",
6381 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6387 # check for uses of S_<PERMS> that could be octal for readability
6388 if ($line =~ /\b($multi_mode_perms_string_search)\b/) {
6390 my $octal = perms_to_octal($oval);
6391 if (WARN("SYMBOLIC_PERMS",
6392 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6394 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
6398 # validate content of MODULE_LICENSE against list from include/linux/module.h
6399 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6400 my $extracted_string = get_quoted_string($line, $rawline);
6401 my $valid_licenses = qr{
6404 GPL\ and\ additional\ rights|
6410 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6411 WARN("MODULE_LICENSE",
6412 "unknown module license " . $extracted_string . "\n" . $herecurr);
6417 # If we have no input at all, then there is nothing to report on
6418 # so just keep quiet.
6419 if ($#rawlines == -1) {
6423 # In mailback mode only produce a report in the negative, for
6424 # things that appear to be patches.
6425 if ($mailback && ($clean == 1 || !$is_patch)) {
6429 # This is not a patch, and we are are in 'no-patch' mode so
6431 if (!$chk_patch && !$is_patch) {
6435 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
6436 ERROR("NOT_UNIFIED_DIFF",
6437 "Does not appear to be a unified-diff format patch\n");
6439 if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6440 ERROR("MISSING_SIGN_OFF",
6441 "Missing Signed-off-by: line(s)\n");
6444 print report_dump();
6445 if ($summary && !($clean == 1 && $quiet == 1)) {
6446 print "$filename " if ($summary_file);
6447 print "total: $cnt_error errors, $cnt_warn warnings, " .
6448 (($check)? "$cnt_chk checks, " : "") .
6449 "$cnt_lines lines checked\n";
6453 # If there were any defects found and not already fixing them
6454 if (!$clean and !$fix) {
6457 NOTE: For some of the reported defects, checkpatch may be able to
6458 mechanically convert to the typical style using --fix or --fix-inplace.
6461 # If there were whitespace errors which cleanpatch can fix
6462 # then suggest that.
6463 if ($rpt_cleaners) {
6467 NOTE: Whitespace errors detected.
6468 You may wish to use scripts/cleanpatch or scripts/cleanfile
6473 if ($clean == 0 && $fix &&
6474 ("@rawlines" ne "@fixed" ||
6475 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6476 my $newfile = $filename;
6477 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6481 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6483 open($f, '>', $newfile)
6484 or die "$P: Can't open $newfile for write\n";
6485 foreach my $fixed_line (@fixed) {
6488 if ($linecount > 3) {
6489 $fixed_line =~ s/^\+//;
6490 print $f $fixed_line . "\n";
6493 print $f $fixed_line . "\n";
6501 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6503 Do _NOT_ trust the results written to this file.
6504 Do _NOT_ submit these changes without inspecting them for correctness.
6506 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6507 No warranties, expressed or implied...
6515 print "$vname has no obvious style problems and is ready for submission.\n";
6517 print "$vname has style problems, please review.\n";