2 # SPDX-License-Identifier: GPL-2.0
4 # (c) 2001, Dave Jones. (the file handling bit)
5 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
6 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
7 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
8 # (c) 2010-2018 Joe Perches <joe@perches.com>
15 use Term::ANSIColor qw(:constants);
16 use Encode qw(decode encode);
19 my $D = dirname(abs_path($P));
23 use Getopt::Long qw(:config no_auto_abbrev);
53 my $configuration_file = ".checkpatch.conf";
54 my $max_line_length = 100;
55 my $ignore_perl_version = 0;
56 my $minimum_perl_version = 5.10.0;
57 my $min_conf_desc_length = 4;
58 my $spelling_file = "$D/spelling.txt";
60 my $codespellfile = "/usr/share/codespell/dictionary.txt";
61 my $conststructsfile = "$D/const_structs.checkpatch";
64 my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
65 # git output parsing needs US English output, so first set backtick child process LANGUAGE
66 my $git_command ='export LANGUAGE=en_US.UTF-8; git';
73 Usage: $P [OPTION]... [FILE]...
78 --no-tree run without a kernel tree
79 --no-signoff do not check for 'Signed-off-by' line
80 --patch treat FILE as patchfile (default)
81 --emacs emacs compile window format
82 --terse one line per report
83 --showfile emit diffed file position, not input file position
84 -g, --git treat FILE as a single commit or git revision range
85 single git commit with:
89 multiple git commits with:
93 git merges are ignored
94 -f, --file treat FILE as regular source file
95 --subjective, --strict enable more subjective tests
96 --list-types list the possible message types
97 --types TYPE(,TYPE2...) show only these comma separated message types
98 --ignore TYPE(,TYPE2...) ignore various comma separated message types
99 --show-types show the specific message type in the output
100 --max-line-length=n set the maximum line length, (default $max_line_length)
101 if exceeded, warn on patches
102 requires --strict for use with --file
103 --min-conf-desc-length=n set the min description length, if shorter, warn
104 --tab-size=n set the number of spaces for tab (default $tabsize)
105 --root=PATH PATH to the kernel tree root
106 --no-summary suppress the per-file summary
107 --mailback only produce a report in case of warnings/errors
108 --summary-file include the filename in summary
109 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
110 'values', 'possible', 'type', and 'attr' (default
112 --test-only=WORD report only warnings/errors containing WORD
114 --fix EXPERIMENTAL - may create horrible results
115 If correctable single-line errors exist, create
116 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
117 with potential errors corrected to the preferred
119 --fix-inplace EXPERIMENTAL - may create horrible results
120 Is the same as --fix, but overwrites the input
121 file. It's your fault if there's no backup or git
122 --ignore-perl-version override checking of perl version. expect
124 --codespell Use the codespell dictionary for spelling/typos
125 (default:/usr/share/codespell/dictionary.txt)
126 --codespellfile Use this codespell dictionary
127 --typedefsfile Read additional types from this file
128 --color[=WHEN] Use colors 'always', 'never', or only when output
129 is a terminal ('auto'). Default is 'auto'.
130 -h, --help, --version display this help and exit
132 When FILE is - read standard input.
140 return grep { !$seen{$_}++ } @_;
150 open(my $script, '<', abs_path($P)) or
151 die "$P: Can't read '$P' $!\n";
153 my $text = <$script>;
157 # Also catch when type or level is passed through a variable
158 for ($text =~ /(?:(?:\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
161 @types = sort(uniq(@types));
162 print("#\tMessage type\n\n");
163 foreach my $type (@types) {
164 print(++$count . "\t" . $type . "\n");
170 my $conf = which_conf($configuration_file);
173 open(my $conffile, '<', "$conf")
174 or warn "$P: Can't find a readable $configuration_file file $!\n";
176 while (<$conffile>) {
179 $line =~ s/\s*\n?$//g;
183 next if ($line =~ m/^\s*#/);
184 next if ($line =~ m/^\s*$/);
186 my @words = split(" ", $line);
187 foreach my $word (@words) {
188 last if ($word =~ m/^#/);
189 push (@conf_args, $word);
193 unshift(@ARGV, @conf_args) if @conf_args;
196 # Perl's Getopt::Long allows options to take optional arguments after a space.
197 # Prevent --color by itself from consuming other arguments
199 if ($_ eq "--color" || $_ eq "-color") {
200 $_ = "--color=$color";
205 'q|quiet+' => \$quiet,
207 'signoff!' => \$chk_signoff,
208 'patch!' => \$chk_patch,
211 'showfile!' => \$showfile,
214 'subjective!' => \$check,
215 'strict!' => \$check,
216 'ignore=s' => \@ignore,
218 'show-types!' => \$show_types,
219 'list-types!' => \$list_types,
220 'max-line-length=i' => \$max_line_length,
221 'min-conf-desc-length=i' => \$min_conf_desc_length,
222 'tab-size=i' => \$tabsize,
224 'summary!' => \$summary,
225 'mailback!' => \$mailback,
226 'summary-file!' => \$summary_file,
228 'fix-inplace!' => \$fix_inplace,
229 'ignore-perl-version!' => \$ignore_perl_version,
230 'debug=s' => \%debug,
231 'test-only=s' => \$tst_only,
232 'codespell!' => \$codespell,
233 'codespellfile=s' => \$codespellfile,
234 'typedefsfile=s' => \$typedefsfile,
235 'color=s' => \$color,
236 'no-color' => \$color, #keep old behaviors of -nocolor
237 'nocolor' => \$color, #keep old behaviors of -nocolor
244 list_types(0) if ($list_types);
246 $fix = 1 if ($fix_inplace);
247 $check_orig = $check;
249 die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file || $fix));
253 my $perl_version_ok = 1;
254 if ($^V && $^V lt $minimum_perl_version) {
255 $perl_version_ok = 0;
256 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
257 exit(1) if (!$ignore_perl_version);
260 #if no filenames are given, push '-' to read patch from stdin
265 if ($color =~ /^[01]$/) {
267 } elsif ($color =~ /^always$/i) {
269 } elsif ($color =~ /^never$/i) {
271 } elsif ($color =~ /^auto$/i) {
272 $color = (-t STDOUT);
274 die "$P: Invalid color mode: $color\n";
277 # skip TAB size 1 to avoid additional checks on $tabsize - 1
278 die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);
280 sub hash_save_array_words {
281 my ($hashRef, $arrayRef) = @_;
283 my @array = split(/,/, join(',', @$arrayRef));
284 foreach my $word (@array) {
285 $word =~ s/\s*\n?$//g;
288 $word =~ tr/[a-z]/[A-Z]/;
290 next if ($word =~ m/^\s*#/);
291 next if ($word =~ m/^\s*$/);
297 sub hash_show_words {
298 my ($hashRef, $prefix) = @_;
300 if (keys %$hashRef) {
301 print "\nNOTE: $prefix message types:";
302 foreach my $word (sort keys %$hashRef) {
309 hash_save_array_words(\%ignore_type, \@ignore);
310 hash_save_array_words(\%use_type, \@use);
313 my $dbg_possible = 0;
316 for my $key (keys %debug) {
318 eval "\${dbg_$key} = '$debug{$key}';";
322 my $rpt_cleaners = 0;
331 if (!top_of_kernel_tree($root)) {
332 die "$P: $root: --root does not point at a valid tree\n";
335 if (top_of_kernel_tree('.')) {
337 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
338 top_of_kernel_tree($1)) {
343 if (!defined $root) {
344 print "Must be run from the top-level dir. of a kernel tree\n";
349 my $emitted_corrupt = 0;
352 [A-Za-z_][A-Za-z\d_]*
353 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
355 our $Storage = qr{extern|static|asmlinkage};
369 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
370 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
371 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
372 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
373 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
375 # Notes to $Attribute:
376 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
398 ____cacheline_aligned|
399 ____cacheline_aligned_in_smp|
400 ____cacheline_internodealigned_in_smp|
404 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
405 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
406 our $Lval = qr{$Ident(?:$Member)*};
408 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
409 our $Binary = qr{(?i)0b[01]+$Int_type?};
410 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
411 our $Int = qr{[0-9]+$Int_type?};
412 our $Octal = qr{0[0-7]+$Int_type?};
413 our $String = qr{"[X\t]*"};
414 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
415 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
416 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
417 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
418 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
419 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
420 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
421 our $Arithmetic = qr{\+|-|\*|\/|%};
425 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
428 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
432 our $NonptrTypeMisordered;
433 our $NonptrTypeWithAttr;
437 our $DeclareMisordered;
439 our $NON_ASCII_UTF8 = qr{
440 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
441 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
442 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
443 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
444 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
445 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
446 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
450 [\x09\x0A\x0D\x20-\x7E] # ASCII
454 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
455 our $typeOtherOSTypedefs = qr{(?x:
456 u_(?:char|short|int|long) | # bsd
457 u(?:nchar|short|int|long) # sysv
459 our $typeKernelTypedefs = qr{(?x:
460 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
463 our $typeTypedefs = qr{(?x:
465 $typeOtherOSTypedefs\b|
466 $typeKernelTypedefs\b
469 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
471 our $logFunctions = qr{(?x:
472 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
473 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
475 WARN(?:_RATELIMIT|_ONCE|)|
478 seq_vprintf|seq_printf|seq_puts
481 our $allocFunctions = qr{(?x:
483 (?:kv|k|v)[czm]alloc(?:_node|_array)? |
486 (?:\w+)?alloc_skb(?:_ip_align)? |
487 # dev_alloc_skb/netdev_alloc_skb, et al
491 our $signature_tags = qr{(?xi:
503 our @typeListMisordered = (
504 qr{char\s+(?:un)?signed},
505 qr{int\s+(?:(?:un)?signed\s+)?short\s},
506 qr{int\s+short(?:\s+(?:un)?signed)},
507 qr{short\s+int(?:\s+(?:un)?signed)},
508 qr{(?:un)?signed\s+int\s+short},
509 qr{short\s+(?:un)?signed},
510 qr{long\s+int\s+(?:un)?signed},
511 qr{int\s+long\s+(?:un)?signed},
512 qr{long\s+(?:un)?signed\s+int},
513 qr{int\s+(?:un)?signed\s+long},
514 qr{int\s+(?:un)?signed},
515 qr{int\s+long\s+long\s+(?:un)?signed},
516 qr{long\s+long\s+int\s+(?:un)?signed},
517 qr{long\s+long\s+(?:un)?signed\s+int},
518 qr{long\s+long\s+(?:un)?signed},
519 qr{long\s+(?:un)?signed},
524 qr{(?:(?:un)?signed\s+)?char},
525 qr{(?:(?:un)?signed\s+)?short\s+int},
526 qr{(?:(?:un)?signed\s+)?short},
527 qr{(?:(?:un)?signed\s+)?int},
528 qr{(?:(?:un)?signed\s+)?long\s+int},
529 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
530 qr{(?:(?:un)?signed\s+)?long\s+long},
531 qr{(?:(?:un)?signed\s+)?long},
540 qr{${Ident}_handler},
541 qr{${Ident}_handler_fn},
545 our $C90_int_types = qr{(?x:
546 long\s+long\s+int\s+(?:un)?signed|
547 long\s+long\s+(?:un)?signed\s+int|
548 long\s+long\s+(?:un)?signed|
549 (?:(?:un)?signed\s+)?long\s+long\s+int|
550 (?:(?:un)?signed\s+)?long\s+long|
551 int\s+long\s+long\s+(?:un)?signed|
552 int\s+(?:(?:un)?signed\s+)?long\s+long|
554 long\s+int\s+(?:un)?signed|
555 long\s+(?:un)?signed\s+int|
556 long\s+(?:un)?signed|
557 (?:(?:un)?signed\s+)?long\s+int|
558 (?:(?:un)?signed\s+)?long|
559 int\s+long\s+(?:un)?signed|
560 int\s+(?:(?:un)?signed\s+)?long|
563 (?:(?:un)?signed\s+)?int
566 our @typeListFile = ();
567 our @typeListWithAttr = (
569 qr{struct\s+$InitAttribute\s+$Ident},
570 qr{union\s+$InitAttribute\s+$Ident},
573 our @modifierList = (
576 our @modifierListFile = ();
578 our @mode_permission_funcs = (
580 ["module_param_(?:array|named|string)", 4],
581 ["module_param_array_named", 5],
582 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
583 ["proc_create(?:_data|)", 2],
584 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
585 ["IIO_DEV_ATTR_[A-Z_]+", 1],
586 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
587 ["SENSOR_TEMPLATE(?:_2|)", 3],
591 my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';
593 #Create a search pattern for all these functions to speed up a loop below
594 our $mode_perms_search = "";
595 foreach my $entry (@mode_permission_funcs) {
596 $mode_perms_search .= '|' if ($mode_perms_search ne "");
597 $mode_perms_search .= $entry->[0];
599 $mode_perms_search = "(?:${mode_perms_search})";
601 our %deprecated_apis = (
602 "synchronize_rcu_bh" => "synchronize_rcu",
603 "synchronize_rcu_bh_expedited" => "synchronize_rcu_expedited",
604 "call_rcu_bh" => "call_rcu",
605 "rcu_barrier_bh" => "rcu_barrier",
606 "synchronize_sched" => "synchronize_rcu",
607 "synchronize_sched_expedited" => "synchronize_rcu_expedited",
608 "call_rcu_sched" => "call_rcu",
609 "rcu_barrier_sched" => "rcu_barrier",
610 "get_state_synchronize_sched" => "get_state_synchronize_rcu",
611 "cond_synchronize_sched" => "cond_synchronize_rcu",
614 #Create a search pattern for all these strings to speed up a loop below
615 our $deprecated_apis_search = "";
616 foreach my $entry (keys %deprecated_apis) {
617 $deprecated_apis_search .= '|' if ($deprecated_apis_search ne "");
618 $deprecated_apis_search .= $entry;
620 $deprecated_apis_search = "(?:${deprecated_apis_search})";
622 our $mode_perms_world_writable = qr{
630 our %mode_permission_string_types = (
649 #Create a search pattern for all these strings to speed up a loop below
650 our $mode_perms_string_search = "";
651 foreach my $entry (keys %mode_permission_string_types) {
652 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
653 $mode_perms_string_search .= $entry;
655 our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
656 our $multi_mode_perms_string_search = qr{
657 ${single_mode_perms_string_search}
658 (?:\s*\|\s*${single_mode_perms_string_search})*
664 return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
671 while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
672 $curpos = pos($string);
675 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
677 $to |= $mode_permission_string_types{$match};
678 $val .= '\s*\|\s*' if ($val ne "");
682 $oval =~ s/^\s*\|\s*//;
683 $oval =~ s/\s*\|\s*$//;
684 return sprintf("%04o", $to);
687 our $allowed_asm_includes = qr{(?x:
693 # memory.h: ARM has a custom one
695 # Load common spelling mistakes and build regular expression list.
699 if (open(my $spelling, '<', $spelling_file)) {
700 while (<$spelling>) {
703 $line =~ s/\s*\n?$//g;
706 next if ($line =~ m/^\s*#/);
707 next if ($line =~ m/^\s*$/);
709 my ($suspect, $fix) = split(/\|\|/, $line);
711 $spelling_fix{$suspect} = $fix;
715 warn "No typos will be found - file '$spelling_file': $!\n";
719 if (open(my $spelling, '<', $codespellfile)) {
720 while (<$spelling>) {
723 $line =~ s/\s*\n?$//g;
726 next if ($line =~ m/^\s*#/);
727 next if ($line =~ m/^\s*$/);
728 next if ($line =~ m/, disabled/i);
732 my ($suspect, $fix) = split(/->/, $line);
734 $spelling_fix{$suspect} = $fix;
738 warn "No codespell typos will be found - file '$codespellfile': $!\n";
742 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
745 my ($wordsRef, $file) = @_;
747 if (open(my $words, '<', $file)) {
751 $line =~ s/\s*\n?$//g;
754 next if ($line =~ m/^\s*#/);
755 next if ($line =~ m/^\s*$/);
757 print("$file: '$line' invalid - ignored\n");
761 $$wordsRef .= '|' if (defined $$wordsRef);
772 if (show_type("CONST_STRUCT")) {
773 read_words(\$const_structs, $conststructsfile)
774 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
777 if (defined($typedefsfile)) {
778 my $typeOtherTypedefs;
779 read_words(\$typeOtherTypedefs, $typedefsfile)
780 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
781 $typeTypedefs .= '|' . $typeOtherTypedefs if (defined $typeOtherTypedefs);
785 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
786 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
787 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
788 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
789 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
795 (?:$Modifier\s+|const\s+)*
797 (?:typeof|__typeof__)\s*\([^\)]*\)|
801 (?:\s+$Modifier|\s+const)*
803 $NonptrTypeMisordered = qr{
804 (?:$Modifier\s+|const\s+)*
808 (?:\s+$Modifier|\s+const)*
810 $NonptrTypeWithAttr = qr{
811 (?:$Modifier\s+|const\s+)*
813 (?:typeof|__typeof__)\s*\([^\)]*\)|
817 (?:\s+$Modifier|\s+const)*
821 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
822 (?:\s+$Inline|\s+$Modifier)*
824 $TypeMisordered = qr{
825 $NonptrTypeMisordered
826 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
827 (?:\s+$Inline|\s+$Modifier)*
829 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
830 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
834 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
836 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
837 # requires at least perl version v5.10.0
838 # Any use must be runtime checked with $^V
840 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
841 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
842 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
844 our $declaration_macros = qr{(?x:
845 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
846 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
847 (?:SKCIPHER_REQUEST|SHASH_DESC|AHASH_REQUEST)_ON_STACK\s*\(
852 return "" if (!defined($string));
854 while ($string =~ /^\s*\(.*\)\s*$/) {
855 $string =~ s@^\s*\(\s*@@;
856 $string =~ s@\s*\)\s*$@@;
859 $string =~ s@\s+@ @g;
864 sub seed_camelcase_file {
867 return if (!(-f $file));
871 open(my $include_file, '<', "$file")
872 or warn "$P: Can't read '$file' $!\n";
873 my $text = <$include_file>;
874 close($include_file);
876 my @lines = split('\n', $text);
878 foreach my $line (@lines) {
879 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
880 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
882 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
884 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
890 our %maintained_status = ();
892 sub is_maintained_obsolete {
895 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
897 if (!exists($maintained_status{$filename})) {
898 $maintained_status{$filename} = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
901 return $maintained_status{$filename} =~ /obsolete/i;
904 sub is_SPDX_License_valid {
907 return 1 if (!$tree || which("python") eq "" || !(-e "$root/scripts/spdxcheck.py") || !(-e "$root/.git"));
909 my $root_path = abs_path($root);
910 my $status = `cd "$root_path"; echo "$license" | python scripts/spdxcheck.py -`;
911 return 0 if ($status ne "");
915 my $camelcase_seeded = 0;
916 sub seed_camelcase_includes {
917 return if ($camelcase_seeded);
920 my $camelcase_cache = "";
921 my @include_files = ();
923 $camelcase_seeded = 1;
926 my $git_last_include_commit = `${git_command} log --no-merges --pretty=format:"%h%n" -1 -- include`;
927 chomp $git_last_include_commit;
928 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
930 my $last_mod_date = 0;
931 $files = `find $root/include -name "*.h"`;
932 @include_files = split('\n', $files);
933 foreach my $file (@include_files) {
934 my $date = POSIX::strftime("%Y%m%d%H%M",
935 localtime((stat $file)[9]));
936 $last_mod_date = $date if ($last_mod_date < $date);
938 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
941 if ($camelcase_cache ne "" && -f $camelcase_cache) {
942 open(my $camelcase_file, '<', "$camelcase_cache")
943 or warn "$P: Can't read '$camelcase_cache' $!\n";
944 while (<$camelcase_file>) {
948 close($camelcase_file);
954 $files = `${git_command} ls-files "include/*.h"`;
955 @include_files = split('\n', $files);
958 foreach my $file (@include_files) {
959 seed_camelcase_file($file);
962 if ($camelcase_cache ne "") {
963 unlink glob ".checkpatch-camelcase.*";
964 open(my $camelcase_file, '>', "$camelcase_cache")
965 or warn "$P: Can't write '$camelcase_cache' $!\n";
966 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
967 print $camelcase_file ("$_\n");
969 close($camelcase_file);
973 sub git_commit_info {
974 my ($commit, $id, $desc) = @_;
976 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
978 my $output = `${git_command} log --no-color --format='%H %s' -1 $commit 2>&1`;
979 $output =~ s/^\s*//gm;
980 my @lines = split("\n", $output);
982 return ($id, $desc) if ($#lines < 0);
984 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous/) {
985 # Maybe one day convert this block of bash into something that returns
986 # all matching commit ids, but it's very slow...
988 # echo "checking commits $1..."
989 # git rev-list --remotes | grep -i "^$1" |
990 # while read line ; do
991 # git log --format='%H %s' -1 $line |
992 # echo "commit $(cut -c 1-12,41-)"
994 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
997 $id = substr($lines[0], 0, 12);
998 $desc = substr($lines[0], 41);
1001 return ($id, $desc);
1004 $chk_signoff = 0 if ($file);
1009 my @fixed_inserted = ();
1010 my @fixed_deleted = ();
1013 # If input is git commits, extract all commits from the commit expressions.
1014 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
1015 die "$P: No git repository found\n" if ($git && !-e ".git");
1019 foreach my $commit_expr (@ARGV) {
1021 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
1022 $git_range = "-$2 $1";
1023 } elsif ($commit_expr =~ m/\.\./) {
1024 $git_range = "$commit_expr";
1026 $git_range = "-1 $commit_expr";
1028 my $lines = `${git_command} log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
1029 foreach my $line (split(/\n/, $lines)) {
1030 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
1031 next if (!defined($1) || !defined($2));
1034 unshift(@commits, $sha1);
1035 $git_commits{$sha1} = $subject;
1038 die "$P: no git commits after extraction!\n" if (@commits == 0);
1043 $allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
1044 for my $filename (@ARGV) {
1047 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
1048 die "$P: $filename: git format-patch failed - $!\n";
1050 open($FILE, '-|', "diff -u /dev/null $filename") ||
1051 die "$P: $filename: diff failed - $!\n";
1052 } elsif ($filename eq '-') {
1053 open($FILE, '<&STDIN');
1055 open($FILE, '<', "$filename") ||
1056 die "$P: $filename: open failed - $!\n";
1058 if ($filename eq '-') {
1059 $vname = 'Your patch';
1061 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1067 push(@rawlines, $_);
1068 $vname = qq("$1") if ($filename eq '-' && $_ =~ m/^Subject:\s+(.+)/i);
1072 if ($#ARGV > 0 && $quiet == 0) {
1073 print '-' x length($vname) . "\n";
1075 print '-' x length($vname) . "\n";
1078 if (!process($filename)) {
1084 @fixed_inserted = ();
1085 @fixed_deleted = ();
1087 @modifierListFile = ();
1093 hash_show_words(\%use_type, "Used");
1094 hash_show_words(\%ignore_type, "Ignored");
1096 if (!$perl_version_ok) {
1099 NOTE: perl $^V is not modern enough to detect all possible issues.
1100 An upgrade to at least perl $minimum_perl_version is suggested.
1106 NOTE: If any of the errors are false positives, please report
1107 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1114 sub top_of_kernel_tree {
1118 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1119 "README", "Documentation", "arch", "include", "drivers",
1120 "fs", "init", "ipc", "kernel", "lib", "scripts",
1123 foreach my $check (@tree_check) {
1124 if (! -e $root . '/' . $check) {
1132 my ($formatted_email) = @_;
1135 my $name_comment = "";
1139 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1142 $comment = $3 if defined $3;
1143 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1145 $comment = $2 if defined $2;
1146 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1148 $comment = $2 if defined $2;
1149 $formatted_email =~ s/\Q$address\E.*$//;
1150 $name = $formatted_email;
1151 $name = trim($name);
1152 $name =~ s/^\"|\"$//g;
1153 # If there's a name left after stripping spaces and
1154 # leading quotes, and the address doesn't have both
1155 # leading and trailing angle brackets, the address
1157 # "joe smith joe@smith.com" bad
1158 # "joe smith <joe@smith.com" bad
1159 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1166 $name = trim($name);
1167 $name =~ s/^\"|\"$//g;
1168 $name =~ s/(\s*\([^\)]+\))\s*//;
1170 $name_comment = trim($1);
1172 $address = trim($address);
1173 $address =~ s/^\<|\>$//g;
1175 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1176 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1177 $name = "\"$name\"";
1180 return ($name, $name_comment, $address, $comment);
1184 my ($name, $address) = @_;
1186 my $formatted_email;
1188 $name = trim($name);
1189 $name =~ s/^\"|\"$//g;
1190 $address = trim($address);
1192 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1193 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1194 $name = "\"$name\"";
1197 if ("$name" eq "") {
1198 $formatted_email = "$address";
1200 $formatted_email = "$name <$address>";
1203 return $formatted_email;
1206 sub reformat_email {
1209 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
1210 return format_email($email_name, $email_address);
1213 sub same_email_addresses {
1214 my ($email1, $email2) = @_;
1216 my ($email1_name, $name1_comment, $email1_address, $comment1) = parse_email($email1);
1217 my ($email2_name, $name2_comment, $email2_address, $comment2) = parse_email($email2);
1219 return $email1_name eq $email2_name &&
1220 $email1_address eq $email2_address;
1226 foreach my $path (split(/:/, $ENV{PATH})) {
1227 if (-e "$path/$bin") {
1228 return "$path/$bin";
1238 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1239 if (-e "$path/$conf") {
1240 return "$path/$conf";
1252 for my $c (split(//, $str)) {
1256 for (; ($n % $tabsize) != 0; $n++) {
1268 (my $res = shift) =~ tr/\t/ /c;
1275 # Drop the diff line leader and expand tabs
1277 $line = expand_tabs($line);
1279 # Pick the indent from the front of the line.
1280 my ($white) = ($line =~ /^(\s*)/);
1282 return (length($line), length($white));
1285 my $sanitise_quote = '';
1287 sub sanitise_line_reset {
1288 my ($in_comment) = @_;
1291 $sanitise_quote = '*/';
1293 $sanitise_quote = '';
1306 # Always copy over the diff marker.
1307 $res = substr($line, 0, 1);
1309 for ($off = 1; $off < length($line); $off++) {
1310 $c = substr($line, $off, 1);
1312 # Comments we are whacking completely including the begin
1313 # and end, all to $;.
1314 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1315 $sanitise_quote = '*/';
1317 substr($res, $off, 2, "$;$;");
1321 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1322 $sanitise_quote = '';
1323 substr($res, $off, 2, "$;$;");
1327 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1328 $sanitise_quote = '//';
1330 substr($res, $off, 2, $sanitise_quote);
1335 # A \ in a string means ignore the next character.
1336 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1338 substr($res, $off, 2, 'XX');
1343 if ($c eq "'" || $c eq '"') {
1344 if ($sanitise_quote eq '') {
1345 $sanitise_quote = $c;
1347 substr($res, $off, 1, $c);
1349 } elsif ($sanitise_quote eq $c) {
1350 $sanitise_quote = '';
1354 #print "c<$c> SQ<$sanitise_quote>\n";
1355 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1356 substr($res, $off, 1, $;);
1357 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1358 substr($res, $off, 1, $;);
1359 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1360 substr($res, $off, 1, 'X');
1362 substr($res, $off, 1, $c);
1366 if ($sanitise_quote eq '//') {
1367 $sanitise_quote = '';
1370 # The pathname on a #include may be surrounded by '<' and '>'.
1371 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1372 my $clean = 'X' x length($1);
1373 $res =~ s@\<.*\>@<$clean>@;
1375 # The whole of a #error is a string.
1376 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1377 my $clean = 'X' x length($1);
1378 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1381 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1383 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1389 sub get_quoted_string {
1390 my ($line, $rawline) = @_;
1392 return "" if (!defined($line) || !defined($rawline));
1393 return "" if ($line !~ m/($String)/g);
1394 return substr($rawline, $-[0], $+[0] - $-[0]);
1397 sub ctx_statement_block {
1398 my ($linenr, $remain, $off) = @_;
1399 my $line = $linenr - 1;
1402 my $coff = $off - 1;
1416 @stack = (['', 0]) if ($#stack == -1);
1418 #warn "CSB: blk<$blk> remain<$remain>\n";
1419 # If we are about to drop off the end, pull in more
1422 for (; $remain > 0; $line++) {
1423 last if (!defined $lines[$line]);
1424 next if ($lines[$line] =~ /^-/);
1427 $blk .= $lines[$line] . "\n";
1428 $len = length($blk);
1432 # Bail if there is no further context.
1433 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1437 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1443 $c = substr($blk, $off, 1);
1444 $remainder = substr($blk, $off);
1446 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1448 # Handle nested #if/#else.
1449 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1450 push(@stack, [ $type, $level ]);
1451 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1452 ($type, $level) = @{$stack[$#stack - 1]};
1453 } elsif ($remainder =~ /^#\s*endif\b/) {
1454 ($type, $level) = @{pop(@stack)};
1457 # Statement ends at the ';' or a close '}' at the
1459 if ($level == 0 && $c eq ';') {
1463 # An else is really a conditional as long as its not else if
1464 if ($level == 0 && $coff_set == 0 &&
1465 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1466 $remainder =~ /^(else)(?:\s|{)/ &&
1467 $remainder !~ /^else\s+if\b/) {
1468 $coff = $off + length($1) - 1;
1470 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1471 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1474 if (($type eq '' || $type eq '(') && $c eq '(') {
1478 if ($type eq '(' && $c eq ')') {
1480 $type = ($level != 0)? '(' : '';
1482 if ($level == 0 && $coff < $soff) {
1485 #warn "CSB: mark coff<$coff>\n";
1488 if (($type eq '' || $type eq '{') && $c eq '{') {
1492 if ($type eq '{' && $c eq '}') {
1494 $type = ($level != 0)? '{' : '';
1497 if (substr($blk, $off + 1, 1) eq ';') {
1503 # Preprocessor commands end at the newline unless escaped.
1504 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1512 # We are truly at the end, so shuffle to the next line.
1519 my $statement = substr($blk, $soff, $off - $soff + 1);
1520 my $condition = substr($blk, $soff, $coff - $soff + 1);
1522 #warn "STATEMENT<$statement>\n";
1523 #warn "CONDITION<$condition>\n";
1525 #print "coff<$coff> soff<$off> loff<$loff>\n";
1527 return ($statement, $condition,
1528 $line, $remain + 1, $off - $loff + 1, $level);
1531 sub statement_lines {
1534 # Strip the diff line prefixes and rip blank lines at start and end.
1535 $stmt =~ s/(^|\n)./$1/g;
1539 my @stmt_lines = ($stmt =~ /\n/g);
1541 return $#stmt_lines + 2;
1544 sub statement_rawlines {
1547 my @stmt_lines = ($stmt =~ /\n/g);
1549 return $#stmt_lines + 2;
1552 sub statement_block_size {
1555 $stmt =~ s/(^|\n)./$1/g;
1561 my @stmt_lines = ($stmt =~ /\n/g);
1562 my @stmt_statements = ($stmt =~ /;/g);
1564 my $stmt_lines = $#stmt_lines + 2;
1565 my $stmt_statements = $#stmt_statements + 1;
1567 if ($stmt_lines > $stmt_statements) {
1570 return $stmt_statements;
1574 sub ctx_statement_full {
1575 my ($linenr, $remain, $off) = @_;
1576 my ($statement, $condition, $level);
1580 # Grab the first conditional/block pair.
1581 ($statement, $condition, $linenr, $remain, $off, $level) =
1582 ctx_statement_block($linenr, $remain, $off);
1583 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1584 push(@chunks, [ $condition, $statement ]);
1585 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1586 return ($level, $linenr, @chunks);
1589 # Pull in the following conditional/block pairs and see if they
1590 # could continue the statement.
1592 ($statement, $condition, $linenr, $remain, $off, $level) =
1593 ctx_statement_block($linenr, $remain, $off);
1594 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1595 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1597 push(@chunks, [ $condition, $statement ]);
1600 return ($level, $linenr, @chunks);
1604 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1606 my $start = $linenr - 1;
1613 my @stack = ($level);
1614 for ($line = $start; $remain > 0; $line++) {
1615 next if ($rawlines[$line] =~ /^-/);
1618 $blk .= $rawlines[$line];
1620 # Handle nested #if/#else.
1621 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1622 push(@stack, $level);
1623 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1624 $level = $stack[$#stack - 1];
1625 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1626 $level = pop(@stack);
1629 foreach my $c (split(//, $lines[$line])) {
1630 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1636 if ($c eq $close && $level > 0) {
1638 last if ($level == 0);
1639 } elsif ($c eq $open) {
1644 if (!$outer || $level <= 1) {
1645 push(@res, $rawlines[$line]);
1648 last if ($level == 0);
1651 return ($level, @res);
1653 sub ctx_block_outer {
1654 my ($linenr, $remain) = @_;
1656 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1660 my ($linenr, $remain) = @_;
1662 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1666 my ($linenr, $remain, $off) = @_;
1668 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1671 sub ctx_block_level {
1672 my ($linenr, $remain) = @_;
1674 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1676 sub ctx_statement_level {
1677 my ($linenr, $remain, $off) = @_;
1679 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1682 sub ctx_locate_comment {
1683 my ($first_line, $end_line) = @_;
1685 # If c99 comment on the current line, or the line before or after
1686 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@^\+.*(//.*$)@);
1687 return $current_comment if (defined $current_comment);
1688 ($current_comment) = ($rawlines[$end_line - 2] =~ m@^[\+ ].*(//.*$)@);
1689 return $current_comment if (defined $current_comment);
1690 ($current_comment) = ($rawlines[$end_line] =~ m@^[\+ ].*(//.*$)@);
1691 return $current_comment if (defined $current_comment);
1693 # Catch a comment on the end of the line itself.
1694 ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1695 return $current_comment if (defined $current_comment);
1697 # Look through the context and try and figure out if there is a
1700 $current_comment = '';
1701 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1702 my $line = $rawlines[$linenr - 1];
1704 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1707 if ($line =~ m@/\*@) {
1710 if (!$in_comment && $current_comment ne '') {
1711 $current_comment = '';
1713 $current_comment .= $line . "\n" if ($in_comment);
1714 if ($line =~ m@\*/@) {
1719 chomp($current_comment);
1720 return($current_comment);
1722 sub ctx_has_comment {
1723 my ($first_line, $end_line) = @_;
1724 my $cmt = ctx_locate_comment($first_line, $end_line);
1726 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1727 ##print "CMMT: $cmt\n";
1729 return ($cmt ne '');
1733 my ($linenr, $cnt) = @_;
1735 my $offset = $linenr - 1;
1740 $line = $rawlines[$offset++];
1741 next if (defined($line) && $line =~ /^-/);
1749 my ($linenr, $lc) = @_;
1751 my $stat_real = raw_line($linenr, 0);
1752 for (my $count = $linenr + 1; $count <= $lc; $count++) {
1753 $stat_real = $stat_real . "\n" . raw_line($count, 0);
1760 my ($linenr, $cnt, $here) = @_;
1762 my $herectx = $here . "\n";
1763 for (my $n = 0; $n < $cnt; $n++) {
1764 $herectx .= raw_line($linenr, $n) . "\n";
1775 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1778 $coded = sprintf("^%c", unpack('C', $2) + 64);
1787 my $av_preprocessor = 0;
1792 sub annotate_reset {
1793 $av_preprocessor = 0;
1795 @av_paren_type = ('E');
1796 $av_pend_colon = 'O';
1799 sub annotate_values {
1800 my ($stream, $type) = @_;
1803 my $var = '_' x length($stream);
1806 print "$stream\n" if ($dbg_values > 1);
1808 while (length($cur)) {
1809 @av_paren_type = ('E') if ($#av_paren_type < 0);
1810 print " <" . join('', @av_paren_type) .
1811 "> <$type> <$av_pending>" if ($dbg_values > 1);
1812 if ($cur =~ /^(\s+)/o) {
1813 print "WS($1)\n" if ($dbg_values > 1);
1814 if ($1 =~ /\n/ && $av_preprocessor) {
1815 $type = pop(@av_paren_type);
1816 $av_preprocessor = 0;
1819 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1820 print "CAST($1)\n" if ($dbg_values > 1);
1821 push(@av_paren_type, $type);
1824 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1825 print "DECLARE($1)\n" if ($dbg_values > 1);
1828 } elsif ($cur =~ /^($Modifier)\s*/) {
1829 print "MODIFIER($1)\n" if ($dbg_values > 1);
1832 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1833 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1834 $av_preprocessor = 1;
1835 push(@av_paren_type, $type);
1841 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1842 print "UNDEF($1)\n" if ($dbg_values > 1);
1843 $av_preprocessor = 1;
1844 push(@av_paren_type, $type);
1846 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1847 print "PRE_START($1)\n" if ($dbg_values > 1);
1848 $av_preprocessor = 1;
1850 push(@av_paren_type, $type);
1851 push(@av_paren_type, $type);
1854 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1855 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1856 $av_preprocessor = 1;
1858 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1862 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1863 print "PRE_END($1)\n" if ($dbg_values > 1);
1865 $av_preprocessor = 1;
1867 # Assume all arms of the conditional end as this
1868 # one does, and continue as if the #endif was not here.
1869 pop(@av_paren_type);
1870 push(@av_paren_type, $type);
1873 } elsif ($cur =~ /^(\\\n)/o) {
1874 print "PRECONT($1)\n" if ($dbg_values > 1);
1876 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1877 print "ATTR($1)\n" if ($dbg_values > 1);
1878 $av_pending = $type;
1881 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1882 print "SIZEOF($1)\n" if ($dbg_values > 1);
1888 } elsif ($cur =~ /^(if|while|for)\b/o) {
1889 print "COND($1)\n" if ($dbg_values > 1);
1893 } elsif ($cur =~/^(case)/o) {
1894 print "CASE($1)\n" if ($dbg_values > 1);
1895 $av_pend_colon = 'C';
1898 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1899 print "KEYWORD($1)\n" if ($dbg_values > 1);
1902 } elsif ($cur =~ /^(\()/o) {
1903 print "PAREN('$1')\n" if ($dbg_values > 1);
1904 push(@av_paren_type, $av_pending);
1908 } elsif ($cur =~ /^(\))/o) {
1909 my $new_type = pop(@av_paren_type);
1910 if ($new_type ne '_') {
1912 print "PAREN('$1') -> $type\n"
1913 if ($dbg_values > 1);
1915 print "PAREN('$1')\n" if ($dbg_values > 1);
1918 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1919 print "FUNC($1)\n" if ($dbg_values > 1);
1923 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1924 if (defined $2 && $type eq 'C' || $type eq 'T') {
1925 $av_pend_colon = 'B';
1926 } elsif ($type eq 'E') {
1927 $av_pend_colon = 'L';
1929 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1932 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1933 print "IDENT($1)\n" if ($dbg_values > 1);
1936 } elsif ($cur =~ /^($Assignment)/o) {
1937 print "ASSIGN($1)\n" if ($dbg_values > 1);
1940 } elsif ($cur =~/^(;|{|})/) {
1941 print "END($1)\n" if ($dbg_values > 1);
1943 $av_pend_colon = 'O';
1945 } elsif ($cur =~/^(,)/) {
1946 print "COMMA($1)\n" if ($dbg_values > 1);
1949 } elsif ($cur =~ /^(\?)/o) {
1950 print "QUESTION($1)\n" if ($dbg_values > 1);
1953 } elsif ($cur =~ /^(:)/o) {
1954 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1956 substr($var, length($res), 1, $av_pend_colon);
1957 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1962 $av_pend_colon = 'O';
1964 } elsif ($cur =~ /^(\[)/o) {
1965 print "CLOSE($1)\n" if ($dbg_values > 1);
1968 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1971 print "OPV($1)\n" if ($dbg_values > 1);
1978 substr($var, length($res), 1, $variant);
1981 } elsif ($cur =~ /^($Operators)/o) {
1982 print "OP($1)\n" if ($dbg_values > 1);
1983 if ($1 ne '++' && $1 ne '--') {
1987 } elsif ($cur =~ /(^.)/o) {
1988 print "C($1)\n" if ($dbg_values > 1);
1991 $cur = substr($cur, length($1));
1992 $res .= $type x length($1);
1996 return ($res, $var);
2000 my ($possible, $line) = @_;
2001 my $notPermitted = qr{(?:
2018 ^(?:typedef|struct|enum)\b
2020 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
2021 if ($possible !~ $notPermitted) {
2022 # Check for modifiers.
2023 $possible =~ s/\s*$Storage\s*//g;
2024 $possible =~ s/\s*$Sparse\s*//g;
2025 if ($possible =~ /^\s*$/) {
2027 } elsif ($possible =~ /\s/) {
2028 $possible =~ s/\s*$Type\s*//g;
2029 for my $modifier (split(' ', $possible)) {
2030 if ($modifier !~ $notPermitted) {
2031 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
2032 push(@modifierListFile, $modifier);
2037 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
2038 push(@typeListFile, $possible);
2042 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
2051 $type =~ tr/[a-z]/[A-Z]/;
2053 return defined $use_type{$type} if (scalar keys %use_type > 0);
2055 return !defined $ignore_type{$type};
2059 my ($level, $type, $msg) = @_;
2061 if (!show_type($type) ||
2062 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
2067 if ($level eq 'ERROR') {
2069 } elsif ($level eq 'WARNING') {
2075 $output .= $prefix . $level . ':';
2077 $output .= BLUE if ($color);
2078 $output .= "$type:";
2080 $output .= RESET if ($color);
2081 $output .= ' ' . $msg . "\n";
2084 my @lines = split("\n", $output, -1);
2085 splice(@lines, 1, 1);
2086 $output = join("\n", @lines);
2088 $output = (split('\n', $output))[0] . "\n" if ($terse);
2090 push(our @report, $output);
2099 sub fixup_current_range {
2100 my ($lineRef, $offset, $length) = @_;
2102 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2105 my $no = $o + $offset;
2106 my $nl = $l + $length;
2107 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2111 sub fix_inserted_deleted_lines {
2112 my ($linesRef, $insertedRef, $deletedRef) = @_;
2114 my $range_last_linenr = 0;
2115 my $delta_offset = 0;
2120 my $next_insert = 0;
2121 my $next_delete = 0;
2125 my $inserted = @{$insertedRef}[$next_insert++];
2126 my $deleted = @{$deletedRef}[$next_delete++];
2128 foreach my $old_line (@{$linesRef}) {
2130 my $line = $old_line; #don't modify the array
2131 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
2133 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2134 $range_last_linenr = $new_linenr;
2135 fixup_current_range(\$line, $delta_offset, 0);
2138 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2139 $deleted = @{$deletedRef}[$next_delete++];
2141 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2144 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2145 push(@lines, ${$inserted}{'LINE'});
2146 $inserted = @{$insertedRef}[$next_insert++];
2148 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2152 push(@lines, $line);
2162 sub fix_insert_line {
2163 my ($linenr, $line) = @_;
2169 push(@fixed_inserted, $inserted);
2172 sub fix_delete_line {
2173 my ($linenr, $line) = @_;
2180 push(@fixed_deleted, $deleted);
2184 my ($type, $msg) = @_;
2186 if (report("ERROR", $type, $msg)) {
2194 my ($type, $msg) = @_;
2196 if (report("WARNING", $type, $msg)) {
2204 my ($type, $msg) = @_;
2206 if ($check && report("CHECK", $type, $msg)) {
2214 sub check_absolute_file {
2215 my ($absolute, $herecurr) = @_;
2216 my $file = $absolute;
2218 ##print "absolute<$absolute>\n";
2220 # See if any suffix of this path is a path within the tree.
2221 while ($file =~ s@^[^/]*/@@) {
2222 if (-f "$root/$file") {
2223 ##print "file<$file>\n";
2231 # It is, so see if the prefix is acceptable.
2232 my $prefix = $absolute;
2233 substr($prefix, -length($file)) = '';
2235 ##print "prefix<$prefix>\n";
2236 if ($prefix ne ".../") {
2237 WARN("USE_RELATIVE_PATH",
2238 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2245 $string =~ s/^\s+|\s+$//g;
2253 $string =~ s/^\s+//;
2261 $string =~ s/\s+$//;
2266 sub string_find_replace {
2267 my ($string, $find, $replace) = @_;
2269 $string =~ s/$find/$replace/g;
2277 my $source_indent = $tabsize;
2278 my $max_spaces_before_tab = $source_indent - 1;
2279 my $spaces_to_tab = " " x $source_indent;
2281 #convert leading spaces to tabs
2282 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2283 #Remove spaces before a tab
2284 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2289 sub pos_last_openparen {
2294 my $opens = $line =~ tr/\(/\(/;
2295 my $closes = $line =~ tr/\)/\)/;
2297 my $last_openparen = 0;
2299 if (($opens == 0) || ($closes >= $opens)) {
2303 my $len = length($line);
2305 for ($pos = 0; $pos < $len; $pos++) {
2306 my $string = substr($line, $pos);
2307 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2308 $pos += length($1) - 1;
2309 } elsif (substr($line, $pos, 1) eq '(') {
2310 $last_openparen = $pos;
2311 } elsif (index($string, '(') == -1) {
2316 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2319 sub get_raw_comment {
2320 my ($line, $rawline) = @_;
2323 for my $i (0 .. (length($line) - 1)) {
2324 if (substr($line, $i, 1) eq "$;") {
2325 $comment .= substr($rawline, $i, 1);
2333 my $filename = shift;
2339 my $stashrawline="";
2349 my $authorsignoff = 0;
2351 my $is_binding_patch = -1;
2352 my $in_header_lines = $file ? 0 : 1;
2353 my $in_commit_log = 0; #Scanning lines before patch
2354 my $has_patch_separator = 0; #Found a --- line
2355 my $has_commit_log = 0; #Encountered lines before patch
2356 my $commit_log_lines = 0; #Number of commit log lines
2357 my $commit_log_possible_stack_dump = 0;
2358 my $commit_log_long_line = 0;
2359 my $commit_log_has_diff = 0;
2360 my $reported_maintainer_file = 0;
2361 my $non_utf8_charset = 0;
2363 my $last_blank_line = 0;
2364 my $last_coalesced_string_linenr = -1;
2372 # Trace the real file/line as we go.
2377 my $context_function; #undef'd unless there's a known function
2379 my $comment_edge = 0;
2383 my $prev_values = 'E';
2386 my %suppress_ifbraces;
2387 my %suppress_whiletrailers;
2388 my %suppress_export;
2389 my $suppress_statement = 0;
2391 my %signatures = ();
2393 # Pre-scan the patch sanitizing the lines.
2394 # Pre-scan the patch looking for any __setup documentation.
2396 my @setup_docs = ();
2399 my $camelcase_file_seeded = 0;
2401 my $checklicenseline = 1;
2403 sanitise_line_reset();
2405 foreach my $rawline (@rawlines) {
2409 push(@fixed, $rawline) if ($fix);
2411 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2413 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.txt$@) {
2418 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2427 # Guestimate if this is a continuing comment. Run
2428 # the context looking for a comment "edge". If this
2429 # edge is a close comment then we must be in a comment
2433 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2434 next if (defined $rawlines[$ln - 1] &&
2435 $rawlines[$ln - 1] =~ /^-/);
2437 #print "RAW<$rawlines[$ln - 1]>\n";
2438 last if (!defined $rawlines[$ln - 1]);
2439 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2440 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2445 if (defined $edge && $edge eq '*/') {
2449 # Guestimate if this is a continuing comment. If this
2450 # is the start of a diff block and this line starts
2451 # ' *' then it is very likely a comment.
2452 if (!defined $edge &&
2453 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2458 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2459 sanitise_line_reset($in_comment);
2461 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2462 # Standardise the strings and chars within the input to
2463 # simplify matching -- only bother with positive lines.
2464 $line = sanitise_line($rawline);
2466 push(@lines, $line);
2469 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2474 #print "==>$rawline\n";
2475 #print "-->$line\n";
2477 if ($setup_docs && $line =~ /^\+/) {
2478 push(@setup_docs, $line);
2487 foreach my $line (@lines) {
2490 my $sline = $line; #copy of $line
2491 $sline =~ s/$;/ /g; #with comments as spaces
2493 my $rawline = $rawlines[$linenr - 1];
2494 my $raw_comment = get_raw_comment($line, $rawline);
2496 # check if it's a mode change, rename or start of a patch
2497 if (!$in_commit_log &&
2498 ($line =~ /^ mode change [0-7]+ => [0-7]+ \S+\s*$/ ||
2499 ($line =~ /^rename (?:from|to) \S+\s*$/ ||
2500 $line =~ /^diff --git a\/[\w\/\.\_\-]+ b\/\S+\s*$/))) {
2504 #extract the line range in the file after the patch is applied
2505 if (!$in_commit_log &&
2506 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2509 $first_line = $linenr + 1;
2519 %suppress_ifbraces = ();
2520 %suppress_whiletrailers = ();
2521 %suppress_export = ();
2522 $suppress_statement = 0;
2523 if ($context =~ /\b(\w+)\s*\(/) {
2524 $context_function = $1;
2526 undef $context_function;
2530 # track the line number as we move through the hunk, note that
2531 # new versions of GNU diff omit the leading space on completely
2532 # blank context lines so we need to count that too.
2533 } elsif ($line =~ /^( |\+|$)/) {
2535 $realcnt-- if ($realcnt != 0);
2537 # Measure the line length and indent.
2538 ($length, $indent) = line_stats($rawline);
2540 # Track the previous line.
2541 ($prevline, $stashline) = ($stashline, $line);
2542 ($previndent, $stashindent) = ($stashindent, $indent);
2543 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2545 #warn "line<$line>\n";
2547 } elsif ($realcnt == 1) {
2551 my $hunk_line = ($realcnt != 0);
2553 $here = "#$linenr: " if (!$file);
2554 $here = "#$realline: " if ($file);
2557 # extract the filename as it passes
2558 if ($line =~ /^diff --git.*?(\S+)$/) {
2560 $realfile =~ s@^([^/]*)/@@ if (!$file);
2563 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2565 $realfile =~ s@^([^/]*)/@@ if (!$file);
2569 if (!$file && $tree && $p1_prefix ne '' &&
2570 -e "$root/$p1_prefix") {
2571 WARN("PATCH_PREFIX",
2572 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2575 if ($realfile =~ m@^include/asm/@) {
2576 ERROR("MODIFIED_INCLUDE_ASM",
2577 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2582 #make up the handle for any error we report on this line
2584 $prefix = "$realfile:$realline: "
2587 $prefix = "$filename:$realline: ";
2589 $prefix = "$filename:$linenr: ";
2594 if (is_maintained_obsolete($realfile)) {
2596 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2598 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2601 $check = $check_orig;
2603 $checklicenseline = 1;
2605 if ($realfile !~ /^MAINTAINERS/) {
2606 my $last_binding_patch = $is_binding_patch;
2608 $is_binding_patch = () = $realfile =~ m@^(?:Documentation/devicetree/|include/dt-bindings/)@;
2610 if (($last_binding_patch != -1) &&
2611 ($last_binding_patch ^ $is_binding_patch)) {
2612 WARN("DT_SPLIT_BINDING_PATCH",
2613 "DT binding docs and includes should be a separate patch. See: Documentation/devicetree/bindings/submitting-patches.rst\n");
2620 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2622 my $hereline = "$here\n$rawline\n";
2623 my $herecurr = "$here\n$rawline\n";
2624 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2626 $cnt_lines++ if ($realcnt != 0);
2628 # Verify the existence of a commit log if appropriate
2629 # 2 is used because a $signature is counted in $commit_log_lines
2630 if ($in_commit_log) {
2631 if ($line !~ /^\s*$/) {
2632 $commit_log_lines++; #could be a $signature
2634 } elsif ($has_commit_log && $commit_log_lines < 2) {
2635 WARN("COMMIT_MESSAGE",
2636 "Missing commit description - Add an appropriate one\n");
2637 $commit_log_lines = 2; #warn only once
2640 # Check if the commit log has what seems like a diff which can confuse patch
2641 if ($in_commit_log && !$commit_log_has_diff &&
2642 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2643 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2644 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2645 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2646 ERROR("DIFF_IN_COMMIT_MSG",
2647 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2648 $commit_log_has_diff = 1;
2651 # Check for incorrect file permissions
2652 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2653 my $permhere = $here . "FILE: $realfile\n";
2654 if ($realfile !~ m@scripts/@ &&
2655 $realfile !~ /\.(py|pl|awk|sh)$/) {
2656 ERROR("EXECUTE_PERMISSIONS",
2657 "do not set execute permissions for source files\n" . $permhere);
2661 # Check the patch for a From:
2662 if (decode("MIME-Header", $line) =~ /^From:\s*(.*)/) {
2664 $author = encode("utf8", $author) if ($line =~ /=\?utf-8\?/i);
2666 $author = reformat_email($author);
2669 # Check the patch for a signoff:
2670 if ($line =~ /^\s*signed-off-by:\s*(.*)/i) {
2673 if ($author ne '') {
2674 if (same_email_addresses($1, $author)) {
2680 # Check for patch separator
2681 if ($line =~ /^---$/) {
2682 $has_patch_separator = 1;
2686 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2687 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2688 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2689 $reported_maintainer_file = 1;
2692 # Check signature styles
2693 if (!$in_header_lines &&
2694 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2695 my $space_before = $1;
2697 my $space_after = $3;
2699 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2701 if ($sign_off !~ /$signature_tags/) {
2702 WARN("BAD_SIGN_OFF",
2703 "Non-standard signature: $sign_off\n" . $herecurr);
2705 if (defined $space_before && $space_before ne "") {
2706 if (WARN("BAD_SIGN_OFF",
2707 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2709 $fixed[$fixlinenr] =
2710 "$ucfirst_sign_off $email";
2713 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2714 if (WARN("BAD_SIGN_OFF",
2715 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2717 $fixed[$fixlinenr] =
2718 "$ucfirst_sign_off $email";
2722 if (!defined $space_after || $space_after ne " ") {
2723 if (WARN("BAD_SIGN_OFF",
2724 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2726 $fixed[$fixlinenr] =
2727 "$ucfirst_sign_off $email";
2731 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
2732 my $suggested_email = format_email(($email_name, $email_address));
2733 if ($suggested_email eq "") {
2734 ERROR("BAD_SIGN_OFF",
2735 "Unrecognized email address: '$email'\n" . $herecurr);
2737 my $dequoted = $suggested_email;
2738 $dequoted =~ s/^"//;
2739 $dequoted =~ s/" </ </;
2740 # Don't force email to have quotes
2741 # Allow just an angle bracketed address
2742 if (!same_email_addresses($email, $suggested_email)) {
2743 WARN("BAD_SIGN_OFF",
2744 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2748 # Check for duplicate signatures
2749 my $sig_nospace = $line;
2750 $sig_nospace =~ s/\s//g;
2751 $sig_nospace = lc($sig_nospace);
2752 if (defined $signatures{$sig_nospace}) {
2753 WARN("BAD_SIGN_OFF",
2754 "Duplicate signature\n" . $herecurr);
2756 $signatures{$sig_nospace} = 1;
2759 # Check Co-developed-by: immediately followed by Signed-off-by: with same name and email
2760 if ($sign_off =~ /^co-developed-by:$/i) {
2761 if ($email eq $author) {
2762 WARN("BAD_SIGN_OFF",
2763 "Co-developed-by: should not be used to attribute nominal patch author '$author'\n" . "$here\n" . $rawline);
2765 if (!defined $lines[$linenr]) {
2766 WARN("BAD_SIGN_OFF",
2767 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline);
2768 } elsif ($rawlines[$linenr] !~ /^\s*signed-off-by:\s*(.*)/i) {
2769 WARN("BAD_SIGN_OFF",
2770 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
2771 } elsif ($1 ne $email) {
2772 WARN("BAD_SIGN_OFF",
2773 "Co-developed-by and Signed-off-by: name/email do not match \n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
2778 # Check email subject for common tools that don't need to be mentioned
2779 if ($in_header_lines &&
2780 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2781 WARN("EMAIL_SUBJECT",
2782 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2785 # Check for Gerrit Change-Ids not in any patch context
2786 if ($realfile eq '' && !$has_patch_separator && $line =~ /^\s*change-id:/i) {
2787 ERROR("GERRIT_CHANGE_ID",
2788 "Remove Gerrit Change-Id's before submitting upstream\n" . $herecurr);
2791 # Check if the commit log is in a possible stack dump
2792 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2793 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2794 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2796 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/) ||
2797 $line =~ /^(?:\s+\w+:\s+[0-9a-fA-F]+){3,3}/ ||
2798 $line =~ /^\s*\#\d+\s*\[[0-9a-fA-F]+\]\s*\w+ at [0-9a-fA-F]+/) {
2799 # stack dump address styles
2800 $commit_log_possible_stack_dump = 1;
2803 # Check for line lengths > 75 in commit log, warn once
2804 if ($in_commit_log && !$commit_log_long_line &&
2805 length($line) > 75 &&
2806 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2807 # file delta changes
2808 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2810 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2811 # A Fixes: or Link: line
2812 $commit_log_possible_stack_dump)) {
2813 WARN("COMMIT_LOG_LONG_LINE",
2814 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2815 $commit_log_long_line = 1;
2818 # Reset possible stack dump if a blank line is found
2819 if ($in_commit_log && $commit_log_possible_stack_dump &&
2821 $commit_log_possible_stack_dump = 0;
2824 # Check for git id commit length and improperly formed commit descriptions
2825 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2826 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink|base-commit):/i &&
2827 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
2828 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2829 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2830 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2831 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2832 my $init_char = "c";
2833 my $orig_commit = "";
2840 my $id = '0123456789ab';
2841 my $orig_desc = "commit description";
2842 my $description = "";
2844 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2846 $orig_commit = lc($2);
2847 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2848 $orig_commit = lc($1);
2851 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2852 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2853 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2854 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2855 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2858 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2859 defined $rawlines[$linenr] &&
2860 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2863 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2864 defined $rawlines[$linenr] &&
2865 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2866 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2868 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2869 $orig_desc .= " " . $1;
2873 ($id, $description) = git_commit_info($orig_commit,
2877 ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
2878 ERROR("GIT_COMMIT_ID",
2879 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2883 # Check for added, moved or deleted files
2884 if (!$reported_maintainer_file && !$in_commit_log &&
2885 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2886 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2887 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2888 (defined($1) || defined($2))))) {
2890 $reported_maintainer_file = 1;
2891 WARN("FILE_PATH_CHANGES",
2892 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2895 # Check for adding new DT bindings not in schema format
2896 if (!$in_commit_log &&
2897 ($line =~ /^new file mode\s*\d+\s*$/) &&
2898 ($realfile =~ m@^Documentation/devicetree/bindings/.*\.txt$@)) {
2899 WARN("DT_SCHEMA_BINDING_PATCH",
2900 "DT bindings should be in DT schema format. See: Documentation/devicetree/writing-schema.rst\n");
2903 # Check for wrappage within a valid hunk of the file
2904 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2905 ERROR("CORRUPTED_PATCH",
2906 "patch seems to be corrupt (line wrapped?)\n" .
2907 $herecurr) if (!$emitted_corrupt++);
2910 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2911 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2912 $rawline !~ m/^$UTF8*$/) {
2913 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2915 my $blank = copy_spacing($rawline);
2916 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2917 my $hereptr = "$hereline$ptr\n";
2920 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2923 # Check if it's the start of a commit log
2924 # (not a header line and we haven't seen the patch filename)
2925 if ($in_header_lines && $realfile =~ /^$/ &&
2926 !($rawline =~ /^\s+(?:\S|$)/ ||
2927 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
2928 $in_header_lines = 0;
2930 $has_commit_log = 1;
2933 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2934 # declined it, i.e defined some charset where it is missing.
2935 if ($in_header_lines &&
2936 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2938 $non_utf8_charset = 1;
2941 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2942 $rawline =~ /$NON_ASCII_UTF8/) {
2943 WARN("UTF8_BEFORE_PATCH",
2944 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2947 # Check for absolute kernel paths in commit message
2948 if ($tree && $in_commit_log) {
2949 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2952 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2953 check_absolute_file($1, $herecurr)) {
2956 check_absolute_file($file, $herecurr);
2961 # Check for various typo / spelling mistakes
2962 if (defined($misspellings) &&
2963 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2964 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2966 my $typo_fix = $spelling_fix{lc($typo)};
2967 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2968 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2969 my $msg_level = \&WARN;
2970 $msg_level = \&CHK if ($file);
2971 if (&{$msg_level}("TYPO_SPELLING",
2972 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2974 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2979 # check for invalid commit id
2980 if ($in_commit_log && $line =~ /(^fixes:|\bcommit)\s+([0-9a-f]{6,40})\b/i) {
2983 ($id, $description) = git_commit_info($2, undef, undef);
2984 if (!defined($id)) {
2985 WARN("UNKNOWN_COMMIT_ID",
2986 "Unknown commit id '$2', maybe rebased or not pulled?\n" . $herecurr);
2990 # ignore non-hunk lines and lines being removed
2991 next if (!$hunk_line || $line =~ /^-/);
2993 #trailing whitespace
2994 if ($line =~ /^\+.*\015/) {
2995 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2996 if (ERROR("DOS_LINE_ENDINGS",
2997 "DOS line endings\n" . $herevet) &&
2999 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
3001 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
3002 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3003 if (ERROR("TRAILING_WHITESPACE",
3004 "trailing whitespace\n" . $herevet) &&
3006 $fixed[$fixlinenr] =~ s/\s+$//;
3012 # Check for FSF mailing addresses.
3013 if ($rawline =~ /\bwrite to the Free/i ||
3014 $rawline =~ /\b675\s+Mass\s+Ave/i ||
3015 $rawline =~ /\b59\s+Temple\s+Pl/i ||
3016 $rawline =~ /\b51\s+Franklin\s+St/i) {
3017 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3018 my $msg_level = \&ERROR;
3019 $msg_level = \&CHK if ($file);
3020 &{$msg_level}("FSF_MAILING_ADDRESS",
3021 "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)
3024 # check for Kconfig help text having a real description
3025 # Only applies when adding the entry originally, after that we do not have
3026 # sufficient context to determine whether it is indeed long enough.
3027 if ($realfile =~ /Kconfig/ &&
3028 # 'choice' is usually the last thing on the line (though
3029 # Kconfig supports named choices), so use a word boundary
3030 # (\b) rather than a whitespace character (\s)
3031 $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
3034 my $ln = $linenr + 1;
3038 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
3039 $f = $lines[$ln - 1];
3040 $cnt-- if ($lines[$ln - 1] !~ /^-/);
3041 $is_end = $lines[$ln - 1] =~ /^\+/;
3043 next if ($f =~ /^-/);
3044 last if (!$file && $f =~ /^\@\@/);
3046 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
3048 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:help|---help---)\s*$/) {
3049 if ($lines[$ln - 1] =~ "---help---") {
3050 WARN("CONFIG_DESCRIPTION",
3051 "prefer 'help' over '---help---' for new help texts\n" . $herecurr);
3059 next if ($f =~ /^$/);
3061 # This only checks context lines in the patch
3062 # and so hopefully shouldn't trigger false
3063 # positives, even though some of these are
3064 # common words in help texts
3065 if ($f =~ /^\s*(?:config|menuconfig|choice|endchoice|
3066 if|endif|menu|endmenu|source)\b/x) {
3072 if ($is_start && $is_end && $length < $min_conf_desc_length) {
3073 WARN("CONFIG_DESCRIPTION",
3074 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
3076 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
3079 # check MAINTAINERS entries
3080 if ($realfile =~ /^MAINTAINERS$/) {
3081 # check MAINTAINERS entries for the right form
3082 if ($rawline =~ /^\+[A-Z]:/ &&
3083 $rawline !~ /^\+[A-Z]:\t\S/) {
3084 if (WARN("MAINTAINERS_STYLE",
3085 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
3087 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
3090 # check MAINTAINERS entries for the right ordering too
3091 my $preferred_order = 'MRLSWQBCPTFXNK';
3092 if ($rawline =~ /^\+[A-Z]:/ &&
3093 $prevrawline =~ /^[\+ ][A-Z]:/) {
3094 $rawline =~ /^\+([A-Z]):\s*(.*)/;
3097 $prevrawline =~ /^[\+ ]([A-Z]):\s*(.*)/;
3100 my $curindex = index($preferred_order, $cur);
3101 my $previndex = index($preferred_order, $prev);
3102 if ($curindex < 0) {
3103 WARN("MAINTAINERS_STYLE",
3104 "Unknown MAINTAINERS entry type: '$cur'\n" . $herecurr);
3106 if ($previndex >= 0 && $curindex < $previndex) {
3107 WARN("MAINTAINERS_STYLE",
3108 "Misordered MAINTAINERS entry - list '$cur:' before '$prev:'\n" . $hereprev);
3109 } elsif ((($prev eq 'F' && $cur eq 'F') ||
3110 ($prev eq 'X' && $cur eq 'X')) &&
3111 ($prevval cmp $curval) > 0) {
3112 WARN("MAINTAINERS_STYLE",
3113 "Misordered MAINTAINERS entry - list file patterns in alphabetic order\n" . $hereprev);
3119 # discourage the use of boolean for type definition attributes of Kconfig options
3120 if ($realfile =~ /Kconfig/ &&
3121 $line =~ /^\+\s*\bboolean\b/) {
3122 WARN("CONFIG_TYPE_BOOLEAN",
3123 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
3126 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
3127 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
3130 'EXTRA_AFLAGS' => 'asflags-y',
3131 'EXTRA_CFLAGS' => 'ccflags-y',
3132 'EXTRA_CPPFLAGS' => 'cppflags-y',
3133 'EXTRA_LDFLAGS' => 'ldflags-y',
3136 WARN("DEPRECATED_VARIABLE",
3137 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
3140 # check for DT compatible documentation
3141 if (defined $root &&
3142 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
3143 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
3145 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
3147 my $dt_path = $root . "/Documentation/devicetree/bindings/";
3148 my $vp_file = $dt_path . "vendor-prefixes.yaml";
3150 foreach my $compat (@compats) {
3151 my $compat2 = $compat;
3152 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
3153 my $compat3 = $compat;
3154 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
3155 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
3157 WARN("UNDOCUMENTED_DT_STRING",
3158 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
3161 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
3163 `grep -Eq "\\"\\^\Q$vendor\E,\\.\\*\\":" $vp_file`;
3165 WARN("UNDOCUMENTED_DT_STRING",
3166 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
3171 # check for using SPDX license tag at beginning of files
3172 if ($realline == $checklicenseline) {
3173 if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
3174 $checklicenseline = 2;
3175 } elsif ($rawline =~ /^\+/) {
3177 if ($realfile =~ /\.(h|s|S)$/) {
3179 } elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
3181 } elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc|yaml)$/) {
3183 } elsif ($realfile =~ /\.rst$/) {
3187 # check SPDX comment style for .[chsS] files
3188 if ($realfile =~ /\.[chsS]$/ &&
3189 $rawline =~ /SPDX-License-Identifier:/ &&
3190 $rawline !~ m@^\+\s*\Q$comment\E\s*@) {
3191 WARN("SPDX_LICENSE_TAG",
3192 "Improper SPDX comment style for '$realfile', please use '$comment' instead\n" . $herecurr);
3195 if ($comment !~ /^$/ &&
3196 $rawline !~ m@^\+\Q$comment\E SPDX-License-Identifier: @) {
3197 WARN("SPDX_LICENSE_TAG",
3198 "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
3199 } elsif ($rawline =~ /(SPDX-License-Identifier: .*)/) {
3200 my $spdx_license = $1;
3201 if (!is_SPDX_License_valid($spdx_license)) {
3202 WARN("SPDX_LICENSE_TAG",
3203 "'$spdx_license' is not supported in LICENSES/...\n" . $herecurr);
3205 if ($realfile =~ m@^Documentation/devicetree/bindings/@ &&
3206 not $spdx_license =~ /GPL-2\.0.*BSD-2-Clause/) {
3207 my $msg_level = \&WARN;
3208 $msg_level = \&CHK if ($file);
3209 if (&{$msg_level}("SPDX_LICENSE_TAG",
3211 "DT binding documents should be licensed (GPL-2.0-only OR BSD-2-Clause)\n" . $herecurr) &&
3213 $fixed[$fixlinenr] =~ s/SPDX-License-Identifier: .*/SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)/;
3220 # check we are in a valid source file if not then ignore this hunk
3221 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
3223 # check for using SPDX-License-Identifier on the wrong line number
3224 if ($realline != $checklicenseline &&
3225 $rawline =~ /\bSPDX-License-Identifier:/ &&
3226 substr($line, @-, @+ - @-) eq "$;" x (@+ - @-)) {
3227 WARN("SPDX_LICENSE_TAG",
3228 "Misplaced SPDX-License-Identifier tag - use line $checklicenseline instead\n" . $herecurr);
3231 # line length limit (with some exclusions)
3233 # There are a few types of lines that may extend beyond $max_line_length:
3234 # logging functions like pr_info that end in a string
3235 # lines with a single string
3236 # #defines that are a single string
3237 # lines with an RFC3986 like URL
3239 # There are 3 different line length message types:
3240 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
3241 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
3242 # LONG_LINE all other lines longer than $max_line_length
3244 # if LONG_LINE is ignored, the other 2 types are also ignored
3247 if ($line =~ /^\+/ && $length > $max_line_length) {
3248 my $msg_type = "LONG_LINE";
3250 # Check the allowed long line types first
3252 # logging functions that end in a string that starts
3253 # before $max_line_length
3254 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
3255 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3258 # lines with only strings (w/ possible termination)
3259 # #defines with only strings
3260 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
3261 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
3264 # More special cases
3265 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3266 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3269 # URL ($rawline is used in case the URL is in a comment)
3270 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
3273 # Otherwise set the alternate message types
3275 # a comment starts before $max_line_length
3276 } elsif ($line =~ /($;[\s$;]*)$/ &&
3277 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3278 $msg_type = "LONG_LINE_COMMENT"
3280 # a quoted string starts before $max_line_length
3281 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3282 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3283 $msg_type = "LONG_LINE_STRING"
3286 if ($msg_type ne "" &&
3287 (show_type("LONG_LINE") || show_type($msg_type))) {
3288 my $msg_level = \&WARN;
3289 $msg_level = \&CHK if ($file);
3290 &{$msg_level}($msg_type,
3291 "line length of $length exceeds $max_line_length columns\n" . $herecurr);
3295 # check for adding lines without a newline.
3296 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3297 WARN("MISSING_EOF_NEWLINE",
3298 "adding a line without newline at end of file\n" . $herecurr);
3301 # check we are in a valid source file C or perl if not then ignore this hunk
3302 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3304 # at the beginning of a line any tabs must come first and anything
3305 # more than $tabsize must use tabs.
3306 if ($rawline =~ /^\+\s* \t\s*\S/ ||
3307 $rawline =~ /^\+\s* \s*/) {
3308 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3310 if (ERROR("CODE_INDENT",
3311 "code indent should use tabs where possible\n" . $herevet) &&
3313 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3317 # check for repeated words separated by a single space
3318 if ($rawline =~ /^\+/) {
3319 while ($rawline =~ /\b($word_pattern) (?=($word_pattern))/g) {
3324 if ($first =~ /(?:struct|union|enum)/) {
3325 pos($rawline) += length($first) + length($second) + 1;
3329 next if ($first ne $second);
3330 next if ($first eq 'long');
3332 if (WARN("REPEATED_WORD",
3333 "Possible repeated word: '$first'\n" . $herecurr) &&
3335 $fixed[$fixlinenr] =~ s/\b$first $second\b/$first/;
3339 # if it's a repeated word on consecutive lines in a comment block
3340 if ($prevline =~ /$;+\s*$/ &&
3341 $prevrawline =~ /($word_pattern)\s*$/) {
3343 if ($rawline =~ /^\+\s*\*\s*$last_word /) {
3344 if (WARN("REPEATED_WORD",
3345 "Possible repeated word: '$last_word'\n" . $hereprev) &&
3347 $fixed[$fixlinenr] =~ s/(\+\s*\*\s*)$last_word /$1/;
3353 # check for space before tabs.
3354 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3355 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3356 if (WARN("SPACE_BEFORE_TAB",
3357 "please, no space before tabs\n" . $herevet) &&
3359 while ($fixed[$fixlinenr] =~
3360 s/(^\+.*) {$tabsize,$tabsize}\t/$1\t\t/) {}
3361 while ($fixed[$fixlinenr] =~
3362 s/(^\+.*) +\t/$1\t/) {}
3366 # check for assignments on the start of a line
3367 if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3368 CHK("ASSIGNMENT_CONTINUATIONS",
3369 "Assignment operator '$1' should be on the previous line\n" . $hereprev);
3372 # check for && or || at the start of a line
3373 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3374 CHK("LOGICAL_CONTINUATIONS",
3375 "Logical continuations should be on the previous line\n" . $hereprev);
3378 # check indentation starts on a tab stop
3379 if ($perl_version_ok &&
3380 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3381 my $indent = length($1);
3382 if ($indent % $tabsize) {
3384 "Statements should start on a tabstop\n" . $herecurr) &&
3386 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/$tabsize)@e;
3391 # check multi-line statement indentation matches previous line
3392 if ($perl_version_ok &&
3393 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3394 $prevline =~ /^\+(\t*)(.*)$/;
3398 my $pos = pos_last_openparen($rest);
3400 $line =~ /^(\+| )([ \t]*)/;
3403 my $goodtabindent = $oldindent .
3404 "\t" x ($pos / $tabsize) .
3405 " " x ($pos % $tabsize);
3406 my $goodspaceindent = $oldindent . " " x $pos;
3408 if ($newindent ne $goodtabindent &&
3409 $newindent ne $goodspaceindent) {
3411 if (CHK("PARENTHESIS_ALIGNMENT",
3412 "Alignment should match open parenthesis\n" . $hereprev) &&
3413 $fix && $line =~ /^\+/) {
3414 $fixed[$fixlinenr] =~
3415 s/^\+[ \t]*/\+$goodtabindent/;
3421 # check for space after cast like "(int) foo" or "(struct foo) bar"
3422 # avoid checking a few false positives:
3423 # "sizeof(<type>)" or "__alignof__(<type>)"
3424 # function pointer declarations like "(*foo)(int) = bar;"
3425 # structure definitions like "(struct foo) { 0 };"
3426 # multiline macros that define functions
3427 # known attributes or the __attribute__ keyword
3428 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3429 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3431 "No space is necessary after a cast\n" . $herecurr) &&
3433 $fixed[$fixlinenr] =~
3434 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3438 # Block comment styles
3439 # Networking with an initial /*
3440 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3441 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3442 $rawline =~ /^\+[ \t]*\*/ &&
3444 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3445 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3448 # Block comments use * on subsequent lines
3449 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3450 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
3451 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3452 $rawline =~ /^\+/ && #line is new
3453 $rawline !~ /^\+[ \t]*\*/) { #no leading *
3454 WARN("BLOCK_COMMENT_STYLE",
3455 "Block comments use * on subsequent lines\n" . $hereprev);
3458 # Block comments use */ on trailing lines
3459 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
3460 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
3461 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
3462 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
3463 WARN("BLOCK_COMMENT_STYLE",
3464 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3467 # Block comment * alignment
3468 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3469 $line =~ /^\+[ \t]*$;/ && #leading comment
3470 $rawline =~ /^\+[ \t]*\*/ && #leading *
3471 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
3472 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3473 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3475 $prevrawline =~ m@^\+([ \t]*/?)\*@;
3477 $oldindent = expand_tabs($1);
3479 $prevrawline =~ m@^\+(.*/?)\*@;
3480 $oldindent = expand_tabs($1);
3482 $rawline =~ m@^\+([ \t]*)\*@;
3484 $newindent = expand_tabs($newindent);
3485 if (length($oldindent) ne length($newindent)) {
3486 WARN("BLOCK_COMMENT_STYLE",
3487 "Block comments should align the * on each line\n" . $hereprev);
3491 # check for missing blank lines after struct/union declarations
3492 # with exceptions for various attributes and macros
3493 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3495 !($line =~ /^\+\s*$/ ||
3496 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
3497 $line =~ /^\+\s*MODULE_/i ||
3498 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3499 $line =~ /^\+[a-z_]*init/ ||
3500 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3501 $line =~ /^\+\s*DECLARE/ ||
3502 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3503 $line =~ /^\+\s*__setup/)) {
3504 if (CHK("LINE_SPACING",
3505 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3507 fix_insert_line($fixlinenr, "\+");
3511 # check for multiple consecutive blank lines
3512 if ($prevline =~ /^[\+ ]\s*$/ &&
3513 $line =~ /^\+\s*$/ &&
3514 $last_blank_line != ($linenr - 1)) {
3515 if (CHK("LINE_SPACING",
3516 "Please don't use multiple blank lines\n" . $hereprev) &&
3518 fix_delete_line($fixlinenr, $rawline);
3521 $last_blank_line = $linenr;
3524 # check for missing blank lines after declarations
3525 if ($sline =~ /^\+\s+\S/ && #Not at char 1
3526 # actual declarations
3527 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3528 # function pointer declarations
3529 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3530 # foo bar; where foo is some local typedef or #define
3531 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3532 # known declaration macros
3533 $prevline =~ /^\+\s+$declaration_macros/) &&
3534 # for "else if" which can look like "$Ident $Ident"
3535 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
3536 # other possible extensions of declaration lines
3537 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
3538 # not starting a section or a macro "\" extended line
3539 $prevline =~ /(?:\{\s*|\\)$/) &&
3540 # looks like a declaration
3541 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
3542 # function pointer declarations
3543 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
3544 # foo bar; where foo is some local typedef or #define
3545 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
3546 # known declaration macros
3547 $sline =~ /^\+\s+$declaration_macros/ ||
3548 # start of struct or union or enum
3549 $sline =~ /^\+\s+(?:static\s+)?(?:const\s+)?(?:union|struct|enum|typedef)\b/ ||
3550 # start or end of block or continuation of declaration
3551 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
3552 # bitfield continuation
3553 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
3554 # other possible extensions of declaration lines
3555 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
3556 # indentation of previous and current line are the same
3557 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
3558 if (WARN("LINE_SPACING",
3559 "Missing a blank line after declarations\n" . $hereprev) &&
3561 fix_insert_line($fixlinenr, "\+");
3565 # check for spaces at the beginning of a line.
3567 # 1) within comments
3568 # 2) indented preprocessor commands
3570 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
3571 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3572 if (WARN("LEADING_SPACE",
3573 "please, no spaces at the start of a line\n" . $herevet) &&
3575 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3579 # check we are in a valid C source file if not then ignore this hunk
3580 next if ($realfile !~ /\.(h|c)$/);
3582 # check for unusual line ending [ or (
3583 if ($line =~ /^\+.*([\[\(])\s*$/) {
3584 CHK("OPEN_ENDED_LINE",
3585 "Lines should not end with a '$1'\n" . $herecurr);
3588 # check if this appears to be the start function declaration, save the name
3589 if ($sline =~ /^\+\{\s*$/ &&
3590 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
3591 $context_function = $1;
3594 # check if this appears to be the end of function declaration
3595 if ($sline =~ /^\+\}\s*$/) {
3596 undef $context_function;
3599 # check indentation of any line with a bare else
3600 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
3601 # if the previous line is a break or return and is indented 1 tab more...
3602 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
3603 my $tabs = length($1) + 1;
3604 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
3605 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
3606 defined $lines[$linenr] &&
3607 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
3608 WARN("UNNECESSARY_ELSE",
3609 "else is not generally useful after a break or return\n" . $hereprev);
3613 # check indentation of a line with a break;
3614 # if the previous line is a goto or return and is indented the same # of tabs
3615 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
3617 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
3618 WARN("UNNECESSARY_BREAK",
3619 "break is not useful after a goto or return\n" . $hereprev);
3623 # check for RCS/CVS revision markers
3624 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
3626 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
3629 # check for old HOTPLUG __dev<foo> section markings
3630 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
3631 WARN("HOTPLUG_SECTION",
3632 "Using $1 is unnecessary\n" . $herecurr);
3635 # Check for potential 'bare' types
3636 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
3638 #print "LINE<$line>\n";
3639 if ($linenr > $suppress_statement &&
3640 $realcnt && $sline =~ /.\s*\S/) {
3641 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3642 ctx_statement_block($linenr, $realcnt, 0);
3643 $stat =~ s/\n./\n /g;
3644 $cond =~ s/\n./\n /g;
3646 #print "linenr<$linenr> <$stat>\n";
3647 # If this statement has no statement boundaries within
3648 # it there is no point in retrying a statement scan
3649 # until we hit end of it.
3650 my $frag = $stat; $frag =~ s/;+\s*$//;
3651 if ($frag !~ /(?:{|;)/) {
3652 #print "skip<$line_nr_next>\n";
3653 $suppress_statement = $line_nr_next;
3656 # Find the real next line.
3657 $realline_next = $line_nr_next;
3658 if (defined $realline_next &&
3659 (!defined $lines[$realline_next - 1] ||
3660 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
3667 # Ignore goto labels.
3668 if ($s =~ /$Ident:\*$/s) {
3670 # Ignore functions being called
3671 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
3673 } elsif ($s =~ /^.\s*else\b/s) {
3675 # declarations always start with types
3676 } 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) {
3679 possible($type, "A:" . $s);
3681 # definitions in global scope can only start with types
3682 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3683 possible($1, "B:" . $s);
3686 # any (foo ... *) is a pointer cast, and foo is a type
3687 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3688 possible($1, "C:" . $s);
3691 # Check for any sort of function declaration.
3692 # int foo(something bar, other baz);
3693 # void (*store_gdt)(x86_descr_ptr *);
3694 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3695 my ($name_len) = length($1);
3698 substr($ctx, 0, $name_len + 1, '');
3699 $ctx =~ s/\)[^\)]*$//;
3701 for my $arg (split(/\s*,\s*/, $ctx)) {
3702 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3704 possible($1, "D:" . $s);
3712 # Checks which may be anchored in the context.
3715 # Check for switch () and associated case and default
3716 # statements should be at the same indent.
3717 if ($line=~/\bswitch\s*\(.*\)/) {
3720 my @ctx = ctx_block_outer($linenr, $realcnt);
3722 for my $ctx (@ctx) {
3723 my ($clen, $cindent) = line_stats($ctx);
3724 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3725 $indent != $cindent) {
3726 $err .= "$sep$ctx\n";
3733 ERROR("SWITCH_CASE_INDENT_LEVEL",
3734 "switch and case should be at the same indent\n$hereline$err");
3738 # if/while/etc brace do not go on next line, unless defining a do while loop,
3739 # or if that brace on the next line is for something else
3740 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3741 my $pre_ctx = "$1$2";
3743 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3745 if ($line =~ /^\+\t{6,}/) {
3746 WARN("DEEP_INDENTATION",
3747 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3750 my $ctx_cnt = $realcnt - $#ctx - 1;
3751 my $ctx = join("\n", @ctx);
3753 my $ctx_ln = $linenr;
3754 my $ctx_skip = $realcnt;
3756 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3757 defined $lines[$ctx_ln - 1] &&
3758 $lines[$ctx_ln - 1] =~ /^-/)) {
3759 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3760 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3764 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3765 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3767 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3769 "that open brace { should be on the previous line\n" .
3770 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3772 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3773 $ctx =~ /\)\s*\;\s*$/ &&
3774 defined $lines[$ctx_ln - 1])
3776 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3777 if ($nindent > $indent) {
3778 WARN("TRAILING_SEMICOLON",
3779 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3780 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3785 # Check relative indent for conditionals and blocks.
3786 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3787 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3788 ctx_statement_block($linenr, $realcnt, 0)
3789 if (!defined $stat);
3790 my ($s, $c) = ($stat, $cond);
3792 substr($s, 0, length($c), '');
3794 # remove inline comments
3798 # Find out how long the conditional actually is.
3799 my @newlines = ($c =~ /\n/gs);
3800 my $cond_lines = 1 + $#newlines;
3802 # Make sure we remove the line prefixes as we have
3803 # none on the first line, and are going to readd them
3806 while ($s =~ /\n\s+\\\n/) {
3807 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3810 # We want to check the first line inside the block
3811 # starting at the end of the conditional, so remove:
3812 # 1) any blank line termination
3813 # 2) any opening brace { on end of the line
3815 my $continuation = 0;
3817 $s =~ s/^.*\bdo\b//;
3819 if ($s =~ s/^\s*\\//) {
3822 if ($s =~ s/^\s*?\n//) {
3827 # Also ignore a loop construct at the end of a
3828 # preprocessor statement.
3829 if (($prevline =~ /^.\s*#\s*define\s/ ||
3830 $prevline =~ /\\\s*$/) && $continuation == 0) {
3836 while ($cond_ptr != $cond_lines) {
3837 $cond_ptr = $cond_lines;
3839 # If we see an #else/#elif then the code
3841 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3846 # 1) blank lines, they should be at 0,
3847 # 2) preprocessor lines, and
3849 if ($continuation ||
3851 $s =~ /^\s*#\s*?/ ||
3852 $s =~ /^\s*$Ident\s*:/) {
3853 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3854 if ($s =~ s/^.*?\n//) {
3860 my (undef, $sindent) = line_stats("+" . $s);
3861 my $stat_real = raw_line($linenr, $cond_lines);
3863 # Check if either of these lines are modified, else
3864 # this is not this patch's fault.
3865 if (!defined($stat_real) ||
3866 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3869 if (defined($stat_real) && $cond_lines > 1) {
3870 $stat_real = "[...]\n$stat_real";
3873 #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";
3875 if ($check && $s ne '' &&
3876 (($sindent % $tabsize) != 0 ||
3877 ($sindent < $indent) ||
3878 ($sindent == $indent &&
3879 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
3880 ($sindent > $indent + $tabsize))) {
3881 WARN("SUSPECT_CODE_INDENT",
3882 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3886 # Track the 'values' across context and added lines.
3887 my $opline = $line; $opline =~ s/^./ /;
3888 my ($curr_values, $curr_vars) =
3889 annotate_values($opline . "\n", $prev_values);
3890 $curr_values = $prev_values . $curr_values;
3892 my $outline = $opline; $outline =~ s/\t/ /g;
3893 print "$linenr > .$outline\n";
3894 print "$linenr > $curr_values\n";
3895 print "$linenr > $curr_vars\n";
3897 $prev_values = substr($curr_values, -1);
3899 #ignore lines not being added
3900 next if ($line =~ /^[^\+]/);
3902 # check for dereferences that span multiple lines
3903 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
3904 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
3905 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
3907 $line =~ /^.\s*($Lval)/;
3910 WARN("MULTILINE_DEREFERENCE",
3911 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
3914 # check for declarations of signed or unsigned without int
3915 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
3918 $var = "" if (!defined $var);
3919 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
3923 $pointer = "" if (!defined $pointer);
3925 if (WARN("UNSPECIFIED_INT",
3926 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
3928 my $decl = trim($sign) . " int ";
3929 my $comp_pointer = $pointer;
3930 $comp_pointer =~ s/\s//g;
3931 $decl .= $comp_pointer;
3932 $decl = rtrim($decl) if ($var eq "");
3933 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
3938 # TEST: allow direct testing of the type matcher.
3940 if ($line =~ /^.\s*$Declare\s*$/) {
3942 "TEST: is type\n" . $herecurr);
3943 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3944 ERROR("TEST_NOT_TYPE",
3945 "TEST: is not type ($1 is)\n". $herecurr);
3949 # TEST: allow direct testing of the attribute matcher.
3951 if ($line =~ /^.\s*$Modifier\s*$/) {
3953 "TEST: is attr\n" . $herecurr);
3954 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3955 ERROR("TEST_NOT_ATTR",
3956 "TEST: is not attr ($1 is)\n". $herecurr);
3961 # check for initialisation to aggregates open brace on the next line
3962 if ($line =~ /^.\s*{/ &&
3963 $prevline =~ /(?:^|[^=])=\s*$/) {
3964 if (ERROR("OPEN_BRACE",
3965 "that open brace { should be on the previous line\n" . $hereprev) &&
3966 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3967 fix_delete_line($fixlinenr - 1, $prevrawline);
3968 fix_delete_line($fixlinenr, $rawline);
3969 my $fixedline = $prevrawline;
3970 $fixedline =~ s/\s*=\s*$/ = {/;
3971 fix_insert_line($fixlinenr, $fixedline);
3973 $fixedline =~ s/^(.\s*)\{\s*/$1/;
3974 fix_insert_line($fixlinenr, $fixedline);
3979 # Checks which are anchored on the added line.
3982 # check for malformed paths in #include statements (uses RAW line)
3983 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3985 if ($path =~ m{//}) {
3986 ERROR("MALFORMED_INCLUDE",
3987 "malformed #include filename\n" . $herecurr);
3989 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3990 ERROR("UAPI_INCLUDE",
3991 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3995 # no C99 // comments
3996 if ($line =~ m{//}) {
3997 if (ERROR("C99_COMMENTS",
3998 "do not use C99 // comments\n" . $herecurr) &&
4000 my $line = $fixed[$fixlinenr];
4001 if ($line =~ /\/\/(.*)$/) {
4002 my $comment = trim($1);
4003 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
4007 # Remove C99 comments.
4009 $opline =~ s@//.*@@;
4011 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
4012 # the whole statement.
4013 #print "APW <$lines[$realline_next - 1]>\n";
4014 if (defined $realline_next &&
4015 exists $lines[$realline_next - 1] &&
4016 !defined $suppress_export{$realline_next} &&
4017 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
4018 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
4019 # Handle definitions which produce identifiers with
4022 # EXPORT_SYMBOL(something_foo);
4024 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
4025 $name =~ /^${Ident}_$2/) {
4026 #print "FOO C name<$name>\n";
4027 $suppress_export{$realline_next} = 1;
4029 } elsif ($stat !~ /(?:
4031 ^.DEFINE_$Ident\(\Q$name\E\)|
4032 ^.DECLARE_$Ident\(\Q$name\E\)|
4033 ^.LIST_HEAD\(\Q$name\E\)|
4034 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
4035 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
4037 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
4038 $suppress_export{$realline_next} = 2;
4040 $suppress_export{$realline_next} = 1;
4043 if (!defined $suppress_export{$linenr} &&
4044 $prevline =~ /^.\s*$/ &&
4045 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
4046 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
4047 #print "FOO B <$lines[$linenr - 1]>\n";
4048 $suppress_export{$linenr} = 2;
4050 if (defined $suppress_export{$linenr} &&
4051 $suppress_export{$linenr} == 2) {
4052 WARN("EXPORT_SYMBOL",
4053 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
4056 # check for global initialisers.
4057 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
4058 if (ERROR("GLOBAL_INITIALISERS",
4059 "do not initialise globals to $1\n" . $herecurr) &&
4061 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
4064 # check for static initialisers.
4065 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
4066 if (ERROR("INITIALISED_STATIC",
4067 "do not initialise statics to $1\n" .
4070 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
4074 # check for misordered declarations of char/short/int/long with signed/unsigned
4075 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
4077 WARN("MISORDERED_TYPE",
4078 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
4081 # check for unnecessary <signed> int declarations of short/long/long long
4082 while ($sline =~ m{\b($TypeMisordered(\s*\*)*|$C90_int_types)\b}g) {
4083 my $type = trim($1);
4084 next if ($type !~ /\bint\b/);
4085 next if ($type !~ /\b(?:short|long\s+long|long)\b/);
4086 my $new_type = $type;
4087 $new_type =~ s/\b\s*int\s*\b/ /;
4088 $new_type =~ s/\b\s*(?:un)?signed\b\s*/ /;
4089 $new_type =~ s/^const\s+//;
4090 $new_type = "unsigned $new_type" if ($type =~ /\bunsigned\b/);
4091 $new_type = "const $new_type" if ($type =~ /^const\b/);
4092 $new_type =~ s/\s+/ /g;
4093 $new_type = trim($new_type);
4094 if (WARN("UNNECESSARY_INT",
4095 "Prefer '$new_type' over '$type' as the int is unnecessary\n" . $herecurr) &&
4097 $fixed[$fixlinenr] =~ s/\b\Q$type\E\b/$new_type/;
4101 # check for static const char * arrays.
4102 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
4103 WARN("STATIC_CONST_CHAR_ARRAY",
4104 "static const char * array should probably be static const char * const\n" .
4108 # check for initialized const char arrays that should be static const
4109 if ($line =~ /^\+\s*const\s+(char|unsigned\s+char|_*u8|(?:[us]_)?int8_t)\s+\w+\s*\[\s*(?:\w+\s*)?\]\s*=\s*"/) {
4110 if (WARN("STATIC_CONST_CHAR_ARRAY",
4111 "const array should probably be static const\n" . $herecurr) &&
4113 $fixed[$fixlinenr] =~ s/(^.\s*)const\b/${1}static const/;
4117 # check for static char foo[] = "bar" declarations.
4118 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
4119 WARN("STATIC_CONST_CHAR_ARRAY",
4120 "static char array declaration should probably be static const char\n" .
4124 # check for const <foo> const where <foo> is not a pointer or array type
4125 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
4127 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
4129 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
4130 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
4132 "'const $found const' should probably be 'const $found'\n" . $herecurr);
4136 # check for non-global char *foo[] = {"bar", ...} declarations.
4137 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
4138 WARN("STATIC_CONST_CHAR_ARRAY",
4139 "char * array declaration might be better as static const\n" .
4143 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
4144 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
4146 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
4148 if (WARN("ARRAY_SIZE",
4149 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
4151 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
4156 # check for function declarations without arguments like "int foo()"
4157 if ($line =~ /(\b$Type\s*$Ident)\s*\(\s*\)/) {
4158 if (ERROR("FUNCTION_WITHOUT_ARGS",
4159 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
4161 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
4165 # check for new typedefs, only function parameters and sparse annotations
4167 if ($line =~ /\btypedef\s/ &&
4168 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
4169 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
4170 $line !~ /\b$typeTypedefs\b/ &&
4171 $line !~ /\b__bitwise\b/) {
4172 WARN("NEW_TYPEDEFS",
4173 "do not add new typedefs\n" . $herecurr);
4176 # * goes on variable not on type
4178 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
4180 my ($ident, $from, $to) = ($1, $2, $2);
4182 # Should start with a space.
4183 $to =~ s/^(\S)/ $1/;
4184 # Should not end with a space.
4186 # '*'s should not have spaces between.
4187 while ($to =~ s/\*\s+\*/\*\*/) {
4190 ## print "1: from<$from> to<$to> ident<$ident>\n";
4192 if (ERROR("POINTER_LOCATION",
4193 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
4195 my $sub_from = $ident;
4196 my $sub_to = $ident;
4197 $sub_to =~ s/\Q$from\E/$to/;
4198 $fixed[$fixlinenr] =~
4199 s@\Q$sub_from\E@$sub_to@;
4203 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
4205 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
4207 # Should start with a space.
4208 $to =~ s/^(\S)/ $1/;
4209 # Should not end with a space.
4211 # '*'s should not have spaces between.
4212 while ($to =~ s/\*\s+\*/\*\*/) {
4214 # Modifiers should have spaces.
4215 $to =~ s/(\b$Modifier$)/$1 /;
4217 ## print "2: from<$from> to<$to> ident<$ident>\n";
4218 if ($from ne $to && $ident !~ /^$Modifier$/) {
4219 if (ERROR("POINTER_LOCATION",
4220 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
4223 my $sub_from = $match;
4224 my $sub_to = $match;
4225 $sub_to =~ s/\Q$from\E/$to/;
4226 $fixed[$fixlinenr] =~
4227 s@\Q$sub_from\E@$sub_to@;
4232 # avoid BUG() or BUG_ON()
4233 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
4234 my $msg_level = \&WARN;
4235 $msg_level = \&CHK if ($file);
4236 &{$msg_level}("AVOID_BUG",
4237 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
4240 # avoid LINUX_VERSION_CODE
4241 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
4242 WARN("LINUX_VERSION_CODE",
4243 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
4246 # check for uses of printk_ratelimit
4247 if ($line =~ /\bprintk_ratelimit\s*\(/) {
4248 WARN("PRINTK_RATELIMITED",
4249 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
4252 # printk should use KERN_* levels
4253 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
4254 WARN("PRINTK_WITHOUT_KERN_LEVEL",
4255 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
4258 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
4260 my $level = lc($orig);
4261 $level = "warn" if ($level eq "warning");
4262 my $level2 = $level;
4263 $level2 = "dbg" if ($level eq "debug");
4264 WARN("PREFER_PR_LEVEL",
4265 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
4268 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
4270 my $level = lc($orig);
4271 $level = "warn" if ($level eq "warning");
4272 $level = "dbg" if ($level eq "debug");
4273 WARN("PREFER_DEV_LEVEL",
4274 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
4277 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
4278 # number of false positives, but assembly files are not checked, so at
4279 # least the arch entry code will not trigger this warning.
4280 if ($line =~ /\bENOSYS\b/) {
4282 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
4285 # ENOTSUPP is not a standard error code and should be avoided in new patches.
4286 # Folks usually mean EOPNOTSUPP (also called ENOTSUP), when they type ENOTSUPP.
4287 # Similarly to ENOSYS warning a small number of false positives is expected.
4288 if (!$file && $line =~ /\bENOTSUPP\b/) {
4289 if (WARN("ENOTSUPP",
4290 "ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP\n" . $herecurr) &&
4292 $fixed[$fixlinenr] =~ s/\bENOTSUPP\b/EOPNOTSUPP/;
4296 # function brace can't be on same line, except for #defines of do while,
4297 # or if closed on same line
4298 if ($perl_version_ok &&
4299 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
4300 $sline !~ /\#\s*define\b.*do\s*\{/ &&
4302 if (ERROR("OPEN_BRACE",
4303 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
4305 fix_delete_line($fixlinenr, $rawline);
4306 my $fixed_line = $rawline;
4307 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
4310 fix_insert_line($fixlinenr, ltrim($line1));
4311 fix_insert_line($fixlinenr, "\+{");
4312 if ($line2 !~ /^\s*$/) {
4313 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
4318 # open braces for enum, union and struct go on the same line.
4319 if ($line =~ /^.\s*{/ &&
4320 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
4321 if (ERROR("OPEN_BRACE",
4322 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
4323 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4324 fix_delete_line($fixlinenr - 1, $prevrawline);
4325 fix_delete_line($fixlinenr, $rawline);
4326 my $fixedline = rtrim($prevrawline) . " {";
4327 fix_insert_line($fixlinenr, $fixedline);
4328 $fixedline = $rawline;
4329 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
4330 if ($fixedline !~ /^\+\s*$/) {
4331 fix_insert_line($fixlinenr, $fixedline);
4336 # missing space after union, struct or enum definition
4337 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4339 "missing space after $1 definition\n" . $herecurr) &&
4341 $fixed[$fixlinenr] =~
4342 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4346 # Function pointer declarations
4347 # check spacing between type, funcptr, and args
4348 # canonical declaration is "type (*funcptr)(args...)"
4349 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4351 my $pre_pointer_space = $2;
4352 my $post_pointer_space = $3;
4354 my $post_funcname_space = $5;
4355 my $pre_args_space = $6;
4357 # the $Declare variable will capture all spaces after the type
4358 # so check it for a missing trailing missing space but pointer return types
4359 # don't need a space so don't warn for those.
4360 my $post_declare_space = "";
4361 if ($declare =~ /(\s+)$/) {
4362 $post_declare_space = $1;
4363 $declare = rtrim($declare);
4365 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4367 "missing space after return type\n" . $herecurr);
4368 $post_declare_space = " ";
4371 # unnecessary space "type (*funcptr)(args...)"
4372 # This test is not currently implemented because these declarations are
4374 # int foo(int bar, ...)
4375 # and this is form shouldn't/doesn't generate a checkpatch warning.
4377 # elsif ($declare =~ /\s{2,}$/) {
4379 # "Multiple spaces after return type\n" . $herecurr);
4382 # unnecessary space "type ( *funcptr)(args...)"
4383 if (defined $pre_pointer_space &&
4384 $pre_pointer_space =~ /^\s/) {
4386 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4389 # unnecessary space "type (* funcptr)(args...)"
4390 if (defined $post_pointer_space &&
4391 $post_pointer_space =~ /^\s/) {
4393 "Unnecessary space before function pointer name\n" . $herecurr);
4396 # unnecessary space "type (*funcptr )(args...)"
4397 if (defined $post_funcname_space &&
4398 $post_funcname_space =~ /^\s/) {
4400 "Unnecessary space after function pointer name\n" . $herecurr);
4403 # unnecessary space "type (*funcptr) (args...)"
4404 if (defined $pre_args_space &&
4405 $pre_args_space =~ /^\s/) {
4407 "Unnecessary space before function pointer arguments\n" . $herecurr);
4410 if (show_type("SPACING") && $fix) {
4411 $fixed[$fixlinenr] =~
4412 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4416 # check for spacing round square brackets; allowed:
4417 # 1. with a type on the left -- int [] a;
4418 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4419 # 3. inside a curly brace -- = { [0...10] = 5 }
4420 while ($line =~ /(.*?\s)\[/g) {
4421 my ($where, $prefix) = ($-[1], $1);
4422 if ($prefix !~ /$Type\s+$/ &&
4423 ($where != 0 || $prefix !~ /^.\s+$/) &&
4424 $prefix !~ /[{,:]\s+$/) {
4425 if (ERROR("BRACKET_SPACE",
4426 "space prohibited before open square bracket '['\n" . $herecurr) &&
4428 $fixed[$fixlinenr] =~
4429 s/^(\+.*?)\s+\[/$1\[/;
4434 # check for spaces between functions and their parentheses.
4435 while ($line =~ /($Ident)\s+\(/g) {
4437 my $ctx_before = substr($line, 0, $-[1]);
4438 my $ctx = "$ctx_before$name";
4440 # Ignore those directives where spaces _are_ permitted.
4442 if|for|while|switch|return|case|
4443 volatile|__volatile__|
4444 __attribute__|format|__extension__|
4447 # cpp #define statements have non-optional spaces, ie
4448 # if there is a space between the name and the open
4449 # parenthesis it is simply not a parameter group.
4450 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4452 # cpp #elif statement condition may start with a (
4453 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4455 # If this whole things ends with a type its most
4456 # likely a typedef for a function.
4457 } elsif ($ctx =~ /$Type$/) {
4461 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4463 $fixed[$fixlinenr] =~
4464 s/\b$name\s+\(/$name\(/;
4469 # Check operator spacing.
4470 if (!($line=~/\#\s*include/)) {
4471 my $fixed_line = "";
4475 <<=|>>=|<=|>=|==|!=|
4476 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
4477 =>|->|<<|>>|<|>|=|!|~|
4478 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
4481 my @elements = split(/($ops|;)/, $opline);
4483 ## print("element count: <" . $#elements . ">\n");
4484 ## foreach my $el (@elements) {
4485 ## print("el: <$el>\n");
4488 my @fix_elements = ();
4491 foreach my $el (@elements) {
4492 push(@fix_elements, substr($rawline, $off, length($el)));
4493 $off += length($el);
4498 my $blank = copy_spacing($opline);
4499 my $last_after = -1;
4501 for (my $n = 0; $n < $#elements; $n += 2) {
4503 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
4505 ## print("n: <$n> good: <$good>\n");
4507 $off += length($elements[$n]);
4509 # Pick up the preceding and succeeding characters.
4510 my $ca = substr($opline, 0, $off);
4512 if (length($opline) >= ($off + length($elements[$n + 1]))) {
4513 $cc = substr($opline, $off + length($elements[$n + 1]));
4515 my $cb = "$ca$;$cc";
4518 $a = 'V' if ($elements[$n] ne '');
4519 $a = 'W' if ($elements[$n] =~ /\s$/);
4520 $a = 'C' if ($elements[$n] =~ /$;$/);
4521 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
4522 $a = 'O' if ($elements[$n] eq '');
4523 $a = 'E' if ($ca =~ /^\s*$/);
4525 my $op = $elements[$n + 1];
4528 if (defined $elements[$n + 2]) {
4529 $c = 'V' if ($elements[$n + 2] ne '');
4530 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
4531 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
4532 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
4533 $c = 'O' if ($elements[$n + 2] eq '');
4534 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
4539 my $ctx = "${a}x${c}";
4541 my $at = "(ctx:$ctx)";
4543 my $ptr = substr($blank, 0, $off) . "^";
4544 my $hereptr = "$hereline$ptr\n";
4546 # Pull out the value of this operator.
4547 my $op_type = substr($curr_values, $off + 1, 1);
4549 # Get the full operator variant.
4550 my $opv = $op . substr($curr_vars, $off, 1);
4552 # Ignore operators passed as parameters.
4553 if ($op_type ne 'V' &&
4554 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
4557 # } elsif ($op =~ /^$;+$/) {
4559 # ; should have either the end of line or a space or \ after it
4560 } elsif ($op eq ';') {
4561 if ($ctx !~ /.x[WEBC]/ &&
4562 $cc !~ /^\\/ && $cc !~ /^;/) {
4563 if (ERROR("SPACING",
4564 "space required after that '$op' $at\n" . $hereptr)) {
4565 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4571 } elsif ($op eq '//') {
4573 # : when part of a bitfield
4574 } elsif ($opv eq ':B') {
4575 # skip the bitfield test for now
4579 } elsif ($op eq '->') {
4580 if ($ctx =~ /Wx.|.xW/) {
4581 if (ERROR("SPACING",
4582 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
4583 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4584 if (defined $fix_elements[$n + 2]) {
4585 $fix_elements[$n + 2] =~ s/^\s+//;
4591 # , must not have a space before and must have a space on the right.
4592 } elsif ($op eq ',') {
4593 my $rtrim_before = 0;
4594 my $space_after = 0;
4595 if ($ctx =~ /Wx./) {
4596 if (ERROR("SPACING",
4597 "space prohibited before that '$op' $at\n" . $hereptr)) {
4602 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
4603 if (ERROR("SPACING",
4604 "space required after that '$op' $at\n" . $hereptr)) {
4610 if ($rtrim_before || $space_after) {
4611 if ($rtrim_before) {
4612 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4614 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4621 # '*' as part of a type definition -- reported already.
4622 } elsif ($opv eq '*_') {
4623 #warn "'*' is part of type\n";
4625 # unary operators should have a space before and
4626 # none after. May be left adjacent to another
4627 # unary operator, or a cast
4628 } elsif ($op eq '!' || $op eq '~' ||
4629 $opv eq '*U' || $opv eq '-U' ||
4630 $opv eq '&U' || $opv eq '&&U') {
4631 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
4632 if (ERROR("SPACING",
4633 "space required before that '$op' $at\n" . $hereptr)) {
4634 if ($n != $last_after + 2) {
4635 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
4640 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
4641 # A unary '*' may be const
4643 } elsif ($ctx =~ /.xW/) {
4644 if (ERROR("SPACING",
4645 "space prohibited after that '$op' $at\n" . $hereptr)) {
4646 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
4647 if (defined $fix_elements[$n + 2]) {
4648 $fix_elements[$n + 2] =~ s/^\s+//;
4654 # unary ++ and unary -- are allowed no space on one side.
4655 } elsif ($op eq '++' or $op eq '--') {
4656 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
4657 if (ERROR("SPACING",
4658 "space required one side of that '$op' $at\n" . $hereptr)) {
4659 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
4663 if ($ctx =~ /Wx[BE]/ ||
4664 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
4665 if (ERROR("SPACING",
4666 "space prohibited before that '$op' $at\n" . $hereptr)) {
4667 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4671 if ($ctx =~ /ExW/) {
4672 if (ERROR("SPACING",
4673 "space prohibited after that '$op' $at\n" . $hereptr)) {
4674 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
4675 if (defined $fix_elements[$n + 2]) {
4676 $fix_elements[$n + 2] =~ s/^\s+//;
4682 # << and >> may either have or not have spaces both sides
4683 } elsif ($op eq '<<' or $op eq '>>' or
4684 $op eq '&' or $op eq '^' or $op eq '|' or
4685 $op eq '+' or $op eq '-' or
4686 $op eq '*' or $op eq '/' or
4690 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
4692 "spaces preferred around that '$op' $at\n" . $hereptr)) {
4693 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4694 $fix_elements[$n + 2] =~ s/^\s+//;
4697 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
4699 "space preferred before that '$op' $at\n" . $hereptr)) {
4700 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
4704 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
4705 if (ERROR("SPACING",
4706 "need consistent spacing around '$op' $at\n" . $hereptr)) {
4707 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4708 if (defined $fix_elements[$n + 2]) {
4709 $fix_elements[$n + 2] =~ s/^\s+//;
4715 # A colon needs no spaces before when it is
4716 # terminating a case value or a label.
4717 } elsif ($opv eq ':C' || $opv eq ':L') {
4718 if ($ctx =~ /Wx./) {
4719 if (ERROR("SPACING",
4720 "space prohibited before that '$op' $at\n" . $hereptr)) {
4721 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4726 # All the others need spaces both sides.
4727 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4730 # Ignore email addresses <foo@bar>
4732 $cc =~ /^\S+\@\S+>/) ||
4734 $ca =~ /<\S+\@\S+$/))
4739 # for asm volatile statements
4740 # ignore a colon with another
4741 # colon immediately before or after
4743 ($ca =~ /:$/ || $cc =~ /^:/)) {
4747 # messages are ERROR, but ?: are CHK
4749 my $msg_level = \&ERROR;
4750 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4752 if (&{$msg_level}("SPACING",
4753 "spaces required around that '$op' $at\n" . $hereptr)) {
4754 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4755 if (defined $fix_elements[$n + 2]) {
4756 $fix_elements[$n + 2] =~ s/^\s+//;
4762 $off += length($elements[$n + 1]);
4764 ## print("n: <$n> GOOD: <$good>\n");
4766 $fixed_line = $fixed_line . $good;
4769 if (($#elements % 2) == 0) {
4770 $fixed_line = $fixed_line . $fix_elements[$#elements];
4773 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4774 $fixed[$fixlinenr] = $fixed_line;
4780 # check for whitespace before a non-naked semicolon
4781 if ($line =~ /^\+.*\S\s+;\s*$/) {
4783 "space prohibited before semicolon\n" . $herecurr) &&
4785 1 while $fixed[$fixlinenr] =~
4786 s/^(\+.*\S)\s+;/$1;/;
4790 # check for multiple assignments
4791 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4792 CHK("MULTIPLE_ASSIGNMENTS",
4793 "multiple assignments should be avoided\n" . $herecurr);
4796 ## # check for multiple declarations, allowing for a function declaration
4798 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4799 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4801 ## # Remove any bracketed sections to ensure we do not
4802 ## # falsly report the parameters of functions.
4804 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4806 ## if ($ln =~ /,/) {
4807 ## WARN("MULTIPLE_DECLARATION",
4808 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4812 #need space before brace following if, while, etc
4813 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
4814 $line =~ /\b(?:else|do)\{/) {
4815 if (ERROR("SPACING",
4816 "space required before the open brace '{'\n" . $herecurr) &&
4818 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|else|\)))\{/$1 {/;
4822 ## # check for blank lines before declarations
4823 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4824 ## $prevrawline =~ /^.\s*$/) {
4826 ## "No blank lines before declarations\n" . $hereprev);
4830 # closing brace should have a space following it when it has anything
4832 if ($line =~ /}(?!(?:,|;|\)|\}))\S/) {
4833 if (ERROR("SPACING",
4834 "space required after that close brace '}'\n" . $herecurr) &&
4836 $fixed[$fixlinenr] =~
4837 s/}((?!(?:,|;|\)))\S)/} $1/;
4841 # check spacing on square brackets
4842 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4843 if (ERROR("SPACING",
4844 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4846 $fixed[$fixlinenr] =~
4850 if ($line =~ /\s\]/) {
4851 if (ERROR("SPACING",
4852 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4854 $fixed[$fixlinenr] =~
4859 # check spacing on parentheses
4860 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4861 $line !~ /for\s*\(\s+;/) {
4862 if (ERROR("SPACING",
4863 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4865 $fixed[$fixlinenr] =~
4869 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4870 $line !~ /for\s*\(.*;\s+\)/ &&
4871 $line !~ /:\s+\)/) {
4872 if (ERROR("SPACING",
4873 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4875 $fixed[$fixlinenr] =~
4880 # check unnecessary parentheses around addressof/dereference single $Lvals
4881 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4883 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4885 if (CHK("UNNECESSARY_PARENTHESES",
4886 "Unnecessary parentheses around $var\n" . $herecurr) &&
4888 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4892 # check for unnecessary parentheses around function pointer uses
4893 # ie: (foo->bar)(); should be foo->bar();
4894 # but not "if (foo->bar) (" to avoid some false positives
4895 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4897 if (CHK("UNNECESSARY_PARENTHESES",
4898 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4900 my $var2 = deparenthesize($var);
4902 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4906 # check for unnecessary parentheses around comparisons in if uses
4907 # when !drivers/staging or command-line uses --strict
4908 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
4909 $perl_version_ok && defined($stat) &&
4910 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
4912 my $test = substr($2, 1, -1);
4914 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
4916 # avoid parentheses around potential macro args
4917 next if ($match =~ /^\s*\w+\s*$/);
4918 if (!defined($herectx)) {
4919 $herectx = $here . "\n";
4920 my $cnt = statement_rawlines($if_stat);
4921 for (my $n = 0; $n < $cnt; $n++) {
4922 my $rl = raw_line($linenr, $n);
4923 $herectx .= $rl . "\n";
4924 last if $rl =~ /^[ \+].*\{/;
4927 CHK("UNNECESSARY_PARENTHESES",
4928 "Unnecessary parentheses around '$match'\n" . $herectx);
4932 #goto labels aren't indented, allow a single space however
4933 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4934 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4935 if (WARN("INDENTED_LABEL",
4936 "labels should not be indented\n" . $herecurr) &&
4938 $fixed[$fixlinenr] =~
4943 # return is not a function
4944 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4946 if ($perl_version_ok &&
4947 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4949 $value = deparenthesize($value);
4950 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4951 ERROR("RETURN_PARENTHESES",
4952 "return is not a function, parentheses are not required\n" . $herecurr);
4954 } elsif ($spacing !~ /\s+/) {
4956 "space required before the open parenthesis '('\n" . $herecurr);
4960 # unnecessary return in a void function
4961 # at end-of-function, with the previous line a single leading tab, then return;
4962 # and the line before that not a goto label target like "out:"
4963 if ($sline =~ /^[ \+]}\s*$/ &&
4964 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4966 $lines[$linenr - 3] =~ /^[ +]/ &&
4967 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4969 "void function return statements are not generally useful\n" . $hereprev);
4972 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4973 if ($perl_version_ok &&
4974 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4975 my $openparens = $1;
4976 my $count = $openparens =~ tr@\(@\(@;
4978 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4979 my $comp = $4; #Not $1 because of $LvalOrFunc
4980 $msg = " - maybe == should be = ?" if ($comp eq "==");
4981 WARN("UNNECESSARY_PARENTHESES",
4982 "Unnecessary parentheses$msg\n" . $herecurr);
4986 # comparisons with a constant or upper case identifier on the left
4987 # avoid cases like "foo + BAR < baz"
4988 # only fix matches surrounded by parentheses to avoid incorrect
4989 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4990 if ($perl_version_ok &&
4991 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4996 my $newcomp = $comp;
4997 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
4998 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4999 WARN("CONSTANT_COMPARISON",
5000 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
5004 } elsif ($comp eq "<=") {
5006 } elsif ($comp eq ">") {
5008 } elsif ($comp eq ">=") {
5011 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
5015 # Return of what appears to be an errno should normally be negative
5016 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
5018 if ($name ne 'EOF' && $name ne 'ERROR') {
5019 WARN("USE_NEGATIVE_ERRNO",
5020 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
5024 # Need a space before open parenthesis after if, while etc
5025 if ($line =~ /\b(if|while|for|switch)\(/) {
5026 if (ERROR("SPACING",
5027 "space required before the open parenthesis '('\n" . $herecurr) &&
5029 $fixed[$fixlinenr] =~
5030 s/\b(if|while|for|switch)\(/$1 \(/;
5034 # Check for illegal assignment in if conditional -- and check for trailing
5035 # statements after the conditional.
5036 if ($line =~ /do\s*(?!{)/) {
5037 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
5038 ctx_statement_block($linenr, $realcnt, 0)
5039 if (!defined $stat);
5040 my ($stat_next) = ctx_statement_block($line_nr_next,
5041 $remain_next, $off_next);
5042 $stat_next =~ s/\n./\n /g;
5043 ##print "stat<$stat> stat_next<$stat_next>\n";
5045 if ($stat_next =~ /^\s*while\b/) {
5046 # If the statement carries leading newlines,
5047 # then count those as offsets.
5049 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
5051 statement_rawlines($whitespace) - 1;
5053 $suppress_whiletrailers{$line_nr_next +
5057 if (!defined $suppress_whiletrailers{$linenr} &&
5058 defined($stat) && defined($cond) &&
5059 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
5060 my ($s, $c) = ($stat, $cond);
5062 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
5063 if (ERROR("ASSIGN_IN_IF",
5064 "do not use assignment in if condition\n" . $herecurr) &&
5065 $fix && $perl_version_ok) {
5066 if ($rawline =~ /^\+(\s+)if\s*\(\s*(\!)?\s*\(\s*(($Lval)\s*=\s*$LvalOrFunc)\s*\)\s*(?:($Compare)\s*($FuncArg))?\s*\)\s*(\{)?\s*$/) {
5074 fix_delete_line($fixlinenr, $rawline);
5075 fix_insert_line($fixlinenr, "$space$statement;");
5076 my $newline = "${space}if (";
5077 $newline .= '!' if defined($not);
5078 $newline .= '(' if (defined $not && defined($test) && defined($against));
5079 $newline .= "$assigned";
5080 $newline .= " $test $against" if (defined($test) && defined($against));
5081 $newline .= ')' if (defined $not && defined($test) && defined($against));
5083 $newline .= " {" if (defined($brace));
5084 fix_insert_line($fixlinenr + 1, $newline);
5089 # Find out what is on the end of the line after the
5091 substr($s, 0, length($c), '');
5093 $s =~ s/$;//g; # Remove any comments
5094 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
5095 $c !~ /}\s*while\s*/)
5097 # Find out how long the conditional actually is.
5098 my @newlines = ($c =~ /\n/gs);
5099 my $cond_lines = 1 + $#newlines;
5102 $stat_real = raw_line($linenr, $cond_lines)
5103 . "\n" if ($cond_lines);
5104 if (defined($stat_real) && $cond_lines > 1) {
5105 $stat_real = "[...]\n$stat_real";
5108 ERROR("TRAILING_STATEMENTS",
5109 "trailing statements should be on next line\n" . $herecurr . $stat_real);
5113 # Check for bitwise tests written as boolean
5125 WARN("HEXADECIMAL_BOOLEAN_TEST",
5126 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
5129 # if and else should not have general statements after it
5130 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
5132 $s =~ s/$;//g; # Remove any comments
5133 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
5134 ERROR("TRAILING_STATEMENTS",
5135 "trailing statements should be on next line\n" . $herecurr);
5138 # if should not continue a brace
5139 if ($line =~ /}\s*if\b/) {
5140 ERROR("TRAILING_STATEMENTS",
5141 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
5144 # case and default should not have general statements after them
5145 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
5147 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
5151 ERROR("TRAILING_STATEMENTS",
5152 "trailing statements should be on next line\n" . $herecurr);
5155 # Check for }<nl>else {, these must be at the same
5156 # indent level to be relevant to each other.
5157 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
5158 $previndent == $indent) {
5159 if (ERROR("ELSE_AFTER_BRACE",
5160 "else should follow close brace '}'\n" . $hereprev) &&
5161 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5162 fix_delete_line($fixlinenr - 1, $prevrawline);
5163 fix_delete_line($fixlinenr, $rawline);
5164 my $fixedline = $prevrawline;
5165 $fixedline =~ s/}\s*$//;
5166 if ($fixedline !~ /^\+\s*$/) {
5167 fix_insert_line($fixlinenr, $fixedline);
5169 $fixedline = $rawline;
5170 $fixedline =~ s/^(.\s*)else/$1} else/;
5171 fix_insert_line($fixlinenr, $fixedline);
5175 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
5176 $previndent == $indent) {
5177 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
5179 # Find out what is on the end of the line after the
5181 substr($s, 0, length($c), '');
5184 if ($s =~ /^\s*;/) {
5185 if (ERROR("WHILE_AFTER_BRACE",
5186 "while should follow close brace '}'\n" . $hereprev) &&
5187 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5188 fix_delete_line($fixlinenr - 1, $prevrawline);
5189 fix_delete_line($fixlinenr, $rawline);
5190 my $fixedline = $prevrawline;
5191 my $trailing = $rawline;
5192 $trailing =~ s/^\+//;
5193 $trailing = trim($trailing);
5194 $fixedline =~ s/}\s*$/} $trailing/;
5195 fix_insert_line($fixlinenr, $fixedline);
5200 #Specific variable tests
5201 while ($line =~ m{($Constant|$Lval)}g) {
5205 if ($var !~ /^$Constant$/ &&
5206 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
5207 #Ignore Page<foo> variants
5208 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
5209 #Ignore SI style variants like nS, mV and dB
5210 #(ie: max_uV, regulator_min_uA_show, RANGE_mA_VALUE)
5211 $var !~ /^(?:[a-z0-9_]*|[A-Z0-9_]*)?_?[a-z][A-Z](?:_[a-z0-9_]+|_[A-Z0-9_]+)?$/ &&
5212 #Ignore some three character SI units explicitly, like MiB and KHz
5213 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
5214 while ($var =~ m{($Ident)}g) {
5216 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
5218 seed_camelcase_includes();
5219 if (!$file && !$camelcase_file_seeded) {
5220 seed_camelcase_file($realfile);
5221 $camelcase_file_seeded = 1;
5224 if (!defined $camelcase{$word}) {
5225 $camelcase{$word} = 1;
5227 "Avoid CamelCase: <$word>\n" . $herecurr);
5233 #no spaces allowed after \ in define
5234 if ($line =~ /\#\s*define.*\\\s+$/) {
5235 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
5236 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
5238 $fixed[$fixlinenr] =~ s/\s+$//;
5242 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
5243 # itself <asm/foo.h> (uses RAW line)
5244 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
5246 my $checkfile = "include/linux/$file";
5247 if (-f "$root/$checkfile" &&
5248 $realfile ne $checkfile &&
5249 $1 !~ /$allowed_asm_includes/)
5251 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
5252 if ($asminclude > 0) {
5253 if ($realfile =~ m{^arch/}) {
5254 CHK("ARCH_INCLUDE_LINUX",
5255 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5257 WARN("INCLUDE_LINUX",
5258 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5264 # multi-statement macros should be enclosed in a do while loop, grab the
5265 # first statement and ensure its the whole macro if its not enclosed
5266 # in a known good container
5267 if ($realfile !~ m@/vmlinux.lds.h$@ &&
5268 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
5271 my ($off, $dstat, $dcond, $rest);
5273 my $has_flow_statement = 0;
5274 my $has_arg_concat = 0;
5275 ($dstat, $dcond, $ln, $cnt, $off) =
5276 ctx_statement_block($linenr, $realcnt, 0);
5278 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
5279 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
5281 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
5282 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
5284 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
5285 my $define_args = $1;
5286 my $define_stmt = $dstat;
5289 if (defined $define_args && $define_args ne "") {
5290 $define_args = substr($define_args, 1, length($define_args) - 2);
5291 $define_args =~ s/\s*//g;
5292 $define_args =~ s/\\\+?//g;
5293 @def_args = split(",", $define_args);
5297 $dstat =~ s/\\\n.//g;
5298 $dstat =~ s/^\s*//s;
5299 $dstat =~ s/\s*$//s;
5301 # Flatten any parentheses and braces
5302 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
5303 $dstat =~ s/\{[^\{\}]*\}/1/ ||
5304 $dstat =~ s/.\[[^\[\]]*\]/1/)
5308 # Flatten any obvious string concatenation.
5309 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
5310 $dstat =~ s/$Ident\s*($String)/$1/)
5314 # Make asm volatile uses seem like a generic function
5315 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
5317 my $exceptions = qr{
5330 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
5333 my $stmt_cnt = statement_rawlines($ctx);
5334 my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
5337 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
5338 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
5339 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
5340 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
5341 $dstat !~ /$exceptions/ &&
5342 $dstat !~ /^\.$Ident\s*=/ && # .foo =
5343 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
5344 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
5345 $dstat !~ /^for\s*$Constant$/ && # for (...)
5346 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
5347 $dstat !~ /^do\s*{/ && # do {...
5348 $dstat !~ /^\(\{/ && # ({...
5349 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
5351 if ($dstat =~ /^\s*if\b/) {
5352 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5353 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5354 } elsif ($dstat =~ /;/) {
5355 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5356 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5358 ERROR("COMPLEX_MACRO",
5359 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5364 # Make $define_stmt single line, comment-free, etc
5365 my @stmt_array = split('\n', $define_stmt);
5368 foreach my $l (@stmt_array) {
5373 } elsif ($l =~ /^[\+ ]/) {
5374 $define_stmt .= substr($l, 1);
5377 $define_stmt =~ s/$;//g;
5378 $define_stmt =~ s/\s+/ /g;
5379 $define_stmt = trim($define_stmt);
5381 # check if any macro arguments are reused (ignore '...' and 'type')
5382 foreach my $arg (@def_args) {
5383 next if ($arg =~ /\.\.\./);
5384 next if ($arg =~ /^type$/i);
5385 my $tmp_stmt = $define_stmt;
5386 $tmp_stmt =~ s/\b(sizeof|typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
5387 $tmp_stmt =~ s/\#+\s*$arg\b//g;
5388 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
5389 my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
5391 CHK("MACRO_ARG_REUSE",
5392 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
5394 # check if any macro arguments may have other precedence issues
5395 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
5396 ((defined($1) && $1 ne ',') ||
5397 (defined($2) && $2 ne ','))) {
5398 CHK("MACRO_ARG_PRECEDENCE",
5399 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
5403 # check for macros with flow control, but without ## concatenation
5404 # ## concatenation is commonly a macro that defines a function so ignore those
5405 if ($has_flow_statement && !$has_arg_concat) {
5406 my $cnt = statement_rawlines($ctx);
5407 my $herectx = get_stat_here($linenr, $cnt, $here);
5409 WARN("MACRO_WITH_FLOW_CONTROL",
5410 "Macros with flow control statements should be avoided\n" . "$herectx");
5413 # check for line continuations outside of #defines, preprocessor #, and asm
5416 if ($prevline !~ /^..*\\$/ &&
5417 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
5418 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
5419 $line =~ /^\+.*\\$/) {
5420 WARN("LINE_CONTINUATIONS",
5421 "Avoid unnecessary line continuations\n" . $herecurr);
5425 # do {} while (0) macro tests:
5426 # single-statement macros do not need to be enclosed in do while (0) loop,
5427 # macro should not end with a semicolon
5428 if ($perl_version_ok &&
5429 $realfile !~ m@/vmlinux.lds.h$@ &&
5430 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5433 my ($off, $dstat, $dcond, $rest);
5435 ($dstat, $dcond, $ln, $cnt, $off) =
5436 ctx_statement_block($linenr, $realcnt, 0);
5439 $dstat =~ s/\\\n.//g;
5442 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5447 my $cnt = statement_rawlines($ctx);
5448 my $herectx = get_stat_here($linenr, $cnt, $here);
5450 if (($stmts =~ tr/;/;/) == 1 &&
5451 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5452 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
5453 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
5455 if (defined $semis && $semis ne "") {
5456 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
5457 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
5459 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
5461 my $cnt = statement_rawlines($ctx);
5462 my $herectx = get_stat_here($linenr, $cnt, $here);
5464 WARN("TRAILING_SEMICOLON",
5465 "macros should not use a trailing semicolon\n" . "$herectx");
5469 # check for redundant bracing round if etc
5470 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
5471 my ($level, $endln, @chunks) =
5472 ctx_statement_full($linenr, $realcnt, 1);
5473 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
5474 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
5475 if ($#chunks > 0 && $level == 0) {
5479 my $herectx = $here . "\n";
5480 my $ln = $linenr - 1;
5481 for my $chunk (@chunks) {
5482 my ($cond, $block) = @{$chunk};
5484 # If the condition carries leading newlines, then count those as offsets.
5485 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
5486 my $offset = statement_rawlines($whitespace) - 1;
5488 $allowed[$allow] = 0;
5489 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
5491 # We have looked at and allowed this specific line.
5492 $suppress_ifbraces{$ln + $offset} = 1;
5494 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
5495 $ln += statement_rawlines($block) - 1;
5497 substr($block, 0, length($cond), '');
5499 $seen++ if ($block =~ /^\s*{/);
5501 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
5502 if (statement_lines($cond) > 1) {
5503 #print "APW: ALLOWED: cond<$cond>\n";
5504 $allowed[$allow] = 1;
5506 if ($block =~/\b(?:if|for|while)\b/) {
5507 #print "APW: ALLOWED: block<$block>\n";
5508 $allowed[$allow] = 1;
5510 if (statement_block_size($block) > 1) {
5511 #print "APW: ALLOWED: lines block<$block>\n";
5512 $allowed[$allow] = 1;
5517 my $sum_allowed = 0;
5518 foreach (@allowed) {
5521 if ($sum_allowed == 0) {
5523 "braces {} are not necessary for any arm of this statement\n" . $herectx);
5524 } elsif ($sum_allowed != $allow &&
5527 "braces {} should be used on all arms of this statement\n" . $herectx);
5532 if (!defined $suppress_ifbraces{$linenr - 1} &&
5533 $line =~ /\b(if|while|for|else)\b/) {
5536 # Check the pre-context.
5537 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
5538 #print "APW: ALLOWED: pre<$1>\n";
5542 my ($level, $endln, @chunks) =
5543 ctx_statement_full($linenr, $realcnt, $-[0]);
5545 # Check the condition.
5546 my ($cond, $block) = @{$chunks[0]};
5547 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
5548 if (defined $cond) {
5549 substr($block, 0, length($cond), '');
5551 if (statement_lines($cond) > 1) {
5552 #print "APW: ALLOWED: cond<$cond>\n";
5555 if ($block =~/\b(?:if|for|while)\b/) {
5556 #print "APW: ALLOWED: block<$block>\n";
5559 if (statement_block_size($block) > 1) {
5560 #print "APW: ALLOWED: lines block<$block>\n";
5563 # Check the post-context.
5564 if (defined $chunks[1]) {
5565 my ($cond, $block) = @{$chunks[1]};
5566 if (defined $cond) {
5567 substr($block, 0, length($cond), '');
5569 if ($block =~ /^\s*\{/) {
5570 #print "APW: ALLOWED: chunk-1 block<$block>\n";
5574 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
5575 my $cnt = statement_rawlines($block);
5576 my $herectx = get_stat_here($linenr, $cnt, $here);
5579 "braces {} are not necessary for single statement blocks\n" . $herectx);
5583 # check for single line unbalanced braces
5584 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
5585 $sline =~ /^.\s*else\s*\{\s*$/) {
5586 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
5589 # check for unnecessary blank lines around braces
5590 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
5592 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
5593 $fix && $prevrawline =~ /^\+/) {
5594 fix_delete_line($fixlinenr - 1, $prevrawline);
5597 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
5599 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
5601 fix_delete_line($fixlinenr, $rawline);
5605 # no volatiles please
5606 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
5607 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
5609 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
5612 # Check for user-visible strings broken across lines, which breaks the ability
5613 # to grep for the string. Make exceptions when the previous string ends in a
5614 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
5615 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
5616 if ($line =~ /^\+\s*$String/ &&
5617 $prevline =~ /"\s*$/ &&
5618 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
5619 if (WARN("SPLIT_STRING",
5620 "quoted string split across lines\n" . $hereprev) &&
5622 $prevrawline =~ /^\+.*"\s*$/ &&
5623 $last_coalesced_string_linenr != $linenr - 1) {
5624 my $extracted_string = get_quoted_string($line, $rawline);
5625 my $comma_close = "";
5626 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
5630 fix_delete_line($fixlinenr - 1, $prevrawline);
5631 fix_delete_line($fixlinenr, $rawline);
5632 my $fixedline = $prevrawline;
5633 $fixedline =~ s/"\s*$//;
5634 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
5635 fix_insert_line($fixlinenr - 1, $fixedline);
5636 $fixedline = $rawline;
5637 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
5638 if ($fixedline !~ /\+\s*$/) {
5639 fix_insert_line($fixlinenr, $fixedline);
5641 $last_coalesced_string_linenr = $linenr;
5645 # check for missing a space in a string concatenation
5646 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
5647 WARN('MISSING_SPACE',
5648 "break quoted strings at a space character\n" . $hereprev);
5651 # check for an embedded function name in a string when the function is known
5652 # This does not work very well for -f --file checking as it depends on patch
5653 # context providing the function name or a single line form for in-file
5654 # function declarations
5655 if ($line =~ /^\+.*$String/ &&
5656 defined($context_function) &&
5657 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
5658 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
5659 WARN("EMBEDDED_FUNCTION_NAME",
5660 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
5663 # check for spaces before a quoted newline
5664 if ($rawline =~ /^.*\".*\s\\n/) {
5665 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
5666 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
5668 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
5673 # concatenated string without spaces between elements
5674 if ($line =~ /$String[A-Za-z0-9_]/ || $line =~ /[A-Za-z0-9_]$String/) {
5675 if (CHK("CONCATENATED_STRING",
5676 "Concatenated strings should use spaces between elements\n" . $herecurr) &&
5678 while ($line =~ /($String)/g) {
5679 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
5680 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
5681 $fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
5686 # uncoalesced string fragments
5687 if ($line =~ /$String\s*"/) {
5688 if (WARN("STRING_FRAGMENTS",
5689 "Consecutive strings are generally better as a single string\n" . $herecurr) &&
5691 while ($line =~ /($String)(?=\s*")/g) {
5692 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
5693 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
5698 # check for non-standard and hex prefixed decimal printf formats
5699 my $show_L = 1; #don't show the same defect twice
5701 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
5702 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
5703 $string =~ s/%%/__/g;
5705 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
5707 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
5711 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
5713 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
5716 # check for 0x<decimal>
5717 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
5718 ERROR("PRINTF_0XDECIMAL",
5719 "Prefixing 0x with decimal output is defective\n" . $herecurr);
5723 # check for line continuations in quoted strings with odd counts of "
5724 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
5725 WARN("LINE_CONTINUATIONS",
5726 "Avoid line continuations in quoted strings\n" . $herecurr);
5730 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
5732 "Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
5736 if ($line =~ /^.\s*\#\s*if\s+1\b/) {
5738 "Consider removing the #if 1 and its #endif\n" . $herecurr);
5741 # check for needless "if (<foo>) fn(<foo>)" uses
5742 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
5743 my $tested = quotemeta($1);
5744 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
5745 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
5747 if (WARN('NEEDLESS_IF',
5748 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
5751 my $leading_tabs = "";
5752 my $new_leading_tabs = "";
5753 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
5758 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
5759 $new_leading_tabs = $1;
5760 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
5767 fix_delete_line($fixlinenr - 1, $prevrawline);
5768 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
5774 # check for unnecessary "Out of Memory" messages
5775 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
5776 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
5777 (defined $1 || defined $3) &&
5780 my $testline = $lines[$linenr - 3];
5782 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
5783 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
5785 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
5786 $s !~ /\b__GFP_NOWARN\b/ ) {
5788 "Possible unnecessary 'out of memory' message\n" . $hereprev);
5792 # check for logging functions with KERN_<LEVEL>
5793 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
5794 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
5796 if (WARN("UNNECESSARY_KERN_LEVEL",
5797 "Possible unnecessary $level\n" . $herecurr) &&
5799 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
5803 # check for logging continuations
5804 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
5805 WARN("LOGGING_CONTINUATION",
5806 "Avoid logging continuation uses where feasible\n" . $herecurr);
5809 # check for mask then right shift without a parentheses
5810 if ($perl_version_ok &&
5811 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
5812 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
5813 WARN("MASK_THEN_SHIFT",
5814 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
5817 # check for pointer comparisons to NULL
5818 if ($perl_version_ok) {
5819 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
5822 $equal = "" if ($4 eq "!=");
5823 if (CHK("COMPARISON_TO_NULL",
5824 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
5826 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
5831 # check for bad placement of section $InitAttribute (e.g.: __initdata)
5832 if ($line =~ /(\b$InitAttribute\b)/) {
5834 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
5837 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
5838 ERROR("MISPLACED_INIT",
5839 "$attr should be placed after $var\n" . $herecurr)) ||
5840 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
5841 WARN("MISPLACED_INIT",
5842 "$attr should be placed after $var\n" . $herecurr))) &&
5844 $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;
5849 # check for $InitAttributeData (ie: __initdata) with const
5850 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5852 $attr =~ /($InitAttributePrefix)(.*)/;
5853 my $attr_prefix = $1;
5855 if (ERROR("INIT_ATTRIBUTE",
5856 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5858 $fixed[$fixlinenr] =~
5859 s/$InitAttributeData/${attr_prefix}initconst/;
5863 # check for $InitAttributeConst (ie: __initconst) without const
5864 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5866 if (ERROR("INIT_ATTRIBUTE",
5867 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5869 my $lead = $fixed[$fixlinenr] =~
5870 /(^\+\s*(?:static\s+))/;
5872 $lead = "$lead " if ($lead !~ /^\+$/);
5873 $lead = "${lead}const ";
5874 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5878 # check for __read_mostly with const non-pointer (should just be const)
5879 if ($line =~ /\b__read_mostly\b/ &&
5880 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5881 if (ERROR("CONST_READ_MOSTLY",
5882 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5884 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5888 # don't use __constant_<foo> functions outside of include/uapi/
5889 if ($realfile !~ m@^include/uapi/@ &&
5890 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5891 my $constant_func = $1;
5892 my $func = $constant_func;
5893 $func =~ s/^__constant_//;
5894 if (WARN("CONSTANT_CONVERSION",
5895 "$constant_func should be $func\n" . $herecurr) &&
5897 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5901 # prefer usleep_range over udelay
5902 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5904 # ignore udelay's < 10, however
5905 if (! ($delay < 10) ) {
5907 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
5909 if ($delay > 2000) {
5911 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5915 # warn about unexpectedly long msleep's
5916 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5919 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
5923 # check for comparisons of jiffies
5924 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5925 WARN("JIFFIES_COMPARISON",
5926 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5929 # check for comparisons of get_jiffies_64()
5930 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5931 WARN("JIFFIES_COMPARISON",
5932 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5935 # warn about #ifdefs in C files
5936 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5937 # print "#ifdef in C files should be avoided\n";
5938 # print "$herecurr";
5942 # warn about spacing in #ifdefs
5943 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5944 if (ERROR("SPACING",
5945 "exactly one space required after that #$1\n" . $herecurr) &&
5947 $fixed[$fixlinenr] =~
5948 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5953 # check for spinlock_t definitions without a comment.
5954 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5955 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5957 if (!ctx_has_comment($first_line, $linenr)) {
5958 CHK("UNCOMMENTED_DEFINITION",
5959 "$1 definition without comment\n" . $herecurr);
5962 # check for memory barriers without a comment.
5969 my $barrier_stems = qr{
5977 my $all_barriers = qr{
5979 smp_(?:$barrier_stems)|
5980 virt_(?:$barrier_stems)
5983 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
5984 if (!ctx_has_comment($first_line, $linenr)) {
5985 WARN("MEMORY_BARRIER",
5986 "memory barrier without comment\n" . $herecurr);
5990 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
5992 if ($realfile !~ m@^include/asm-generic/@ &&
5993 $realfile !~ m@/barrier\.h$@ &&
5994 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
5995 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
5996 WARN("MEMORY_BARRIER",
5997 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6000 # check for waitqueue_active without a comment.
6001 if ($line =~ /\bwaitqueue_active\s*\(/) {
6002 if (!ctx_has_comment($first_line, $linenr)) {
6003 WARN("WAITQUEUE_ACTIVE",
6004 "waitqueue_active without comment\n" . $herecurr);
6008 # check for data_race without a comment.
6009 if ($line =~ /\bdata_race\s*\(/) {
6010 if (!ctx_has_comment($first_line, $linenr)) {
6012 "data_race without comment\n" . $herecurr);
6016 # check of hardware specific defines
6017 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
6019 "architecture specific defines should be avoided\n" . $herecurr);
6022 # check that the storage class is not after a type
6023 if ($line =~ /\b($Type)\s+($Storage)\b/) {
6024 WARN("STORAGE_CLASS",
6025 "storage class '$2' should be located before type '$1'\n" . $herecurr);
6027 # Check that the storage class is at the beginning of a declaration
6028 if ($line =~ /\b$Storage\b/ &&
6029 $line !~ /^.\s*$Storage/ &&
6030 $line =~ /^.\s*(.+?)\$Storage\s/ &&
6031 $1 !~ /[\,\)]\s*$/) {
6032 WARN("STORAGE_CLASS",
6033 "storage class should be at the beginning of the declaration\n" . $herecurr);
6036 # check the location of the inline attribute, that it is between
6037 # storage class and type.
6038 if ($line =~ /\b$Type\s+$Inline\b/ ||
6039 $line =~ /\b$Inline\s+$Storage\b/) {
6040 ERROR("INLINE_LOCATION",
6041 "inline keyword should sit between storage class and type\n" . $herecurr);
6044 # Check for __inline__ and __inline, prefer inline
6045 if ($realfile !~ m@\binclude/uapi/@ &&
6046 $line =~ /\b(__inline__|__inline)\b/) {
6048 "plain inline is preferred over $1\n" . $herecurr) &&
6050 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
6055 # Check for __attribute__ packed, prefer __packed
6056 if ($realfile !~ m@\binclude/uapi/@ &&
6057 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
6058 WARN("PREFER_PACKED",
6059 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
6062 # Check for __attribute__ aligned, prefer __aligned
6063 if ($realfile !~ m@\binclude/uapi/@ &&
6064 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
6065 WARN("PREFER_ALIGNED",
6066 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
6069 # Check for __attribute__ section, prefer __section
6070 if ($realfile !~ m@\binclude/uapi/@ &&
6071 $line =~ /\b__attribute__\s*\(\s*\(.*_*section_*\s*\(\s*("[^"]*")/) {
6072 my $old = substr($rawline, $-[1], $+[1] - $-[1]);
6073 my $new = substr($old, 1, -1);
6074 if (WARN("PREFER_SECTION",
6075 "__section($new) is preferred over __attribute__((section($old)))\n" . $herecurr) &&
6077 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*_*section_*\s*\(\s*\Q$old\E\s*\)\s*\)\s*\)/__section($new)/;
6081 # Check for __attribute__ format(printf, prefer __printf
6082 if ($realfile !~ m@\binclude/uapi/@ &&
6083 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
6084 if (WARN("PREFER_PRINTF",
6085 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
6087 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
6092 # Check for __attribute__ format(scanf, prefer __scanf
6093 if ($realfile !~ m@\binclude/uapi/@ &&
6094 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
6095 if (WARN("PREFER_SCANF",
6096 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
6098 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
6102 # Check for __attribute__ weak, or __weak declarations (may have link issues)
6103 if ($perl_version_ok &&
6104 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
6105 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
6106 $line =~ /\b__weak\b/)) {
6107 ERROR("WEAK_DECLARATION",
6108 "Using weak declarations can have unintended link defects\n" . $herecurr);
6111 # check for c99 types like uint8_t used outside of uapi/ and tools/
6112 if ($realfile !~ m@\binclude/uapi/@ &&
6113 $realfile !~ m@\btools/@ &&
6114 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
6116 if ($type =~ /\b($typeC99Typedefs)\b/) {
6118 my $kernel_type = 'u';
6119 $kernel_type = 's' if ($type =~ /^_*[si]/);
6122 if (CHK("PREFER_KERNEL_TYPES",
6123 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6125 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6130 # check for cast of C90 native int or longer types constants
6131 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
6134 if (WARN("TYPECAST_INT_CONSTANT",
6135 "Unnecessary typecast of c90 int constant\n" . $herecurr) &&
6138 my $newconst = $const;
6139 $newconst =~ s/${Int_type}$//;
6140 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6141 if ($cast =~ /\blong\s+long\b/) {
6143 } elsif ($cast =~ /\blong\b/) {
6146 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6150 # check for sizeof(&)
6151 if ($line =~ /\bsizeof\s*\(\s*\&/) {
6152 WARN("SIZEOF_ADDRESS",
6153 "sizeof(& should be avoided\n" . $herecurr);
6156 # check for sizeof without parenthesis
6157 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
6158 if (WARN("SIZEOF_PARENTHESIS",
6159 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6161 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
6165 # check for struct spinlock declarations
6166 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
6167 WARN("USE_SPINLOCK_T",
6168 "struct spinlock should be spinlock_t\n" . $herecurr);
6171 # check for seq_printf uses that could be seq_puts
6172 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
6173 my $fmt = get_quoted_string($line, $rawline);
6176 if (WARN("PREFER_SEQ_PUTS",
6177 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
6179 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6184 # check for vsprintf extension %p<foo> misuses
6185 if ($perl_version_ok &&
6187 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
6188 $1 !~ /^_*volatile_*$/) {
6191 my $lc = $stat =~ tr@\n@@;
6192 $lc = $lc + $linenr;
6193 for (my $count = $linenr; $count <= $lc; $count++) {
6197 my $bad_specifier = "";
6198 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
6201 while ($fmt =~ /(\%[\*\d\.]*p(\w)(\w*))/g) {
6205 if ($extension !~ /[SsBKRraEehMmIiUDdgVCbGNOxtf]/ ||
6206 ($extension eq "f" &&
6207 defined $qualifier && $qualifier !~ /^w/)) {
6208 $bad_specifier = $specifier;
6211 if ($extension eq "x" && !defined($stat_real)) {
6212 if (!defined($stat_real)) {
6213 $stat_real = get_stat_real($linenr, $lc);
6215 WARN("VSPRINTF_SPECIFIER_PX",
6216 "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");
6219 if ($bad_specifier ne "") {
6220 my $stat_real = get_stat_real($linenr, $lc);
6221 my $ext_type = "Invalid";
6223 if ($bad_specifier =~ /p[Ff]/) {
6224 $use = " - use %pS instead";
6225 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6228 WARN("VSPRINTF_POINTER_EXTENSION",
6229 "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6234 # Check for misused memsets
6235 if ($perl_version_ok &&
6237 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
6243 if ($ms_size =~ /^(0x|)0$/i) {
6245 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6246 } elsif ($ms_size =~ /^(0x|)1$/i) {
6248 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6252 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6253 # if ($perl_version_ok &&
6255 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6256 # if (WARN("PREFER_ETHER_ADDR_COPY",
6257 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6259 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
6263 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6264 # if ($perl_version_ok &&
6266 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6267 # WARN("PREFER_ETHER_ADDR_EQUAL",
6268 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6271 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6272 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
6273 # if ($perl_version_ok &&
6275 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6279 # if ($ms_val =~ /^(?:0x|)0+$/i) {
6280 # if (WARN("PREFER_ETH_ZERO_ADDR",
6281 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
6283 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
6285 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
6286 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
6287 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
6289 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
6294 # typecasts on min/max could be min_t/max_t
6295 if ($perl_version_ok &&
6297 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
6298 if (defined $2 || defined $7) {
6300 my $cast1 = deparenthesize($2);
6302 my $cast2 = deparenthesize($7);
6306 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
6307 $cast = "$cast1 or $cast2";
6308 } elsif ($cast1 ne "") {
6314 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
6318 # check usleep_range arguments
6319 if ($perl_version_ok &&
6321 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
6325 WARN("USLEEP_RANGE",
6326 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6327 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
6329 WARN("USLEEP_RANGE",
6330 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6334 # check for naked sscanf
6335 if ($perl_version_ok &&
6337 $line =~ /\bsscanf\b/ &&
6338 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
6339 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
6340 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
6341 my $lc = $stat =~ tr@\n@@;
6342 $lc = $lc + $linenr;
6343 my $stat_real = get_stat_real($linenr, $lc);
6344 WARN("NAKED_SSCANF",
6345 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
6348 # check for simple sscanf that should be kstrto<foo>
6349 if ($perl_version_ok &&
6351 $line =~ /\bsscanf\b/) {
6352 my $lc = $stat =~ tr@\n@@;
6353 $lc = $lc + $linenr;
6354 my $stat_real = get_stat_real($linenr, $lc);
6355 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
6357 my $count = $format =~ tr@%@%@;
6359 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
6360 WARN("SSCANF_TO_KSTRTO",
6361 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
6366 # check for new externs in .h files.
6367 if ($realfile =~ /\.h$/ &&
6368 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
6369 if (CHK("AVOID_EXTERNS",
6370 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
6372 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
6376 # check for new externs in .c files.
6377 if ($realfile =~ /\.c$/ && defined $stat &&
6378 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
6380 my $function_name = $1;
6381 my $paren_space = $2;
6384 if (defined $cond) {
6385 substr($s, 0, length($cond), '');
6389 WARN("AVOID_EXTERNS",
6390 "externs should be avoided in .c files\n" . $herecurr);
6393 if ($paren_space =~ /\n/) {
6394 WARN("FUNCTION_ARGUMENTS",
6395 "arguments for function declarations should follow identifier\n" . $herecurr);
6398 } elsif ($realfile =~ /\.c$/ && defined $stat &&
6399 $stat =~ /^.\s*extern\s+/)
6401 WARN("AVOID_EXTERNS",
6402 "externs should be avoided in .c files\n" . $herecurr);
6405 # check for function declarations that have arguments without identifier names
6406 if (defined $stat &&
6407 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
6409 my $args = trim($1);
6410 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
6412 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
6413 WARN("FUNCTION_ARGUMENTS",
6414 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
6419 # check for function definitions
6420 if ($perl_version_ok &&
6422 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
6423 $context_function = $1;
6425 # check for multiline function definition with misplaced open brace
6427 my $cnt = statement_rawlines($stat);
6428 my $herectx = $here . "\n";
6429 for (my $n = 0; $n < $cnt; $n++) {
6430 my $rl = raw_line($linenr, $n);
6431 $herectx .= $rl . "\n";
6432 $ok = 1 if ($rl =~ /^[ \+]\{/);
6433 $ok = 1 if ($rl =~ /\{/ && $n == 0);
6434 last if $rl =~ /^[ \+].*\{/;
6438 "open brace '{' following function definitions go on the next line\n" . $herectx);
6442 # checks for new __setup's
6443 if ($rawline =~ /\b__setup\("([^"]*)"/) {
6446 if (!grep(/$name/, @setup_docs)) {
6447 CHK("UNDOCUMENTED_SETUP",
6448 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
6452 # check for pointless casting of alloc functions
6453 if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
6454 WARN("UNNECESSARY_CASTS",
6455 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
6459 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
6460 if ($perl_version_ok &&
6461 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
6462 CHK("ALLOC_SIZEOF_STRUCT",
6463 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
6466 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
6467 if ($perl_version_ok &&
6469 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
6473 my $newfunc = "kmalloc_array";
6474 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
6477 if ($a1 =~ /^sizeof\s*\S/) {
6481 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
6482 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
6483 my $cnt = statement_rawlines($stat);
6484 my $herectx = get_stat_here($linenr, $cnt, $here);
6486 if (WARN("ALLOC_WITH_MULTIPLY",
6487 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
6490 $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;
6495 # check for krealloc arg reuse
6496 if ($perl_version_ok &&
6497 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*($Lval)\s*,/ &&
6499 WARN("KREALLOC_ARG_REUSE",
6500 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
6503 # check for alloc argument mismatch
6504 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
6505 WARN("ALLOC_ARRAY_ARGS",
6506 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
6509 # check for multiple semicolons
6510 if ($line =~ /;\s*;\s*$/) {
6511 if (WARN("ONE_SEMICOLON",
6512 "Statements terminations use 1 semicolon\n" . $herecurr) &&
6514 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
6518 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
6519 if ($realfile !~ m@^include/uapi/@ &&
6520 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
6522 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
6523 if (CHK("BIT_MACRO",
6524 "Prefer using the BIT$ull macro\n" . $herecurr) &&
6526 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
6530 # check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
6531 if ($rawline =~ /\bIS_ENABLED\s*\(\s*(\w+)\s*\)/ && $1 !~ /^CONFIG_/) {
6532 WARN("IS_ENABLED_CONFIG",
6533 "IS_ENABLED($1) is normally used as IS_ENABLED(CONFIG_$1)\n" . $herecurr);
6536 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
6537 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(CONFIG_[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
6539 if (WARN("PREFER_IS_ENABLED",
6540 "Prefer IS_ENABLED(<FOO>) to CONFIG_<FOO> || CONFIG_<FOO>_MODULE\n" . $herecurr) &&
6542 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
6546 # check for /* fallthrough */ like comment, prefer fallthrough;
6547 my @fallthroughs = (
6550 'lint -fallthrough[ \t]*',
6551 'intentional(?:ly)?[ \t]*fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)',
6552 '(?:else,?\s*)?FALL(?:S | |-)?THR(?:OUGH|U|EW)[ \t.!]*(?:-[^\n\r]*)?',
6553 'Fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
6554 'fall(?:s | |-)?thr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
6556 if ($raw_comment ne '') {
6557 foreach my $ft (@fallthroughs) {
6558 if ($raw_comment =~ /$ft/) {
6559 my $msg_level = \&WARN;
6560 $msg_level = \&CHK if ($file);
6561 &{$msg_level}("PREFER_FALLTHROUGH",
6562 "Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
6568 # check for switch/default statements without a break;
6569 if ($perl_version_ok &&
6571 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
6572 my $cnt = statement_rawlines($stat);
6573 my $herectx = get_stat_here($linenr, $cnt, $here);
6575 WARN("DEFAULT_NO_BREAK",
6576 "switch default: should use break\n" . $herectx);
6579 # check for gcc specific __FUNCTION__
6580 if ($line =~ /\b__FUNCTION__\b/) {
6581 if (WARN("USE_FUNC",
6582 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
6584 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
6588 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
6589 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
6591 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
6594 # check for use of yield()
6595 if ($line =~ /\byield\s*\(\s*\)/) {
6597 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
6600 # check for comparisons against true and false
6601 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
6609 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
6611 my $type = lc($otype);
6612 if ($type =~ /^(?:true|false)$/) {
6613 if (("$test" eq "==" && "$type" eq "true") ||
6614 ("$test" eq "!=" && "$type" eq "false")) {
6618 CHK("BOOL_COMPARISON",
6619 "Using comparison to $otype is error prone\n" . $herecurr);
6621 ## maybe suggesting a correct construct would better
6622 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
6627 # check for semaphores initialized locked
6628 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
6629 WARN("CONSIDER_COMPLETION",
6630 "consider using a completion\n" . $herecurr);
6633 # recommend kstrto* over simple_strto* and strict_strto*
6634 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
6635 WARN("CONSIDER_KSTRTO",
6636 "$1 is obsolete, use k$3 instead\n" . $herecurr);
6639 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
6640 if ($line =~ /^.\s*__initcall\s*\(/) {
6641 WARN("USE_DEVICE_INITCALL",
6642 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
6645 # check for spin_is_locked(), suggest lockdep instead
6646 if ($line =~ /\bspin_is_locked\(/) {
6648 "Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
6651 # check for deprecated apis
6652 if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
6653 my $deprecated_api = $1;
6654 my $new_api = $deprecated_apis{$deprecated_api};
6655 WARN("DEPRECATED_API",
6656 "Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
6659 # check for various structs that are normally const (ops, kgdb, device_tree)
6660 # and avoid what seem like struct definitions 'struct foo {'
6661 if (defined($const_structs) &&
6662 $line !~ /\bconst\b/ &&
6663 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
6664 WARN("CONST_STRUCT",
6665 "struct $1 should normally be const\n" . $herecurr);
6668 # use of NR_CPUS is usually wrong
6669 # ignore definitions of NR_CPUS and usage to define arrays as likely right
6670 if ($line =~ /\bNR_CPUS\b/ &&
6671 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
6672 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
6673 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
6674 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
6675 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
6678 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
6681 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
6682 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
6683 ERROR("DEFINE_ARCH_HAS",
6684 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
6687 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
6688 if ($perl_version_ok &&
6689 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
6690 WARN("LIKELY_MISUSE",
6691 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
6694 # nested likely/unlikely calls
6695 if ($line =~ /\b(?:(?:un)?likely)\s*\(\s*!?\s*(IS_ERR(?:_OR_NULL|_VALUE)?|WARN)/) {
6696 WARN("LIKELY_MISUSE",
6697 "nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
6700 # whine mightly about in_atomic
6701 if ($line =~ /\bin_atomic\s*\(/) {
6702 if ($realfile =~ m@^drivers/@) {
6704 "do not use in_atomic in drivers\n" . $herecurr);
6705 } elsif ($realfile !~ m@^kernel/@) {
6707 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
6711 # check for mutex_trylock_recursive usage
6712 if ($line =~ /mutex_trylock_recursive/) {
6714 "recursive locking is bad, do not use this ever.\n" . $herecurr);
6717 # check for lockdep_set_novalidate_class
6718 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
6719 $line =~ /__lockdep_no_validate__\s*\)/ ) {
6720 if ($realfile !~ m@^kernel/lockdep@ &&
6721 $realfile !~ m@^include/linux/lockdep@ &&
6722 $realfile !~ m@^drivers/base/core@) {
6724 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
6728 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
6729 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
6730 WARN("EXPORTED_WORLD_WRITABLE",
6731 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
6734 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
6735 # and whether or not function naming is typical and if
6736 # DEVICE_ATTR permissions uses are unusual too
6737 if ($perl_version_ok &&
6739 $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*\)/) {
6744 my $octal_perms = perms_to_octal($perms);
6745 if ($show =~ /^${var}_show$/ &&
6746 $store =~ /^${var}_store$/ &&
6747 $octal_perms eq "0644") {
6748 if (WARN("DEVICE_ATTR_RW",
6749 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
6751 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
6753 } elsif ($show =~ /^${var}_show$/ &&
6754 $store =~ /^NULL$/ &&
6755 $octal_perms eq "0444") {
6756 if (WARN("DEVICE_ATTR_RO",
6757 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
6759 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
6761 } elsif ($show =~ /^NULL$/ &&
6762 $store =~ /^${var}_store$/ &&
6763 $octal_perms eq "0200") {
6764 if (WARN("DEVICE_ATTR_WO",
6765 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
6767 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
6769 } elsif ($octal_perms eq "0644" ||
6770 $octal_perms eq "0444" ||
6771 $octal_perms eq "0200") {
6772 my $newshow = "$show";
6773 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
6774 my $newstore = $store;
6775 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
6777 if ($show ne $newshow) {
6778 $rename .= " '$show' to '$newshow'";
6780 if ($store ne $newstore) {
6781 $rename .= " '$store' to '$newstore'";
6783 WARN("DEVICE_ATTR_FUNCTIONS",
6784 "Consider renaming function(s)$rename\n" . $herecurr);
6786 WARN("DEVICE_ATTR_PERMS",
6787 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
6791 # Mode permission misuses where it seems decimal should be octal
6792 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
6793 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
6794 # specific definition of not visible in sysfs.
6795 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
6796 # use the default permissions
6797 if ($perl_version_ok &&
6799 $line =~ /$mode_perms_search/) {
6800 foreach my $entry (@mode_permission_funcs) {
6801 my $func = $entry->[0];
6802 my $arg_pos = $entry->[1];
6804 my $lc = $stat =~ tr@\n@@;
6805 $lc = $lc + $linenr;
6806 my $stat_real = get_stat_real($linenr, $lc);
6811 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
6813 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
6814 if ($stat =~ /$test/) {
6816 $val = $6 if ($skip_args ne "");
6817 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
6818 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
6819 ($val =~ /^$Octal$/ && length($val) ne 4))) {
6820 ERROR("NON_OCTAL_PERMISSIONS",
6821 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
6823 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
6824 ERROR("EXPORTED_WORLD_WRITABLE",
6825 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
6831 # check for uses of S_<PERMS> that could be octal for readability
6832 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
6834 my $octal = perms_to_octal($oval);
6835 if (WARN("SYMBOLIC_PERMS",
6836 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
6838 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
6842 # validate content of MODULE_LICENSE against list from include/linux/module.h
6843 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
6844 my $extracted_string = get_quoted_string($line, $rawline);
6845 my $valid_licenses = qr{
6848 GPL\ and\ additional\ rights|
6854 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
6855 WARN("MODULE_LICENSE",
6856 "unknown module license " . $extracted_string . "\n" . $herecurr);
6860 # check for sysctl duplicate constants
6861 if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
6862 WARN("DUPLICATED_SYSCTL_CONST",
6863 "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
6867 # If we have no input at all, then there is nothing to report on
6868 # so just keep quiet.
6869 if ($#rawlines == -1) {
6873 # In mailback mode only produce a report in the negative, for
6874 # things that appear to be patches.
6875 if ($mailback && ($clean == 1 || !$is_patch)) {
6879 # This is not a patch, and we are are in 'no-patch' mode so
6881 if (!$chk_patch && !$is_patch) {
6885 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
6886 ERROR("NOT_UNIFIED_DIFF",
6887 "Does not appear to be a unified-diff format patch\n");
6889 if ($is_patch && $has_commit_log && $chk_signoff) {
6890 if ($signoff == 0) {
6891 ERROR("MISSING_SIGN_OFF",
6892 "Missing Signed-off-by: line(s)\n");
6893 } elsif (!$authorsignoff) {
6894 WARN("NO_AUTHOR_SIGN_OFF",
6895 "Missing Signed-off-by: line by nominal patch author '$author'\n");
6899 print report_dump();
6900 if ($summary && !($clean == 1 && $quiet == 1)) {
6901 print "$filename " if ($summary_file);
6902 print "total: $cnt_error errors, $cnt_warn warnings, " .
6903 (($check)? "$cnt_chk checks, " : "") .
6904 "$cnt_lines lines checked\n";
6908 # If there were any defects found and not already fixing them
6909 if (!$clean and !$fix) {
6912 NOTE: For some of the reported defects, checkpatch may be able to
6913 mechanically convert to the typical style using --fix or --fix-inplace.
6916 # If there were whitespace errors which cleanpatch can fix
6917 # then suggest that.
6918 if ($rpt_cleaners) {
6922 NOTE: Whitespace errors detected.
6923 You may wish to use scripts/cleanpatch or scripts/cleanfile
6928 if ($clean == 0 && $fix &&
6929 ("@rawlines" ne "@fixed" ||
6930 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
6931 my $newfile = $filename;
6932 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
6936 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
6938 open($f, '>', $newfile)
6939 or die "$P: Can't open $newfile for write\n";
6940 foreach my $fixed_line (@fixed) {
6943 if ($linecount > 3) {
6944 $fixed_line =~ s/^\+//;
6945 print $f $fixed_line . "\n";
6948 print $f $fixed_line . "\n";
6956 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
6958 Do _NOT_ trust the results written to this file.
6959 Do _NOT_ submit these changes without inspecting them for correctness.
6961 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
6962 No warranties, expressed or implied...
6970 print "$vname has no obvious style problems and is ready for submission.\n";
6972 print "$vname has style problems, please review.\n";