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*\(|
795 (?:SKCIPHER_REQUEST|SHASH_DESC|AHASH_REQUEST)_ON_STACK\s*\(
800 return "" if (!defined($string));
802 while ($string =~ /^\s*\(.*\)\s*$/) {
803 $string =~ s@^\s*\(\s*@@;
804 $string =~ s@\s*\)\s*$@@;
807 $string =~ s@\s+@ @g;
812 sub seed_camelcase_file {
815 return if (!(-f $file));
819 open(my $include_file, '<', "$file")
820 or warn "$P: Can't read '$file' $!\n";
821 my $text = <$include_file>;
822 close($include_file);
824 my @lines = split('\n', $text);
826 foreach my $line (@lines) {
827 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
828 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
830 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
832 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
838 sub is_maintained_obsolete {
841 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
843 my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
845 return $status =~ /obsolete/i;
848 my $camelcase_seeded = 0;
849 sub seed_camelcase_includes {
850 return if ($camelcase_seeded);
853 my $camelcase_cache = "";
854 my @include_files = ();
856 $camelcase_seeded = 1;
859 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
860 chomp $git_last_include_commit;
861 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
863 my $last_mod_date = 0;
864 $files = `find $root/include -name "*.h"`;
865 @include_files = split('\n', $files);
866 foreach my $file (@include_files) {
867 my $date = POSIX::strftime("%Y%m%d%H%M",
868 localtime((stat $file)[9]));
869 $last_mod_date = $date if ($last_mod_date < $date);
871 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
874 if ($camelcase_cache ne "" && -f $camelcase_cache) {
875 open(my $camelcase_file, '<', "$camelcase_cache")
876 or warn "$P: Can't read '$camelcase_cache' $!\n";
877 while (<$camelcase_file>) {
881 close($camelcase_file);
887 $files = `git ls-files "include/*.h"`;
888 @include_files = split('\n', $files);
891 foreach my $file (@include_files) {
892 seed_camelcase_file($file);
895 if ($camelcase_cache ne "") {
896 unlink glob ".checkpatch-camelcase.*";
897 open(my $camelcase_file, '>', "$camelcase_cache")
898 or warn "$P: Can't write '$camelcase_cache' $!\n";
899 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
900 print $camelcase_file ("$_\n");
902 close($camelcase_file);
906 sub git_commit_info {
907 my ($commit, $id, $desc) = @_;
909 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
911 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
912 $output =~ s/^\s*//gm;
913 my @lines = split("\n", $output);
915 return ($id, $desc) if ($#lines < 0);
917 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
918 # Maybe one day convert this block of bash into something that returns
919 # all matching commit ids, but it's very slow...
921 # echo "checking commits $1..."
922 # git rev-list --remotes | grep -i "^$1" |
923 # while read line ; do
924 # git log --format='%H %s' -1 $line |
925 # echo "commit $(cut -c 1-12,41-)"
927 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
930 $id = substr($lines[0], 0, 12);
931 $desc = substr($lines[0], 41);
937 $chk_signoff = 0 if ($file);
942 my @fixed_inserted = ();
943 my @fixed_deleted = ();
946 # If input is git commits, extract all commits from the commit expressions.
947 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
948 die "$P: No git repository found\n" if ($git && !-e ".git");
952 foreach my $commit_expr (@ARGV) {
954 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
955 $git_range = "-$2 $1";
956 } elsif ($commit_expr =~ m/\.\./) {
957 $git_range = "$commit_expr";
959 $git_range = "-1 $commit_expr";
961 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
962 foreach my $line (split(/\n/, $lines)) {
963 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
964 next if (!defined($1) || !defined($2));
967 unshift(@commits, $sha1);
968 $git_commits{$sha1} = $subject;
971 die "$P: no git commits after extraction!\n" if (@commits == 0);
976 for my $filename (@ARGV) {
979 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
980 die "$P: $filename: git format-patch failed - $!\n";
982 open($FILE, '-|', "diff -u /dev/null $filename") ||
983 die "$P: $filename: diff failed - $!\n";
984 } elsif ($filename eq '-') {
985 open($FILE, '<&STDIN');
987 open($FILE, '<', "$filename") ||
988 die "$P: $filename: open failed - $!\n";
990 if ($filename eq '-') {
991 $vname = 'Your patch';
993 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1003 if ($#ARGV > 0 && $quiet == 0) {
1004 print '-' x length($vname) . "\n";
1006 print '-' x length($vname) . "\n";
1009 if (!process($filename)) {
1015 @fixed_inserted = ();
1016 @fixed_deleted = ();
1018 @modifierListFile = ();
1024 hash_show_words(\%use_type, "Used");
1025 hash_show_words(\%ignore_type, "Ignored");
1027 if ($^V lt 5.10.0) {
1030 NOTE: perl $^V is not modern enough to detect all possible issues.
1031 An upgrade to at least perl v5.10.0 is suggested.
1037 NOTE: If any of the errors are false positives, please report
1038 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1045 sub top_of_kernel_tree {
1049 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1050 "README", "Documentation", "arch", "include", "drivers",
1051 "fs", "init", "ipc", "kernel", "lib", "scripts",
1054 foreach my $check (@tree_check) {
1055 if (! -e $root . '/' . $check) {
1063 my ($formatted_email) = @_;
1069 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1072 $comment = $3 if defined $3;
1073 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1075 $comment = $2 if defined $2;
1076 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1078 $comment = $2 if defined $2;
1079 $formatted_email =~ s/\Q$address\E.*$//;
1080 $name = $formatted_email;
1081 $name = trim($name);
1082 $name =~ s/^\"|\"$//g;
1083 # If there's a name left after stripping spaces and
1084 # leading quotes, and the address doesn't have both
1085 # leading and trailing angle brackets, the address
1087 # "joe smith joe@smith.com" bad
1088 # "joe smith <joe@smith.com" bad
1089 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1096 $name = trim($name);
1097 $name =~ s/^\"|\"$//g;
1098 $address = trim($address);
1099 $address =~ s/^\<|\>$//g;
1101 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1102 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1103 $name = "\"$name\"";
1106 return ($name, $address, $comment);
1110 my ($name, $address) = @_;
1112 my $formatted_email;
1114 $name = trim($name);
1115 $name =~ s/^\"|\"$//g;
1116 $address = trim($address);
1118 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1119 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1120 $name = "\"$name\"";
1123 if ("$name" eq "") {
1124 $formatted_email = "$address";
1126 $formatted_email = "$name <$address>";
1129 return $formatted_email;
1135 foreach my $path (split(/:/, $ENV{PATH})) {
1136 if (-e "$path/$bin") {
1137 return "$path/$bin";
1147 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1148 if (-e "$path/$conf") {
1149 return "$path/$conf";
1161 for my $c (split(//, $str)) {
1165 for (; ($n % 8) != 0; $n++) {
1177 (my $res = shift) =~ tr/\t/ /c;
1184 # Drop the diff line leader and expand tabs
1186 $line = expand_tabs($line);
1188 # Pick the indent from the front of the line.
1189 my ($white) = ($line =~ /^(\s*)/);
1191 return (length($line), length($white));
1194 my $sanitise_quote = '';
1196 sub sanitise_line_reset {
1197 my ($in_comment) = @_;
1200 $sanitise_quote = '*/';
1202 $sanitise_quote = '';
1215 # Always copy over the diff marker.
1216 $res = substr($line, 0, 1);
1218 for ($off = 1; $off < length($line); $off++) {
1219 $c = substr($line, $off, 1);
1221 # Comments we are whacking completely including the begin
1222 # and end, all to $;.
1223 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1224 $sanitise_quote = '*/';
1226 substr($res, $off, 2, "$;$;");
1230 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1231 $sanitise_quote = '';
1232 substr($res, $off, 2, "$;$;");
1236 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1237 $sanitise_quote = '//';
1239 substr($res, $off, 2, $sanitise_quote);
1244 # A \ in a string means ignore the next character.
1245 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1247 substr($res, $off, 2, 'XX');
1252 if ($c eq "'" || $c eq '"') {
1253 if ($sanitise_quote eq '') {
1254 $sanitise_quote = $c;
1256 substr($res, $off, 1, $c);
1258 } elsif ($sanitise_quote eq $c) {
1259 $sanitise_quote = '';
1263 #print "c<$c> SQ<$sanitise_quote>\n";
1264 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1265 substr($res, $off, 1, $;);
1266 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1267 substr($res, $off, 1, $;);
1268 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1269 substr($res, $off, 1, 'X');
1271 substr($res, $off, 1, $c);
1275 if ($sanitise_quote eq '//') {
1276 $sanitise_quote = '';
1279 # The pathname on a #include may be surrounded by '<' and '>'.
1280 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1281 my $clean = 'X' x length($1);
1282 $res =~ s@\<.*\>@<$clean>@;
1284 # The whole of a #error is a string.
1285 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1286 my $clean = 'X' x length($1);
1287 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1290 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1292 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1298 sub get_quoted_string {
1299 my ($line, $rawline) = @_;
1301 return "" if (!defined($line) || !defined($rawline));
1302 return "" if ($line !~ m/($String)/g);
1303 return substr($rawline, $-[0], $+[0] - $-[0]);
1306 sub ctx_statement_block {
1307 my ($linenr, $remain, $off) = @_;
1308 my $line = $linenr - 1;
1311 my $coff = $off - 1;
1325 @stack = (['', 0]) if ($#stack == -1);
1327 #warn "CSB: blk<$blk> remain<$remain>\n";
1328 # If we are about to drop off the end, pull in more
1331 for (; $remain > 0; $line++) {
1332 last if (!defined $lines[$line]);
1333 next if ($lines[$line] =~ /^-/);
1336 $blk .= $lines[$line] . "\n";
1337 $len = length($blk);
1341 # Bail if there is no further context.
1342 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1346 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1352 $c = substr($blk, $off, 1);
1353 $remainder = substr($blk, $off);
1355 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1357 # Handle nested #if/#else.
1358 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1359 push(@stack, [ $type, $level ]);
1360 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1361 ($type, $level) = @{$stack[$#stack - 1]};
1362 } elsif ($remainder =~ /^#\s*endif\b/) {
1363 ($type, $level) = @{pop(@stack)};
1366 # Statement ends at the ';' or a close '}' at the
1368 if ($level == 0 && $c eq ';') {
1372 # An else is really a conditional as long as its not else if
1373 if ($level == 0 && $coff_set == 0 &&
1374 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1375 $remainder =~ /^(else)(?:\s|{)/ &&
1376 $remainder !~ /^else\s+if\b/) {
1377 $coff = $off + length($1) - 1;
1379 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1380 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1383 if (($type eq '' || $type eq '(') && $c eq '(') {
1387 if ($type eq '(' && $c eq ')') {
1389 $type = ($level != 0)? '(' : '';
1391 if ($level == 0 && $coff < $soff) {
1394 #warn "CSB: mark coff<$coff>\n";
1397 if (($type eq '' || $type eq '{') && $c eq '{') {
1401 if ($type eq '{' && $c eq '}') {
1403 $type = ($level != 0)? '{' : '';
1406 if (substr($blk, $off + 1, 1) eq ';') {
1412 # Preprocessor commands end at the newline unless escaped.
1413 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1421 # We are truly at the end, so shuffle to the next line.
1428 my $statement = substr($blk, $soff, $off - $soff + 1);
1429 my $condition = substr($blk, $soff, $coff - $soff + 1);
1431 #warn "STATEMENT<$statement>\n";
1432 #warn "CONDITION<$condition>\n";
1434 #print "coff<$coff> soff<$off> loff<$loff>\n";
1436 return ($statement, $condition,
1437 $line, $remain + 1, $off - $loff + 1, $level);
1440 sub statement_lines {
1443 # Strip the diff line prefixes and rip blank lines at start and end.
1444 $stmt =~ s/(^|\n)./$1/g;
1448 my @stmt_lines = ($stmt =~ /\n/g);
1450 return $#stmt_lines + 2;
1453 sub statement_rawlines {
1456 my @stmt_lines = ($stmt =~ /\n/g);
1458 return $#stmt_lines + 2;
1461 sub statement_block_size {
1464 $stmt =~ s/(^|\n)./$1/g;
1470 my @stmt_lines = ($stmt =~ /\n/g);
1471 my @stmt_statements = ($stmt =~ /;/g);
1473 my $stmt_lines = $#stmt_lines + 2;
1474 my $stmt_statements = $#stmt_statements + 1;
1476 if ($stmt_lines > $stmt_statements) {
1479 return $stmt_statements;
1483 sub ctx_statement_full {
1484 my ($linenr, $remain, $off) = @_;
1485 my ($statement, $condition, $level);
1489 # Grab the first conditional/block pair.
1490 ($statement, $condition, $linenr, $remain, $off, $level) =
1491 ctx_statement_block($linenr, $remain, $off);
1492 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1493 push(@chunks, [ $condition, $statement ]);
1494 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1495 return ($level, $linenr, @chunks);
1498 # Pull in the following conditional/block pairs and see if they
1499 # could continue the statement.
1501 ($statement, $condition, $linenr, $remain, $off, $level) =
1502 ctx_statement_block($linenr, $remain, $off);
1503 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1504 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1506 push(@chunks, [ $condition, $statement ]);
1509 return ($level, $linenr, @chunks);
1513 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1515 my $start = $linenr - 1;
1522 my @stack = ($level);
1523 for ($line = $start; $remain > 0; $line++) {
1524 next if ($rawlines[$line] =~ /^-/);
1527 $blk .= $rawlines[$line];
1529 # Handle nested #if/#else.
1530 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1531 push(@stack, $level);
1532 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1533 $level = $stack[$#stack - 1];
1534 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1535 $level = pop(@stack);
1538 foreach my $c (split(//, $lines[$line])) {
1539 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1545 if ($c eq $close && $level > 0) {
1547 last if ($level == 0);
1548 } elsif ($c eq $open) {
1553 if (!$outer || $level <= 1) {
1554 push(@res, $rawlines[$line]);
1557 last if ($level == 0);
1560 return ($level, @res);
1562 sub ctx_block_outer {
1563 my ($linenr, $remain) = @_;
1565 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1569 my ($linenr, $remain) = @_;
1571 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1575 my ($linenr, $remain, $off) = @_;
1577 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1580 sub ctx_block_level {
1581 my ($linenr, $remain) = @_;
1583 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1585 sub ctx_statement_level {
1586 my ($linenr, $remain, $off) = @_;
1588 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1591 sub ctx_locate_comment {
1592 my ($first_line, $end_line) = @_;
1594 # Catch a comment on the end of the line itself.
1595 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1596 return $current_comment if (defined $current_comment);
1598 # Look through the context and try and figure out if there is a
1601 $current_comment = '';
1602 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1603 my $line = $rawlines[$linenr - 1];
1605 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1608 if ($line =~ m@/\*@) {
1611 if (!$in_comment && $current_comment ne '') {
1612 $current_comment = '';
1614 $current_comment .= $line . "\n" if ($in_comment);
1615 if ($line =~ m@\*/@) {
1620 chomp($current_comment);
1621 return($current_comment);
1623 sub ctx_has_comment {
1624 my ($first_line, $end_line) = @_;
1625 my $cmt = ctx_locate_comment($first_line, $end_line);
1627 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1628 ##print "CMMT: $cmt\n";
1630 return ($cmt ne '');
1634 my ($linenr, $cnt) = @_;
1636 my $offset = $linenr - 1;
1641 $line = $rawlines[$offset++];
1642 next if (defined($line) && $line =~ /^-/);
1650 my ($linenr, $lc) = @_;
1652 my $stat_real = raw_line($linenr, 0);
1653 for (my $count = $linenr + 1; $count <= $lc; $count++) {
1654 $stat_real = $stat_real . "\n" . raw_line($count, 0);
1661 my ($linenr, $cnt, $here) = @_;
1663 my $herectx = $here . "\n";
1664 for (my $n = 0; $n < $cnt; $n++) {
1665 $herectx .= raw_line($linenr, $n) . "\n";
1676 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1679 $coded = sprintf("^%c", unpack('C', $2) + 64);
1688 my $av_preprocessor = 0;
1693 sub annotate_reset {
1694 $av_preprocessor = 0;
1696 @av_paren_type = ('E');
1697 $av_pend_colon = 'O';
1700 sub annotate_values {
1701 my ($stream, $type) = @_;
1704 my $var = '_' x length($stream);
1707 print "$stream\n" if ($dbg_values > 1);
1709 while (length($cur)) {
1710 @av_paren_type = ('E') if ($#av_paren_type < 0);
1711 print " <" . join('', @av_paren_type) .
1712 "> <$type> <$av_pending>" if ($dbg_values > 1);
1713 if ($cur =~ /^(\s+)/o) {
1714 print "WS($1)\n" if ($dbg_values > 1);
1715 if ($1 =~ /\n/ && $av_preprocessor) {
1716 $type = pop(@av_paren_type);
1717 $av_preprocessor = 0;
1720 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1721 print "CAST($1)\n" if ($dbg_values > 1);
1722 push(@av_paren_type, $type);
1725 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1726 print "DECLARE($1)\n" if ($dbg_values > 1);
1729 } elsif ($cur =~ /^($Modifier)\s*/) {
1730 print "MODIFIER($1)\n" if ($dbg_values > 1);
1733 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1734 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1735 $av_preprocessor = 1;
1736 push(@av_paren_type, $type);
1742 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1743 print "UNDEF($1)\n" if ($dbg_values > 1);
1744 $av_preprocessor = 1;
1745 push(@av_paren_type, $type);
1747 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1748 print "PRE_START($1)\n" if ($dbg_values > 1);
1749 $av_preprocessor = 1;
1751 push(@av_paren_type, $type);
1752 push(@av_paren_type, $type);
1755 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1756 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1757 $av_preprocessor = 1;
1759 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1763 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1764 print "PRE_END($1)\n" if ($dbg_values > 1);
1766 $av_preprocessor = 1;
1768 # Assume all arms of the conditional end as this
1769 # one does, and continue as if the #endif was not here.
1770 pop(@av_paren_type);
1771 push(@av_paren_type, $type);
1774 } elsif ($cur =~ /^(\\\n)/o) {
1775 print "PRECONT($1)\n" if ($dbg_values > 1);
1777 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1778 print "ATTR($1)\n" if ($dbg_values > 1);
1779 $av_pending = $type;
1782 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1783 print "SIZEOF($1)\n" if ($dbg_values > 1);
1789 } elsif ($cur =~ /^(if|while|for)\b/o) {
1790 print "COND($1)\n" if ($dbg_values > 1);
1794 } elsif ($cur =~/^(case)/o) {
1795 print "CASE($1)\n" if ($dbg_values > 1);
1796 $av_pend_colon = 'C';
1799 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1800 print "KEYWORD($1)\n" if ($dbg_values > 1);
1803 } elsif ($cur =~ /^(\()/o) {
1804 print "PAREN('$1')\n" if ($dbg_values > 1);
1805 push(@av_paren_type, $av_pending);
1809 } elsif ($cur =~ /^(\))/o) {
1810 my $new_type = pop(@av_paren_type);
1811 if ($new_type ne '_') {
1813 print "PAREN('$1') -> $type\n"
1814 if ($dbg_values > 1);
1816 print "PAREN('$1')\n" if ($dbg_values > 1);
1819 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1820 print "FUNC($1)\n" if ($dbg_values > 1);
1824 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1825 if (defined $2 && $type eq 'C' || $type eq 'T') {
1826 $av_pend_colon = 'B';
1827 } elsif ($type eq 'E') {
1828 $av_pend_colon = 'L';
1830 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1833 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1834 print "IDENT($1)\n" if ($dbg_values > 1);
1837 } elsif ($cur =~ /^($Assignment)/o) {
1838 print "ASSIGN($1)\n" if ($dbg_values > 1);
1841 } elsif ($cur =~/^(;|{|})/) {
1842 print "END($1)\n" if ($dbg_values > 1);
1844 $av_pend_colon = 'O';
1846 } elsif ($cur =~/^(,)/) {
1847 print "COMMA($1)\n" if ($dbg_values > 1);
1850 } elsif ($cur =~ /^(\?)/o) {
1851 print "QUESTION($1)\n" if ($dbg_values > 1);
1854 } elsif ($cur =~ /^(:)/o) {
1855 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1857 substr($var, length($res), 1, $av_pend_colon);
1858 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1863 $av_pend_colon = 'O';
1865 } elsif ($cur =~ /^(\[)/o) {
1866 print "CLOSE($1)\n" if ($dbg_values > 1);
1869 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1872 print "OPV($1)\n" if ($dbg_values > 1);
1879 substr($var, length($res), 1, $variant);
1882 } elsif ($cur =~ /^($Operators)/o) {
1883 print "OP($1)\n" if ($dbg_values > 1);
1884 if ($1 ne '++' && $1 ne '--') {
1888 } elsif ($cur =~ /(^.)/o) {
1889 print "C($1)\n" if ($dbg_values > 1);
1892 $cur = substr($cur, length($1));
1893 $res .= $type x length($1);
1897 return ($res, $var);
1901 my ($possible, $line) = @_;
1902 my $notPermitted = qr{(?:
1919 ^(?:typedef|struct|enum)\b
1921 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1922 if ($possible !~ $notPermitted) {
1923 # Check for modifiers.
1924 $possible =~ s/\s*$Storage\s*//g;
1925 $possible =~ s/\s*$Sparse\s*//g;
1926 if ($possible =~ /^\s*$/) {
1928 } elsif ($possible =~ /\s/) {
1929 $possible =~ s/\s*$Type\s*//g;
1930 for my $modifier (split(' ', $possible)) {
1931 if ($modifier !~ $notPermitted) {
1932 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1933 push(@modifierListFile, $modifier);
1938 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1939 push(@typeListFile, $possible);
1943 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1952 $type =~ tr/[a-z]/[A-Z]/;
1954 return defined $use_type{$type} if (scalar keys %use_type > 0);
1956 return !defined $ignore_type{$type};
1960 my ($level, $type, $msg) = @_;
1962 if (!show_type($type) ||
1963 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1968 if ($level eq 'ERROR') {
1970 } elsif ($level eq 'WARNING') {
1976 $output .= $prefix . $level . ':';
1978 $output .= BLUE if ($color);
1979 $output .= "$type:";
1981 $output .= RESET if ($color);
1982 $output .= ' ' . $msg . "\n";
1985 my @lines = split("\n", $output, -1);
1986 splice(@lines, 1, 1);
1987 $output = join("\n", @lines);
1989 $output = (split('\n', $output))[0] . "\n" if ($terse);
1991 push(our @report, $output);
2000 sub fixup_current_range {
2001 my ($lineRef, $offset, $length) = @_;
2003 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2006 my $no = $o + $offset;
2007 my $nl = $l + $length;
2008 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2012 sub fix_inserted_deleted_lines {
2013 my ($linesRef, $insertedRef, $deletedRef) = @_;
2015 my $range_last_linenr = 0;
2016 my $delta_offset = 0;
2021 my $next_insert = 0;
2022 my $next_delete = 0;
2026 my $inserted = @{$insertedRef}[$next_insert++];
2027 my $deleted = @{$deletedRef}[$next_delete++];
2029 foreach my $old_line (@{$linesRef}) {
2031 my $line = $old_line; #don't modify the array
2032 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
2034 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2035 $range_last_linenr = $new_linenr;
2036 fixup_current_range(\$line, $delta_offset, 0);
2039 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2040 $deleted = @{$deletedRef}[$next_delete++];
2042 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2045 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2046 push(@lines, ${$inserted}{'LINE'});
2047 $inserted = @{$insertedRef}[$next_insert++];
2049 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2053 push(@lines, $line);
2063 sub fix_insert_line {
2064 my ($linenr, $line) = @_;
2070 push(@fixed_inserted, $inserted);
2073 sub fix_delete_line {
2074 my ($linenr, $line) = @_;
2081 push(@fixed_deleted, $deleted);
2085 my ($type, $msg) = @_;
2087 if (report("ERROR", $type, $msg)) {
2095 my ($type, $msg) = @_;
2097 if (report("WARNING", $type, $msg)) {
2105 my ($type, $msg) = @_;
2107 if ($check && report("CHECK", $type, $msg)) {
2115 sub check_absolute_file {
2116 my ($absolute, $herecurr) = @_;
2117 my $file = $absolute;
2119 ##print "absolute<$absolute>\n";
2121 # See if any suffix of this path is a path within the tree.
2122 while ($file =~ s@^[^/]*/@@) {
2123 if (-f "$root/$file") {
2124 ##print "file<$file>\n";
2132 # It is, so see if the prefix is acceptable.
2133 my $prefix = $absolute;
2134 substr($prefix, -length($file)) = '';
2136 ##print "prefix<$prefix>\n";
2137 if ($prefix ne ".../") {
2138 WARN("USE_RELATIVE_PATH",
2139 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2146 $string =~ s/^\s+|\s+$//g;
2154 $string =~ s/^\s+//;
2162 $string =~ s/\s+$//;
2167 sub string_find_replace {
2168 my ($string, $find, $replace) = @_;
2170 $string =~ s/$find/$replace/g;
2178 my $source_indent = 8;
2179 my $max_spaces_before_tab = $source_indent - 1;
2180 my $spaces_to_tab = " " x $source_indent;
2182 #convert leading spaces to tabs
2183 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2184 #Remove spaces before a tab
2185 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2190 sub pos_last_openparen {
2195 my $opens = $line =~ tr/\(/\(/;
2196 my $closes = $line =~ tr/\)/\)/;
2198 my $last_openparen = 0;
2200 if (($opens == 0) || ($closes >= $opens)) {
2204 my $len = length($line);
2206 for ($pos = 0; $pos < $len; $pos++) {
2207 my $string = substr($line, $pos);
2208 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2209 $pos += length($1) - 1;
2210 } elsif (substr($line, $pos, 1) eq '(') {
2211 $last_openparen = $pos;
2212 } elsif (index($string, '(') == -1) {
2217 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2221 my $filename = shift;
2227 my $stashrawline="";
2237 my $in_header_lines = $file ? 0 : 1;
2238 my $in_commit_log = 0; #Scanning lines before patch
2239 my $has_commit_log = 0; #Encountered lines before patch
2240 my $commit_log_possible_stack_dump = 0;
2241 my $commit_log_long_line = 0;
2242 my $commit_log_has_diff = 0;
2243 my $reported_maintainer_file = 0;
2244 my $non_utf8_charset = 0;
2246 my $last_blank_line = 0;
2247 my $last_coalesced_string_linenr = -1;
2255 # Trace the real file/line as we go.
2260 my $context_function; #undef'd unless there's a known function
2262 my $comment_edge = 0;
2266 my $prev_values = 'E';
2269 my %suppress_ifbraces;
2270 my %suppress_whiletrailers;
2271 my %suppress_export;
2272 my $suppress_statement = 0;
2274 my %signatures = ();
2276 # Pre-scan the patch sanitizing the lines.
2277 # Pre-scan the patch looking for any __setup documentation.
2279 my @setup_docs = ();
2282 my $camelcase_file_seeded = 0;
2284 my $checklicenseline = 1;
2286 sanitise_line_reset();
2288 foreach my $rawline (@rawlines) {
2292 push(@fixed, $rawline) if ($fix);
2294 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2296 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
2301 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2310 # Guestimate if this is a continuing comment. Run
2311 # the context looking for a comment "edge". If this
2312 # edge is a close comment then we must be in a comment
2316 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2317 next if (defined $rawlines[$ln - 1] &&
2318 $rawlines[$ln - 1] =~ /^-/);
2320 #print "RAW<$rawlines[$ln - 1]>\n";
2321 last if (!defined $rawlines[$ln - 1]);
2322 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2323 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2328 if (defined $edge && $edge eq '*/') {
2332 # Guestimate if this is a continuing comment. If this
2333 # is the start of a diff block and this line starts
2334 # ' *' then it is very likely a comment.
2335 if (!defined $edge &&
2336 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2341 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2342 sanitise_line_reset($in_comment);
2344 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2345 # Standardise the strings and chars within the input to
2346 # simplify matching -- only bother with positive lines.
2347 $line = sanitise_line($rawline);
2349 push(@lines, $line);
2352 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2357 #print "==>$rawline\n";
2358 #print "-->$line\n";
2360 if ($setup_docs && $line =~ /^\+/) {
2361 push(@setup_docs, $line);
2370 foreach my $line (@lines) {
2373 my $sline = $line; #copy of $line
2374 $sline =~ s/$;/ /g; #with comments as spaces
2376 my $rawline = $rawlines[$linenr - 1];
2378 #extract the line range in the file after the patch is applied
2379 if (!$in_commit_log &&
2380 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2383 $first_line = $linenr + 1;
2393 %suppress_ifbraces = ();
2394 %suppress_whiletrailers = ();
2395 %suppress_export = ();
2396 $suppress_statement = 0;
2397 if ($context =~ /\b(\w+)\s*\(/) {
2398 $context_function = $1;
2400 undef $context_function;
2404 # track the line number as we move through the hunk, note that
2405 # new versions of GNU diff omit the leading space on completely
2406 # blank context lines so we need to count that too.
2407 } elsif ($line =~ /^( |\+|$)/) {
2409 $realcnt-- if ($realcnt != 0);
2411 # Measure the line length and indent.
2412 ($length, $indent) = line_stats($rawline);
2414 # Track the previous line.
2415 ($prevline, $stashline) = ($stashline, $line);
2416 ($previndent, $stashindent) = ($stashindent, $indent);
2417 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2419 #warn "line<$line>\n";
2421 } elsif ($realcnt == 1) {
2425 my $hunk_line = ($realcnt != 0);
2427 $here = "#$linenr: " if (!$file);
2428 $here = "#$realline: " if ($file);
2431 # extract the filename as it passes
2432 if ($line =~ /^diff --git.*?(\S+)$/) {
2434 $realfile =~ s@^([^/]*)/@@ if (!$file);
2437 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2439 $realfile =~ s@^([^/]*)/@@ if (!$file);
2443 if (!$file && $tree && $p1_prefix ne '' &&
2444 -e "$root/$p1_prefix") {
2445 WARN("PATCH_PREFIX",
2446 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2449 if ($realfile =~ m@^include/asm/@) {
2450 ERROR("MODIFIED_INCLUDE_ASM",
2451 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2456 #make up the handle for any error we report on this line
2458 $prefix = "$realfile:$realline: "
2461 $prefix = "$filename:$realline: ";
2463 $prefix = "$filename:$linenr: ";
2468 if (is_maintained_obsolete($realfile)) {
2470 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2472 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2475 $check = $check_orig;
2477 $checklicenseline = 1;
2481 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2483 my $hereline = "$here\n$rawline\n";
2484 my $herecurr = "$here\n$rawline\n";
2485 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2487 $cnt_lines++ if ($realcnt != 0);
2489 # Check if the commit log has what seems like a diff which can confuse patch
2490 if ($in_commit_log && !$commit_log_has_diff &&
2491 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2492 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2493 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2494 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2495 ERROR("DIFF_IN_COMMIT_MSG",
2496 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2497 $commit_log_has_diff = 1;
2500 # Check for incorrect file permissions
2501 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2502 my $permhere = $here . "FILE: $realfile\n";
2503 if ($realfile !~ m@scripts/@ &&
2504 $realfile !~ /\.(py|pl|awk|sh)$/) {
2505 ERROR("EXECUTE_PERMISSIONS",
2506 "do not set execute permissions for source files\n" . $permhere);
2510 # Check the patch for a signoff:
2511 if ($line =~ /^\s*signed-off-by:/i) {
2516 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2517 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2518 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2519 $reported_maintainer_file = 1;
2522 # Check signature styles
2523 if (!$in_header_lines &&
2524 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2525 my $space_before = $1;
2527 my $space_after = $3;
2529 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2531 if ($sign_off !~ /$signature_tags/) {
2532 WARN("BAD_SIGN_OFF",
2533 "Non-standard signature: $sign_off\n" . $herecurr);
2535 if (defined $space_before && $space_before ne "") {
2536 if (WARN("BAD_SIGN_OFF",
2537 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2539 $fixed[$fixlinenr] =
2540 "$ucfirst_sign_off $email";
2543 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2544 if (WARN("BAD_SIGN_OFF",
2545 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2547 $fixed[$fixlinenr] =
2548 "$ucfirst_sign_off $email";
2552 if (!defined $space_after || $space_after ne " ") {
2553 if (WARN("BAD_SIGN_OFF",
2554 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2556 $fixed[$fixlinenr] =
2557 "$ucfirst_sign_off $email";
2561 my ($email_name, $email_address, $comment) = parse_email($email);
2562 my $suggested_email = format_email(($email_name, $email_address));
2563 if ($suggested_email eq "") {
2564 ERROR("BAD_SIGN_OFF",
2565 "Unrecognized email address: '$email'\n" . $herecurr);
2567 my $dequoted = $suggested_email;
2568 $dequoted =~ s/^"//;
2569 $dequoted =~ s/" </ </;
2570 # Don't force email to have quotes
2571 # Allow just an angle bracketed address
2572 if ("$dequoted$comment" ne $email &&
2573 "<$email_address>$comment" ne $email &&
2574 "$suggested_email$comment" ne $email) {
2575 WARN("BAD_SIGN_OFF",
2576 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2580 # Check for duplicate signatures
2581 my $sig_nospace = $line;
2582 $sig_nospace =~ s/\s//g;
2583 $sig_nospace = lc($sig_nospace);
2584 if (defined $signatures{$sig_nospace}) {
2585 WARN("BAD_SIGN_OFF",
2586 "Duplicate signature\n" . $herecurr);
2588 $signatures{$sig_nospace} = 1;
2592 # Check email subject for common tools that don't need to be mentioned
2593 if ($in_header_lines &&
2594 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2595 WARN("EMAIL_SUBJECT",
2596 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2599 # Check for old stable address
2600 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2601 ERROR("STABLE_ADDRESS",
2602 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2605 # Check for unwanted Gerrit info
2606 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2607 ERROR("GERRIT_CHANGE_ID",
2608 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2611 # Check if the commit log is in a possible stack dump
2612 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2613 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2614 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2616 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2617 # stack dump address
2618 $commit_log_possible_stack_dump = 1;
2621 # Check for line lengths > 75 in commit log, warn once
2622 if ($in_commit_log && !$commit_log_long_line &&
2623 length($line) > 75 &&
2624 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2625 # file delta changes
2626 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2628 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2629 # A Fixes: or Link: line
2630 $commit_log_possible_stack_dump)) {
2631 WARN("COMMIT_LOG_LONG_LINE",
2632 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2633 $commit_log_long_line = 1;
2636 # Reset possible stack dump if a blank line is found
2637 if ($in_commit_log && $commit_log_possible_stack_dump &&
2639 $commit_log_possible_stack_dump = 0;
2642 # Check for git id commit length and improperly formed commit descriptions
2643 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2644 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
2645 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
2646 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2647 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2648 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2649 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2650 my $init_char = "c";
2651 my $orig_commit = "";
2658 my $id = '0123456789ab';
2659 my $orig_desc = "commit description";
2660 my $description = "";
2662 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2664 $orig_commit = lc($2);
2665 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2666 $orig_commit = lc($1);
2669 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2670 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2671 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2672 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2673 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2676 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2677 defined $rawlines[$linenr] &&
2678 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2681 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2682 defined $rawlines[$linenr] &&
2683 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2684 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2686 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2687 $orig_desc .= " " . $1;
2691 ($id, $description) = git_commit_info($orig_commit,
2695 ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
2696 ERROR("GIT_COMMIT_ID",
2697 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2701 # Check for added, moved or deleted files
2702 if (!$reported_maintainer_file && !$in_commit_log &&
2703 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2704 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2705 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2706 (defined($1) || defined($2))))) {
2708 $reported_maintainer_file = 1;
2709 WARN("FILE_PATH_CHANGES",
2710 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2713 # Check for wrappage within a valid hunk of the file
2714 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2715 ERROR("CORRUPTED_PATCH",
2716 "patch seems to be corrupt (line wrapped?)\n" .
2717 $herecurr) if (!$emitted_corrupt++);
2720 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2721 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2722 $rawline !~ m/^$UTF8*$/) {
2723 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2725 my $blank = copy_spacing($rawline);
2726 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2727 my $hereptr = "$hereline$ptr\n";
2730 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2733 # Check if it's the start of a commit log
2734 # (not a header line and we haven't seen the patch filename)
2735 if ($in_header_lines && $realfile =~ /^$/ &&
2736 !($rawline =~ /^\s+(?:\S|$)/ ||
2737 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
2738 $in_header_lines = 0;
2740 $has_commit_log = 1;
2743 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2744 # declined it, i.e defined some charset where it is missing.
2745 if ($in_header_lines &&
2746 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2748 $non_utf8_charset = 1;
2751 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2752 $rawline =~ /$NON_ASCII_UTF8/) {
2753 WARN("UTF8_BEFORE_PATCH",
2754 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2757 # Check for absolute kernel paths in commit message
2758 if ($tree && $in_commit_log) {
2759 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2762 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2763 check_absolute_file($1, $herecurr)) {
2766 check_absolute_file($file, $herecurr);
2771 # Check for various typo / spelling mistakes
2772 if (defined($misspellings) &&
2773 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2774 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2776 my $typo_fix = $spelling_fix{lc($typo)};
2777 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2778 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2779 my $msg_level = \&WARN;
2780 $msg_level = \&CHK if ($file);
2781 if (&{$msg_level}("TYPO_SPELLING",
2782 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2784 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2789 # ignore non-hunk lines and lines being removed
2790 next if (!$hunk_line || $line =~ /^-/);
2792 #trailing whitespace
2793 if ($line =~ /^\+.*\015/) {
2794 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2795 if (ERROR("DOS_LINE_ENDINGS",
2796 "DOS line endings\n" . $herevet) &&
2798 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2800 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2801 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2802 if (ERROR("TRAILING_WHITESPACE",
2803 "trailing whitespace\n" . $herevet) &&
2805 $fixed[$fixlinenr] =~ s/\s+$//;
2811 # Check for FSF mailing addresses.
2812 if ($rawline =~ /\bwrite to the Free/i ||
2813 $rawline =~ /\b675\s+Mass\s+Ave/i ||
2814 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2815 $rawline =~ /\b51\s+Franklin\s+St/i) {
2816 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2817 my $msg_level = \&ERROR;
2818 $msg_level = \&CHK if ($file);
2819 &{$msg_level}("FSF_MAILING_ADDRESS",
2820 "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)
2823 # check for Kconfig help text having a real description
2824 # Only applies when adding the entry originally, after that we do not have
2825 # sufficient context to determine whether it is indeed long enough.
2826 if ($realfile =~ /Kconfig/ &&
2827 # 'choice' is usually the last thing on the line (though
2828 # Kconfig supports named choices), so use a word boundary
2829 # (\b) rather than a whitespace character (\s)
2830 $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
2833 my $ln = $linenr + 1;
2837 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2838 $f = $lines[$ln - 1];
2839 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2840 $is_end = $lines[$ln - 1] =~ /^\+/;
2842 next if ($f =~ /^-/);
2843 last if (!$file && $f =~ /^\@\@/);
2845 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
2847 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:help|---help---)\s*$/) {
2848 if ($lines[$ln - 1] =~ "---help---") {
2849 WARN("CONFIG_DESCRIPTION",
2850 "prefer 'help' over '---help---' for new help texts\n" . $herecurr);
2858 next if ($f =~ /^$/);
2860 # This only checks context lines in the patch
2861 # and so hopefully shouldn't trigger false
2862 # positives, even though some of these are
2863 # common words in help texts
2864 if ($f =~ /^\s*(?:config|menuconfig|choice|endchoice|
2865 if|endif|menu|endmenu|source)\b/x) {
2871 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2872 WARN("CONFIG_DESCRIPTION",
2873 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2875 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2878 # check for MAINTAINERS entries that don't have the right form
2879 if ($realfile =~ /^MAINTAINERS$/ &&
2880 $rawline =~ /^\+[A-Z]:/ &&
2881 $rawline !~ /^\+[A-Z]:\t\S/) {
2882 if (WARN("MAINTAINERS_STYLE",
2883 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
2885 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
2889 # discourage the use of boolean for type definition attributes of Kconfig options
2890 if ($realfile =~ /Kconfig/ &&
2891 $line =~ /^\+\s*\bboolean\b/) {
2892 WARN("CONFIG_TYPE_BOOLEAN",
2893 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2896 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2897 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2900 'EXTRA_AFLAGS' => 'asflags-y',
2901 'EXTRA_CFLAGS' => 'ccflags-y',
2902 'EXTRA_CPPFLAGS' => 'cppflags-y',
2903 'EXTRA_LDFLAGS' => 'ldflags-y',
2906 WARN("DEPRECATED_VARIABLE",
2907 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2910 # check for DT compatible documentation
2911 if (defined $root &&
2912 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2913 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2915 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2917 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2918 my $vp_file = $dt_path . "vendor-prefixes.txt";
2920 foreach my $compat (@compats) {
2921 my $compat2 = $compat;
2922 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2923 my $compat3 = $compat;
2924 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2925 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2927 WARN("UNDOCUMENTED_DT_STRING",
2928 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2931 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2933 `grep -Eq "^$vendor\\b" $vp_file`;
2935 WARN("UNDOCUMENTED_DT_STRING",
2936 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2941 # check for using SPDX license tag at beginning of files
2942 if ($realline == $checklicenseline) {
2943 if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
2944 $checklicenseline = 2;
2945 } elsif ($rawline =~ /^\+/) {
2947 if ($realfile =~ /\.(h|s|S)$/) {
2949 } elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
2951 } elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc)$/) {
2953 } elsif ($realfile =~ /\.rst$/) {
2957 if ($comment !~ /^$/ &&
2958 $rawline !~ /^\+\Q$comment\E SPDX-License-Identifier: /) {
2959 WARN("SPDX_LICENSE_TAG",
2960 "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
2965 # check we are in a valid source file if not then ignore this hunk
2966 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
2968 # line length limit (with some exclusions)
2970 # There are a few types of lines that may extend beyond $max_line_length:
2971 # logging functions like pr_info that end in a string
2972 # lines with a single string
2973 # #defines that are a single string
2974 # lines with an RFC3986 like URL
2976 # There are 3 different line length message types:
2977 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
2978 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2979 # LONG_LINE all other lines longer than $max_line_length
2981 # if LONG_LINE is ignored, the other 2 types are also ignored
2984 if ($line =~ /^\+/ && $length > $max_line_length) {
2985 my $msg_type = "LONG_LINE";
2987 # Check the allowed long line types first
2989 # logging functions that end in a string that starts
2990 # before $max_line_length
2991 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2992 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2995 # lines with only strings (w/ possible termination)
2996 # #defines with only strings
2997 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2998 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
3001 # More special cases
3002 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3003 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3006 # URL ($rawline is used in case the URL is in a comment)
3007 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
3010 # Otherwise set the alternate message types
3012 # a comment starts before $max_line_length
3013 } elsif ($line =~ /($;[\s$;]*)$/ &&
3014 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3015 $msg_type = "LONG_LINE_COMMENT"
3017 # a quoted string starts before $max_line_length
3018 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3019 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3020 $msg_type = "LONG_LINE_STRING"
3023 if ($msg_type ne "" &&
3024 (show_type("LONG_LINE") || show_type($msg_type))) {
3026 "line over $max_line_length characters\n" . $herecurr);
3030 # check for adding lines without a newline.
3031 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3032 WARN("MISSING_EOF_NEWLINE",
3033 "adding a line without newline at end of file\n" . $herecurr);
3036 # check we are in a valid source file C or perl if not then ignore this hunk
3037 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3039 # at the beginning of a line any tabs must come first and anything
3040 # more than 8 must use tabs.
3041 if ($rawline =~ /^\+\s* \t\s*\S/ ||
3042 $rawline =~ /^\+\s* \s*/) {
3043 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3045 if (ERROR("CODE_INDENT",
3046 "code indent should use tabs where possible\n" . $herevet) &&
3048 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3052 # check for space before tabs.
3053 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3054 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3055 if (WARN("SPACE_BEFORE_TAB",
3056 "please, no space before tabs\n" . $herevet) &&
3058 while ($fixed[$fixlinenr] =~
3059 s/(^\+.*) {8,8}\t/$1\t\t/) {}
3060 while ($fixed[$fixlinenr] =~
3061 s/(^\+.*) +\t/$1\t/) {}
3065 # check for assignments on the start of a line
3066 if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3067 CHK("ASSIGNMENT_CONTINUATIONS",
3068 "Assignment operator '$1' should be on the previous line\n" . $hereprev);
3071 # check for && or || at the start of a line
3072 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3073 CHK("LOGICAL_CONTINUATIONS",
3074 "Logical continuations should be on the previous line\n" . $hereprev);
3077 # check indentation starts on a tab stop
3078 if ($^V && $^V ge 5.10.0 &&
3079 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3080 my $indent = length($1);
3083 "Statements should start on a tabstop\n" . $herecurr) &&
3085 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
3090 # check multi-line statement indentation matches previous line
3091 if ($^V && $^V ge 5.10.0 &&
3092 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3093 $prevline =~ /^\+(\t*)(.*)$/;
3097 my $pos = pos_last_openparen($rest);
3099 $line =~ /^(\+| )([ \t]*)/;
3102 my $goodtabindent = $oldindent .
3105 my $goodspaceindent = $oldindent . " " x $pos;
3107 if ($newindent ne $goodtabindent &&
3108 $newindent ne $goodspaceindent) {
3110 if (CHK("PARENTHESIS_ALIGNMENT",
3111 "Alignment should match open parenthesis\n" . $hereprev) &&
3112 $fix && $line =~ /^\+/) {
3113 $fixed[$fixlinenr] =~
3114 s/^\+[ \t]*/\+$goodtabindent/;
3120 # check for space after cast like "(int) foo" or "(struct foo) bar"
3121 # avoid checking a few false positives:
3122 # "sizeof(<type>)" or "__alignof__(<type>)"
3123 # function pointer declarations like "(*foo)(int) = bar;"
3124 # structure definitions like "(struct foo) { 0 };"
3125 # multiline macros that define functions
3126 # known attributes or the __attribute__ keyword
3127 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3128 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3130 "No space is necessary after a cast\n" . $herecurr) &&
3132 $fixed[$fixlinenr] =~
3133 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3137 # Block comment styles
3138 # Networking with an initial /*
3139 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3140 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3141 $rawline =~ /^\+[ \t]*\*/ &&
3143 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3144 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3147 # Block comments use * on subsequent lines
3148 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3149 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
3150 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3151 $rawline =~ /^\+/ && #line is new
3152 $rawline !~ /^\+[ \t]*\*/) { #no leading *
3153 WARN("BLOCK_COMMENT_STYLE",
3154 "Block comments use * on subsequent lines\n" . $hereprev);
3157 # Block comments use */ on trailing lines
3158 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
3159 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3160 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3161 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
3162 WARN("BLOCK_COMMENT_STYLE",
3163 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3166 # Block comment * alignment
3167 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3168 $line =~ /^\+[ \t]*$;/ && #leading comment
3169 $rawline =~ /^\+[ \t]*\*/ && #leading *
3170 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
3171 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3172 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3174 $prevrawline =~ m@^\+([ \t]*/?)\*@;
3176 $oldindent = expand_tabs($1);
3178 $prevrawline =~ m@^\+(.*/?)\*@;
3179 $oldindent = expand_tabs($1);
3181 $rawline =~ m@^\+([ \t]*)\*@;
3183 $newindent = expand_tabs($newindent);
3184 if (length($oldindent) ne length($newindent)) {
3185 WARN("BLOCK_COMMENT_STYLE",
3186 "Block comments should align the * on each line\n" . $hereprev);
3190 # check for missing blank lines after struct/union declarations
3191 # with exceptions for various attributes and macros
3192 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3194 !($line =~ /^\+\s*$/ ||
3195 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3196 $line =~ /^\+\s*MODULE_/i ||
3197 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3198 $line =~ /^\+[a-z_]*init/ ||
3199 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3200 $line =~ /^\+\s*DECLARE/ ||
3201 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3202 $line =~ /^\+\s*__setup/)) {
3203 if (CHK("LINE_SPACING",
3204 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3206 fix_insert_line($fixlinenr, "\+");
3210 # check for multiple consecutive blank lines
3211 if ($prevline =~ /^[\+ ]\s*$/ &&
3212 $line =~ /^\+\s*$/ &&
3213 $last_blank_line != ($linenr - 1)) {
3214 if (CHK("LINE_SPACING",
3215 "Please don't use multiple blank lines\n" . $hereprev) &&
3217 fix_delete_line($fixlinenr, $rawline);
3220 $last_blank_line = $linenr;
3223 # check for missing blank lines after declarations
3224 if ($sline =~ /^\+\s+\S/ && #Not at char 1
3225 # actual declarations
3226 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3227 # function pointer declarations
3228 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3229 # foo bar; where foo is some local typedef or #define
3230 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3231 # known declaration macros
3232 $prevline =~ /^\+\s+$declaration_macros/) &&
3233 # for "else if" which can look like "$Ident $Ident"
3234 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3235 # other possible extensions of declaration lines
3236 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3237 # not starting a section or a macro "\" extended line
3238 $prevline =~ /(?:\{\s*|\\)$/) &&
3239 # looks like a declaration
3240 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3241 # function pointer declarations
3242 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3243 # foo bar; where foo is some local typedef or #define
3244 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3245 # known declaration macros
3246 $sline =~ /^\+\s+$declaration_macros/ ||
3247 # start of struct or union or enum
3248 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
3249 # start or end of block or continuation of declaration
3250 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3251 # bitfield continuation
3252 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3253 # other possible extensions of declaration lines
3254 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3255 # indentation of previous and current line are the same
3256 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3257 if (WARN("LINE_SPACING",
3258 "Missing a blank line after declarations\n" . $hereprev) &&
3260 fix_insert_line($fixlinenr, "\+");
3264 # check for spaces at the beginning of a line.
3266 # 1) within comments
3267 # 2) indented preprocessor commands
3269 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3270 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3271 if (WARN("LEADING_SPACE",
3272 "please, no spaces at the start of a line\n" . $herevet) &&
3274 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3278 # check we are in a valid C source file if not then ignore this hunk
3279 next if ($realfile !~ /\.(h|c)$/);
3281 # check for unusual line ending [ or (
3282 if ($line =~ /^\+.*([\[\(])\s*$/) {
3283 CHK("OPEN_ENDED_LINE",
3284 "Lines should not end with a '$1'\n" . $herecurr);
3287 # check if this appears to be the start function declaration, save the name
3288 if ($sline =~ /^\+\{\s*$/ &&
3289 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3290 $context_function = $1;
3293 # check if this appears to be the end of function declaration
3294 if ($sline =~ /^\+\}\s*$/) {
3295 undef $context_function;
3298 # check indentation of any line with a bare else
3299 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3300 # if the previous line is a break or return and is indented 1 tab more...
3301 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3302 my $tabs = length($1) + 1;
3303 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3304 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3305 defined $lines[$linenr] &&
3306 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3307 WARN("UNNECESSARY_ELSE",
3308 "else is not generally useful after a break or return\n" . $hereprev);
3312 # check indentation of a line with a break;
3313 # if the previous line is a goto or return and is indented the same # of tabs
3314 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3316 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3317 WARN("UNNECESSARY_BREAK",
3318 "break is not useful after a goto or return\n" . $hereprev);
3322 # check for RCS/CVS revision markers
3323 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3325 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3328 # check for old HOTPLUG __dev<foo> section markings
3329 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3330 WARN("HOTPLUG_SECTION",
3331 "Using $1 is unnecessary\n" . $herecurr);
3334 # Check for potential 'bare' types
3335 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3337 #print "LINE<$line>\n";
3338 if ($linenr > $suppress_statement &&
3339 $realcnt && $sline =~ /.\s*\S/) {
3340 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3341 ctx_statement_block($linenr, $realcnt, 0);
3342 $stat =~ s/\n./\n /g;
3343 $cond =~ s/\n./\n /g;
3345 #print "linenr<$linenr> <$stat>\n";
3346 # If this statement has no statement boundaries within
3347 # it there is no point in retrying a statement scan
3348 # until we hit end of it.
3349 my $frag = $stat; $frag =~ s/;+\s*$//;
3350 if ($frag !~ /(?:{|;)/) {
3351 #print "skip<$line_nr_next>\n";
3352 $suppress_statement = $line_nr_next;
3355 # Find the real next line.
3356 $realline_next = $line_nr_next;
3357 if (defined $realline_next &&
3358 (!defined $lines[$realline_next - 1] ||
3359 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3366 # Ignore goto labels.
3367 if ($s =~ /$Ident:\*$/s) {
3369 # Ignore functions being called
3370 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3372 } elsif ($s =~ /^.\s*else\b/s) {
3374 # declarations always start with types
3375 } 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) {
3378 possible($type, "A:" . $s);
3380 # definitions in global scope can only start with types
3381 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3382 possible($1, "B:" . $s);
3385 # any (foo ... *) is a pointer cast, and foo is a type
3386 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3387 possible($1, "C:" . $s);
3390 # Check for any sort of function declaration.
3391 # int foo(something bar, other baz);
3392 # void (*store_gdt)(x86_descr_ptr *);
3393 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3394 my ($name_len) = length($1);
3397 substr($ctx, 0, $name_len + 1, '');
3398 $ctx =~ s/\)[^\)]*$//;
3400 for my $arg (split(/\s*,\s*/, $ctx)) {
3401 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3403 possible($1, "D:" . $s);
3411 # Checks which may be anchored in the context.
3414 # Check for switch () and associated case and default
3415 # statements should be at the same indent.
3416 if ($line=~/\bswitch\s*\(.*\)/) {
3419 my @ctx = ctx_block_outer($linenr, $realcnt);
3421 for my $ctx (@ctx) {
3422 my ($clen, $cindent) = line_stats($ctx);
3423 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3424 $indent != $cindent) {
3425 $err .= "$sep$ctx\n";
3432 ERROR("SWITCH_CASE_INDENT_LEVEL",
3433 "switch and case should be at the same indent\n$hereline$err");
3437 # if/while/etc brace do not go on next line, unless defining a do while loop,
3438 # or if that brace on the next line is for something else
3439 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3440 my $pre_ctx = "$1$2";
3442 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3444 if ($line =~ /^\+\t{6,}/) {
3445 WARN("DEEP_INDENTATION",
3446 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3449 my $ctx_cnt = $realcnt - $#ctx - 1;
3450 my $ctx = join("\n", @ctx);
3452 my $ctx_ln = $linenr;
3453 my $ctx_skip = $realcnt;
3455 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3456 defined $lines[$ctx_ln - 1] &&
3457 $lines[$ctx_ln - 1] =~ /^-/)) {
3458 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3459 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3463 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3464 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3466 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3468 "that open brace { should be on the previous line\n" .
3469 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3471 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3472 $ctx =~ /\)\s*\;\s*$/ &&
3473 defined $lines[$ctx_ln - 1])
3475 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3476 if ($nindent > $indent) {
3477 WARN("TRAILING_SEMICOLON",
3478 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3479 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3484 # Check relative indent for conditionals and blocks.
3485 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3486 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3487 ctx_statement_block($linenr, $realcnt, 0)
3488 if (!defined $stat);
3489 my ($s, $c) = ($stat, $cond);
3491 substr($s, 0, length($c), '');
3493 # remove inline comments
3497 # Find out how long the conditional actually is.
3498 my @newlines = ($c =~ /\n/gs);
3499 my $cond_lines = 1 + $#newlines;
3501 # Make sure we remove the line prefixes as we have
3502 # none on the first line, and are going to readd them
3505 while ($s =~ /\n\s+\\\n/) {
3506 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3509 # We want to check the first line inside the block
3510 # starting at the end of the conditional, so remove:
3511 # 1) any blank line termination
3512 # 2) any opening brace { on end of the line
3514 my $continuation = 0;
3516 $s =~ s/^.*\bdo\b//;
3518 if ($s =~ s/^\s*\\//) {
3521 if ($s =~ s/^\s*?\n//) {
3526 # Also ignore a loop construct at the end of a
3527 # preprocessor statement.
3528 if (($prevline =~ /^.\s*#\s*define\s/ ||
3529 $prevline =~ /\\\s*$/) && $continuation == 0) {
3535 while ($cond_ptr != $cond_lines) {
3536 $cond_ptr = $cond_lines;
3538 # If we see an #else/#elif then the code
3540 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3545 # 1) blank lines, they should be at 0,
3546 # 2) preprocessor lines, and
3548 if ($continuation ||
3550 $s =~ /^\s*#\s*?/ ||
3551 $s =~ /^\s*$Ident\s*:/) {
3552 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3553 if ($s =~ s/^.*?\n//) {
3559 my (undef, $sindent) = line_stats("+" . $s);
3560 my $stat_real = raw_line($linenr, $cond_lines);
3562 # Check if either of these lines are modified, else
3563 # this is not this patch's fault.
3564 if (!defined($stat_real) ||
3565 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3568 if (defined($stat_real) && $cond_lines > 1) {
3569 $stat_real = "[...]\n$stat_real";
3572 #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";
3574 if ($check && $s ne '' &&
3575 (($sindent % 8) != 0 ||
3576 ($sindent < $indent) ||
3577 ($sindent == $indent &&
3578 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
3579 ($sindent > $indent + 8))) {
3580 WARN("SUSPECT_CODE_INDENT",
3581 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3585 # Track the 'values' across context and added lines.
3586 my $opline = $line; $opline =~ s/^./ /;
3587 my ($curr_values, $curr_vars) =
3588 annotate_values($opline . "\n", $prev_values);
3589 $curr_values = $prev_values . $curr_values;
3591 my $outline = $opline; $outline =~ s/\t/ /g;
3592 print "$linenr > .$outline\n";
3593 print "$linenr > $curr_values\n";
3594 print "$linenr > $curr_vars\n";
3596 $prev_values = substr($curr_values, -1);
3598 #ignore lines not being added
3599 next if ($line =~ /^[^\+]/);
3601 # check for dereferences that span multiple lines
3602 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3603 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3604 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3606 $line =~ /^.\s*($Lval)/;
3609 WARN("MULTILINE_DEREFERENCE",
3610 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3613 # check for declarations of signed or unsigned without int
3614 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3617 $var = "" if (!defined $var);
3618 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3622 $pointer = "" if (!defined $pointer);
3624 if (WARN("UNSPECIFIED_INT",
3625 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3627 my $decl = trim($sign) . " int ";
3628 my $comp_pointer = $pointer;
3629 $comp_pointer =~ s/\s//g;
3630 $decl .= $comp_pointer;
3631 $decl = rtrim($decl) if ($var eq "");
3632 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3637 # TEST: allow direct testing of the type matcher.
3639 if ($line =~ /^.\s*$Declare\s*$/) {
3641 "TEST: is type\n" . $herecurr);
3642 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3643 ERROR("TEST_NOT_TYPE",
3644 "TEST: is not type ($1 is)\n". $herecurr);
3648 # TEST: allow direct testing of the attribute matcher.
3650 if ($line =~ /^.\s*$Modifier\s*$/) {
3652 "TEST: is attr\n" . $herecurr);
3653 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3654 ERROR("TEST_NOT_ATTR",
3655 "TEST: is not attr ($1 is)\n". $herecurr);
3660 # check for initialisation to aggregates open brace on the next line
3661 if ($line =~ /^.\s*{/ &&
3662 $prevline =~ /(?:^|[^=])=\s*$/) {
3663 if (ERROR("OPEN_BRACE",
3664 "that open brace { should be on the previous line\n" . $hereprev) &&
3665 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3666 fix_delete_line($fixlinenr - 1, $prevrawline);
3667 fix_delete_line($fixlinenr, $rawline);
3668 my $fixedline = $prevrawline;
3669 $fixedline =~ s/\s*=\s*$/ = {/;
3670 fix_insert_line($fixlinenr, $fixedline);
3672 $fixedline =~ s/^(.\s*)\{\s*/$1/;
3673 fix_insert_line($fixlinenr, $fixedline);
3678 # Checks which are anchored on the added line.
3681 # check for malformed paths in #include statements (uses RAW line)
3682 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3684 if ($path =~ m{//}) {
3685 ERROR("MALFORMED_INCLUDE",
3686 "malformed #include filename\n" . $herecurr);
3688 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3689 ERROR("UAPI_INCLUDE",
3690 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3694 # no C99 // comments
3695 if ($line =~ m{//}) {
3696 if (ERROR("C99_COMMENTS",
3697 "do not use C99 // comments\n" . $herecurr) &&
3699 my $line = $fixed[$fixlinenr];
3700 if ($line =~ /\/\/(.*)$/) {
3701 my $comment = trim($1);
3702 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3706 # Remove C99 comments.
3708 $opline =~ s@//.*@@;
3710 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3711 # the whole statement.
3712 #print "APW <$lines[$realline_next - 1]>\n";
3713 if (defined $realline_next &&
3714 exists $lines[$realline_next - 1] &&
3715 !defined $suppress_export{$realline_next} &&
3716 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3717 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3718 # Handle definitions which produce identifiers with
3721 # EXPORT_SYMBOL(something_foo);
3723 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3724 $name =~ /^${Ident}_$2/) {
3725 #print "FOO C name<$name>\n";
3726 $suppress_export{$realline_next} = 1;
3728 } elsif ($stat !~ /(?:
3730 ^.DEFINE_$Ident\(\Q$name\E\)|
3731 ^.DECLARE_$Ident\(\Q$name\E\)|
3732 ^.LIST_HEAD\(\Q$name\E\)|
3733 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3734 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3736 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3737 $suppress_export{$realline_next} = 2;
3739 $suppress_export{$realline_next} = 1;
3742 if (!defined $suppress_export{$linenr} &&
3743 $prevline =~ /^.\s*$/ &&
3744 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3745 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3746 #print "FOO B <$lines[$linenr - 1]>\n";
3747 $suppress_export{$linenr} = 2;
3749 if (defined $suppress_export{$linenr} &&
3750 $suppress_export{$linenr} == 2) {
3751 WARN("EXPORT_SYMBOL",
3752 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3755 # check for global initialisers.
3756 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3757 if (ERROR("GLOBAL_INITIALISERS",
3758 "do not initialise globals to $1\n" . $herecurr) &&
3760 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3763 # check for static initialisers.
3764 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3765 if (ERROR("INITIALISED_STATIC",
3766 "do not initialise statics to $1\n" .
3769 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3773 # check for misordered declarations of char/short/int/long with signed/unsigned
3774 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3776 WARN("MISORDERED_TYPE",
3777 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3780 # check for static const char * arrays.
3781 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3782 WARN("STATIC_CONST_CHAR_ARRAY",
3783 "static const char * array should probably be static const char * const\n" .
3787 # check for static char foo[] = "bar" declarations.
3788 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3789 WARN("STATIC_CONST_CHAR_ARRAY",
3790 "static char array declaration should probably be static const char\n" .
3794 # check for const <foo> const where <foo> is not a pointer or array type
3795 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3797 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3799 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3800 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3802 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3806 # check for non-global char *foo[] = {"bar", ...} declarations.
3807 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3808 WARN("STATIC_CONST_CHAR_ARRAY",
3809 "char * array declaration might be better as static const\n" .
3813 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3814 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3816 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3818 if (WARN("ARRAY_SIZE",
3819 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3821 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3826 # check for function declarations without arguments like "int foo()"
3827 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3828 if (ERROR("FUNCTION_WITHOUT_ARGS",
3829 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3831 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3835 # check for new typedefs, only function parameters and sparse annotations
3837 if ($line =~ /\btypedef\s/ &&
3838 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3839 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3840 $line !~ /\b$typeTypedefs\b/ &&
3841 $line !~ /\b__bitwise\b/) {
3842 WARN("NEW_TYPEDEFS",
3843 "do not add new typedefs\n" . $herecurr);
3846 # * goes on variable not on type
3848 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3850 my ($ident, $from, $to) = ($1, $2, $2);
3852 # Should start with a space.
3853 $to =~ s/^(\S)/ $1/;
3854 # Should not end with a space.
3856 # '*'s should not have spaces between.
3857 while ($to =~ s/\*\s+\*/\*\*/) {
3860 ## print "1: from<$from> to<$to> ident<$ident>\n";
3862 if (ERROR("POINTER_LOCATION",
3863 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3865 my $sub_from = $ident;
3866 my $sub_to = $ident;
3867 $sub_to =~ s/\Q$from\E/$to/;
3868 $fixed[$fixlinenr] =~
3869 s@\Q$sub_from\E@$sub_to@;
3873 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3875 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3877 # Should start with a space.
3878 $to =~ s/^(\S)/ $1/;
3879 # Should not end with a space.
3881 # '*'s should not have spaces between.
3882 while ($to =~ s/\*\s+\*/\*\*/) {
3884 # Modifiers should have spaces.
3885 $to =~ s/(\b$Modifier$)/$1 /;
3887 ## print "2: from<$from> to<$to> ident<$ident>\n";
3888 if ($from ne $to && $ident !~ /^$Modifier$/) {
3889 if (ERROR("POINTER_LOCATION",
3890 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3893 my $sub_from = $match;
3894 my $sub_to = $match;
3895 $sub_to =~ s/\Q$from\E/$to/;
3896 $fixed[$fixlinenr] =~
3897 s@\Q$sub_from\E@$sub_to@;
3902 # avoid BUG() or BUG_ON()
3903 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3904 my $msg_level = \&WARN;
3905 $msg_level = \&CHK if ($file);
3906 &{$msg_level}("AVOID_BUG",
3907 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3910 # avoid LINUX_VERSION_CODE
3911 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3912 WARN("LINUX_VERSION_CODE",
3913 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3916 # check for uses of printk_ratelimit
3917 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3918 WARN("PRINTK_RATELIMITED",
3919 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3922 # printk should use KERN_* levels
3923 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
3924 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3925 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
3928 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3930 my $level = lc($orig);
3931 $level = "warn" if ($level eq "warning");
3932 my $level2 = $level;
3933 $level2 = "dbg" if ($level eq "debug");
3934 WARN("PREFER_PR_LEVEL",
3935 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3938 if ($line =~ /\bpr_warning\s*\(/) {
3939 if (WARN("PREFER_PR_LEVEL",
3940 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3942 $fixed[$fixlinenr] =~
3943 s/\bpr_warning\b/pr_warn/;
3947 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3949 my $level = lc($orig);
3950 $level = "warn" if ($level eq "warning");
3951 $level = "dbg" if ($level eq "debug");
3952 WARN("PREFER_DEV_LEVEL",
3953 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3956 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
3957 # number of false positives, but assembly files are not checked, so at
3958 # least the arch entry code will not trigger this warning.
3959 if ($line =~ /\bENOSYS\b/) {
3961 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3964 # function brace can't be on same line, except for #defines of do while,
3965 # or if closed on same line
3966 if ($^V && $^V ge 5.10.0 &&
3967 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
3968 $sline !~ /\#\s*define\b.*do\s*\{/ &&
3970 if (ERROR("OPEN_BRACE",
3971 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
3973 fix_delete_line($fixlinenr, $rawline);
3974 my $fixed_line = $rawline;
3975 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3978 fix_insert_line($fixlinenr, ltrim($line1));
3979 fix_insert_line($fixlinenr, "\+{");
3980 if ($line2 !~ /^\s*$/) {
3981 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3986 # open braces for enum, union and struct go on the same line.
3987 if ($line =~ /^.\s*{/ &&
3988 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3989 if (ERROR("OPEN_BRACE",
3990 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3991 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3992 fix_delete_line($fixlinenr - 1, $prevrawline);
3993 fix_delete_line($fixlinenr, $rawline);
3994 my $fixedline = rtrim($prevrawline) . " {";
3995 fix_insert_line($fixlinenr, $fixedline);
3996 $fixedline = $rawline;
3997 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
3998 if ($fixedline !~ /^\+\s*$/) {
3999 fix_insert_line($fixlinenr, $fixedline);
4004 # missing space after union, struct or enum definition
4005 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4007 "missing space after $1 definition\n" . $herecurr) &&
4009 $fixed[$fixlinenr] =~
4010 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4014 # Function pointer declarations
4015 # check spacing between type, funcptr, and args
4016 # canonical declaration is "type (*funcptr)(args...)"
4017 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4019 my $pre_pointer_space = $2;
4020 my $post_pointer_space = $3;
4022 my $post_funcname_space = $5;
4023 my $pre_args_space = $6;
4025 # the $Declare variable will capture all spaces after the type
4026 # so check it for a missing trailing missing space but pointer return types
4027 # don't need a space so don't warn for those.
4028 my $post_declare_space = "";
4029 if ($declare =~ /(\s+)$/) {
4030 $post_declare_space = $1;
4031 $declare = rtrim($declare);
4033 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4035 "missing space after return type\n" . $herecurr);
4036 $post_declare_space = " ";
4039 # unnecessary space "type (*funcptr)(args...)"
4040 # This test is not currently implemented because these declarations are
4042 # int foo(int bar, ...)
4043 # and this is form shouldn't/doesn't generate a checkpatch warning.
4045 # elsif ($declare =~ /\s{2,}$/) {
4047 # "Multiple spaces after return type\n" . $herecurr);
4050 # unnecessary space "type ( *funcptr)(args...)"
4051 if (defined $pre_pointer_space &&
4052 $pre_pointer_space =~ /^\s/) {
4054 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4057 # unnecessary space "type (* funcptr)(args...)"
4058 if (defined $post_pointer_space &&
4059 $post_pointer_space =~ /^\s/) {
4061 "Unnecessary space before function pointer name\n" . $herecurr);
4064 # unnecessary space "type (*funcptr )(args...)"
4065 if (defined $post_funcname_space &&
4066 $post_funcname_space =~ /^\s/) {
4068 "Unnecessary space after function pointer name\n" . $herecurr);
4071 # unnecessary space "type (*funcptr) (args...)"
4072 if (defined $pre_args_space &&
4073 $pre_args_space =~ /^\s/) {
4075 "Unnecessary space before function pointer arguments\n" . $herecurr);
4078 if (show_type("SPACING") && $fix) {
4079 $fixed[$fixlinenr] =~
4080 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4084 # check for spacing round square brackets; allowed:
4085 # 1. with a type on the left -- int [] a;
4086 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4087 # 3. inside a curly brace -- = { [0...10] = 5 }
4088 while ($line =~ /(.*?\s)\[/g) {
4089 my ($where, $prefix) = ($-[1], $1);
4090 if ($prefix !~ /$Type\s+$/ &&
4091 ($where != 0 || $prefix !~ /^.\s+$/) &&
4092 $prefix !~ /[{,:]\s+$/) {
4093 if (ERROR("BRACKET_SPACE",
4094 "space prohibited before open square bracket '['\n" . $herecurr) &&
4096 $fixed[$fixlinenr] =~
4097 s/^(\+.*?)\s+\[/$1\[/;
4102 # check for spaces between functions and their parentheses.
4103 while ($line =~ /($Ident)\s+\(/g) {
4105 my $ctx_before = substr($line, 0, $-[1]);
4106 my $ctx = "$ctx_before$name";
4108 # Ignore those directives where spaces _are_ permitted.
4110 if|for|while|switch|return|case|
4111 volatile|__volatile__|
4112 __attribute__|format|__extension__|
4115 # cpp #define statements have non-optional spaces, ie
4116 # if there is a space between the name and the open
4117 # parenthesis it is simply not a parameter group.
4118 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4120 # cpp #elif statement condition may start with a (
4121 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4123 # If this whole things ends with a type its most
4124 # likely a typedef for a function.
4125 } elsif ($ctx =~ /$Type$/) {
4129 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4131 $fixed[$fixlinenr] =~
4132 s/\b$name\s+\(/$name\(/;
4137 # Check operator spacing.
4138 if (!($line=~/\#\s*include/)) {
4139 my $fixed_line = "";
4143 <<=|>>=|<=|>=|==|!=|
4144 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4145 =>|->|<<|>>|<|>|=|!|~|
4146 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4149 my @elements = split(/($ops|;)/, $opline);
4151 ## print("element count: <" . $#elements . ">\n");
4152 ## foreach my $el (@elements) {
4153 ## print("el: <$el>\n");
4156 my @fix_elements = ();
4159 foreach my $el (@elements) {
4160 push(@fix_elements, substr($rawline, $off, length($el)));
4161 $off += length($el);
4166 my $blank = copy_spacing($opline);
4167 my $last_after = -1;
4169 for (my $n = 0; $n < $#elements; $n += 2) {
4171 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4173 ## print("n: <$n> good: <$good>\n");
4175 $off += length($elements[$n]);
4177 # Pick up the preceding and succeeding characters.
4178 my $ca = substr($opline, 0, $off);
4180 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4181 $cc = substr($opline, $off + length($elements[$n + 1]));
4183 my $cb = "$ca$;$cc";
4186 $a = 'V' if ($elements[$n] ne '');
4187 $a = 'W' if ($elements[$n] =~ /\s$/);
4188 $a = 'C' if ($elements[$n] =~ /$;$/);
4189 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4190 $a = 'O' if ($elements[$n] eq '');
4191 $a = 'E' if ($ca =~ /^\s*$/);
4193 my $op = $elements[$n + 1];
4196 if (defined $elements[$n + 2]) {
4197 $c = 'V' if ($elements[$n + 2] ne '');
4198 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4199 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4200 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4201 $c = 'O' if ($elements[$n + 2] eq '');
4202 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4207 my $ctx = "${a}x${c}";
4209 my $at = "(ctx:$ctx)";
4211 my $ptr = substr($blank, 0, $off) . "^";
4212 my $hereptr = "$hereline$ptr\n";
4214 # Pull out the value of this operator.
4215 my $op_type = substr($curr_values, $off + 1, 1);
4217 # Get the full operator variant.
4218 my $opv = $op . substr($curr_vars, $off, 1);
4220 # Ignore operators passed as parameters.
4221 if ($op_type ne 'V' &&
4222 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4225 # } elsif ($op =~ /^$;+$/) {
4227 # ; should have either the end of line or a space or \ after it
4228 } elsif ($op eq ';') {
4229 if ($ctx !~ /.x[WEBC]/ &&
4230 $cc !~ /^\\/ && $cc !~ /^;/) {
4231 if (ERROR("SPACING",
4232 "space required after that '$op' $at\n" . $hereptr)) {
4233 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4239 } elsif ($op eq '//') {
4241 # : when part of a bitfield
4242 } elsif ($opv eq ':B') {
4243 # skip the bitfield test for now
4247 } elsif ($op eq '->') {
4248 if ($ctx =~ /Wx.|.xW/) {
4249 if (ERROR("SPACING",
4250 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4251 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4252 if (defined $fix_elements[$n + 2]) {
4253 $fix_elements[$n + 2] =~ s/^\s+//;
4259 # , must not have a space before and must have a space on the right.
4260 } elsif ($op eq ',') {
4261 my $rtrim_before = 0;
4262 my $space_after = 0;
4263 if ($ctx =~ /Wx./) {
4264 if (ERROR("SPACING",
4265 "space prohibited before that '$op' $at\n" . $hereptr)) {
4270 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4271 if (ERROR("SPACING",
4272 "space required after that '$op' $at\n" . $hereptr)) {
4278 if ($rtrim_before || $space_after) {
4279 if ($rtrim_before) {
4280 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4282 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4289 # '*' as part of a type definition -- reported already.
4290 } elsif ($opv eq '*_') {
4291 #warn "'*' is part of type\n";
4293 # unary operators should have a space before and
4294 # none after. May be left adjacent to another
4295 # unary operator, or a cast
4296 } elsif ($op eq '!' || $op eq '~' ||
4297 $opv eq '*U' || $opv eq '-U' ||
4298 $opv eq '&U' || $opv eq '&&U') {
4299 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4300 if (ERROR("SPACING",
4301 "space required before that '$op' $at\n" . $hereptr)) {
4302 if ($n != $last_after + 2) {
4303 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4308 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4309 # A unary '*' may be const
4311 } elsif ($ctx =~ /.xW/) {
4312 if (ERROR("SPACING",
4313 "space prohibited after that '$op' $at\n" . $hereptr)) {
4314 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4315 if (defined $fix_elements[$n + 2]) {
4316 $fix_elements[$n + 2] =~ s/^\s+//;
4322 # unary ++ and unary -- are allowed no space on one side.
4323 } elsif ($op eq '++' or $op eq '--') {
4324 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4325 if (ERROR("SPACING",
4326 "space required one side of that '$op' $at\n" . $hereptr)) {
4327 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4331 if ($ctx =~ /Wx[BE]/ ||
4332 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4333 if (ERROR("SPACING",
4334 "space prohibited before that '$op' $at\n" . $hereptr)) {
4335 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4339 if ($ctx =~ /ExW/) {
4340 if (ERROR("SPACING",
4341 "space prohibited after that '$op' $at\n" . $hereptr)) {
4342 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4343 if (defined $fix_elements[$n + 2]) {
4344 $fix_elements[$n + 2] =~ s/^\s+//;
4350 # << and >> may either have or not have spaces both sides
4351 } elsif ($op eq '<<' or $op eq '>>' or
4352 $op eq '&' or $op eq '^' or $op eq '|' or
4353 $op eq '+' or $op eq '-' or
4354 $op eq '*' or $op eq '/' or
4358 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4360 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4361 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4362 $fix_elements[$n + 2] =~ s/^\s+//;
4365 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4367 "space preferred before that '$op' $at\n" . $hereptr)) {
4368 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4372 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4373 if (ERROR("SPACING",
4374 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4375 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4376 if (defined $fix_elements[$n + 2]) {
4377 $fix_elements[$n + 2] =~ s/^\s+//;
4383 # A colon needs no spaces before when it is
4384 # terminating a case value or a label.
4385 } elsif ($opv eq ':C' || $opv eq ':L') {
4386 if ($ctx =~ /Wx./) {
4387 if (ERROR("SPACING",
4388 "space prohibited before that '$op' $at\n" . $hereptr)) {
4389 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4394 # All the others need spaces both sides.
4395 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4398 # Ignore email addresses <foo@bar>
4400 $cc =~ /^\S+\@\S+>/) ||
4402 $ca =~ /<\S+\@\S+$/))
4407 # for asm volatile statements
4408 # ignore a colon with another
4409 # colon immediately before or after
4411 ($ca =~ /:$/ || $cc =~ /^:/)) {
4415 # messages are ERROR, but ?: are CHK
4417 my $msg_level = \&ERROR;
4418 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4420 if (&{$msg_level}("SPACING",
4421 "spaces required around that '$op' $at\n" . $hereptr)) {
4422 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4423 if (defined $fix_elements[$n + 2]) {
4424 $fix_elements[$n + 2] =~ s/^\s+//;
4430 $off += length($elements[$n + 1]);
4432 ## print("n: <$n> GOOD: <$good>\n");
4434 $fixed_line = $fixed_line . $good;
4437 if (($#elements % 2) == 0) {
4438 $fixed_line = $fixed_line . $fix_elements[$#elements];
4441 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4442 $fixed[$fixlinenr] = $fixed_line;
4448 # check for whitespace before a non-naked semicolon
4449 if ($line =~ /^\+.*\S\s+;\s*$/) {
4451 "space prohibited before semicolon\n" . $herecurr) &&
4453 1 while $fixed[$fixlinenr] =~
4454 s/^(\+.*\S)\s+;/$1;/;
4458 # check for multiple assignments
4459 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4460 CHK("MULTIPLE_ASSIGNMENTS",
4461 "multiple assignments should be avoided\n" . $herecurr);
4464 ## # check for multiple declarations, allowing for a function declaration
4466 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4467 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4469 ## # Remove any bracketed sections to ensure we do not
4470 ## # falsly report the parameters of functions.
4472 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4474 ## if ($ln =~ /,/) {
4475 ## WARN("MULTIPLE_DECLARATION",
4476 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4480 #need space before brace following if, while, etc
4481 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4483 if (ERROR("SPACING",
4484 "space required before the open brace '{'\n" . $herecurr) &&
4486 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\)))\{/$1 {/;
4490 ## # check for blank lines before declarations
4491 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4492 ## $prevrawline =~ /^.\s*$/) {
4494 ## "No blank lines before declarations\n" . $hereprev);
4498 # closing brace should have a space following it when it has anything
4500 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4501 if (ERROR("SPACING",
4502 "space required after that close brace '}'\n" . $herecurr) &&
4504 $fixed[$fixlinenr] =~
4505 s/}((?!(?:,|;|\)))\S)/} $1/;
4509 # check spacing on square brackets
4510 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4511 if (ERROR("SPACING",
4512 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4514 $fixed[$fixlinenr] =~
4518 if ($line =~ /\s\]/) {
4519 if (ERROR("SPACING",
4520 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4522 $fixed[$fixlinenr] =~
4527 # check spacing on parentheses
4528 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4529 $line !~ /for\s*\(\s+;/) {
4530 if (ERROR("SPACING",
4531 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4533 $fixed[$fixlinenr] =~
4537 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4538 $line !~ /for\s*\(.*;\s+\)/ &&
4539 $line !~ /:\s+\)/) {
4540 if (ERROR("SPACING",
4541 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4543 $fixed[$fixlinenr] =~
4548 # check unnecessary parentheses around addressof/dereference single $Lvals
4549 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4551 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4553 if (CHK("UNNECESSARY_PARENTHESES",
4554 "Unnecessary parentheses around $var\n" . $herecurr) &&
4556 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4560 # check for unnecessary parentheses around function pointer uses
4561 # ie: (foo->bar)(); should be foo->bar();
4562 # but not "if (foo->bar) (" to avoid some false positives
4563 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4565 if (CHK("UNNECESSARY_PARENTHESES",
4566 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4568 my $var2 = deparenthesize($var);
4570 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4574 # check for unnecessary parentheses around comparisons in if uses
4575 # when !drivers/staging or command-line uses --strict
4576 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
4577 $^V && $^V ge 5.10.0 && defined($stat) &&
4578 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
4580 my $test = substr($2, 1, -1);
4582 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
4584 # avoid parentheses around potential macro args
4585 next if ($match =~ /^\s*\w+\s*$/);
4586 if (!defined($herectx)) {
4587 $herectx = $here . "\n";
4588 my $cnt = statement_rawlines($if_stat);
4589 for (my $n = 0; $n < $cnt; $n++) {
4590 my $rl = raw_line($linenr, $n);
4591 $herectx .= $rl . "\n";
4592 last if $rl =~ /^[ \+].*\{/;
4595 CHK("UNNECESSARY_PARENTHESES",
4596 "Unnecessary parentheses around '$match'\n" . $herectx);
4600 #goto labels aren't indented, allow a single space however
4601 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4602 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4603 if (WARN("INDENTED_LABEL",
4604 "labels should not be indented\n" . $herecurr) &&
4606 $fixed[$fixlinenr] =~
4611 # return is not a function
4612 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4614 if ($^V && $^V ge 5.10.0 &&
4615 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4617 $value = deparenthesize($value);
4618 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4619 ERROR("RETURN_PARENTHESES",
4620 "return is not a function, parentheses are not required\n" . $herecurr);
4622 } elsif ($spacing !~ /\s+/) {
4624 "space required before the open parenthesis '('\n" . $herecurr);
4628 # unnecessary return in a void function
4629 # at end-of-function, with the previous line a single leading tab, then return;
4630 # and the line before that not a goto label target like "out:"
4631 if ($sline =~ /^[ \+]}\s*$/ &&
4632 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4634 $lines[$linenr - 3] =~ /^[ +]/ &&
4635 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4637 "void function return statements are not generally useful\n" . $hereprev);
4640 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4641 if ($^V && $^V ge 5.10.0 &&
4642 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4643 my $openparens = $1;
4644 my $count = $openparens =~ tr@\(@\(@;
4646 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4647 my $comp = $4; #Not $1 because of $LvalOrFunc
4648 $msg = " - maybe == should be = ?" if ($comp eq "==");
4649 WARN("UNNECESSARY_PARENTHESES",
4650 "Unnecessary parentheses$msg\n" . $herecurr);
4654 # comparisons with a constant or upper case identifier on the left
4655 # avoid cases like "foo + BAR < baz"
4656 # only fix matches surrounded by parentheses to avoid incorrect
4657 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4658 if ($^V && $^V ge 5.10.0 &&
4659 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4664 my $newcomp = $comp;
4665 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4666 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4667 WARN("CONSTANT_COMPARISON",
4668 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4672 } elsif ($comp eq "<=") {
4674 } elsif ($comp eq ">") {
4676 } elsif ($comp eq ">=") {
4679 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4683 # Return of what appears to be an errno should normally be negative
4684 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4686 if ($name ne 'EOF' && $name ne 'ERROR') {
4687 WARN("USE_NEGATIVE_ERRNO",
4688 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4692 # Need a space before open parenthesis after if, while etc
4693 if ($line =~ /\b(if|while|for|switch)\(/) {
4694 if (ERROR("SPACING",
4695 "space required before the open parenthesis '('\n" . $herecurr) &&
4697 $fixed[$fixlinenr] =~
4698 s/\b(if|while|for|switch)\(/$1 \(/;
4702 # Check for illegal assignment in if conditional -- and check for trailing
4703 # statements after the conditional.
4704 if ($line =~ /do\s*(?!{)/) {
4705 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4706 ctx_statement_block($linenr, $realcnt, 0)
4707 if (!defined $stat);
4708 my ($stat_next) = ctx_statement_block($line_nr_next,
4709 $remain_next, $off_next);
4710 $stat_next =~ s/\n./\n /g;
4711 ##print "stat<$stat> stat_next<$stat_next>\n";
4713 if ($stat_next =~ /^\s*while\b/) {
4714 # If the statement carries leading newlines,
4715 # then count those as offsets.
4717 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4719 statement_rawlines($whitespace) - 1;
4721 $suppress_whiletrailers{$line_nr_next +
4725 if (!defined $suppress_whiletrailers{$linenr} &&
4726 defined($stat) && defined($cond) &&
4727 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4728 my ($s, $c) = ($stat, $cond);
4730 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4731 ERROR("ASSIGN_IN_IF",
4732 "do not use assignment in if condition\n" . $herecurr);
4735 # Find out what is on the end of the line after the
4737 substr($s, 0, length($c), '');
4739 $s =~ s/$;//g; # Remove any comments
4740 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4741 $c !~ /}\s*while\s*/)
4743 # Find out how long the conditional actually is.
4744 my @newlines = ($c =~ /\n/gs);
4745 my $cond_lines = 1 + $#newlines;
4748 $stat_real = raw_line($linenr, $cond_lines)
4749 . "\n" if ($cond_lines);
4750 if (defined($stat_real) && $cond_lines > 1) {
4751 $stat_real = "[...]\n$stat_real";
4754 ERROR("TRAILING_STATEMENTS",
4755 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4759 # Check for bitwise tests written as boolean
4771 WARN("HEXADECIMAL_BOOLEAN_TEST",
4772 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4775 # if and else should not have general statements after it
4776 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4778 $s =~ s/$;//g; # Remove any comments
4779 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4780 ERROR("TRAILING_STATEMENTS",
4781 "trailing statements should be on next line\n" . $herecurr);
4784 # if should not continue a brace
4785 if ($line =~ /}\s*if\b/) {
4786 ERROR("TRAILING_STATEMENTS",
4787 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4790 # case and default should not have general statements after them
4791 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4793 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4797 ERROR("TRAILING_STATEMENTS",
4798 "trailing statements should be on next line\n" . $herecurr);
4801 # Check for }<nl>else {, these must be at the same
4802 # indent level to be relevant to each other.
4803 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4804 $previndent == $indent) {
4805 if (ERROR("ELSE_AFTER_BRACE",
4806 "else should follow close brace '}'\n" . $hereprev) &&
4807 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4808 fix_delete_line($fixlinenr - 1, $prevrawline);
4809 fix_delete_line($fixlinenr, $rawline);
4810 my $fixedline = $prevrawline;
4811 $fixedline =~ s/}\s*$//;
4812 if ($fixedline !~ /^\+\s*$/) {
4813 fix_insert_line($fixlinenr, $fixedline);
4815 $fixedline = $rawline;
4816 $fixedline =~ s/^(.\s*)else/$1} else/;
4817 fix_insert_line($fixlinenr, $fixedline);
4821 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4822 $previndent == $indent) {
4823 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4825 # Find out what is on the end of the line after the
4827 substr($s, 0, length($c), '');
4830 if ($s =~ /^\s*;/) {
4831 if (ERROR("WHILE_AFTER_BRACE",
4832 "while should follow close brace '}'\n" . $hereprev) &&
4833 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4834 fix_delete_line($fixlinenr - 1, $prevrawline);
4835 fix_delete_line($fixlinenr, $rawline);
4836 my $fixedline = $prevrawline;
4837 my $trailing = $rawline;
4838 $trailing =~ s/^\+//;
4839 $trailing = trim($trailing);
4840 $fixedline =~ s/}\s*$/} $trailing/;
4841 fix_insert_line($fixlinenr, $fixedline);
4846 #Specific variable tests
4847 while ($line =~ m{($Constant|$Lval)}g) {
4850 #gcc binary extension
4851 if ($var =~ /^$Binary$/) {
4852 if (WARN("GCC_BINARY_CONSTANT",
4853 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4855 my $hexval = sprintf("0x%x", oct($var));
4856 $fixed[$fixlinenr] =~
4857 s/\b$var\b/$hexval/;
4862 if ($var !~ /^$Constant$/ &&
4863 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4864 #Ignore Page<foo> variants
4865 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4866 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4867 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4868 #Ignore some three character SI units explicitly, like MiB and KHz
4869 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4870 while ($var =~ m{($Ident)}g) {
4872 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4874 seed_camelcase_includes();
4875 if (!$file && !$camelcase_file_seeded) {
4876 seed_camelcase_file($realfile);
4877 $camelcase_file_seeded = 1;
4880 if (!defined $camelcase{$word}) {
4881 $camelcase{$word} = 1;
4883 "Avoid CamelCase: <$word>\n" . $herecurr);
4889 #no spaces allowed after \ in define
4890 if ($line =~ /\#\s*define.*\\\s+$/) {
4891 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4892 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4894 $fixed[$fixlinenr] =~ s/\s+$//;
4898 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4899 # itself <asm/foo.h> (uses RAW line)
4900 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4902 my $checkfile = "include/linux/$file";
4903 if (-f "$root/$checkfile" &&
4904 $realfile ne $checkfile &&
4905 $1 !~ /$allowed_asm_includes/)
4907 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4908 if ($asminclude > 0) {
4909 if ($realfile =~ m{^arch/}) {
4910 CHK("ARCH_INCLUDE_LINUX",
4911 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4913 WARN("INCLUDE_LINUX",
4914 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4920 # multi-statement macros should be enclosed in a do while loop, grab the
4921 # first statement and ensure its the whole macro if its not enclosed
4922 # in a known good container
4923 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4924 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4927 my ($off, $dstat, $dcond, $rest);
4929 my $has_flow_statement = 0;
4930 my $has_arg_concat = 0;
4931 ($dstat, $dcond, $ln, $cnt, $off) =
4932 ctx_statement_block($linenr, $realcnt, 0);
4934 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4935 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4937 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4938 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
4940 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
4941 my $define_args = $1;
4942 my $define_stmt = $dstat;
4945 if (defined $define_args && $define_args ne "") {
4946 $define_args = substr($define_args, 1, length($define_args) - 2);
4947 $define_args =~ s/\s*//g;
4948 @def_args = split(",", $define_args);
4952 $dstat =~ s/\\\n.//g;
4953 $dstat =~ s/^\s*//s;
4954 $dstat =~ s/\s*$//s;
4956 # Flatten any parentheses and braces
4957 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4958 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4959 $dstat =~ s/.\[[^\[\]]*\]/1/)
4963 # Flatten any obvious string concatentation.
4964 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4965 $dstat =~ s/$Ident\s*($String)/$1/)
4969 # Make asm volatile uses seem like a generic function
4970 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
4972 my $exceptions = qr{
4985 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4988 my $stmt_cnt = statement_rawlines($ctx);
4989 my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
4992 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4993 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4994 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4995 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4996 $dstat !~ /$exceptions/ &&
4997 $dstat !~ /^\.$Ident\s*=/ && # .foo =
4998 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4999 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
5000 $dstat !~ /^for\s*$Constant$/ && # for (...)
5001 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
5002 $dstat !~ /^do\s*{/ && # do {...
5003 $dstat !~ /^\(\{/ && # ({...
5004 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
5006 if ($dstat =~ /^\s*if\b/) {
5007 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5008 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5009 } elsif ($dstat =~ /;/) {
5010 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5011 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5013 ERROR("COMPLEX_MACRO",
5014 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5019 # Make $define_stmt single line, comment-free, etc
5020 my @stmt_array = split('\n', $define_stmt);
5023 foreach my $l (@stmt_array) {
5028 } elsif ($l =~ /^[\+ ]/) {
5029 $define_stmt .= substr($l, 1);
5032 $define_stmt =~ s/$;//g;
5033 $define_stmt =~ s/\s+/ /g;
5034 $define_stmt = trim($define_stmt);
5036 # check if any macro arguments are reused (ignore '...' and 'type')
5037 foreach my $arg (@def_args) {
5038 next if ($arg =~ /\.\.\./);
5039 next if ($arg =~ /^type$/i);
5040 my $tmp_stmt = $define_stmt;
5041 $tmp_stmt =~ s/\b(typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
5042 $tmp_stmt =~ s/\#+\s*$arg\b//g;
5043 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
5044 my $use_cnt = $tmp_stmt =~ s/\b$arg\b//g;
5046 CHK("MACRO_ARG_REUSE",
5047 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
5049 # check if any macro arguments may have other precedence issues
5050 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
5051 ((defined($1) && $1 ne ',') ||
5052 (defined($2) && $2 ne ','))) {
5053 CHK("MACRO_ARG_PRECEDENCE",
5054 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
5058 # check for macros with flow control, but without ## concatenation
5059 # ## concatenation is commonly a macro that defines a function so ignore those
5060 if ($has_flow_statement && !$has_arg_concat) {
5061 my $cnt = statement_rawlines($ctx);
5062 my $herectx = get_stat_here($linenr, $cnt, $here);
5064 WARN("MACRO_WITH_FLOW_CONTROL",
5065 "Macros with flow control statements should be avoided\n" . "$herectx");
5068 # check for line continuations outside of #defines, preprocessor #, and asm
5071 if ($prevline !~ /^..*\\$/ &&
5072 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
5073 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
5074 $line =~ /^\+.*\\$/) {
5075 WARN("LINE_CONTINUATIONS",
5076 "Avoid unnecessary line continuations\n" . $herecurr);
5080 # do {} while (0) macro tests:
5081 # single-statement macros do not need to be enclosed in do while (0) loop,
5082 # macro should not end with a semicolon
5083 if ($^V && $^V ge 5.10.0 &&
5084 $realfile !~ m@/vmlinux.lds.h$@ &&
5085 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5088 my ($off, $dstat, $dcond, $rest);
5090 ($dstat, $dcond, $ln, $cnt, $off) =
5091 ctx_statement_block($linenr, $realcnt, 0);
5094 $dstat =~ s/\\\n.//g;
5097 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5102 my $cnt = statement_rawlines($ctx);
5103 my $herectx = get_stat_here($linenr, $cnt, $here);
5105 if (($stmts =~ tr/;/;/) == 1 &&
5106 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5107 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5108 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5110 if (defined $semis && $semis ne "") {
5111 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5112 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5114 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5116 my $cnt = statement_rawlines($ctx);
5117 my $herectx = get_stat_here($linenr, $cnt, $here);
5119 WARN("TRAILING_SEMICOLON",
5120 "macros should not use a trailing semicolon\n" . "$herectx");
5124 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
5125 # all assignments may have only one of the following with an assignment:
5128 # VMLINUX_SYMBOL(...)
5129 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
5130 WARN("MISSING_VMLINUX_SYMBOL",
5131 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
5134 # check for redundant bracing round if etc
5135 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5136 my ($level, $endln, @chunks) =
5137 ctx_statement_full($linenr, $realcnt, 1);
5138 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5139 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5140 if ($#chunks > 0 && $level == 0) {
5144 my $herectx = $here . "\n";
5145 my $ln = $linenr - 1;
5146 for my $chunk (@chunks) {
5147 my ($cond, $block) = @{$chunk};
5149 # If the condition carries leading newlines, then count those as offsets.
5150 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5151 my $offset = statement_rawlines($whitespace) - 1;
5153 $allowed[$allow] = 0;
5154 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5156 # We have looked at and allowed this specific line.
5157 $suppress_ifbraces{$ln + $offset} = 1;
5159 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5160 $ln += statement_rawlines($block) - 1;
5162 substr($block, 0, length($cond), '');
5164 $seen++ if ($block =~ /^\s*{/);
5166 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5167 if (statement_lines($cond) > 1) {
5168 #print "APW: ALLOWED: cond<$cond>\n";
5169 $allowed[$allow] = 1;
5171 if ($block =~/\b(?:if|for|while)\b/) {
5172 #print "APW: ALLOWED: block<$block>\n";
5173 $allowed[$allow] = 1;
5175 if (statement_block_size($block) > 1) {
5176 #print "APW: ALLOWED: lines block<$block>\n";
5177 $allowed[$allow] = 1;
5182 my $sum_allowed = 0;
5183 foreach (@allowed) {
5186 if ($sum_allowed == 0) {
5188 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5189 } elsif ($sum_allowed != $allow &&
5192 "braces {} should be used on all arms of this statement\n" . $herectx);
5197 if (!defined $suppress_ifbraces{$linenr - 1} &&
5198 $line =~ /\b(if|while|for|else)\b/) {
5201 # Check the pre-context.
5202 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5203 #print "APW: ALLOWED: pre<$1>\n";
5207 my ($level, $endln, @chunks) =
5208 ctx_statement_full($linenr, $realcnt, $-[0]);
5210 # Check the condition.
5211 my ($cond, $block) = @{$chunks[0]};
5212 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5213 if (defined $cond) {
5214 substr($block, 0, length($cond), '');
5216 if (statement_lines($cond) > 1) {
5217 #print "APW: ALLOWED: cond<$cond>\n";
5220 if ($block =~/\b(?:if|for|while)\b/) {
5221 #print "APW: ALLOWED: block<$block>\n";
5224 if (statement_block_size($block) > 1) {
5225 #print "APW: ALLOWED: lines block<$block>\n";
5228 # Check the post-context.
5229 if (defined $chunks[1]) {
5230 my ($cond, $block) = @{$chunks[1]};
5231 if (defined $cond) {
5232 substr($block, 0, length($cond), '');
5234 if ($block =~ /^\s*\{/) {
5235 #print "APW: ALLOWED: chunk-1 block<$block>\n";
5239 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5240 my $cnt = statement_rawlines($block);
5241 my $herectx = get_stat_here($linenr, $cnt, $here);
5244 "braces {} are not necessary for single statement blocks\n" . $herectx);
5248 # check for single line unbalanced braces
5249 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5250 $sline =~ /^.\s*else\s*\{\s*$/) {
5251 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5254 # check for unnecessary blank lines around braces
5255 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5257 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5258 $fix && $prevrawline =~ /^\+/) {
5259 fix_delete_line($fixlinenr - 1, $prevrawline);
5262 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5264 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5266 fix_delete_line($fixlinenr, $rawline);
5270 # no volatiles please
5271 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5272 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5274 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5277 # Check for user-visible strings broken across lines, which breaks the ability
5278 # to grep for the string. Make exceptions when the previous string ends in a
5279 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5280 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5281 if ($line =~ /^\+\s*$String/ &&
5282 $prevline =~ /"\s*$/ &&
5283 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5284 if (WARN("SPLIT_STRING",
5285 "quoted string split across lines\n" . $hereprev) &&
5287 $prevrawline =~ /^\+.*"\s*$/ &&
5288 $last_coalesced_string_linenr != $linenr - 1) {
5289 my $extracted_string = get_quoted_string($line, $rawline);
5290 my $comma_close = "";
5291 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5295 fix_delete_line($fixlinenr - 1, $prevrawline);
5296 fix_delete_line($fixlinenr, $rawline);
5297 my $fixedline = $prevrawline;
5298 $fixedline =~ s/"\s*$//;
5299 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5300 fix_insert_line($fixlinenr - 1, $fixedline);
5301 $fixedline = $rawline;
5302 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5303 if ($fixedline !~ /\+\s*$/) {
5304 fix_insert_line($fixlinenr, $fixedline);
5306 $last_coalesced_string_linenr = $linenr;
5310 # check for missing a space in a string concatenation
5311 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5312 WARN('MISSING_SPACE',
5313 "break quoted strings at a space character\n" . $hereprev);
5316 # check for an embedded function name in a string when the function is known
5317 # This does not work very well for -f --file checking as it depends on patch
5318 # context providing the function name or a single line form for in-file
5319 # function declarations
5320 if ($line =~ /^\+.*$String/ &&
5321 defined($context_function) &&
5322 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
5323 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
5324 WARN("EMBEDDED_FUNCTION_NAME",
5325 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
5328 # check for spaces before a quoted newline
5329 if ($rawline =~ /^.*\".*\s\\n/) {
5330 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5331 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5333 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5338 # concatenated string without spaces between elements
5339 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5340 CHK("CONCATENATED_STRING",
5341 "Concatenated strings should use spaces between elements\n" . $herecurr);
5344 # uncoalesced string fragments
5345 if ($line =~ /$String\s*"/) {
5346 WARN("STRING_FRAGMENTS",
5347 "Consecutive strings are generally better as a single string\n" . $herecurr);
5350 # check for non-standard and hex prefixed decimal printf formats
5351 my $show_L = 1; #don't show the same defect twice
5353 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5354 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
5355 $string =~ s/%%/__/g;
5357 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
5359 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
5363 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
5365 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
5368 # check for 0x<decimal>
5369 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
5370 ERROR("PRINTF_0XDECIMAL",
5371 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5375 # check for line continuations in quoted strings with odd counts of "
5376 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
5377 WARN("LINE_CONTINUATIONS",
5378 "Avoid line continuations in quoted strings\n" . $herecurr);
5382 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5383 CHK("REDUNDANT_CODE",
5384 "if this code is redundant consider removing it\n" .
5388 # check for needless "if (<foo>) fn(<foo>)" uses
5389 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5390 my $tested = quotemeta($1);
5391 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5392 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5394 if (WARN('NEEDLESS_IF',
5395 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5398 my $leading_tabs = "";
5399 my $new_leading_tabs = "";
5400 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5405 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5406 $new_leading_tabs = $1;
5407 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5414 fix_delete_line($fixlinenr - 1, $prevrawline);
5415 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5421 # check for unnecessary "Out of Memory" messages
5422 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5423 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5424 (defined $1 || defined $3) &&
5427 my $testline = $lines[$linenr - 3];
5429 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5430 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5432 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)/) {
5434 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5438 # check for logging functions with KERN_<LEVEL>
5439 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5440 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5442 if (WARN("UNNECESSARY_KERN_LEVEL",
5443 "Possible unnecessary $level\n" . $herecurr) &&
5445 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5449 # check for logging continuations
5450 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
5451 WARN("LOGGING_CONTINUATION",
5452 "Avoid logging continuation uses where feasible\n" . $herecurr);
5455 # check for mask then right shift without a parentheses
5456 if ($^V && $^V ge 5.10.0 &&
5457 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5458 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5459 WARN("MASK_THEN_SHIFT",
5460 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5463 # check for pointer comparisons to NULL
5464 if ($^V && $^V ge 5.10.0) {
5465 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5468 $equal = "" if ($4 eq "!=");
5469 if (CHK("COMPARISON_TO_NULL",
5470 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5472 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5477 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5478 if ($line =~ /(\b$InitAttribute\b)/) {
5480 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5483 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5484 ERROR("MISPLACED_INIT",
5485 "$attr should be placed after $var\n" . $herecurr)) ||
5486 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5487 WARN("MISPLACED_INIT",
5488 "$attr should be placed after $var\n" . $herecurr))) &&
5490 $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;
5495 # check for $InitAttributeData (ie: __initdata) with const
5496 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5498 $attr =~ /($InitAttributePrefix)(.*)/;
5499 my $attr_prefix = $1;
5501 if (ERROR("INIT_ATTRIBUTE",
5502 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5504 $fixed[$fixlinenr] =~
5505 s/$InitAttributeData/${attr_prefix}initconst/;
5509 # check for $InitAttributeConst (ie: __initconst) without const
5510 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5512 if (ERROR("INIT_ATTRIBUTE",
5513 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5515 my $lead = $fixed[$fixlinenr] =~
5516 /(^\+\s*(?:static\s+))/;
5518 $lead = "$lead " if ($lead !~ /^\+$/);
5519 $lead = "${lead}const ";
5520 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5524 # check for __read_mostly with const non-pointer (should just be const)
5525 if ($line =~ /\b__read_mostly\b/ &&
5526 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5527 if (ERROR("CONST_READ_MOSTLY",
5528 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5530 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5534 # don't use __constant_<foo> functions outside of include/uapi/
5535 if ($realfile !~ m@^include/uapi/@ &&
5536 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5537 my $constant_func = $1;
5538 my $func = $constant_func;
5539 $func =~ s/^__constant_//;
5540 if (WARN("CONSTANT_CONVERSION",
5541 "$constant_func should be $func\n" . $herecurr) &&
5543 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5547 # prefer usleep_range over udelay
5548 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5550 # ignore udelay's < 10, however
5551 if (! ($delay < 10) ) {
5553 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5555 if ($delay > 2000) {
5557 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5561 # warn about unexpectedly long msleep's
5562 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5565 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5569 # check for comparisons of jiffies
5570 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5571 WARN("JIFFIES_COMPARISON",
5572 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5575 # check for comparisons of get_jiffies_64()
5576 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5577 WARN("JIFFIES_COMPARISON",
5578 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5581 # warn about #ifdefs in C files
5582 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5583 # print "#ifdef in C files should be avoided\n";
5584 # print "$herecurr";
5588 # warn about spacing in #ifdefs
5589 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5590 if (ERROR("SPACING",
5591 "exactly one space required after that #$1\n" . $herecurr) &&
5593 $fixed[$fixlinenr] =~
5594 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5599 # check for spinlock_t definitions without a comment.
5600 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5601 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5603 if (!ctx_has_comment($first_line, $linenr)) {
5604 CHK("UNCOMMENTED_DEFINITION",
5605 "$1 definition without comment\n" . $herecurr);
5608 # check for memory barriers without a comment.
5614 read_barrier_depends
5616 my $barrier_stems = qr{
5624 my $all_barriers = qr{
5626 smp_(?:$barrier_stems)|
5627 virt_(?:$barrier_stems)
5630 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5631 if (!ctx_has_comment($first_line, $linenr)) {
5632 WARN("MEMORY_BARRIER",
5633 "memory barrier without comment\n" . $herecurr);
5637 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5639 if ($realfile !~ m@^include/asm-generic/@ &&
5640 $realfile !~ m@/barrier\.h$@ &&
5641 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5642 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5643 WARN("MEMORY_BARRIER",
5644 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
5647 # check for waitqueue_active without a comment.
5648 if ($line =~ /\bwaitqueue_active\s*\(/) {
5649 if (!ctx_has_comment($first_line, $linenr)) {
5650 WARN("WAITQUEUE_ACTIVE",
5651 "waitqueue_active without comment\n" . $herecurr);
5655 # check for smp_read_barrier_depends and read_barrier_depends
5656 if (!$file && $line =~ /\b(smp_|)read_barrier_depends\s*\(/) {
5657 WARN("READ_BARRIER_DEPENDS",
5658 "$1read_barrier_depends should only be used in READ_ONCE or DEC Alpha code\n" . $herecurr);
5661 # check of hardware specific defines
5662 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5664 "architecture specific defines should be avoided\n" . $herecurr);
5667 # check that the storage class is not after a type
5668 if ($line =~ /\b($Type)\s+($Storage)\b/) {
5669 WARN("STORAGE_CLASS",
5670 "storage class '$2' should be located before type '$1'\n" . $herecurr);
5672 # Check that the storage class is at the beginning of a declaration
5673 if ($line =~ /\b$Storage\b/ &&
5674 $line !~ /^.\s*$Storage/ &&
5675 $line =~ /^.\s*(.+?)\$Storage\s/ &&
5676 $1 !~ /[\,\)]\s*$/) {
5677 WARN("STORAGE_CLASS",
5678 "storage class should be at the beginning of the declaration\n" . $herecurr);
5681 # check the location of the inline attribute, that it is between
5682 # storage class and type.
5683 if ($line =~ /\b$Type\s+$Inline\b/ ||
5684 $line =~ /\b$Inline\s+$Storage\b/) {
5685 ERROR("INLINE_LOCATION",
5686 "inline keyword should sit between storage class and type\n" . $herecurr);
5689 # Check for __inline__ and __inline, prefer inline
5690 if ($realfile !~ m@\binclude/uapi/@ &&
5691 $line =~ /\b(__inline__|__inline)\b/) {
5693 "plain inline is preferred over $1\n" . $herecurr) &&
5695 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5700 # Check for __attribute__ packed, prefer __packed
5701 if ($realfile !~ m@\binclude/uapi/@ &&
5702 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5703 WARN("PREFER_PACKED",
5704 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5707 # Check for __attribute__ aligned, prefer __aligned
5708 if ($realfile !~ m@\binclude/uapi/@ &&
5709 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5710 WARN("PREFER_ALIGNED",
5711 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5714 # Check for __attribute__ format(printf, prefer __printf
5715 if ($realfile !~ m@\binclude/uapi/@ &&
5716 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5717 if (WARN("PREFER_PRINTF",
5718 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5720 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5725 # Check for __attribute__ format(scanf, prefer __scanf
5726 if ($realfile !~ m@\binclude/uapi/@ &&
5727 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5728 if (WARN("PREFER_SCANF",
5729 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5731 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5735 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5736 if ($^V && $^V ge 5.10.0 &&
5737 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5738 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5739 $line =~ /\b__weak\b/)) {
5740 ERROR("WEAK_DECLARATION",
5741 "Using weak declarations can have unintended link defects\n" . $herecurr);
5744 # check for c99 types like uint8_t used outside of uapi/ and tools/
5745 if ($realfile !~ m@\binclude/uapi/@ &&
5746 $realfile !~ m@\btools/@ &&
5747 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5749 if ($type =~ /\b($typeC99Typedefs)\b/) {
5751 my $kernel_type = 'u';
5752 $kernel_type = 's' if ($type =~ /^_*[si]/);
5755 if (CHK("PREFER_KERNEL_TYPES",
5756 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5758 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5763 # check for cast of C90 native int or longer types constants
5764 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
5767 if (WARN("TYPECAST_INT_CONSTANT",
5768 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
5771 my $newconst = $const;
5772 $newconst =~ s/${Int_type}$//;
5773 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
5774 if ($cast =~ /\blong\s+long\b/) {
5776 } elsif ($cast =~ /\blong\b/) {
5779 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
5783 # check for sizeof(&)
5784 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5785 WARN("SIZEOF_ADDRESS",
5786 "sizeof(& should be avoided\n" . $herecurr);
5789 # check for sizeof without parenthesis
5790 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5791 if (WARN("SIZEOF_PARENTHESIS",
5792 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5794 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5798 # check for struct spinlock declarations
5799 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5800 WARN("USE_SPINLOCK_T",
5801 "struct spinlock should be spinlock_t\n" . $herecurr);
5804 # check for seq_printf uses that could be seq_puts
5805 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5806 my $fmt = get_quoted_string($line, $rawline);
5809 if (WARN("PREFER_SEQ_PUTS",
5810 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5812 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5817 # check for vsprintf extension %p<foo> misuses
5818 if ($^V && $^V ge 5.10.0 &&
5820 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
5821 $1 !~ /^_*volatile_*$/) {
5824 my $bad_specifier = "";
5827 my $lc = $stat =~ tr@\n@@;
5828 $lc = $lc + $linenr;
5829 for (my $count = $linenr; $count <= $lc; $count++) {
5830 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
5833 while ($fmt =~ /(\%[\*\d\.]*p(\w))/g) {
5836 if ($extension !~ /[SsBKRraEhMmIiUDdgVCbGNOx]/) {
5837 $bad_specifier = $specifier;
5840 if ($extension eq "x" && !defined($stat_real)) {
5841 if (!defined($stat_real)) {
5842 $stat_real = get_stat_real($linenr, $lc);
5844 WARN("VSPRINTF_SPECIFIER_PX",
5845 "Using vsprintf specifier '\%px' potentially exposes the kernel memory layout, if you don't really need the address please consider using '\%p'.\n" . "$here\n$stat_real\n");
5848 if ($bad_specifier ne "") {
5849 my $stat_real = get_stat_real($linenr, $lc);
5850 my $ext_type = "Invalid";
5852 if ($bad_specifier =~ /p[Ff]/) {
5853 $ext_type = "Deprecated";
5854 $use = " - use %pS instead";
5855 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
5858 WARN("VSPRINTF_POINTER_EXTENSION",
5859 "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
5864 # Check for misused memsets
5865 if ($^V && $^V ge 5.10.0 &&
5867 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5873 if ($ms_size =~ /^(0x|)0$/i) {
5875 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5876 } elsif ($ms_size =~ /^(0x|)1$/i) {
5878 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5882 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5883 # if ($^V && $^V ge 5.10.0 &&
5885 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5886 # if (WARN("PREFER_ETHER_ADDR_COPY",
5887 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5889 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5893 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5894 # if ($^V && $^V ge 5.10.0 &&
5896 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5897 # WARN("PREFER_ETHER_ADDR_EQUAL",
5898 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5901 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5902 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5903 # if ($^V && $^V ge 5.10.0 &&
5905 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5909 # if ($ms_val =~ /^(?:0x|)0+$/i) {
5910 # if (WARN("PREFER_ETH_ZERO_ADDR",
5911 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5913 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5915 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5916 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
5917 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5919 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5924 # typecasts on min/max could be min_t/max_t
5925 if ($^V && $^V ge 5.10.0 &&
5927 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5928 if (defined $2 || defined $7) {
5930 my $cast1 = deparenthesize($2);
5932 my $cast2 = deparenthesize($7);
5936 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5937 $cast = "$cast1 or $cast2";
5938 } elsif ($cast1 ne "") {
5944 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5948 # check usleep_range arguments
5949 if ($^V && $^V ge 5.10.0 &&
5951 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5955 WARN("USLEEP_RANGE",
5956 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5957 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5959 WARN("USLEEP_RANGE",
5960 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5964 # check for naked sscanf
5965 if ($^V && $^V ge 5.10.0 &&
5967 $line =~ /\bsscanf\b/ &&
5968 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5969 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5970 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5971 my $lc = $stat =~ tr@\n@@;
5972 $lc = $lc + $linenr;
5973 my $stat_real = get_stat_real($linenr, $lc);
5974 WARN("NAKED_SSCANF",
5975 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5978 # check for simple sscanf that should be kstrto<foo>
5979 if ($^V && $^V ge 5.10.0 &&
5981 $line =~ /\bsscanf\b/) {
5982 my $lc = $stat =~ tr@\n@@;
5983 $lc = $lc + $linenr;
5984 my $stat_real = get_stat_real($linenr, $lc);
5985 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5987 my $count = $format =~ tr@%@%@;
5989 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5990 WARN("SSCANF_TO_KSTRTO",
5991 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5996 # check for new externs in .h files.
5997 if ($realfile =~ /\.h$/ &&
5998 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5999 if (CHK("AVOID_EXTERNS",
6000 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
6002 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
6006 # check for new externs in .c files.
6007 if ($realfile =~ /\.c$/ && defined $stat &&
6008 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
6010 my $function_name = $1;
6011 my $paren_space = $2;
6014 if (defined $cond) {
6015 substr($s, 0, length($cond), '');
6017 if ($s =~ /^\s*;/ &&
6018 $function_name ne 'uninitialized_var')
6020 WARN("AVOID_EXTERNS",
6021 "externs should be avoided in .c files\n" . $herecurr);
6024 if ($paren_space =~ /\n/) {
6025 WARN("FUNCTION_ARGUMENTS",
6026 "arguments for function declarations should follow identifier\n" . $herecurr);
6029 } elsif ($realfile =~ /\.c$/ && defined $stat &&
6030 $stat =~ /^.\s*extern\s+/)
6032 WARN("AVOID_EXTERNS",
6033 "externs should be avoided in .c files\n" . $herecurr);
6036 # check for function declarations that have arguments without identifier names
6037 if (defined $stat &&
6038 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
6040 my $args = trim($1);
6041 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
6043 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
6044 WARN("FUNCTION_ARGUMENTS",
6045 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
6050 # check for function definitions
6051 if ($^V && $^V ge 5.10.0 &&
6053 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
6054 $context_function = $1;
6056 # check for multiline function definition with misplaced open brace
6058 my $cnt = statement_rawlines($stat);
6059 my $herectx = $here . "\n";
6060 for (my $n = 0; $n < $cnt; $n++) {
6061 my $rl = raw_line($linenr, $n);
6062 $herectx .= $rl . "\n";
6063 $ok = 1 if ($rl =~ /^[ \+]\{/);
6064 $ok = 1 if ($rl =~ /\{/ && $n == 0);
6065 last if $rl =~ /^[ \+].*\{/;
6069 "open brace '{' following function definitions go on the next line\n" . $herectx);
6073 # checks for new __setup's
6074 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6077 if (!grep(/$name/, @setup_docs)) {
6078 CHK("UNDOCUMENTED_SETUP",
6079 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.rst\n" . $herecurr);
6083 # check for pointless casting of kmalloc return
6084 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
6085 WARN("UNNECESSARY_CASTS",
6086 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6090 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6091 if ($^V && $^V ge 5.10.0 &&
6092 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6093 CHK("ALLOC_SIZEOF_STRUCT",
6094 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6097 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6098 if ($^V && $^V ge 5.10.0 &&
6100 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6104 my $newfunc = "kmalloc_array";
6105 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6108 if ($a1 =~ /^sizeof\s*\S/) {
6112 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6113 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6114 my $cnt = statement_rawlines($stat);
6115 my $herectx = get_stat_here($linenr, $cnt, $here);
6117 if (WARN("ALLOC_WITH_MULTIPLY",
6118 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6121 $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;
6126 # check for krealloc arg reuse
6127 if ($^V && $^V ge 5.10.0 &&
6128 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
6129 WARN("KREALLOC_ARG_REUSE",
6130 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6133 # check for alloc argument mismatch
6134 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6135 WARN("ALLOC_ARRAY_ARGS",
6136 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6139 # check for multiple semicolons
6140 if ($line =~ /;\s*;\s*$/) {
6141 if (WARN("ONE_SEMICOLON",
6142 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6144 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6148 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6149 if ($realfile !~ m@^include/uapi/@ &&
6150 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6152 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6153 if (CHK("BIT_MACRO",
6154 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6156 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6160 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6161 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6163 if (WARN("PREFER_IS_ENABLED",
6164 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6166 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6170 # check for case / default statements not preceded by break/fallthrough/switch
6171 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
6173 my $has_statement = 0;
6175 my $prevline = $linenr;
6176 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
6178 my $rline = $rawlines[$prevline - 1];
6179 my $fline = $lines[$prevline - 1];
6180 last if ($fline =~ /^\@\@/);
6181 next if ($fline =~ /^\-/);
6182 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
6183 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
6184 next if ($fline =~ /^.[\s$;]*$/);
6187 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|exit\s*\(\b|return\b|goto\b|continue\b)/);
6189 if (!$has_break && $has_statement) {
6190 WARN("MISSING_BREAK",
6191 "Possible switch case/default not preceded by break or fallthrough comment\n" . $herecurr);
6195 # check for switch/default statements without a break;
6196 if ($^V && $^V ge 5.10.0 &&
6198 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6199 my $cnt = statement_rawlines($stat);
6200 my $herectx = get_stat_here($linenr, $cnt, $here);
6202 WARN("DEFAULT_NO_BREAK",
6203 "switch default: should use break\n" . $herectx);
6206 # check for gcc specific __FUNCTION__
6207 if ($line =~ /\b__FUNCTION__\b/) {
6208 if (WARN("USE_FUNC",
6209 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
6211 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
6215 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
6216 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6218 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6221 # check for use of yield()
6222 if ($line =~ /\byield\s*\(\s*\)/) {
6224 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
6227 # check for comparisons against true and false
6228 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6236 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6238 my $type = lc($otype);
6239 if ($type =~ /^(?:true|false)$/) {
6240 if (("$test" eq "==" && "$type" eq "true") ||
6241 ("$test" eq "!=" && "$type" eq "false")) {
6245 CHK("BOOL_COMPARISON",
6246 "Using comparison to $otype is error prone\n" . $herecurr);
6248 ## maybe suggesting a correct construct would better
6249 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6254 # check for bool bitfields
6255 if ($sline =~ /^.\s+bool\s*$Ident\s*:\s*\d+\s*;/) {
6256 WARN("BOOL_BITFIELD",
6257 "Avoid using bool as bitfield. Prefer bool bitfields as unsigned int or u<8|16|32>\n" . $herecurr);
6260 # check for semaphores initialized locked
6261 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6262 WARN("CONSIDER_COMPLETION",
6263 "consider using a completion\n" . $herecurr);
6266 # recommend kstrto* over simple_strto* and strict_strto*
6267 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6268 WARN("CONSIDER_KSTRTO",
6269 "$1 is obsolete, use k$3 instead\n" . $herecurr);
6272 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
6273 if ($line =~ /^.\s*__initcall\s*\(/) {
6274 WARN("USE_DEVICE_INITCALL",
6275 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6278 # check for various structs that are normally const (ops, kgdb, device_tree)
6279 # and avoid what seem like struct definitions 'struct foo {'
6280 if ($line !~ /\bconst\b/ &&
6281 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
6282 WARN("CONST_STRUCT",
6283 "struct $1 should normally be const\n" . $herecurr);
6286 # use of NR_CPUS is usually wrong
6287 # ignore definitions of NR_CPUS and usage to define arrays as likely right
6288 if ($line =~ /\bNR_CPUS\b/ &&
6289 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6290 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6291 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6292 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6293 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6296 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6299 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6300 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6301 ERROR("DEFINE_ARCH_HAS",
6302 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6305 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
6306 if ($^V && $^V ge 5.10.0 &&
6307 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6308 WARN("LIKELY_MISUSE",
6309 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6312 # whine mightly about in_atomic
6313 if ($line =~ /\bin_atomic\s*\(/) {
6314 if ($realfile =~ m@^drivers/@) {
6316 "do not use in_atomic in drivers\n" . $herecurr);
6317 } elsif ($realfile !~ m@^kernel/@) {
6319 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6323 # check for mutex_trylock_recursive usage
6324 if ($line =~ /mutex_trylock_recursive/) {
6326 "recursive locking is bad, do not use this ever.\n" . $herecurr);
6329 # check for lockdep_set_novalidate_class
6330 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6331 $line =~ /__lockdep_no_validate__\s*\)/ ) {
6332 if ($realfile !~ m@^kernel/lockdep@ &&
6333 $realfile !~ m@^include/linux/lockdep@ &&
6334 $realfile !~ m@^drivers/base/core@) {
6336 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6340 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6341 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6342 WARN("EXPORTED_WORLD_WRITABLE",
6343 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6346 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
6347 # and whether or not function naming is typical and if
6348 # DEVICE_ATTR permissions uses are unusual too
6349 if ($^V && $^V ge 5.10.0 &&
6351 $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*\)/) {
6356 my $octal_perms = perms_to_octal($perms);
6357 if ($show =~ /^${var}_show$/ &&
6358 $store =~ /^${var}_store$/ &&
6359 $octal_perms eq "0644") {
6360 if (WARN("DEVICE_ATTR_RW",
6361 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
6363 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
6365 } elsif ($show =~ /^${var}_show$/ &&
6366 $store =~ /^NULL$/ &&
6367 $octal_perms eq "0444") {
6368 if (WARN("DEVICE_ATTR_RO",
6369 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
6371 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
6373 } elsif ($show =~ /^NULL$/ &&
6374 $store =~ /^${var}_store$/ &&
6375 $octal_perms eq "0200") {
6376 if (WARN("DEVICE_ATTR_WO",
6377 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
6379 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
6381 } elsif ($octal_perms eq "0644" ||
6382 $octal_perms eq "0444" ||
6383 $octal_perms eq "0200") {
6384 my $newshow = "$show";
6385 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
6386 my $newstore = $store;
6387 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
6389 if ($show ne $newshow) {
6390 $rename .= " '$show' to '$newshow'";
6392 if ($store ne $newstore) {
6393 $rename .= " '$store' to '$newstore'";
6395 WARN("DEVICE_ATTR_FUNCTIONS",
6396 "Consider renaming function(s)$rename\n" . $herecurr);
6398 WARN("DEVICE_ATTR_PERMS",
6399 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
6403 # Mode permission misuses where it seems decimal should be octal
6404 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6405 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
6406 # specific definition of not visible in sysfs.
6407 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
6408 # use the default permissions
6409 if ($^V && $^V ge 5.10.0 &&
6411 $line =~ /$mode_perms_search/) {
6412 foreach my $entry (@mode_permission_funcs) {
6413 my $func = $entry->[0];
6414 my $arg_pos = $entry->[1];
6416 my $lc = $stat =~ tr@\n@@;
6417 $lc = $lc + $linenr;
6418 my $stat_real = get_stat_real($linenr, $lc);
6423 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6425 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6426 if ($stat =~ /$test/) {
6428 $val = $6 if ($skip_args ne "");
6429 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
6430 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6431 ($val =~ /^$Octal$/ && length($val) ne 4))) {
6432 ERROR("NON_OCTAL_PERMISSIONS",
6433 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6435 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6436 ERROR("EXPORTED_WORLD_WRITABLE",
6437 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6443 # check for uses of S_<PERMS> that could be octal for readability
6444 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
6446 my $octal = perms_to_octal($oval);
6447 if (WARN("SYMBOLIC_PERMS",
6448 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6450 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
6454 # validate content of MODULE_LICENSE against list from include/linux/module.h
6455 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6456 my $extracted_string = get_quoted_string($line, $rawline);
6457 my $valid_licenses = qr{
6460 GPL\ and\ additional\ rights|
6466 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6467 WARN("MODULE_LICENSE",
6468 "unknown module license " . $extracted_string . "\n" . $herecurr);
6473 # If we have no input at all, then there is nothing to report on
6474 # so just keep quiet.
6475 if ($#rawlines == -1) {
6479 # In mailback mode only produce a report in the negative, for
6480 # things that appear to be patches.
6481 if ($mailback && ($clean == 1 || !$is_patch)) {
6485 # This is not a patch, and we are are in 'no-patch' mode so
6487 if (!$chk_patch && !$is_patch) {
6491 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
6492 ERROR("NOT_UNIFIED_DIFF",
6493 "Does not appear to be a unified-diff format patch\n");
6495 if ($is_patch && $has_commit_log && $chk_signoff && $signoff == 0) {
6496 ERROR("MISSING_SIGN_OFF",
6497 "Missing Signed-off-by: line(s)\n");
6500 print report_dump();
6501 if ($summary && !($clean == 1 && $quiet == 1)) {
6502 print "$filename " if ($summary_file);
6503 print "total: $cnt_error errors, $cnt_warn warnings, " .
6504 (($check)? "$cnt_chk checks, " : "") .
6505 "$cnt_lines lines checked\n";
6509 # If there were any defects found and not already fixing them
6510 if (!$clean and !$fix) {
6513 NOTE: For some of the reported defects, checkpatch may be able to
6514 mechanically convert to the typical style using --fix or --fix-inplace.
6517 # If there were whitespace errors which cleanpatch can fix
6518 # then suggest that.
6519 if ($rpt_cleaners) {
6523 NOTE: Whitespace errors detected.
6524 You may wish to use scripts/cleanpatch or scripts/cleanfile
6529 if ($clean == 0 && $fix &&
6530 ("@rawlines" ne "@fixed" ||
6531 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6532 my $newfile = $filename;
6533 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6537 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6539 open($f, '>', $newfile)
6540 or die "$P: Can't open $newfile for write\n";
6541 foreach my $fixed_line (@fixed) {
6544 if ($linecount > 3) {
6545 $fixed_line =~ s/^\+//;
6546 print $f $fixed_line . "\n";
6549 print $f $fixed_line . "\n";
6557 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6559 Do _NOT_ trust the results written to this file.
6560 Do _NOT_ submit these changes without inspecting them for correctness.
6562 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6563 No warranties, expressed or implied...
6571 print "$vname has no obvious style problems and is ready for submission.\n";
6573 print "$vname has style problems, please review.\n";