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);
27 my %verbose_messages = ();
28 my %verbose_emitted = ();
49 my $gitroot = $ENV{'GIT_DIR'};
50 $gitroot = ".git" if !defined($gitroot);
58 my $configuration_file = ".checkpatch.conf";
59 my $max_line_length = 100;
60 my $ignore_perl_version = 0;
61 my $minimum_perl_version = 5.10.0;
62 my $min_conf_desc_length = 4;
63 my $spelling_file = "$D/spelling.txt";
65 my $codespellfile = "/usr/share/codespell/dictionary.txt";
66 my $user_codespellfile = "";
67 my $conststructsfile = "$D/const_structs.checkpatch";
68 my $docsfile = "$D/../Documentation/dev-tools/checkpatch.rst";
71 my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
72 # git output parsing needs US English output, so first set backtick child process LANGUAGE
73 my $git_command ='export LANGUAGE=en_US.UTF-8; git';
75 my ${CONFIG_} = "CONFIG_";
77 my %maybe_linker_symbol; # for externs in c exceptions, when seen in *vmlinux.lds.h
83 Usage: $P [OPTION]... [FILE]...
88 -v, --verbose verbose mode
89 --no-tree run without a kernel tree
90 --no-signoff do not check for 'Signed-off-by' line
91 --patch treat FILE as patchfile (default)
92 --emacs emacs compile window format
93 --terse one line per report
94 --showfile emit diffed file position, not input file position
95 -g, --git treat FILE as a single commit or git revision range
96 single git commit with:
100 multiple git commits with:
104 git merges are ignored
105 -f, --file treat FILE as regular source file
106 --subjective, --strict enable more subjective tests
107 --list-types list the possible message types
108 --types TYPE(,TYPE2...) show only these comma separated message types
109 --ignore TYPE(,TYPE2...) ignore various comma separated message types
110 --show-types show the specific message type in the output
111 --max-line-length=n set the maximum line length, (default $max_line_length)
112 if exceeded, warn on patches
113 requires --strict for use with --file
114 --min-conf-desc-length=n set the min description length, if shorter, warn
115 --tab-size=n set the number of spaces for tab (default $tabsize)
116 --root=PATH PATH to the kernel tree root
117 --no-summary suppress the per-file summary
118 --mailback only produce a report in case of warnings/errors
119 --summary-file include the filename in summary
120 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
121 'values', 'possible', 'type', and 'attr' (default
123 --test-only=WORD report only warnings/errors containing WORD
125 --fix EXPERIMENTAL - may create horrible results
126 If correctable single-line errors exist, create
127 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
128 with potential errors corrected to the preferred
130 --fix-inplace EXPERIMENTAL - may create horrible results
131 Is the same as --fix, but overwrites the input
132 file. It's your fault if there's no backup or git
133 --ignore-perl-version override checking of perl version. expect
135 --codespell Use the codespell dictionary for spelling/typos
136 (default:$codespellfile)
137 --codespellfile Use this codespell dictionary
138 --typedefsfile Read additional types from this file
139 --color[=WHEN] Use colors 'always', 'never', or only when output
140 is a terminal ('auto'). Default is 'auto'.
141 --kconfig-prefix=WORD use WORD as a prefix for Kconfig symbols (default
143 -h, --help, --version display this help and exit
145 When FILE is - read standard input.
153 return grep { !$seen{$_}++ } @_;
163 open(my $script, '<', abs_path($P)) or
164 die "$P: Can't read '$P' $!\n";
166 my $text = <$script>;
170 # Also catch when type or level is passed through a variable
171 while ($text =~ /(?:(\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
173 if (exists($types{$2})) {
174 $types{$2} .= ",$1" if ($types{$2} ne $1);
179 $types{$2} = "UNDETERMINED";
183 print("#\tMessage type\n\n");
185 print(" ( Color coding: ");
186 print(RED . "ERROR" . RESET);
188 print(YELLOW . "WARNING" . RESET);
190 print(GREEN . "CHECK" . RESET);
192 print("Multiple levels / Undetermined");
196 foreach my $type (sort keys %types) {
197 my $orig_type = $type;
199 my $level = $types{$type};
200 if ($level eq "ERROR") {
201 $type = RED . $type . RESET;
202 } elsif ($level eq "WARN") {
203 $type = YELLOW . $type . RESET;
204 } elsif ($level eq "CHK") {
205 $type = GREEN . $type . RESET;
208 print(++$count . "\t" . $type . "\n");
209 if ($verbose && exists($verbose_messages{$orig_type})) {
210 my $message = $verbose_messages{$orig_type};
211 $message =~ s/\n/\n\t/g;
212 print("\t" . $message . "\n\n");
219 my $conf = which_conf($configuration_file);
222 open(my $conffile, '<', "$conf")
223 or warn "$P: Can't find a readable $configuration_file file $!\n";
225 while (<$conffile>) {
228 $line =~ s/\s*\n?$//g;
232 next if ($line =~ m/^\s*#/);
233 next if ($line =~ m/^\s*$/);
235 my @words = split(" ", $line);
236 foreach my $word (@words) {
237 last if ($word =~ m/^#/);
238 push (@conf_args, $word);
242 unshift(@ARGV, @conf_args) if @conf_args;
246 open(my $docs, '<', "$docsfile")
247 or warn "$P: Can't read the documentation file $docsfile $!\n";
258 if ($line =~ /^\s*\*\*(.+)\*\*$/) {
260 $verbose_messages{$type} = trim($desc);
266 if ($line =~ /^(?:\s{4,}|$)/) {
271 $verbose_messages{$type} = trim($desc);
280 $verbose_messages{$type} = trim($desc);
285 # Perl's Getopt::Long allows options to take optional arguments after a space.
286 # Prevent --color by itself from consuming other arguments
288 if ($_ eq "--color" || $_ eq "-color") {
289 $_ = "--color=$color";
294 'q|quiet+' => \$quiet,
295 'v|verbose!' => \$verbose,
297 'signoff!' => \$chk_signoff,
298 'patch!' => \$chk_patch,
301 'showfile!' => \$showfile,
304 'subjective!' => \$check,
305 'strict!' => \$check,
306 'ignore=s' => \@ignore,
308 'show-types!' => \$show_types,
309 'list-types!' => \$list_types,
310 'max-line-length=i' => \$max_line_length,
311 'min-conf-desc-length=i' => \$min_conf_desc_length,
312 'tab-size=i' => \$tabsize,
314 'summary!' => \$summary,
315 'mailback!' => \$mailback,
316 'summary-file!' => \$summary_file,
318 'fix-inplace!' => \$fix_inplace,
319 'ignore-perl-version!' => \$ignore_perl_version,
320 'debug=s' => \%debug,
321 'test-only=s' => \$tst_only,
322 'codespell!' => \$codespell,
323 'codespellfile=s' => \$user_codespellfile,
324 'typedefsfile=s' => \$typedefsfile,
325 'color=s' => \$color,
326 'no-color' => \$color, #keep old behaviors of -nocolor
327 'nocolor' => \$color, #keep old behaviors of -nocolor
328 'kconfig-prefix=s' => \${CONFIG_},
333 if ($user_codespellfile) {
334 # Use the user provided codespell file unconditionally
335 $codespellfile = $user_codespellfile;
336 } elsif (!(-f $codespellfile)) {
337 # If /usr/share/codespell/dictionary.txt is not present, try to find it
338 # under codespell's install directory: <codespell_root>/data/dictionary.txt
339 if (($codespell || $help) && which("python3") ne "") {
340 my $python_codespell_dict = << "EOF";
344 codespell_dir = op.dirname(codespell_lib.__file__)
345 codespell_file = op.join(codespell_dir, 'data', 'dictionary.txt')
346 print(codespell_file, end='')
349 my $codespell_dict = `python3 -c "$python_codespell_dict" 2> /dev/null`;
350 $codespellfile = $codespell_dict if (-f $codespell_dict);
354 # $help is 1 if either -h, --help or --version is passed as option - exitcode: 0
355 # $help is 2 if invalid option is passed - exitcode: 1
356 help($help - 1) if ($help);
358 die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file || $fix));
359 die "$P: --verbose cannot be used with --terse\n" if ($verbose && $terse);
361 if ($color =~ /^[01]$/) {
363 } elsif ($color =~ /^always$/i) {
365 } elsif ($color =~ /^never$/i) {
367 } elsif ($color =~ /^auto$/i) {
368 $color = (-t STDOUT);
370 die "$P: Invalid color mode: $color\n";
373 load_docs() if ($verbose);
374 list_types(0) if ($list_types);
376 $fix = 1 if ($fix_inplace);
377 $check_orig = $check;
381 my $perl_version_ok = 1;
382 if ($^V && $^V lt $minimum_perl_version) {
383 $perl_version_ok = 0;
384 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
385 exit(1) if (!$ignore_perl_version);
388 #if no filenames are given, push '-' to read patch from stdin
393 # skip TAB size 1 to avoid additional checks on $tabsize - 1
394 die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);
396 sub hash_save_array_words {
397 my ($hashRef, $arrayRef) = @_;
399 my @array = split(/,/, join(',', @$arrayRef));
400 foreach my $word (@array) {
401 $word =~ s/\s*\n?$//g;
404 $word =~ tr/[a-z]/[A-Z]/;
406 next if ($word =~ m/^\s*#/);
407 next if ($word =~ m/^\s*$/);
413 sub hash_show_words {
414 my ($hashRef, $prefix) = @_;
416 if (keys %$hashRef) {
417 print "\nNOTE: $prefix message types:";
418 foreach my $word (sort keys %$hashRef) {
425 hash_save_array_words(\%ignore_type, \@ignore);
426 hash_save_array_words(\%use_type, \@use);
429 my $dbg_possible = 0;
432 for my $key (keys %debug) {
434 eval "\${dbg_$key} = '$debug{$key}';";
438 my $rpt_cleaners = 0;
447 if (!top_of_kernel_tree($root)) {
448 die "$P: $root: --root does not point at a valid tree\n";
451 if (top_of_kernel_tree('.')) {
453 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
454 top_of_kernel_tree($1)) {
459 if (!defined $root) {
460 print "Must be run from the top-level dir. of a kernel tree\n";
465 my $emitted_corrupt = 0;
468 [A-Za-z_][A-Za-z\d_]*
469 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
471 our $Storage = qr{extern|static|asmlinkage};
485 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
486 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
487 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
488 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
489 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
491 # Notes to $Attribute:
492 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
516 ____cacheline_aligned|
517 ____cacheline_aligned_in_smp|
518 ____cacheline_internodealigned_in_smp|
520 __alloc_size\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\)
523 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
524 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
525 our $Lval = qr{$Ident(?:$Member)*};
527 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
528 our $Binary = qr{(?i)0b[01]+$Int_type?};
529 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
530 our $Int = qr{[0-9]+$Int_type?};
531 our $Octal = qr{0[0-7]+$Int_type?};
532 our $String = qr{(?:\b[Lu])?"[X\t]*"};
533 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
534 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
535 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
536 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
537 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
538 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
539 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
540 our $Arithmetic = qr{\+|-|\*|\/|%};
544 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
547 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
551 our $NonptrTypeMisordered;
552 our $NonptrTypeWithAttr;
556 our $DeclareMisordered;
558 our $NON_ASCII_UTF8 = qr{
559 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
560 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
561 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
562 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
563 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
564 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
565 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
569 [\x09\x0A\x0D\x20-\x7E] # ASCII
573 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
574 our $typeOtherOSTypedefs = qr{(?x:
575 u_(?:char|short|int|long) | # bsd
576 u(?:nchar|short|int|long) # sysv
578 our $typeKernelTypedefs = qr{(?x:
579 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
582 our $typeStdioTypedefs = qr{(?x:
585 our $typeTypedefs = qr{(?x:
587 $typeOtherOSTypedefs\b|
588 $typeKernelTypedefs\b|
592 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
594 our $logFunctions = qr{(?x:
595 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
596 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
598 WARN(?:_RATELIMIT|_ONCE|)|
601 seq_vprintf|seq_printf|seq_puts
604 our $allocFunctions = qr{(?x:
606 (?:kv|k|v)[czm]alloc(?:_array)?(?:_node)? |
609 (?:\w+)?alloc_skb(?:_ip_align)? |
610 # dev_alloc_skb/netdev_alloc_skb, et al
614 our $signature_tags = qr{(?xi:
626 our @link_tags = qw(Link Closes);
628 #Create a search and print patterns for all these strings to be used directly below
629 our $link_tags_search = "";
630 our $link_tags_print = "";
631 foreach my $entry (@link_tags) {
632 if ($link_tags_search ne "") {
633 $link_tags_search .= '|';
634 $link_tags_print .= ' or ';
637 $link_tags_search .= $entry;
638 $link_tags_print .= "'$entry'";
640 $link_tags_search = "(?:${link_tags_search})";
642 our $tracing_logging_tags = qr{(?xi:
666 sub edit_distance_min {
668 my $len = scalar @arr;
669 if ((scalar @arr) < 1) {
670 # if underflow, return
674 for my $i (0 .. ($len-1)) {
675 if ($arr[$i] < $min) {
682 sub get_edit_distance {
683 my ($str1, $str2) = @_;
688 my $len1 = length($str1);
689 my $len2 = length($str2);
690 # two dimensional array storing minimum edit distance
692 for my $i (0 .. $len1) {
693 for my $j (0 .. $len2) {
695 $distance[$i][$j] = $j;
697 $distance[$i][$j] = $i;
698 } elsif (substr($str1, $i-1, 1) eq substr($str2, $j-1, 1)) {
699 $distance[$i][$j] = $distance[$i - 1][$j - 1];
701 my $dist1 = $distance[$i][$j - 1]; #insert distance
702 my $dist2 = $distance[$i - 1][$j]; # remove
703 my $dist3 = $distance[$i - 1][$j - 1]; #replace
704 $distance[$i][$j] = 1 + edit_distance_min($dist1, $dist2, $dist3);
708 return $distance[$len1][$len2];
711 sub find_standard_signature {
713 my @standard_signature_tags = (
714 'Signed-off-by:', 'Co-developed-by:', 'Acked-by:', 'Tested-by:',
715 'Reviewed-by:', 'Reported-by:', 'Suggested-by:'
717 foreach my $signature (@standard_signature_tags) {
718 return $signature if (get_edit_distance($sign_off, $signature) <= 2);
724 our $obsolete_archives = qr{(?xi:
725 \Qfreedesktop.org/archives/dri-devel\E |
726 \Qlists.infradead.org\E |
728 \Qmail-archive.com\E |
729 \Qmailman.alsa-project.org/pipermail\E |
731 \Qozlabs.org/pipermail\E |
735 our @typeListMisordered = (
736 qr{char\s+(?:un)?signed},
737 qr{int\s+(?:(?:un)?signed\s+)?short\s},
738 qr{int\s+short(?:\s+(?:un)?signed)},
739 qr{short\s+int(?:\s+(?:un)?signed)},
740 qr{(?:un)?signed\s+int\s+short},
741 qr{short\s+(?:un)?signed},
742 qr{long\s+int\s+(?:un)?signed},
743 qr{int\s+long\s+(?:un)?signed},
744 qr{long\s+(?:un)?signed\s+int},
745 qr{int\s+(?:un)?signed\s+long},
746 qr{int\s+(?:un)?signed},
747 qr{int\s+long\s+long\s+(?:un)?signed},
748 qr{long\s+long\s+int\s+(?:un)?signed},
749 qr{long\s+long\s+(?:un)?signed\s+int},
750 qr{long\s+long\s+(?:un)?signed},
751 qr{long\s+(?:un)?signed},
756 qr{(?:(?:un)?signed\s+)?char},
757 qr{(?:(?:un)?signed\s+)?short\s+int},
758 qr{(?:(?:un)?signed\s+)?short},
759 qr{(?:(?:un)?signed\s+)?int},
760 qr{(?:(?:un)?signed\s+)?long\s+int},
761 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
762 qr{(?:(?:un)?signed\s+)?long\s+long},
763 qr{(?:(?:un)?signed\s+)?long},
772 qr{${Ident}_handler},
773 qr{${Ident}_handler_fn},
777 our $C90_int_types = qr{(?x:
778 long\s+long\s+int\s+(?:un)?signed|
779 long\s+long\s+(?:un)?signed\s+int|
780 long\s+long\s+(?:un)?signed|
781 (?:(?:un)?signed\s+)?long\s+long\s+int|
782 (?:(?:un)?signed\s+)?long\s+long|
783 int\s+long\s+long\s+(?:un)?signed|
784 int\s+(?:(?:un)?signed\s+)?long\s+long|
786 long\s+int\s+(?:un)?signed|
787 long\s+(?:un)?signed\s+int|
788 long\s+(?:un)?signed|
789 (?:(?:un)?signed\s+)?long\s+int|
790 (?:(?:un)?signed\s+)?long|
791 int\s+long\s+(?:un)?signed|
792 int\s+(?:(?:un)?signed\s+)?long|
795 (?:(?:un)?signed\s+)?int
798 our @typeListFile = ();
799 our @typeListWithAttr = (
801 qr{struct\s+$InitAttribute\s+$Ident},
802 qr{union\s+$InitAttribute\s+$Ident},
805 our @modifierList = (
808 our @modifierListFile = ();
810 our @mode_permission_funcs = (
812 ["module_param_(?:array|named|string)", 4],
813 ["module_param_array_named", 5],
814 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
815 ["proc_create(?:_data|)", 2],
816 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
817 ["IIO_DEV_ATTR_[A-Z_]+", 1],
818 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
819 ["SENSOR_TEMPLATE(?:_2|)", 3],
823 my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';
825 #Create a search pattern for all these functions to speed up a loop below
826 our $mode_perms_search = "";
827 foreach my $entry (@mode_permission_funcs) {
828 $mode_perms_search .= '|' if ($mode_perms_search ne "");
829 $mode_perms_search .= $entry->[0];
831 $mode_perms_search = "(?:${mode_perms_search})";
833 our %deprecated_apis = (
834 "synchronize_rcu_bh" => "synchronize_rcu",
835 "synchronize_rcu_bh_expedited" => "synchronize_rcu_expedited",
836 "call_rcu_bh" => "call_rcu",
837 "rcu_barrier_bh" => "rcu_barrier",
838 "synchronize_sched" => "synchronize_rcu",
839 "synchronize_sched_expedited" => "synchronize_rcu_expedited",
840 "call_rcu_sched" => "call_rcu",
841 "rcu_barrier_sched" => "rcu_barrier",
842 "get_state_synchronize_sched" => "get_state_synchronize_rcu",
843 "cond_synchronize_sched" => "cond_synchronize_rcu",
844 "kmap" => "kmap_local_page",
845 "kunmap" => "kunmap_local",
846 "kmap_atomic" => "kmap_local_page",
847 "kunmap_atomic" => "kunmap_local",
850 #Create a search pattern for all these strings to speed up a loop below
851 our $deprecated_apis_search = "";
852 foreach my $entry (keys %deprecated_apis) {
853 $deprecated_apis_search .= '|' if ($deprecated_apis_search ne "");
854 $deprecated_apis_search .= $entry;
856 $deprecated_apis_search = "(?:${deprecated_apis_search})";
858 our $mode_perms_world_writable = qr{
866 our %mode_permission_string_types = (
885 #Create a search pattern for all these strings to speed up a loop below
886 our $mode_perms_string_search = "";
887 foreach my $entry (keys %mode_permission_string_types) {
888 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
889 $mode_perms_string_search .= $entry;
891 our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
892 our $multi_mode_perms_string_search = qr{
893 ${single_mode_perms_string_search}
894 (?:\s*\|\s*${single_mode_perms_string_search})*
900 return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
907 while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
908 $curpos = pos($string);
911 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
913 $to |= $mode_permission_string_types{$match};
914 $val .= '\s*\|\s*' if ($val ne "");
918 $oval =~ s/^\s*\|\s*//;
919 $oval =~ s/\s*\|\s*$//;
920 return sprintf("%04o", $to);
923 our $allowed_asm_includes = qr{(?x:
929 # memory.h: ARM has a custom one
931 # Load common spelling mistakes and build regular expression list.
935 if (open(my $spelling, '<', $spelling_file)) {
936 while (<$spelling>) {
939 $line =~ s/\s*\n?$//g;
942 next if ($line =~ m/^\s*#/);
943 next if ($line =~ m/^\s*$/);
945 my ($suspect, $fix) = split(/\|\|/, $line);
947 $spelling_fix{$suspect} = $fix;
951 warn "No typos will be found - file '$spelling_file': $!\n";
955 if (open(my $spelling, '<', $codespellfile)) {
956 while (<$spelling>) {
959 $line =~ s/\s*\n?$//g;
962 next if ($line =~ m/^\s*#/);
963 next if ($line =~ m/^\s*$/);
964 next if ($line =~ m/, disabled/i);
968 my ($suspect, $fix) = split(/->/, $line);
970 $spelling_fix{$suspect} = $fix;
974 warn "No codespell typos will be found - file '$codespellfile': $!\n";
978 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
981 my ($wordsRef, $file) = @_;
983 if (open(my $words, '<', $file)) {
987 $line =~ s/\s*\n?$//g;
990 next if ($line =~ m/^\s*#/);
991 next if ($line =~ m/^\s*$/);
993 print("$file: '$line' invalid - ignored\n");
997 $$wordsRef .= '|' if (defined $$wordsRef);
1008 if (show_type("CONST_STRUCT")) {
1009 read_words(\$const_structs, $conststructsfile)
1010 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
1013 if (defined($typedefsfile)) {
1014 my $typeOtherTypedefs;
1015 read_words(\$typeOtherTypedefs, $typedefsfile)
1016 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
1017 $typeTypedefs .= '|' . $typeOtherTypedefs if (defined $typeOtherTypedefs);
1021 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
1022 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
1023 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
1024 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
1025 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
1027 (?:$typeTypedefs\b)|
1031 (?:$Modifier\s+|const\s+)*
1033 (?:typeof|__typeof__)\s*\([^\)]*\)|
1034 (?:$typeTypedefs\b)|
1037 (?:\s+$Modifier|\s+const)*
1039 $NonptrTypeMisordered = qr{
1040 (?:$Modifier\s+|const\s+)*
1044 (?:\s+$Modifier|\s+const)*
1046 $NonptrTypeWithAttr = qr{
1047 (?:$Modifier\s+|const\s+)*
1049 (?:typeof|__typeof__)\s*\([^\)]*\)|
1050 (?:$typeTypedefs\b)|
1051 (?:${allWithAttr}\b)
1053 (?:\s+$Modifier|\s+const)*
1057 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
1058 (?:\s+$Inline|\s+$Modifier)*
1060 $TypeMisordered = qr{
1061 $NonptrTypeMisordered
1062 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
1063 (?:\s+$Inline|\s+$Modifier)*
1065 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
1066 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
1070 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
1072 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
1073 # requires at least perl version v5.10.0
1074 # Any use must be runtime checked with $^V
1076 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
1077 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
1078 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
1080 our $declaration_macros = qr{(?x:
1081 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
1082 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
1083 (?:SKCIPHER_REQUEST|SHASH_DESC|AHASH_REQUEST)_ON_STACK\s*\(|
1084 (?:$Storage\s+)?(?:XA_STATE|XA_STATE_ORDER)\s*\(
1087 our %allow_repeated_words = (
1094 sub deparenthesize {
1096 return "" if (!defined($string));
1098 while ($string =~ /^\s*\(.*\)\s*$/) {
1099 $string =~ s@^\s*\(\s*@@;
1100 $string =~ s@\s*\)\s*$@@;
1103 $string =~ s@\s+@ @g;
1108 sub seed_camelcase_file {
1111 return if (!(-f $file));
1115 open(my $include_file, '<', "$file")
1116 or warn "$P: Can't read '$file' $!\n";
1117 my $text = <$include_file>;
1118 close($include_file);
1120 my @lines = split('\n', $text);
1122 foreach my $line (@lines) {
1123 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
1124 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
1126 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
1128 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
1134 our %maintained_status = ();
1136 sub is_maintained_obsolete {
1137 my ($filename) = @_;
1139 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
1141 if (!exists($maintained_status{$filename})) {
1142 $maintained_status{$filename} = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
1145 return $maintained_status{$filename} =~ /obsolete/i;
1148 sub is_SPDX_License_valid {
1151 return 1 if (!$tree || which("python3") eq "" || !(-x "$root/scripts/spdxcheck.py") || !(-e "$gitroot"));
1153 my $root_path = abs_path($root);
1154 my $status = `cd "$root_path"; echo "$license" | scripts/spdxcheck.py -`;
1155 return 0 if ($status ne "");
1159 my $camelcase_seeded = 0;
1160 sub seed_camelcase_includes {
1161 return if ($camelcase_seeded);
1164 my $camelcase_cache = "";
1165 my @include_files = ();
1167 $camelcase_seeded = 1;
1169 if (-e "$gitroot") {
1170 my $git_last_include_commit = `${git_command} log --no-merges --pretty=format:"%h%n" -1 -- include`;
1171 chomp $git_last_include_commit;
1172 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
1174 my $last_mod_date = 0;
1175 $files = `find $root/include -name "*.h"`;
1176 @include_files = split('\n', $files);
1177 foreach my $file (@include_files) {
1178 my $date = POSIX::strftime("%Y%m%d%H%M",
1179 localtime((stat $file)[9]));
1180 $last_mod_date = $date if ($last_mod_date < $date);
1182 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
1185 if ($camelcase_cache ne "" && -f $camelcase_cache) {
1186 open(my $camelcase_file, '<', "$camelcase_cache")
1187 or warn "$P: Can't read '$camelcase_cache' $!\n";
1188 while (<$camelcase_file>) {
1192 close($camelcase_file);
1197 if (-e "$gitroot") {
1198 $files = `${git_command} ls-files "include/*.h"`;
1199 @include_files = split('\n', $files);
1202 foreach my $file (@include_files) {
1203 seed_camelcase_file($file);
1206 if ($camelcase_cache ne "") {
1207 unlink glob ".checkpatch-camelcase.*";
1208 open(my $camelcase_file, '>', "$camelcase_cache")
1209 or warn "$P: Can't write '$camelcase_cache' $!\n";
1210 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
1211 print $camelcase_file ("$_\n");
1213 close($camelcase_file);
1217 sub git_is_single_file {
1218 my ($filename) = @_;
1220 return 0 if ((which("git") eq "") || !(-e "$gitroot"));
1222 my $output = `${git_command} ls-files -- $filename 2>/dev/null`;
1223 my $count = $output =~ tr/\n//;
1224 return $count eq 1 && $output =~ m{^${filename}$};
1227 sub git_commit_info {
1228 my ($commit, $id, $desc) = @_;
1230 return ($id, $desc) if ((which("git") eq "") || !(-e "$gitroot"));
1232 my $output = `${git_command} log --no-color --format='%H %s' -1 $commit 2>&1`;
1233 $output =~ s/^\s*//gm;
1234 my @lines = split("\n", $output);
1236 return ($id, $desc) if ($#lines < 0);
1238 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous/) {
1239 # Maybe one day convert this block of bash into something that returns
1240 # all matching commit ids, but it's very slow...
1242 # echo "checking commits $1..."
1243 # git rev-list --remotes | grep -i "^$1" |
1244 # while read line ; do
1245 # git log --format='%H %s' -1 $line |
1246 # echo "commit $(cut -c 1-12,41-)"
1248 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./ ||
1249 $lines[0] =~ /^fatal: bad object $commit/) {
1252 $id = substr($lines[0], 0, 12);
1253 $desc = substr($lines[0], 41);
1256 return ($id, $desc);
1259 $chk_signoff = 0 if ($file);
1264 my @fixed_inserted = ();
1265 my @fixed_deleted = ();
1268 # If input is git commits, extract all commits from the commit expressions.
1269 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
1270 die "$P: No git repository found\n" if ($git && !-e "$gitroot");
1274 foreach my $commit_expr (@ARGV) {
1276 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
1277 $git_range = "-$2 $1";
1278 } elsif ($commit_expr =~ m/\.\./) {
1279 $git_range = "$commit_expr";
1281 $git_range = "-1 $commit_expr";
1283 my $lines = `${git_command} log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
1284 foreach my $line (split(/\n/, $lines)) {
1285 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
1286 next if (!defined($1) || !defined($2));
1289 unshift(@commits, $sha1);
1290 $git_commits{$sha1} = $subject;
1293 die "$P: no git commits after extraction!\n" if (@commits == 0);
1298 $allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
1299 for my $filename (@ARGV) {
1301 my $is_git_file = git_is_single_file($filename);
1302 my $oldfile = $file;
1303 $file = 1 if ($is_git_file);
1305 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
1306 die "$P: $filename: git format-patch failed - $!\n";
1308 open($FILE, '-|', "diff -u /dev/null $filename") ||
1309 die "$P: $filename: diff failed - $!\n";
1310 } elsif ($filename eq '-') {
1311 open($FILE, '<&STDIN');
1313 open($FILE, '<', "$filename") ||
1314 die "$P: $filename: open failed - $!\n";
1316 if ($filename eq '-') {
1317 $vname = 'Your patch';
1319 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1325 push(@rawlines, $_);
1326 $vname = qq("$1") if ($filename eq '-' && $_ =~ m/^Subject:\s+(.+)/i);
1330 if ($#ARGV > 0 && $quiet == 0) {
1331 print '-' x length($vname) . "\n";
1333 print '-' x length($vname) . "\n";
1336 if (!process($filename)) {
1342 @fixed_inserted = ();
1343 @fixed_deleted = ();
1345 @modifierListFile = ();
1348 $file = $oldfile if ($is_git_file);
1352 hash_show_words(\%use_type, "Used");
1353 hash_show_words(\%ignore_type, "Ignored");
1355 if (!$perl_version_ok) {
1358 NOTE: perl $^V is not modern enough to detect all possible issues.
1359 An upgrade to at least perl $minimum_perl_version is suggested.
1365 NOTE: If any of the errors are false positives, please report
1366 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1373 sub top_of_kernel_tree {
1377 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1378 "README", "Documentation", "arch", "include", "drivers",
1379 "fs", "init", "ipc", "kernel", "lib", "scripts",
1382 foreach my $check (@tree_check) {
1383 if (! -e $root . '/' . $check) {
1391 my ($formatted_email) = @_;
1395 my $name_comment = "";
1399 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1402 $comment = $3 if defined $3;
1403 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1405 $comment = $2 if defined $2;
1406 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1408 $comment = $2 if defined $2;
1409 $formatted_email =~ s/\Q$address\E.*$//;
1410 $name = $formatted_email;
1411 $name = trim($name);
1412 $name =~ s/^\"|\"$//g;
1413 # If there's a name left after stripping spaces and
1414 # leading quotes, and the address doesn't have both
1415 # leading and trailing angle brackets, the address
1417 # "joe smith joe@smith.com" bad
1418 # "joe smith <joe@smith.com" bad
1419 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1426 # Extract comments from names excluding quoted parts
1427 # "John D. (Doe)" - Do not extract
1428 if ($name =~ s/\"(.+)\"//) {
1431 while ($name =~ s/\s*($balanced_parens)\s*/ /) {
1432 $name_comment .= trim($1);
1434 $name =~ s/^[ \"]+|[ \"]+$//g;
1435 $name = trim("$quoted $name");
1437 $address = trim($address);
1438 $address =~ s/^\<|\>$//g;
1439 $comment = trim($comment);
1441 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1442 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1443 $name = "\"$name\"";
1446 return ($name, $name_comment, $address, $comment);
1450 my ($name, $name_comment, $address, $comment) = @_;
1452 my $formatted_email;
1454 $name =~ s/^[ \"]+|[ \"]+$//g;
1455 $address = trim($address);
1456 $address =~ s/(?:\.|\,|\")+$//; ##trailing commas, dots or quotes
1458 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1459 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1460 $name = "\"$name\"";
1463 $name_comment = trim($name_comment);
1464 $name_comment = " $name_comment" if ($name_comment ne "");
1465 $comment = trim($comment);
1466 $comment = " $comment" if ($comment ne "");
1468 if ("$name" eq "") {
1469 $formatted_email = "$address";
1471 $formatted_email = "$name$name_comment <$address>";
1473 $formatted_email .= "$comment";
1474 return $formatted_email;
1477 sub reformat_email {
1480 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
1481 return format_email($email_name, $name_comment, $email_address, $comment);
1484 sub same_email_addresses {
1485 my ($email1, $email2) = @_;
1487 my ($email1_name, $name1_comment, $email1_address, $comment1) = parse_email($email1);
1488 my ($email2_name, $name2_comment, $email2_address, $comment2) = parse_email($email2);
1490 return $email1_name eq $email2_name &&
1491 $email1_address eq $email2_address &&
1492 $name1_comment eq $name2_comment &&
1493 $comment1 eq $comment2;
1499 foreach my $path (split(/:/, $ENV{PATH})) {
1500 if (-e "$path/$bin") {
1501 return "$path/$bin";
1511 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1512 if (-e "$path/$conf") {
1513 return "$path/$conf";
1525 for my $c (split(//, $str)) {
1529 for (; ($n % $tabsize) != 0; $n++) {
1541 (my $res = shift) =~ tr/\t/ /c;
1548 # Drop the diff line leader and expand tabs
1550 $line = expand_tabs($line);
1552 # Pick the indent from the front of the line.
1553 my ($white) = ($line =~ /^(\s*)/);
1555 return (length($line), length($white));
1558 my $sanitise_quote = '';
1560 sub sanitise_line_reset {
1561 my ($in_comment) = @_;
1564 $sanitise_quote = '*/';
1566 $sanitise_quote = '';
1579 # Always copy over the diff marker.
1580 $res = substr($line, 0, 1);
1582 for ($off = 1; $off < length($line); $off++) {
1583 $c = substr($line, $off, 1);
1585 # Comments we are whacking completely including the begin
1586 # and end, all to $;.
1587 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1588 $sanitise_quote = '*/';
1590 substr($res, $off, 2, "$;$;");
1594 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1595 $sanitise_quote = '';
1596 substr($res, $off, 2, "$;$;");
1600 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1601 $sanitise_quote = '//';
1603 substr($res, $off, 2, $sanitise_quote);
1608 # A \ in a string means ignore the next character.
1609 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1611 substr($res, $off, 2, 'XX');
1616 if ($c eq "'" || $c eq '"') {
1617 if ($sanitise_quote eq '') {
1618 $sanitise_quote = $c;
1620 substr($res, $off, 1, $c);
1622 } elsif ($sanitise_quote eq $c) {
1623 $sanitise_quote = '';
1627 #print "c<$c> SQ<$sanitise_quote>\n";
1628 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1629 substr($res, $off, 1, $;);
1630 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1631 substr($res, $off, 1, $;);
1632 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1633 substr($res, $off, 1, 'X');
1635 substr($res, $off, 1, $c);
1639 if ($sanitise_quote eq '//') {
1640 $sanitise_quote = '';
1643 # The pathname on a #include may be surrounded by '<' and '>'.
1644 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1645 my $clean = 'X' x length($1);
1646 $res =~ s@\<.*\>@<$clean>@;
1648 # The whole of a #error is a string.
1649 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1650 my $clean = 'X' x length($1);
1651 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1654 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1656 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1662 sub get_quoted_string {
1663 my ($line, $rawline) = @_;
1665 return "" if (!defined($line) || !defined($rawline));
1666 return "" if ($line !~ m/($String)/g);
1667 return substr($rawline, $-[0], $+[0] - $-[0]);
1670 sub ctx_statement_block {
1671 my ($linenr, $remain, $off) = @_;
1672 my $line = $linenr - 1;
1675 my $coff = $off - 1;
1689 @stack = (['', 0]) if ($#stack == -1);
1691 #warn "CSB: blk<$blk> remain<$remain>\n";
1692 # If we are about to drop off the end, pull in more
1695 for (; $remain > 0; $line++) {
1696 last if (!defined $lines[$line]);
1697 next if ($lines[$line] =~ /^-/);
1700 $blk .= $lines[$line] . "\n";
1701 $len = length($blk);
1705 # Bail if there is no further context.
1706 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1710 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1716 $c = substr($blk, $off, 1);
1717 $remainder = substr($blk, $off);
1719 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1721 # Handle nested #if/#else.
1722 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1723 push(@stack, [ $type, $level ]);
1724 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1725 ($type, $level) = @{$stack[$#stack - 1]};
1726 } elsif ($remainder =~ /^#\s*endif\b/) {
1727 ($type, $level) = @{pop(@stack)};
1730 # Statement ends at the ';' or a close '}' at the
1732 if ($level == 0 && $c eq ';') {
1736 # An else is really a conditional as long as its not else if
1737 if ($level == 0 && $coff_set == 0 &&
1738 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1739 $remainder =~ /^(else)(?:\s|{)/ &&
1740 $remainder !~ /^else\s+if\b/) {
1741 $coff = $off + length($1) - 1;
1743 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1744 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1747 if (($type eq '' || $type eq '(') && $c eq '(') {
1751 if ($type eq '(' && $c eq ')') {
1753 $type = ($level != 0)? '(' : '';
1755 if ($level == 0 && $coff < $soff) {
1758 #warn "CSB: mark coff<$coff>\n";
1761 if (($type eq '' || $type eq '{') && $c eq '{') {
1765 if ($type eq '{' && $c eq '}') {
1767 $type = ($level != 0)? '{' : '';
1770 if (substr($blk, $off + 1, 1) eq ';') {
1776 # Preprocessor commands end at the newline unless escaped.
1777 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1785 # We are truly at the end, so shuffle to the next line.
1792 my $statement = substr($blk, $soff, $off - $soff + 1);
1793 my $condition = substr($blk, $soff, $coff - $soff + 1);
1795 #warn "STATEMENT<$statement>\n";
1796 #warn "CONDITION<$condition>\n";
1798 #print "coff<$coff> soff<$off> loff<$loff>\n";
1800 return ($statement, $condition,
1801 $line, $remain + 1, $off - $loff + 1, $level);
1804 sub statement_lines {
1807 # Strip the diff line prefixes and rip blank lines at start and end.
1808 $stmt =~ s/(^|\n)./$1/g;
1812 my @stmt_lines = ($stmt =~ /\n/g);
1814 return $#stmt_lines + 2;
1817 sub statement_rawlines {
1820 my @stmt_lines = ($stmt =~ /\n/g);
1822 return $#stmt_lines + 2;
1825 sub statement_block_size {
1828 $stmt =~ s/(^|\n)./$1/g;
1834 my @stmt_lines = ($stmt =~ /\n/g);
1835 my @stmt_statements = ($stmt =~ /;/g);
1837 my $stmt_lines = $#stmt_lines + 2;
1838 my $stmt_statements = $#stmt_statements + 1;
1840 if ($stmt_lines > $stmt_statements) {
1843 return $stmt_statements;
1847 sub ctx_statement_full {
1848 my ($linenr, $remain, $off) = @_;
1849 my ($statement, $condition, $level);
1853 # Grab the first conditional/block pair.
1854 ($statement, $condition, $linenr, $remain, $off, $level) =
1855 ctx_statement_block($linenr, $remain, $off);
1856 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1857 push(@chunks, [ $condition, $statement ]);
1858 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1859 return ($level, $linenr, @chunks);
1862 # Pull in the following conditional/block pairs and see if they
1863 # could continue the statement.
1865 ($statement, $condition, $linenr, $remain, $off, $level) =
1866 ctx_statement_block($linenr, $remain, $off);
1867 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1868 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1870 push(@chunks, [ $condition, $statement ]);
1873 return ($level, $linenr, @chunks);
1877 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1879 my $start = $linenr - 1;
1886 my @stack = ($level);
1887 for ($line = $start; $remain > 0; $line++) {
1888 next if ($rawlines[$line] =~ /^-/);
1891 $blk .= $rawlines[$line];
1893 # Handle nested #if/#else.
1894 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1895 push(@stack, $level);
1896 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1897 $level = $stack[$#stack - 1];
1898 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1899 $level = pop(@stack);
1902 foreach my $c (split(//, $lines[$line])) {
1903 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1909 if ($c eq $close && $level > 0) {
1911 last if ($level == 0);
1912 } elsif ($c eq $open) {
1917 if (!$outer || $level <= 1) {
1918 push(@res, $rawlines[$line]);
1921 last if ($level == 0);
1924 return ($level, @res);
1926 sub ctx_block_outer {
1927 my ($linenr, $remain) = @_;
1929 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1933 my ($linenr, $remain) = @_;
1935 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1939 my ($linenr, $remain, $off) = @_;
1941 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1944 sub ctx_block_level {
1945 my ($linenr, $remain) = @_;
1947 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1949 sub ctx_statement_level {
1950 my ($linenr, $remain, $off) = @_;
1952 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1955 sub ctx_locate_comment {
1956 my ($first_line, $end_line) = @_;
1958 # If c99 comment on the current line, or the line before or after
1959 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@^\+.*(//.*$)@);
1960 return $current_comment if (defined $current_comment);
1961 ($current_comment) = ($rawlines[$end_line - 2] =~ m@^[\+ ].*(//.*$)@);
1962 return $current_comment if (defined $current_comment);
1963 ($current_comment) = ($rawlines[$end_line] =~ m@^[\+ ].*(//.*$)@);
1964 return $current_comment if (defined $current_comment);
1966 # Catch a comment on the end of the line itself.
1967 ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1968 return $current_comment if (defined $current_comment);
1970 # Look through the context and try and figure out if there is a
1973 $current_comment = '';
1974 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1975 my $line = $rawlines[$linenr - 1];
1977 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1980 if ($line =~ m@/\*@) {
1983 if (!$in_comment && $current_comment ne '') {
1984 $current_comment = '';
1986 $current_comment .= $line . "\n" if ($in_comment);
1987 if ($line =~ m@\*/@) {
1992 chomp($current_comment);
1993 return($current_comment);
1995 sub ctx_has_comment {
1996 my ($first_line, $end_line) = @_;
1997 my $cmt = ctx_locate_comment($first_line, $end_line);
1999 ##print "LINE: $rawlines[$end_line - 1 ]\n";
2000 ##print "CMMT: $cmt\n";
2002 return ($cmt ne '');
2006 my ($linenr, $cnt) = @_;
2008 my $offset = $linenr - 1;
2013 $line = $rawlines[$offset++];
2014 next if (defined($line) && $line =~ /^-/);
2022 my ($linenr, $lc) = @_;
2024 my $stat_real = raw_line($linenr, 0);
2025 for (my $count = $linenr + 1; $count <= $lc; $count++) {
2026 $stat_real = $stat_real . "\n" . raw_line($count, 0);
2033 my ($linenr, $cnt, $here) = @_;
2035 my $herectx = $here . "\n";
2036 for (my $n = 0; $n < $cnt; $n++) {
2037 $herectx .= raw_line($linenr, $n) . "\n";
2048 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
2051 $coded = sprintf("^%c", unpack('C', $2) + 64);
2060 my $av_preprocessor = 0;
2065 sub annotate_reset {
2066 $av_preprocessor = 0;
2068 @av_paren_type = ('E');
2069 $av_pend_colon = 'O';
2072 sub annotate_values {
2073 my ($stream, $type) = @_;
2076 my $var = '_' x length($stream);
2079 print "$stream\n" if ($dbg_values > 1);
2081 while (length($cur)) {
2082 @av_paren_type = ('E') if ($#av_paren_type < 0);
2083 print " <" . join('', @av_paren_type) .
2084 "> <$type> <$av_pending>" if ($dbg_values > 1);
2085 if ($cur =~ /^(\s+)/o) {
2086 print "WS($1)\n" if ($dbg_values > 1);
2087 if ($1 =~ /\n/ && $av_preprocessor) {
2088 $type = pop(@av_paren_type);
2089 $av_preprocessor = 0;
2092 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
2093 print "CAST($1)\n" if ($dbg_values > 1);
2094 push(@av_paren_type, $type);
2097 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
2098 print "DECLARE($1)\n" if ($dbg_values > 1);
2101 } elsif ($cur =~ /^($Modifier)\s*/) {
2102 print "MODIFIER($1)\n" if ($dbg_values > 1);
2105 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
2106 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
2107 $av_preprocessor = 1;
2108 push(@av_paren_type, $type);
2114 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
2115 print "UNDEF($1)\n" if ($dbg_values > 1);
2116 $av_preprocessor = 1;
2117 push(@av_paren_type, $type);
2119 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
2120 print "PRE_START($1)\n" if ($dbg_values > 1);
2121 $av_preprocessor = 1;
2123 push(@av_paren_type, $type);
2124 push(@av_paren_type, $type);
2127 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
2128 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
2129 $av_preprocessor = 1;
2131 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
2135 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
2136 print "PRE_END($1)\n" if ($dbg_values > 1);
2138 $av_preprocessor = 1;
2140 # Assume all arms of the conditional end as this
2141 # one does, and continue as if the #endif was not here.
2142 pop(@av_paren_type);
2143 push(@av_paren_type, $type);
2146 } elsif ($cur =~ /^(\\\n)/o) {
2147 print "PRECONT($1)\n" if ($dbg_values > 1);
2149 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
2150 print "ATTR($1)\n" if ($dbg_values > 1);
2151 $av_pending = $type;
2154 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
2155 print "SIZEOF($1)\n" if ($dbg_values > 1);
2161 } elsif ($cur =~ /^(if|while|for)\b/o) {
2162 print "COND($1)\n" if ($dbg_values > 1);
2166 } elsif ($cur =~/^(case)/o) {
2167 print "CASE($1)\n" if ($dbg_values > 1);
2168 $av_pend_colon = 'C';
2171 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
2172 print "KEYWORD($1)\n" if ($dbg_values > 1);
2175 } elsif ($cur =~ /^(\()/o) {
2176 print "PAREN('$1')\n" if ($dbg_values > 1);
2177 push(@av_paren_type, $av_pending);
2181 } elsif ($cur =~ /^(\))/o) {
2182 my $new_type = pop(@av_paren_type);
2183 if ($new_type ne '_') {
2185 print "PAREN('$1') -> $type\n"
2186 if ($dbg_values > 1);
2188 print "PAREN('$1')\n" if ($dbg_values > 1);
2191 } elsif ($cur =~ /^($Ident)\s*\(/o) {
2192 print "FUNC($1)\n" if ($dbg_values > 1);
2196 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
2197 if (defined $2 && $type eq 'C' || $type eq 'T') {
2198 $av_pend_colon = 'B';
2199 } elsif ($type eq 'E') {
2200 $av_pend_colon = 'L';
2202 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
2205 } elsif ($cur =~ /^($Ident|$Constant)/o) {
2206 print "IDENT($1)\n" if ($dbg_values > 1);
2209 } elsif ($cur =~ /^($Assignment)/o) {
2210 print "ASSIGN($1)\n" if ($dbg_values > 1);
2213 } elsif ($cur =~/^(;|{|})/) {
2214 print "END($1)\n" if ($dbg_values > 1);
2216 $av_pend_colon = 'O';
2218 } elsif ($cur =~/^(,)/) {
2219 print "COMMA($1)\n" if ($dbg_values > 1);
2222 } elsif ($cur =~ /^(\?)/o) {
2223 print "QUESTION($1)\n" if ($dbg_values > 1);
2226 } elsif ($cur =~ /^(:)/o) {
2227 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
2229 substr($var, length($res), 1, $av_pend_colon);
2230 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
2235 $av_pend_colon = 'O';
2237 } elsif ($cur =~ /^(\[)/o) {
2238 print "CLOSE($1)\n" if ($dbg_values > 1);
2241 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
2244 print "OPV($1)\n" if ($dbg_values > 1);
2251 substr($var, length($res), 1, $variant);
2254 } elsif ($cur =~ /^($Operators)/o) {
2255 print "OP($1)\n" if ($dbg_values > 1);
2256 if ($1 ne '++' && $1 ne '--') {
2260 } elsif ($cur =~ /(^.)/o) {
2261 print "C($1)\n" if ($dbg_values > 1);
2264 $cur = substr($cur, length($1));
2265 $res .= $type x length($1);
2269 return ($res, $var);
2273 my ($possible, $line) = @_;
2274 my $notPermitted = qr{(?:
2291 ^(?:typedef|struct|enum)\b
2293 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
2294 if ($possible !~ $notPermitted) {
2295 # Check for modifiers.
2296 $possible =~ s/\s*$Storage\s*//g;
2297 $possible =~ s/\s*$Sparse\s*//g;
2298 if ($possible =~ /^\s*$/) {
2300 } elsif ($possible =~ /\s/) {
2301 $possible =~ s/\s*$Type\s*//g;
2302 for my $modifier (split(' ', $possible)) {
2303 if ($modifier !~ $notPermitted) {
2304 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
2305 push(@modifierListFile, $modifier);
2310 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
2311 push(@typeListFile, $possible);
2315 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
2324 $type =~ tr/[a-z]/[A-Z]/;
2326 return defined $use_type{$type} if (scalar keys %use_type > 0);
2328 return !defined $ignore_type{$type};
2332 my ($level, $type, $msg) = @_;
2334 if (!show_type($type) ||
2335 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
2340 if ($level eq 'ERROR') {
2342 } elsif ($level eq 'WARNING') {
2348 $output .= $prefix . $level . ':';
2350 $output .= BLUE if ($color);
2351 $output .= "$type:";
2353 $output .= RESET if ($color);
2354 $output .= ' ' . $msg . "\n";
2357 my @lines = split("\n", $output, -1);
2358 splice(@lines, 1, 1);
2359 $output = join("\n", @lines);
2363 $output = (split('\n', $output))[0] . "\n";
2366 if ($verbose && exists($verbose_messages{$type}) &&
2367 !exists($verbose_emitted{$type})) {
2368 $output .= $verbose_messages{$type} . "\n\n";
2369 $verbose_emitted{$type} = 1;
2372 push(our @report, $output);
2381 sub fixup_current_range {
2382 my ($lineRef, $offset, $length) = @_;
2384 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2387 my $no = $o + $offset;
2388 my $nl = $l + $length;
2389 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2393 sub fix_inserted_deleted_lines {
2394 my ($linesRef, $insertedRef, $deletedRef) = @_;
2396 my $range_last_linenr = 0;
2397 my $delta_offset = 0;
2402 my $next_insert = 0;
2403 my $next_delete = 0;
2407 my $inserted = @{$insertedRef}[$next_insert++];
2408 my $deleted = @{$deletedRef}[$next_delete++];
2410 foreach my $old_line (@{$linesRef}) {
2412 my $line = $old_line; #don't modify the array
2413 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
2415 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2416 $range_last_linenr = $new_linenr;
2417 fixup_current_range(\$line, $delta_offset, 0);
2420 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2421 $deleted = @{$deletedRef}[$next_delete++];
2423 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2426 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2427 push(@lines, ${$inserted}{'LINE'});
2428 $inserted = @{$insertedRef}[$next_insert++];
2430 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2434 push(@lines, $line);
2444 sub fix_insert_line {
2445 my ($linenr, $line) = @_;
2451 push(@fixed_inserted, $inserted);
2454 sub fix_delete_line {
2455 my ($linenr, $line) = @_;
2462 push(@fixed_deleted, $deleted);
2466 my ($type, $msg) = @_;
2468 if (report("ERROR", $type, $msg)) {
2476 my ($type, $msg) = @_;
2478 if (report("WARNING", $type, $msg)) {
2486 my ($type, $msg) = @_;
2488 if ($check && report("CHECK", $type, $msg)) {
2496 sub check_absolute_file {
2497 my ($absolute, $herecurr) = @_;
2498 my $file = $absolute;
2500 ##print "absolute<$absolute>\n";
2502 # See if any suffix of this path is a path within the tree.
2503 while ($file =~ s@^[^/]*/@@) {
2504 if (-f "$root/$file") {
2505 ##print "file<$file>\n";
2513 # It is, so see if the prefix is acceptable.
2514 my $prefix = $absolute;
2515 substr($prefix, -length($file)) = '';
2517 ##print "prefix<$prefix>\n";
2518 if ($prefix ne ".../") {
2519 WARN("USE_RELATIVE_PATH",
2520 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2527 $string =~ s/^\s+|\s+$//g;
2535 $string =~ s/^\s+//;
2543 $string =~ s/\s+$//;
2548 sub string_find_replace {
2549 my ($string, $find, $replace) = @_;
2551 $string =~ s/$find/$replace/g;
2559 my $source_indent = $tabsize;
2560 my $max_spaces_before_tab = $source_indent - 1;
2561 my $spaces_to_tab = " " x $source_indent;
2563 #convert leading spaces to tabs
2564 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2565 #Remove spaces before a tab
2566 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2571 sub pos_last_openparen {
2576 my $opens = $line =~ tr/\(/\(/;
2577 my $closes = $line =~ tr/\)/\)/;
2579 my $last_openparen = 0;
2581 if (($opens == 0) || ($closes >= $opens)) {
2585 my $len = length($line);
2587 for ($pos = 0; $pos < $len; $pos++) {
2588 my $string = substr($line, $pos);
2589 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2590 $pos += length($1) - 1;
2591 } elsif (substr($line, $pos, 1) eq '(') {
2592 $last_openparen = $pos;
2593 } elsif (index($string, '(') == -1) {
2598 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2601 sub get_raw_comment {
2602 my ($line, $rawline) = @_;
2605 for my $i (0 .. (length($line) - 1)) {
2606 if (substr($line, $i, 1) eq "$;") {
2607 $comment .= substr($rawline, $i, 1);
2614 sub exclude_global_initialisers {
2615 my ($realfile) = @_;
2617 # Do not check for BPF programs (tools/testing/selftests/bpf/progs/*.c, samples/bpf/*_kern.c, *.bpf.c).
2618 return $realfile =~ m@^tools/testing/selftests/bpf/progs/.*\.c$@ ||
2619 $realfile =~ m@^samples/bpf/.*_kern\.c$@ ||
2620 $realfile =~ m@/bpf/.*\.bpf\.c$@;
2624 my $filename = shift;
2630 my $stashrawline="";
2640 my $authorsignoff = 0;
2641 my $author_sob = '';
2643 my $is_binding_patch = -1;
2644 my $in_header_lines = $file ? 0 : 1;
2645 my $in_commit_log = 0; #Scanning lines before patch
2646 my $has_patch_separator = 0; #Found a --- line
2647 my $has_commit_log = 0; #Encountered lines before patch
2648 my $commit_log_lines = 0; #Number of commit log lines
2649 my $commit_log_possible_stack_dump = 0;
2650 my $commit_log_long_line = 0;
2651 my $commit_log_has_diff = 0;
2652 my $reported_maintainer_file = 0;
2653 my $non_utf8_charset = 0;
2655 my $last_git_commit_id_linenr = -1;
2657 my $last_blank_line = 0;
2658 my $last_coalesced_string_linenr = -1;
2666 # Trace the real file/line as we go.
2671 my $context_function; #undef'd unless there's a known function
2673 my $comment_edge = 0;
2677 my $prev_values = 'E';
2680 my %suppress_ifbraces;
2681 my %suppress_whiletrailers;
2682 my %suppress_export;
2683 my $suppress_statement = 0;
2685 my %signatures = ();
2687 # Pre-scan the patch sanitizing the lines.
2688 # Pre-scan the patch looking for any __setup documentation.
2690 my @setup_docs = ();
2693 my $camelcase_file_seeded = 0;
2695 my $checklicenseline = 1;
2697 sanitise_line_reset();
2699 foreach my $rawline (@rawlines) {
2703 push(@fixed, $rawline) if ($fix);
2705 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2707 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.txt$@) {
2712 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2721 # Guestimate if this is a continuing comment. Run
2722 # the context looking for a comment "edge". If this
2723 # edge is a close comment then we must be in a comment
2727 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2728 next if (defined $rawlines[$ln - 1] &&
2729 $rawlines[$ln - 1] =~ /^-/);
2731 #print "RAW<$rawlines[$ln - 1]>\n";
2732 last if (!defined $rawlines[$ln - 1]);
2733 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2734 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2739 if (defined $edge && $edge eq '*/') {
2743 # Guestimate if this is a continuing comment. If this
2744 # is the start of a diff block and this line starts
2745 # ' *' then it is very likely a comment.
2746 if (!defined $edge &&
2747 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2752 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2753 sanitise_line_reset($in_comment);
2755 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2756 # Standardise the strings and chars within the input to
2757 # simplify matching -- only bother with positive lines.
2758 $line = sanitise_line($rawline);
2760 push(@lines, $line);
2763 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2768 #print "==>$rawline\n";
2769 #print "-->$line\n";
2771 if ($setup_docs && $line =~ /^\+/) {
2772 push(@setup_docs, $line);
2781 foreach my $line (@lines) {
2784 my $sline = $line; #copy of $line
2785 $sline =~ s/$;/ /g; #with comments as spaces
2787 my $rawline = $rawlines[$linenr - 1];
2788 my $raw_comment = get_raw_comment($line, $rawline);
2790 # check if it's a mode change, rename or start of a patch
2791 if (!$in_commit_log &&
2792 ($line =~ /^ mode change [0-7]+ => [0-7]+ \S+\s*$/ ||
2793 ($line =~ /^rename (?:from|to) \S+\s*$/ ||
2794 $line =~ /^diff --git a\/[\w\/\.\_\-]+ b\/\S+\s*$/))) {
2798 #extract the line range in the file after the patch is applied
2799 if (!$in_commit_log &&
2800 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2803 $first_line = $linenr + 1;
2813 %suppress_ifbraces = ();
2814 %suppress_whiletrailers = ();
2815 %suppress_export = ();
2816 $suppress_statement = 0;
2817 if ($context =~ /\b(\w+)\s*\(/) {
2818 $context_function = $1;
2820 undef $context_function;
2824 # track the line number as we move through the hunk, note that
2825 # new versions of GNU diff omit the leading space on completely
2826 # blank context lines so we need to count that too.
2827 } elsif ($line =~ /^( |\+|$)/) {
2829 $realcnt-- if ($realcnt != 0);
2831 # Measure the line length and indent.
2832 ($length, $indent) = line_stats($rawline);
2834 # Track the previous line.
2835 ($prevline, $stashline) = ($stashline, $line);
2836 ($previndent, $stashindent) = ($stashindent, $indent);
2837 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2839 #warn "line<$line>\n";
2841 } elsif ($realcnt == 1) {
2845 my $hunk_line = ($realcnt != 0);
2847 $here = "#$linenr: " if (!$file);
2848 $here = "#$realline: " if ($file);
2851 # extract the filename as it passes
2852 if ($line =~ /^diff --git.*?(\S+)$/) {
2854 $realfile =~ s@^([^/]*)/@@ if (!$file);
2857 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2859 $realfile =~ s@^([^/]*)/@@ if (!$file);
2863 if (!$file && $tree && $p1_prefix ne '' &&
2864 -e "$root/$p1_prefix") {
2865 WARN("PATCH_PREFIX",
2866 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2869 if ($realfile =~ m@^include/asm/@) {
2870 ERROR("MODIFIED_INCLUDE_ASM",
2871 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2876 #make up the handle for any error we report on this line
2878 $prefix = "$realfile:$realline: "
2881 $prefix = "$filename:$realline: ";
2883 $prefix = "$filename:$linenr: ";
2888 if (is_maintained_obsolete($realfile)) {
2890 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2892 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2895 $check = $check_orig;
2897 $checklicenseline = 1;
2899 if ($realfile !~ /^MAINTAINERS/) {
2900 my $last_binding_patch = $is_binding_patch;
2902 $is_binding_patch = () = $realfile =~ m@^(?:Documentation/devicetree/|include/dt-bindings/)@;
2904 if (($last_binding_patch != -1) &&
2905 ($last_binding_patch ^ $is_binding_patch)) {
2906 WARN("DT_SPLIT_BINDING_PATCH",
2907 "DT binding docs and includes should be a separate patch. See: Documentation/devicetree/bindings/submitting-patches.rst\n");
2914 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2916 my $hereline = "$here\n$rawline\n";
2917 my $herecurr = "$here\n$rawline\n";
2918 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2920 $cnt_lines++ if ($realcnt != 0);
2922 # Verify the existence of a commit log if appropriate
2923 # 2 is used because a $signature is counted in $commit_log_lines
2924 if ($in_commit_log) {
2925 if ($line !~ /^\s*$/) {
2926 $commit_log_lines++; #could be a $signature
2928 } elsif ($has_commit_log && $commit_log_lines < 2) {
2929 WARN("COMMIT_MESSAGE",
2930 "Missing commit description - Add an appropriate one\n");
2931 $commit_log_lines = 2; #warn only once
2934 # Check if the commit log has what seems like a diff which can confuse patch
2935 if ($in_commit_log && !$commit_log_has_diff &&
2936 (($line =~ m@^\s+diff\b.*a/([\w/]+)@ &&
2937 $line =~ m@^\s+diff\b.*a/[\w/]+\s+b/$1\b@) ||
2938 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2939 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2940 ERROR("DIFF_IN_COMMIT_MSG",
2941 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2942 $commit_log_has_diff = 1;
2945 # Check for incorrect file permissions
2946 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2947 my $permhere = $here . "FILE: $realfile\n";
2948 if ($realfile !~ m@scripts/@ &&
2949 $realfile !~ /\.(py|pl|awk|sh)$/) {
2950 ERROR("EXECUTE_PERMISSIONS",
2951 "do not set execute permissions for source files\n" . $permhere);
2955 # Check the patch for a From:
2956 if (decode("MIME-Header", $line) =~ /^From:\s*(.*)/) {
2958 my $curline = $linenr;
2959 while(defined($rawlines[$curline]) && ($rawlines[$curline++] =~ /^[ \t]\s*(.*)/)) {
2962 $author = encode("utf8", $author) if ($line =~ /=\?utf-8\?/i);
2964 $author = reformat_email($author);
2967 # Check the patch for a signoff:
2968 if ($line =~ /^\s*signed-off-by:\s*(.*)/i) {
2971 if ($author ne '' && $authorsignoff != 1) {
2972 if (same_email_addresses($1, $author)) {
2976 my ($email_name, $email_comment, $email_address, $comment1) = parse_email($ctx);
2977 my ($author_name, $author_comment, $author_address, $comment2) = parse_email($author);
2979 if (lc $email_address eq lc $author_address && $email_name eq $author_name) {
2982 } elsif (lc $email_address eq lc $author_address) {
2985 } elsif ($email_name eq $author_name) {
2989 my $address1 = $email_address;
2990 my $address2 = $author_address;
2992 if ($address1 =~ /(\S+)\+\S+(\@.*)/) {
2995 if ($address2 =~ /(\S+)\+\S+(\@.*)/) {
2998 if ($address1 eq $address2) {
3006 # Check for patch separator
3007 if ($line =~ /^---$/) {
3008 $has_patch_separator = 1;
3012 # Check if MAINTAINERS is being updated. If so, there's probably no need to
3013 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
3014 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
3015 $reported_maintainer_file = 1;
3018 # Check signature styles
3019 if (!$in_header_lines &&
3020 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
3021 my $space_before = $1;
3023 my $space_after = $3;
3025 my $ucfirst_sign_off = ucfirst(lc($sign_off));
3027 if ($sign_off !~ /$signature_tags/) {
3028 my $suggested_signature = find_standard_signature($sign_off);
3029 if ($suggested_signature eq "") {
3030 WARN("BAD_SIGN_OFF",
3031 "Non-standard signature: $sign_off\n" . $herecurr);
3033 if (WARN("BAD_SIGN_OFF",
3034 "Non-standard signature: '$sign_off' - perhaps '$suggested_signature'?\n" . $herecurr) &&
3036 $fixed[$fixlinenr] =~ s/$sign_off/$suggested_signature/;
3040 if (defined $space_before && $space_before ne "") {
3041 if (WARN("BAD_SIGN_OFF",
3042 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
3044 $fixed[$fixlinenr] =
3045 "$ucfirst_sign_off $email";
3048 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
3049 if (WARN("BAD_SIGN_OFF",
3050 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
3052 $fixed[$fixlinenr] =
3053 "$ucfirst_sign_off $email";
3057 if (!defined $space_after || $space_after ne " ") {
3058 if (WARN("BAD_SIGN_OFF",
3059 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
3061 $fixed[$fixlinenr] =
3062 "$ucfirst_sign_off $email";
3066 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
3067 my $suggested_email = format_email(($email_name, $name_comment, $email_address, $comment));
3068 if ($suggested_email eq "") {
3069 ERROR("BAD_SIGN_OFF",
3070 "Unrecognized email address: '$email'\n" . $herecurr);
3072 my $dequoted = $suggested_email;
3073 $dequoted =~ s/^"//;
3074 $dequoted =~ s/" </ </;
3075 # Don't force email to have quotes
3076 # Allow just an angle bracketed address
3077 if (!same_email_addresses($email, $suggested_email)) {
3078 if (WARN("BAD_SIGN_OFF",
3079 "email address '$email' might be better as '$suggested_email'\n" . $herecurr) &&
3081 $fixed[$fixlinenr] =~ s/\Q$email\E/$suggested_email/;
3085 # Address part shouldn't have comments
3086 my $stripped_address = $email_address;
3087 $stripped_address =~ s/\([^\(\)]*\)//g;
3088 if ($email_address ne $stripped_address) {
3089 if (WARN("BAD_SIGN_OFF",
3090 "address part of email should not have comments: '$email_address'\n" . $herecurr) &&
3092 $fixed[$fixlinenr] =~ s/\Q$email_address\E/$stripped_address/;
3096 # Only one name comment should be allowed
3097 my $comment_count = () = $name_comment =~ /\([^\)]+\)/g;
3098 if ($comment_count > 1) {
3099 WARN("BAD_SIGN_OFF",
3100 "Use a single name comment in email: '$email'\n" . $herecurr);
3104 # stable@vger.kernel.org or stable@kernel.org shouldn't
3105 # have an email name. In addition comments should strictly
3107 if ($email =~ /^.*stable\@(?:vger\.)?kernel\.org/i) {
3108 if (($comment ne "" && $comment !~ /^#.+/) ||
3109 ($email_name ne "")) {
3110 my $cur_name = $email_name;
3111 my $new_comment = $comment;
3112 $cur_name =~ s/[a-zA-Z\s\-\"]+//g;
3114 # Remove brackets enclosing comment text
3115 # and # from start of comments to get comment text
3116 $new_comment =~ s/^\((.*)\)$/$1/;
3117 $new_comment =~ s/^\[(.*)\]$/$1/;
3118 $new_comment =~ s/^[\s\#]+|\s+$//g;
3120 $new_comment = trim("$new_comment $cur_name") if ($cur_name ne $new_comment);
3121 $new_comment = " # $new_comment" if ($new_comment ne "");
3122 my $new_email = "$email_address$new_comment";
3124 if (WARN("BAD_STABLE_ADDRESS_STYLE",
3125 "Invalid email format for stable: '$email', prefer '$new_email'\n" . $herecurr) &&
3127 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3130 } elsif ($comment ne "" && $comment !~ /^(?:#.+|\(.+\))$/) {
3131 my $new_comment = $comment;
3133 # Extract comment text from within brackets or
3134 # c89 style /*...*/ comments
3135 $new_comment =~ s/^\[(.*)\]$/$1/;
3136 $new_comment =~ s/^\/\*(.*)\*\/$/$1/;
3138 $new_comment = trim($new_comment);
3139 $new_comment =~ s/^[^\w]$//; # Single lettered comment with non word character is usually a typo
3140 $new_comment = "($new_comment)" if ($new_comment ne "");
3141 my $new_email = format_email($email_name, $name_comment, $email_address, $new_comment);
3143 if (WARN("BAD_SIGN_OFF",
3144 "Unexpected content after email: '$email', should be: '$new_email'\n" . $herecurr) &&
3146 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3151 # Check for duplicate signatures
3152 my $sig_nospace = $line;
3153 $sig_nospace =~ s/\s//g;
3154 $sig_nospace = lc($sig_nospace);
3155 if (defined $signatures{$sig_nospace}) {
3156 WARN("BAD_SIGN_OFF",
3157 "Duplicate signature\n" . $herecurr);
3159 $signatures{$sig_nospace} = 1;
3162 # Check Co-developed-by: immediately followed by Signed-off-by: with same name and email
3163 if ($sign_off =~ /^co-developed-by:$/i) {
3164 if ($email eq $author) {
3165 WARN("BAD_SIGN_OFF",
3166 "Co-developed-by: should not be used to attribute nominal patch author '$author'\n" . $herecurr);
3168 if (!defined $lines[$linenr]) {
3169 WARN("BAD_SIGN_OFF",
3170 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . $herecurr);
3171 } elsif ($rawlines[$linenr] !~ /^signed-off-by:\s*(.*)/i) {
3172 WARN("BAD_SIGN_OFF",
3173 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . $herecurr . $rawlines[$linenr] . "\n");
3174 } elsif ($1 ne $email) {
3175 WARN("BAD_SIGN_OFF",
3176 "Co-developed-by and Signed-off-by: name/email do not match\n" . $herecurr . $rawlines[$linenr] . "\n");
3180 # check if Reported-by: is followed by a Closes: tag
3181 if ($sign_off =~ /^reported(?:|-and-tested)-by:$/i) {
3182 if (!defined $lines[$linenr]) {
3183 WARN("BAD_REPORTED_BY_LINK",
3184 "Reported-by: should be immediately followed by Closes: with a URL to the report\n" . $herecurr . "\n");
3185 } elsif ($rawlines[$linenr] !~ /^closes:\s*/i) {
3186 WARN("BAD_REPORTED_BY_LINK",
3187 "Reported-by: should be immediately followed by Closes: with a URL to the report\n" . $herecurr . $rawlines[$linenr] . "\n");
3193 # Check Fixes: styles is correct
3194 if (!$in_header_lines &&
3195 $line =~ /^\s*fixes:?\s*(?:commit\s*)?[0-9a-f]{5,}\b/i) {
3196 my $orig_commit = "";
3197 my $id = "0123456789ab";
3198 my $title = "commit title";
3203 my $title_has_quotes = 0;
3205 if ($line =~ /(\s*fixes:?)\s+([0-9a-f]{5,})\s+($balanced_parens)/i) {
3210 $tag_case = 0 if $tag eq "Fixes:";
3211 $tag_space = 0 if ($line =~ /^fixes:? [0-9a-f]{5,} ($balanced_parens)/i);
3213 $id_length = 0 if ($orig_commit =~ /^[0-9a-f]{12}$/i);
3214 $id_case = 0 if ($orig_commit !~ /[A-F]/);
3216 # Always strip leading/trailing parens then double quotes if existing
3217 $title = substr($title, 1, -1);
3218 if ($title =~ /^".*"$/) {
3219 $title = substr($title, 1, -1);
3220 $title_has_quotes = 1;
3224 my ($cid, $ctitle) = git_commit_info($orig_commit, $id,
3227 if ($ctitle ne $title || $tag_case || $tag_space ||
3228 $id_length || $id_case || !$title_has_quotes) {
3229 if (WARN("BAD_FIXES_TAG",
3230 "Please use correct Fixes: style 'Fixes: <12 chars of sha1> (\"<title line>\")' - ie: 'Fixes: $cid (\"$ctitle\")'\n" . $herecurr) &&
3232 $fixed[$fixlinenr] = "Fixes: $cid (\"$ctitle\")";
3237 # Check email subject for common tools that don't need to be mentioned
3238 if ($in_header_lines &&
3239 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
3240 WARN("EMAIL_SUBJECT",
3241 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
3244 # Check for Gerrit Change-Ids not in any patch context
3245 if ($realfile eq '' && !$has_patch_separator && $line =~ /^\s*change-id:/i) {
3246 if (ERROR("GERRIT_CHANGE_ID",
3247 "Remove Gerrit Change-Id's before submitting upstream\n" . $herecurr) &&
3249 fix_delete_line($fixlinenr, $rawline);
3253 # Check if the commit log is in a possible stack dump
3254 if ($in_commit_log && !$commit_log_possible_stack_dump &&
3255 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
3256 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
3258 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/) ||
3259 $line =~ /^(?:\s+\w+:\s+[0-9a-fA-F]+){3,3}/ ||
3260 $line =~ /^\s*\#\d+\s*\[[0-9a-fA-F]+\]\s*\w+ at [0-9a-fA-F]+/) {
3261 # stack dump address styles
3262 $commit_log_possible_stack_dump = 1;
3265 # Check for line lengths > 75 in commit log, warn once
3266 if ($in_commit_log && !$commit_log_long_line &&
3267 length($line) > 75 &&
3268 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
3269 # file delta changes
3270 $line =~ /^\s*(?:[\w\.\-\+]*\/)++[\w\.\-\+]+:/ ||
3272 $line =~ /^\s*(?:Fixes:|$link_tags_search|$signature_tags)/i ||
3273 # A Fixes:, link or signature tag line
3274 $commit_log_possible_stack_dump)) {
3275 WARN("COMMIT_LOG_LONG_LINE",
3276 "Prefer a maximum 75 chars per line (possible unwrapped commit description?)\n" . $herecurr);
3277 $commit_log_long_line = 1;
3280 # Reset possible stack dump if a blank line is found
3281 if ($in_commit_log && $commit_log_possible_stack_dump &&
3283 $commit_log_possible_stack_dump = 0;
3286 # Check for odd tags before a URI/URL
3287 if ($in_commit_log &&
3288 $line =~ /^\s*(\w+:)\s*http/ && $1 !~ /^$link_tags_search$/) {
3289 if ($1 =~ /^v(?:ersion)?\d+/i) {
3290 WARN("COMMIT_LOG_VERSIONING",
3291 "Patch version information should be after the --- line\n" . $herecurr);
3293 WARN("COMMIT_LOG_USE_LINK",
3294 "Unknown link reference '$1', use $link_tags_print instead\n" . $herecurr);
3298 # Check for misuse of the link tags
3299 if ($in_commit_log &&
3300 $line =~ /^\s*(\w+:)\s*(\S+)/) {
3303 if ($tag =~ /^$link_tags_search$/ && $value !~ m{^https?://}) {
3304 WARN("COMMIT_LOG_WRONG_LINK",
3305 "'$tag' should be followed by a public http(s) link\n" . $herecurr);
3309 # Check for lines starting with a #
3310 if ($in_commit_log && $line =~ /^#/) {
3311 if (WARN("COMMIT_COMMENT_SYMBOL",
3312 "Commit log lines starting with '#' are dropped by git as comments\n" . $herecurr) &&
3314 $fixed[$fixlinenr] =~ s/^/ /;
3318 # Check for git id commit length and improperly formed commit descriptions
3319 # A correctly formed commit description is:
3320 # commit <SHA-1 hash length 12+ chars> ("Complete commit subject")
3321 # with the commit subject '("' prefix and '")' suffix
3322 # This is a fairly compilicated block as it tests for what appears to be
3323 # bare SHA-1 hash with minimum length of 5. It also avoids several types of
3324 # possible SHA-1 matches.
3325 # A commit match can span multiple lines so this block attempts to find a
3326 # complete typical commit on a maximum of 3 lines
3327 if ($perl_version_ok &&
3328 $in_commit_log && !$commit_log_possible_stack_dump &&
3329 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink|base-commit):/i &&
3330 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
3331 (($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
3332 ($line =~ /\bcommit\s*$/i && defined($rawlines[$linenr]) && $rawlines[$linenr] =~ /^\s*[0-9a-f]{5,}\b/i)) ||
3333 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
3334 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
3335 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
3336 my $init_char = "c";
3337 my $orig_commit = "";
3342 my $id = '0123456789ab';
3343 my $orig_desc = "commit description";
3344 my $description = "";
3345 my $herectx = $herecurr;
3350 if ($line =~ /(?:\bcommit\s+[0-9a-f]{5,}|\bcommit\s*$)/i) {
3351 for (my $n = 0; $n < 2; $n++) {
3352 if ($input =~ /\bcommit\s+[0-9a-f]{5,}\s*($balanced_parens)/i) {
3355 # Always strip leading/trailing parens then double quotes if existing
3356 $orig_desc = substr($orig_desc, 1, -1);
3357 if ($orig_desc =~ /^".*"$/) {
3358 $orig_desc = substr($orig_desc, 1, -1);
3363 last if ($#lines < $linenr + $n);
3364 $input .= " " . trim($rawlines[$linenr + $n]);
3365 $herectx .= "$rawlines[$linenr + $n]\n";
3367 $herectx = $herecurr if (!$has_parens);
3370 if ($input =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
3372 $orig_commit = lc($2);
3373 $short = 0 if ($input =~ /\bcommit\s+[0-9a-f]{12,40}/i);
3374 $long = 1 if ($input =~ /\bcommit\s+[0-9a-f]{41,}/i);
3375 $space = 0 if ($input =~ /\bcommit [0-9a-f]/i);
3376 $case = 0 if ($input =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
3377 } elsif ($input =~ /\b([0-9a-f]{12,40})\b/i) {
3378 $orig_commit = lc($1);
3381 ($id, $description) = git_commit_info($orig_commit,
3385 ($short || $long || $space || $case || ($orig_desc ne $description) || !$has_quotes) &&
3386 $last_git_commit_id_linenr != $linenr - 1) {
3387 ERROR("GIT_COMMIT_ID",
3388 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herectx);
3390 #don't report the next line if this line ends in commit and the sha1 hash is the next line
3391 $last_git_commit_id_linenr = $linenr if ($line =~ /\bcommit\s*$/i);
3394 # Check for mailing list archives other than lore.kernel.org
3395 if ($rawline =~ m{http.*\b$obsolete_archives}) {
3396 WARN("PREFER_LORE_ARCHIVE",
3397 "Use lore.kernel.org archive links when possible - see https://lore.kernel.org/lists.html\n" . $herecurr);
3400 # Check for added, moved or deleted files
3401 if (!$reported_maintainer_file && !$in_commit_log &&
3402 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
3403 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
3404 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
3405 (defined($1) || defined($2))))) {
3407 $reported_maintainer_file = 1;
3408 WARN("FILE_PATH_CHANGES",
3409 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
3412 # Check for adding new DT bindings not in schema format
3413 if (!$in_commit_log &&
3414 ($line =~ /^new file mode\s*\d+\s*$/) &&
3415 ($realfile =~ m@^Documentation/devicetree/bindings/.*\.txt$@)) {
3416 WARN("DT_SCHEMA_BINDING_PATCH",
3417 "DT bindings should be in DT schema format. See: Documentation/devicetree/bindings/writing-schema.rst\n");
3420 # Check for wrappage within a valid hunk of the file
3421 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
3422 ERROR("CORRUPTED_PATCH",
3423 "patch seems to be corrupt (line wrapped?)\n" .
3424 $herecurr) if (!$emitted_corrupt++);
3427 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
3428 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
3429 $rawline !~ m/^$UTF8*$/) {
3430 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
3432 my $blank = copy_spacing($rawline);
3433 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
3434 my $hereptr = "$hereline$ptr\n";
3437 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
3440 # Check if it's the start of a commit log
3441 # (not a header line and we haven't seen the patch filename)
3442 if ($in_header_lines && $realfile =~ /^$/ &&
3443 !($rawline =~ /^\s+(?:\S|$)/ ||
3444 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
3445 $in_header_lines = 0;
3447 $has_commit_log = 1;
3450 # Check if there is UTF-8 in a commit log when a mail header has explicitly
3451 # declined it, i.e defined some charset where it is missing.
3452 if ($in_header_lines &&
3453 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
3455 $non_utf8_charset = 1;
3458 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
3459 $rawline =~ /$NON_ASCII_UTF8/) {
3460 WARN("UTF8_BEFORE_PATCH",
3461 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
3464 # Check for absolute kernel paths in commit message
3465 if ($tree && $in_commit_log) {
3466 while ($line =~ m{(?:^|\s)(/\S*)}g) {
3469 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
3470 check_absolute_file($1, $herecurr)) {
3473 check_absolute_file($file, $herecurr);
3478 # Check for various typo / spelling mistakes
3479 if (defined($misspellings) &&
3480 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
3481 while ($rawline =~ /(?:^|[^\w\-'`])($misspellings)(?:[^\w\-'`]|$)/gi) {
3483 my $blank = copy_spacing($rawline);
3484 my $ptr = substr($blank, 0, $-[1]) . "^" x length($typo);
3485 my $hereptr = "$hereline$ptr\n";
3486 my $typo_fix = $spelling_fix{lc($typo)};
3487 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
3488 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
3489 my $msg_level = \&WARN;
3490 $msg_level = \&CHK if ($file);
3491 if (&{$msg_level}("TYPO_SPELLING",
3492 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $hereptr) &&
3494 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
3499 # check for invalid commit id
3500 if ($in_commit_log && $line =~ /(^fixes:|\bcommit)\s+([0-9a-f]{6,40})\b/i) {
3503 ($id, $description) = git_commit_info($2, undef, undef);
3504 if (!defined($id)) {
3505 WARN("UNKNOWN_COMMIT_ID",
3506 "Unknown commit id '$2', maybe rebased or not pulled?\n" . $herecurr);
3510 # check for repeated words separated by a single space
3511 # avoid false positive from list command eg, '-rw-r--r-- 1 root root'
3512 if (($rawline =~ /^\+/ || $in_commit_log) &&
3513 $rawline !~ /[bcCdDlMnpPs\?-][rwxsStT-]{9}/) {
3514 pos($rawline) = 1 if (!$in_commit_log);
3515 while ($rawline =~ /\b($word_pattern) (?=($word_pattern))/g) {
3519 my $start_pos = $-[1];
3520 my $end_pos = $+[2];
3521 if ($first =~ /(?:struct|union|enum)/) {
3522 pos($rawline) += length($first) + length($second) + 1;
3526 next if (lc($first) ne lc($second));
3527 next if ($first eq 'long');
3529 # check for character before and after the word matches
3530 my $start_char = '';
3532 $start_char = substr($rawline, $start_pos - 1, 1) if ($start_pos > ($in_commit_log ? 0 : 1));
3533 $end_char = substr($rawline, $end_pos, 1) if ($end_pos < length($rawline));
3535 next if ($start_char =~ /^\S$/);
3536 next if (index(" \t.,;?!", $end_char) == -1);
3538 # avoid repeating hex occurrences like 'ff ff fe 09 ...'
3539 if ($first =~ /\b[0-9a-f]{2,}\b/i) {
3540 next if (!exists($allow_repeated_words{lc($first)}));
3543 if (WARN("REPEATED_WORD",
3544 "Possible repeated word: '$first'\n" . $herecurr) &&
3546 $fixed[$fixlinenr] =~ s/\b$first $second\b/$first/;
3550 # if it's a repeated word on consecutive lines in a comment block
3551 if ($prevline =~ /$;+\s*$/ &&
3552 $prevrawline =~ /($word_pattern)\s*$/) {
3554 if ($rawline =~ /^\+\s*\*\s*$last_word /) {
3555 if (WARN("REPEATED_WORD",
3556 "Possible repeated word: '$last_word'\n" . $hereprev) &&
3558 $fixed[$fixlinenr] =~ s/(\+\s*\*\s*)$last_word /$1/;
3564 # ignore non-hunk lines and lines being removed
3565 next if (!$hunk_line || $line =~ /^-/);
3567 #trailing whitespace
3568 if ($line =~ /^\+.*\015/) {
3569 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3570 if (ERROR("DOS_LINE_ENDINGS",
3571 "DOS line endings\n" . $herevet) &&
3573 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
3575 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
3576 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3577 if (ERROR("TRAILING_WHITESPACE",
3578 "trailing whitespace\n" . $herevet) &&
3580 $fixed[$fixlinenr] =~ s/\s+$//;
3586 # Check for FSF mailing addresses.
3587 if ($rawline =~ /\bwrite to the Free/i ||
3588 $rawline =~ /\b675\s+Mass\s+Ave/i ||
3589 $rawline =~ /\b59\s+Temple\s+Pl/i ||
3590 $rawline =~ /\b51\s+Franklin\s+St/i) {
3591 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3592 my $msg_level = \&ERROR;
3593 $msg_level = \&CHK if ($file);
3594 &{$msg_level}("FSF_MAILING_ADDRESS",
3595 "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)
3598 # check for Kconfig help text having a real description
3599 # Only applies when adding the entry originally, after that we do not have
3600 # sufficient context to determine whether it is indeed long enough.
3601 if ($realfile =~ /Kconfig/ &&
3602 # 'choice' is usually the last thing on the line (though
3603 # Kconfig supports named choices), so use a word boundary
3604 # (\b) rather than a whitespace character (\s)
3605 $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
3609 my $help_length = 0;
3610 while (defined $lines[$ln]) {
3611 my $f = $lines[$ln++];
3613 next if ($f =~ /^-/);
3614 last if ($f !~ /^[\+ ]/); # !patch context
3616 if ($f =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
3620 if ($f =~ /^\+\s*help\s*$/) {
3625 $f =~ s/^.//; # strip patch context [+ ]
3626 $f =~ s/#.*//; # strip # directives
3627 $f =~ s/^\s+//; # strip leading blanks
3628 next if ($f =~ /^$/); # skip blank lines
3630 # At the end of this Kconfig block:
3631 # This only checks context lines in the patch
3632 # and so hopefully shouldn't trigger false
3633 # positives, even though some of these are
3634 # common words in help texts
3635 if ($f =~ /^(?:config|menuconfig|choice|endchoice|
3636 if|endif|menu|endmenu|source)\b/x) {
3639 $help_length++ if ($has_help);
3642 $help_length < $min_conf_desc_length) {
3643 my $stat_real = get_stat_real($linenr, $ln - 1);
3644 WARN("CONFIG_DESCRIPTION",
3645 "please write a help paragraph that fully describes the config symbol\n" . "$here\n$stat_real\n");
3649 # check MAINTAINERS entries
3650 if ($realfile =~ /^MAINTAINERS$/) {
3651 # check MAINTAINERS entries for the right form
3652 if ($rawline =~ /^\+[A-Z]:/ &&
3653 $rawline !~ /^\+[A-Z]:\t\S/) {
3654 if (WARN("MAINTAINERS_STYLE",
3655 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
3657 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
3660 # check MAINTAINERS entries for the right ordering too
3661 my $preferred_order = 'MRLSWQBCPTFXNK';
3662 if ($rawline =~ /^\+[A-Z]:/ &&
3663 $prevrawline =~ /^[\+ ][A-Z]:/) {
3664 $rawline =~ /^\+([A-Z]):\s*(.*)/;
3667 $prevrawline =~ /^[\+ ]([A-Z]):\s*(.*)/;
3670 my $curindex = index($preferred_order, $cur);
3671 my $previndex = index($preferred_order, $prev);
3672 if ($curindex < 0) {
3673 WARN("MAINTAINERS_STYLE",
3674 "Unknown MAINTAINERS entry type: '$cur'\n" . $herecurr);
3676 if ($previndex >= 0 && $curindex < $previndex) {
3677 WARN("MAINTAINERS_STYLE",
3678 "Misordered MAINTAINERS entry - list '$cur:' before '$prev:'\n" . $hereprev);
3679 } elsif ((($prev eq 'F' && $cur eq 'F') ||
3680 ($prev eq 'X' && $cur eq 'X')) &&
3681 ($prevval cmp $curval) > 0) {
3682 WARN("MAINTAINERS_STYLE",
3683 "Misordered MAINTAINERS entry - list file patterns in alphabetic order\n" . $hereprev);
3689 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
3690 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
3693 'EXTRA_AFLAGS' => 'asflags-y',
3694 'EXTRA_CFLAGS' => 'ccflags-y',
3695 'EXTRA_CPPFLAGS' => 'cppflags-y',
3696 'EXTRA_LDFLAGS' => 'ldflags-y',
3699 WARN("DEPRECATED_VARIABLE",
3700 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
3703 # check for DT compatible documentation
3704 if (defined $root &&
3705 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
3706 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
3708 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
3710 my $dt_path = $root . "/Documentation/devicetree/bindings/";
3711 my $vp_file = $dt_path . "vendor-prefixes.yaml";
3713 foreach my $compat (@compats) {
3714 my $compat2 = $compat;
3715 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
3716 my $compat3 = $compat;
3717 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
3718 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
3720 WARN("UNDOCUMENTED_DT_STRING",
3721 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
3724 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
3726 `grep -Eq "\\"\\^\Q$vendor\E,\\.\\*\\":" $vp_file`;
3728 WARN("UNDOCUMENTED_DT_STRING",
3729 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
3734 # check for using SPDX license tag at beginning of files
3735 if ($realline == $checklicenseline) {
3736 if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
3737 $checklicenseline = 2;
3738 } elsif ($rawline =~ /^\+/) {
3740 if ($realfile =~ /\.(h|s|S)$/) {
3742 } elsif ($realfile =~ /\.(c|rs|dts|dtsi)$/) {
3744 } elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc|yaml)$/) {
3746 } elsif ($realfile =~ /\.rst$/) {
3750 # check SPDX comment style for .[chsS] files
3751 if ($realfile =~ /\.[chsS]$/ &&
3752 $rawline =~ /SPDX-License-Identifier:/ &&
3753 $rawline !~ m@^\+\s*\Q$comment\E\s*@) {
3754 WARN("SPDX_LICENSE_TAG",
3755 "Improper SPDX comment style for '$realfile', please use '$comment' instead\n" . $herecurr);
3758 if ($comment !~ /^$/ &&
3759 $rawline !~ m@^\+\Q$comment\E SPDX-License-Identifier: @) {
3760 WARN("SPDX_LICENSE_TAG",
3761 "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
3762 } elsif ($rawline =~ /(SPDX-License-Identifier: .*)/) {
3763 my $spdx_license = $1;
3764 if (!is_SPDX_License_valid($spdx_license)) {
3765 WARN("SPDX_LICENSE_TAG",
3766 "'$spdx_license' is not supported in LICENSES/...\n" . $herecurr);
3768 if ($realfile =~ m@^Documentation/devicetree/bindings/@ &&
3769 $spdx_license !~ /GPL-2\.0(?:-only)? OR BSD-2-Clause/) {
3770 my $msg_level = \&WARN;
3771 $msg_level = \&CHK if ($file);
3772 if (&{$msg_level}("SPDX_LICENSE_TAG",
3774 "DT binding documents should be licensed (GPL-2.0-only OR BSD-2-Clause)\n" . $herecurr) &&
3776 $fixed[$fixlinenr] =~ s/SPDX-License-Identifier: .*/SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)/;
3779 if ($realfile =~ m@^include/dt-bindings/@ &&
3780 $spdx_license !~ /GPL-2\.0(?:-only)? OR \S+/) {
3781 WARN("SPDX_LICENSE_TAG",
3782 "DT binding headers should be licensed (GPL-2.0-only OR .*)\n" . $herecurr);
3788 # check for embedded filenames
3789 if ($rawline =~ /^\+.*\b\Q$realfile\E\b/) {
3790 WARN("EMBEDDED_FILENAME",
3791 "It's generally not useful to have the filename in the file\n" . $herecurr);
3794 # check we are in a valid source file if not then ignore this hunk
3795 next if ($realfile !~ /\.(h|c|rs|s|S|sh|dtsi|dts)$/);
3797 # check for using SPDX-License-Identifier on the wrong line number
3798 if ($realline != $checklicenseline &&
3799 $rawline =~ /\bSPDX-License-Identifier:/ &&
3800 substr($line, @-, @+ - @-) eq "$;" x (@+ - @-)) {
3801 WARN("SPDX_LICENSE_TAG",
3802 "Misplaced SPDX-License-Identifier tag - use line $checklicenseline instead\n" . $herecurr);
3805 # line length limit (with some exclusions)
3807 # There are a few types of lines that may extend beyond $max_line_length:
3808 # logging functions like pr_info that end in a string
3809 # lines with a single string
3810 # #defines that are a single string
3811 # lines with an RFC3986 like URL
3813 # There are 3 different line length message types:
3814 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
3815 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
3816 # LONG_LINE all other lines longer than $max_line_length
3818 # if LONG_LINE is ignored, the other 2 types are also ignored
3821 if ($line =~ /^\+/ && $length > $max_line_length) {
3822 my $msg_type = "LONG_LINE";
3824 # Check the allowed long line types first
3826 # logging functions that end in a string that starts
3827 # before $max_line_length
3828 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
3829 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3832 # lines with only strings (w/ possible termination)
3833 # #defines with only strings
3834 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
3835 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
3838 # More special cases
3839 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3840 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3843 # URL ($rawline is used in case the URL is in a comment)
3844 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
3847 # Otherwise set the alternate message types
3849 # a comment starts before $max_line_length
3850 } elsif ($line =~ /($;[\s$;]*)$/ &&
3851 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3852 $msg_type = "LONG_LINE_COMMENT"
3854 # a quoted string starts before $max_line_length
3855 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3856 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3857 $msg_type = "LONG_LINE_STRING"
3860 if ($msg_type ne "" &&
3861 (show_type("LONG_LINE") || show_type($msg_type))) {
3862 my $msg_level = \&WARN;
3863 $msg_level = \&CHK if ($file);
3864 &{$msg_level}($msg_type,
3865 "line length of $length exceeds $max_line_length columns\n" . $herecurr);
3869 # check for adding lines without a newline.
3870 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3871 if (WARN("MISSING_EOF_NEWLINE",
3872 "adding a line without newline at end of file\n" . $herecurr) &&
3874 fix_delete_line($fixlinenr+1, "No newline at end of file");
3878 # check for .L prefix local symbols in .S files
3879 if ($realfile =~ /\.S$/ &&
3880 $line =~ /^\+\s*(?:[A-Z]+_)?SYM_[A-Z]+_(?:START|END)(?:_[A-Z_]+)?\s*\(\s*\.L/) {
3881 WARN("AVOID_L_PREFIX",
3882 "Avoid using '.L' prefixed local symbol names for denoting a range of code via 'SYM_*_START/END' annotations; see Documentation/core-api/asm-annotations.rst\n" . $herecurr);
3885 # check we are in a valid source file C or perl if not then ignore this hunk
3886 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3888 # at the beginning of a line any tabs must come first and anything
3889 # more than $tabsize must use tabs.
3890 if ($rawline =~ /^\+\s* \t\s*\S/ ||
3891 $rawline =~ /^\+\s* \s*/) {
3892 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3894 if (ERROR("CODE_INDENT",
3895 "code indent should use tabs where possible\n" . $herevet) &&
3897 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3901 # check for space before tabs.
3902 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3903 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3904 if (WARN("SPACE_BEFORE_TAB",
3905 "please, no space before tabs\n" . $herevet) &&
3907 while ($fixed[$fixlinenr] =~
3908 s/(^\+.*) {$tabsize,$tabsize}\t/$1\t\t/) {}
3909 while ($fixed[$fixlinenr] =~
3910 s/(^\+.*) +\t/$1\t/) {}
3914 # check for assignments on the start of a line
3915 if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3917 if (CHK("ASSIGNMENT_CONTINUATIONS",
3918 "Assignment operator '$1' should be on the previous line\n" . $hereprev) &&
3919 $fix && $prevrawline =~ /^\+/) {
3920 # add assignment operator to the previous line, remove from current line
3921 $fixed[$fixlinenr - 1] .= " $operator";
3922 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3926 # check for && or || at the start of a line
3927 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3929 if (CHK("LOGICAL_CONTINUATIONS",
3930 "Logical continuations should be on the previous line\n" . $hereprev) &&
3931 $fix && $prevrawline =~ /^\+/) {
3932 # insert logical operator at last non-comment, non-whitepsace char on previous line
3933 $prevline =~ /[\s$;]*$/;
3934 my $line_end = substr($prevrawline, $-[0]);
3935 $fixed[$fixlinenr - 1] =~ s/\Q$line_end\E$/ $operator$line_end/;
3936 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3940 # check indentation starts on a tab stop
3941 if ($perl_version_ok &&
3942 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3943 my $indent = length($1);
3944 if ($indent % $tabsize) {
3946 "Statements should start on a tabstop\n" . $herecurr) &&
3948 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/$tabsize)@e;
3953 # check multi-line statement indentation matches previous line
3954 if ($perl_version_ok &&
3955 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3956 $prevline =~ /^\+(\t*)(.*)$/;
3960 my $pos = pos_last_openparen($rest);
3962 $line =~ /^(\+| )([ \t]*)/;
3965 my $goodtabindent = $oldindent .
3966 "\t" x ($pos / $tabsize) .
3967 " " x ($pos % $tabsize);
3968 my $goodspaceindent = $oldindent . " " x $pos;
3970 if ($newindent ne $goodtabindent &&
3971 $newindent ne $goodspaceindent) {
3973 if (CHK("PARENTHESIS_ALIGNMENT",
3974 "Alignment should match open parenthesis\n" . $hereprev) &&
3975 $fix && $line =~ /^\+/) {
3976 $fixed[$fixlinenr] =~
3977 s/^\+[ \t]*/\+$goodtabindent/;
3983 # check for space after cast like "(int) foo" or "(struct foo) bar"
3984 # avoid checking a few false positives:
3985 # "sizeof(<type>)" or "__alignof__(<type>)"
3986 # function pointer declarations like "(*foo)(int) = bar;"
3987 # structure definitions like "(struct foo) { 0 };"
3988 # multiline macros that define functions
3989 # known attributes or the __attribute__ keyword
3990 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3991 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3993 "No space is necessary after a cast\n" . $herecurr) &&
3995 $fixed[$fixlinenr] =~
3996 s/(\(\s*$Type\s*\))[ \t]+/$1/;
4000 # Block comment styles
4001 # Networking with an initial /*
4002 if ($realfile =~ m@^(drivers/net/|net/)@ &&
4003 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
4004 $rawline =~ /^\+[ \t]*\*/ &&
4005 $realline > 3) { # Do not warn about the initial copyright comment block after SPDX-License-Identifier
4006 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
4007 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
4010 # Block comments use * on subsequent lines
4011 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
4012 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
4013 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
4014 $rawline =~ /^\+/ && #line is new
4015 $rawline !~ /^\+[ \t]*\*/) { #no leading *
4016 WARN("BLOCK_COMMENT_STYLE",
4017 "Block comments use * on subsequent lines\n" . $hereprev);
4020 # Block comments use */ on trailing lines
4021 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
4022 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
4023 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
4024 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
4025 WARN("BLOCK_COMMENT_STYLE",
4026 "Block comments use a trailing */ on a separate line\n" . $herecurr);
4029 # Block comment * alignment
4030 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
4031 $line =~ /^\+[ \t]*$;/ && #leading comment
4032 $rawline =~ /^\+[ \t]*\*/ && #leading *
4033 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
4034 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
4035 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
4037 $prevrawline =~ m@^\+([ \t]*/?)\*@;
4039 $oldindent = expand_tabs($1);
4041 $prevrawline =~ m@^\+(.*/?)\*@;
4042 $oldindent = expand_tabs($1);
4044 $rawline =~ m@^\+([ \t]*)\*@;
4046 $newindent = expand_tabs($newindent);
4047 if (length($oldindent) ne length($newindent)) {
4048 WARN("BLOCK_COMMENT_STYLE",
4049 "Block comments should align the * on each line\n" . $hereprev);
4053 # check for missing blank lines after struct/union declarations
4054 # with exceptions for various attributes and macros
4055 if ($prevline =~ /^[\+ ]};?\s*$/ &&
4057 !($line =~ /^\+\s*$/ ||
4058 $line =~ /^\+\s*(?:EXPORT_SYMBOL|early_param|ALLOW_ERROR_INJECTION)/ ||
4059 $line =~ /^\+\s*MODULE_/i ||
4060 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
4061 $line =~ /^\+[a-z_]*init/ ||
4062 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
4063 $line =~ /^\+\s*DECLARE/ ||
4064 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
4065 $line =~ /^\+\s*__setup/)) {
4066 if (CHK("LINE_SPACING",
4067 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
4069 fix_insert_line($fixlinenr, "\+");
4073 # check for multiple consecutive blank lines
4074 if ($prevline =~ /^[\+ ]\s*$/ &&
4075 $line =~ /^\+\s*$/ &&
4076 $last_blank_line != ($linenr - 1)) {
4077 if (CHK("LINE_SPACING",
4078 "Please don't use multiple blank lines\n" . $hereprev) &&
4080 fix_delete_line($fixlinenr, $rawline);
4083 $last_blank_line = $linenr;
4086 # check for missing blank lines after declarations
4087 # (declarations must have the same indentation and not be at the start of line)
4088 if (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/) {
4092 # remove $Attribute/$Sparse uses to simplify comparisons
4093 $sl =~ s/\b(?:$Attribute|$Sparse)\b//g;
4094 $pl =~ s/\b(?:$Attribute|$Sparse)\b//g;
4095 if (($pl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
4096 # function pointer declarations
4097 $pl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
4098 # foo bar; where foo is some local typedef or #define
4099 $pl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
4100 # known declaration macros
4101 $pl =~ /^\+\s+$declaration_macros/) &&
4102 # for "else if" which can look like "$Ident $Ident"
4103 !($pl =~ /^\+\s+$c90_Keywords\b/ ||
4104 # other possible extensions of declaration lines
4105 $pl =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
4106 # not starting a section or a macro "\" extended line
4107 $pl =~ /(?:\{\s*|\\)$/) &&
4108 # looks like a declaration
4109 !($sl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
4110 # function pointer declarations
4111 $sl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
4112 # foo bar; where foo is some local typedef or #define
4113 $sl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
4114 # known declaration macros
4115 $sl =~ /^\+\s+$declaration_macros/ ||
4116 # start of struct or union or enum
4117 $sl =~ /^\+\s+(?:static\s+)?(?:const\s+)?(?:union|struct|enum|typedef)\b/ ||
4118 # start or end of block or continuation of declaration
4119 $sl =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
4120 # bitfield continuation
4121 $sl =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
4122 # other possible extensions of declaration lines
4123 $sl =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/)) {
4124 if (WARN("LINE_SPACING",
4125 "Missing a blank line after declarations\n" . $hereprev) &&
4127 fix_insert_line($fixlinenr, "\+");
4132 # check for spaces at the beginning of a line.
4134 # 1) within comments
4135 # 2) indented preprocessor commands
4137 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
4138 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
4139 if (WARN("LEADING_SPACE",
4140 "please, no spaces at the start of a line\n" . $herevet) &&
4142 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
4146 # check we are in a valid C source file if not then ignore this hunk
4147 next if ($realfile !~ /\.(h|c)$/);
4149 # check for unusual line ending [ or (
4150 if ($line =~ /^\+.*([\[\(])\s*$/) {
4151 CHK("OPEN_ENDED_LINE",
4152 "Lines should not end with a '$1'\n" . $herecurr);
4155 # check if this appears to be the start function declaration, save the name
4156 if ($sline =~ /^\+\{\s*$/ &&
4157 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
4158 $context_function = $1;
4161 # check if this appears to be the end of function declaration
4162 if ($sline =~ /^\+\}\s*$/) {
4163 undef $context_function;
4166 # check indentation of any line with a bare else
4167 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
4168 # if the previous line is a break or return and is indented 1 tab more...
4169 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
4170 my $tabs = length($1) + 1;
4171 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
4172 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
4173 defined $lines[$linenr] &&
4174 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
4175 WARN("UNNECESSARY_ELSE",
4176 "else is not generally useful after a break or return\n" . $hereprev);
4180 # check indentation of a line with a break;
4181 # if the previous line is a goto, return or break
4182 # and is indented the same # of tabs
4183 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
4185 if ($prevline =~ /^\+$tabs(goto|return|break)\b/) {
4186 if (WARN("UNNECESSARY_BREAK",
4187 "break is not useful after a $1\n" . $hereprev) &&
4189 fix_delete_line($fixlinenr, $rawline);
4194 # check for RCS/CVS revision markers
4195 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
4197 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
4200 # check for old HOTPLUG __dev<foo> section markings
4201 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
4202 WARN("HOTPLUG_SECTION",
4203 "Using $1 is unnecessary\n" . $herecurr);
4206 # Check for potential 'bare' types
4207 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
4209 #print "LINE<$line>\n";
4210 if ($linenr > $suppress_statement &&
4211 $realcnt && $sline =~ /.\s*\S/) {
4212 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4213 ctx_statement_block($linenr, $realcnt, 0);
4214 $stat =~ s/\n./\n /g;
4215 $cond =~ s/\n./\n /g;
4217 #print "linenr<$linenr> <$stat>\n";
4218 # If this statement has no statement boundaries within
4219 # it there is no point in retrying a statement scan
4220 # until we hit end of it.
4221 my $frag = $stat; $frag =~ s/;+\s*$//;
4222 if ($frag !~ /(?:{|;)/) {
4223 #print "skip<$line_nr_next>\n";
4224 $suppress_statement = $line_nr_next;
4227 # Find the real next line.
4228 $realline_next = $line_nr_next;
4229 if (defined $realline_next &&
4230 (!defined $lines[$realline_next - 1] ||
4231 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
4238 # Ignore goto labels.
4239 if ($s =~ /$Ident:\*$/s) {
4241 # Ignore functions being called
4242 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
4244 } elsif ($s =~ /^.\s*else\b/s) {
4246 # declarations always start with types
4247 } 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) {
4250 possible($type, "A:" . $s);
4252 # definitions in global scope can only start with types
4253 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
4254 possible($1, "B:" . $s);
4257 # any (foo ... *) is a pointer cast, and foo is a type
4258 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
4259 possible($1, "C:" . $s);
4262 # Check for any sort of function declaration.
4263 # int foo(something bar, other baz);
4264 # void (*store_gdt)(x86_descr_ptr *);
4265 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
4266 my ($name_len) = length($1);
4269 substr($ctx, 0, $name_len + 1, '');
4270 $ctx =~ s/\)[^\)]*$//;
4272 for my $arg (split(/\s*,\s*/, $ctx)) {
4273 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
4275 possible($1, "D:" . $s);
4283 # Checks which may be anchored in the context.
4286 # Check for switch () and associated case and default
4287 # statements should be at the same indent.
4288 if ($line=~/\bswitch\s*\(.*\)/) {
4291 my @ctx = ctx_block_outer($linenr, $realcnt);
4293 for my $ctx (@ctx) {
4294 my ($clen, $cindent) = line_stats($ctx);
4295 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
4296 $indent != $cindent) {
4297 $err .= "$sep$ctx\n";
4304 ERROR("SWITCH_CASE_INDENT_LEVEL",
4305 "switch and case should be at the same indent\n$hereline$err");
4309 # if/while/etc brace do not go on next line, unless defining a do while loop,
4310 # or if that brace on the next line is for something else
4311 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
4312 my $pre_ctx = "$1$2";
4314 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
4316 if ($line =~ /^\+\t{6,}/) {
4317 WARN("DEEP_INDENTATION",
4318 "Too many leading tabs - consider code refactoring\n" . $herecurr);
4321 my $ctx_cnt = $realcnt - $#ctx - 1;
4322 my $ctx = join("\n", @ctx);
4324 my $ctx_ln = $linenr;
4325 my $ctx_skip = $realcnt;
4327 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
4328 defined $lines[$ctx_ln - 1] &&
4329 $lines[$ctx_ln - 1] =~ /^-/)) {
4330 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
4331 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
4335 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
4336 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
4338 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
4340 "that open brace { should be on the previous line\n" .
4341 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4343 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
4344 $ctx =~ /\)\s*\;\s*$/ &&
4345 defined $lines[$ctx_ln - 1])
4347 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
4348 if ($nindent > $indent) {
4349 WARN("TRAILING_SEMICOLON",
4350 "trailing semicolon indicates no statements, indent implies otherwise\n" .
4351 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4356 # Check relative indent for conditionals and blocks.
4357 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
4358 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4359 ctx_statement_block($linenr, $realcnt, 0)
4360 if (!defined $stat);
4361 my ($s, $c) = ($stat, $cond);
4363 substr($s, 0, length($c), '');
4365 # remove inline comments
4369 # Find out how long the conditional actually is.
4370 my @newlines = ($c =~ /\n/gs);
4371 my $cond_lines = 1 + $#newlines;
4373 # Make sure we remove the line prefixes as we have
4374 # none on the first line, and are going to readd them
4377 while ($s =~ /\n\s+\\\n/) {
4378 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
4381 # We want to check the first line inside the block
4382 # starting at the end of the conditional, so remove:
4383 # 1) any blank line termination
4384 # 2) any opening brace { on end of the line
4386 my $continuation = 0;
4388 $s =~ s/^.*\bdo\b//;
4390 if ($s =~ s/^\s*\\//) {
4393 if ($s =~ s/^\s*?\n//) {
4398 # Also ignore a loop construct at the end of a
4399 # preprocessor statement.
4400 if (($prevline =~ /^.\s*#\s*define\s/ ||
4401 $prevline =~ /\\\s*$/) && $continuation == 0) {
4407 while ($cond_ptr != $cond_lines) {
4408 $cond_ptr = $cond_lines;
4410 # If we see an #else/#elif then the code
4412 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
4417 # 1) blank lines, they should be at 0,
4418 # 2) preprocessor lines, and
4420 if ($continuation ||
4422 $s =~ /^\s*#\s*?/ ||
4423 $s =~ /^\s*$Ident\s*:/) {
4424 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
4425 if ($s =~ s/^.*?\n//) {
4431 my (undef, $sindent) = line_stats("+" . $s);
4432 my $stat_real = raw_line($linenr, $cond_lines);
4434 # Check if either of these lines are modified, else
4435 # this is not this patch's fault.
4436 if (!defined($stat_real) ||
4437 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
4440 if (defined($stat_real) && $cond_lines > 1) {
4441 $stat_real = "[...]\n$stat_real";
4444 #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";
4446 if ($check && $s ne '' &&
4447 (($sindent % $tabsize) != 0 ||
4448 ($sindent < $indent) ||
4449 ($sindent == $indent &&
4450 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
4451 ($sindent > $indent + $tabsize))) {
4452 WARN("SUSPECT_CODE_INDENT",
4453 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
4457 # Track the 'values' across context and added lines.
4458 my $opline = $line; $opline =~ s/^./ /;
4459 my ($curr_values, $curr_vars) =
4460 annotate_values($opline . "\n", $prev_values);
4461 $curr_values = $prev_values . $curr_values;
4463 my $outline = $opline; $outline =~ s/\t/ /g;
4464 print "$linenr > .$outline\n";
4465 print "$linenr > $curr_values\n";
4466 print "$linenr > $curr_vars\n";
4468 $prev_values = substr($curr_values, -1);
4470 #ignore lines not being added
4471 next if ($line =~ /^[^\+]/);
4473 # check for self assignments used to avoid compiler warnings
4474 # e.g.: int foo = foo, *bar = NULL;
4475 # struct foo bar = *(&(bar));
4476 if ($line =~ /^\+\s*(?:$Declare)?([A-Za-z_][A-Za-z\d_]*)\s*=/) {
4478 if ($line =~ /^\+\s*(?:$Declare)?$var\s*=\s*(?:$var|\*\s*\(?\s*&\s*\(?\s*$var\s*\)?\s*\)?)\s*[;,]/) {
4479 WARN("SELF_ASSIGNMENT",
4480 "Do not use self-assignments to avoid compiler warnings\n" . $herecurr);
4484 # check for dereferences that span multiple lines
4485 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
4486 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
4487 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
4489 $line =~ /^.\s*($Lval)/;
4492 WARN("MULTILINE_DEREFERENCE",
4493 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
4496 # check for declarations of signed or unsigned without int
4497 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
4500 $var = "" if (!defined $var);
4501 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
4505 $pointer = "" if (!defined $pointer);
4507 if (WARN("UNSPECIFIED_INT",
4508 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
4510 my $decl = trim($sign) . " int ";
4511 my $comp_pointer = $pointer;
4512 $comp_pointer =~ s/\s//g;
4513 $decl .= $comp_pointer;
4514 $decl = rtrim($decl) if ($var eq "");
4515 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
4520 # TEST: allow direct testing of the type matcher.
4522 if ($line =~ /^.\s*$Declare\s*$/) {
4524 "TEST: is type\n" . $herecurr);
4525 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
4526 ERROR("TEST_NOT_TYPE",
4527 "TEST: is not type ($1 is)\n". $herecurr);
4531 # TEST: allow direct testing of the attribute matcher.
4533 if ($line =~ /^.\s*$Modifier\s*$/) {
4535 "TEST: is attr\n" . $herecurr);
4536 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
4537 ERROR("TEST_NOT_ATTR",
4538 "TEST: is not attr ($1 is)\n". $herecurr);
4543 # check for initialisation to aggregates open brace on the next line
4544 if ($line =~ /^.\s*{/ &&
4545 $prevline =~ /(?:^|[^=])=\s*$/) {
4546 if (ERROR("OPEN_BRACE",
4547 "that open brace { should be on the previous line\n" . $hereprev) &&
4548 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4549 fix_delete_line($fixlinenr - 1, $prevrawline);
4550 fix_delete_line($fixlinenr, $rawline);
4551 my $fixedline = $prevrawline;
4552 $fixedline =~ s/\s*=\s*$/ = {/;
4553 fix_insert_line($fixlinenr, $fixedline);
4555 $fixedline =~ s/^(.\s*)\{\s*/$1/;
4556 fix_insert_line($fixlinenr, $fixedline);
4561 # Checks which are anchored on the added line.
4564 # check for malformed paths in #include statements (uses RAW line)
4565 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
4567 if ($path =~ m{//}) {
4568 ERROR("MALFORMED_INCLUDE",
4569 "malformed #include filename\n" . $herecurr);
4571 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
4572 ERROR("UAPI_INCLUDE",
4573 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
4577 # no C99 // comments
4578 if ($line =~ m{//}) {
4579 if (ERROR("C99_COMMENTS",
4580 "do not use C99 // comments\n" . $herecurr) &&
4582 my $line = $fixed[$fixlinenr];
4583 if ($line =~ /\/\/(.*)$/) {
4584 my $comment = trim($1);
4585 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
4589 # Remove C99 comments.
4591 $opline =~ s@//.*@@;
4593 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
4594 # the whole statement.
4595 #print "APW <$lines[$realline_next - 1]>\n";
4596 if (defined $realline_next &&
4597 exists $lines[$realline_next - 1] &&
4598 !defined $suppress_export{$realline_next} &&
4599 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4600 # Handle definitions which produce identifiers with
4603 # EXPORT_SYMBOL(something_foo);
4605 $name =~ s/^\s*($Ident).*/$1/;
4606 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
4607 $name =~ /^${Ident}_$2/) {
4608 #print "FOO C name<$name>\n";
4609 $suppress_export{$realline_next} = 1;
4611 } elsif ($stat !~ /(?:
4613 ^.DEFINE_$Ident\(\Q$name\E\)|
4614 ^.DECLARE_$Ident\(\Q$name\E\)|
4615 ^.LIST_HEAD\(\Q$name\E\)|
4616 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
4617 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
4619 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
4620 $suppress_export{$realline_next} = 2;
4622 $suppress_export{$realline_next} = 1;
4625 if (!defined $suppress_export{$linenr} &&
4626 $prevline =~ /^.\s*$/ &&
4627 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4628 #print "FOO B <$lines[$linenr - 1]>\n";
4629 $suppress_export{$linenr} = 2;
4631 if (defined $suppress_export{$linenr} &&
4632 $suppress_export{$linenr} == 2) {
4633 WARN("EXPORT_SYMBOL",
4634 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
4637 # check for global initialisers.
4638 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/ &&
4639 !exclude_global_initialisers($realfile)) {
4640 if (ERROR("GLOBAL_INITIALISERS",
4641 "do not initialise globals to $1\n" . $herecurr) &&
4643 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
4646 # check for static initialisers.
4647 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
4648 if (ERROR("INITIALISED_STATIC",
4649 "do not initialise statics to $1\n" .
4652 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
4656 # check for misordered declarations of char/short/int/long with signed/unsigned
4657 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
4659 WARN("MISORDERED_TYPE",
4660 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
4663 # check for unnecessary <signed> int declarations of short/long/long long
4664 while ($sline =~ m{\b($TypeMisordered(\s*\*)*|$C90_int_types)\b}g) {
4665 my $type = trim($1);
4666 next if ($type !~ /\bint\b/);
4667 next if ($type !~ /\b(?:short|long\s+long|long)\b/);
4668 my $new_type = $type;
4669 $new_type =~ s/\b\s*int\s*\b/ /;
4670 $new_type =~ s/\b\s*(?:un)?signed\b\s*/ /;
4671 $new_type =~ s/^const\s+//;
4672 $new_type = "unsigned $new_type" if ($type =~ /\bunsigned\b/);
4673 $new_type = "const $new_type" if ($type =~ /^const\b/);
4674 $new_type =~ s/\s+/ /g;
4675 $new_type = trim($new_type);
4676 if (WARN("UNNECESSARY_INT",
4677 "Prefer '$new_type' over '$type' as the int is unnecessary\n" . $herecurr) &&
4679 $fixed[$fixlinenr] =~ s/\b\Q$type\E\b/$new_type/;
4683 # check for static const char * arrays.
4684 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
4685 WARN("STATIC_CONST_CHAR_ARRAY",
4686 "static const char * array should probably be static const char * const\n" .
4690 # check for initialized const char arrays that should be static const
4691 if ($line =~ /^\+\s*const\s+(char|unsigned\s+char|_*u8|(?:[us]_)?int8_t)\s+\w+\s*\[\s*(?:\w+\s*)?\]\s*=\s*"/) {
4692 if (WARN("STATIC_CONST_CHAR_ARRAY",
4693 "const array should probably be static const\n" . $herecurr) &&
4695 $fixed[$fixlinenr] =~ s/(^.\s*)const\b/${1}static const/;
4699 # check for static char foo[] = "bar" declarations.
4700 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
4701 WARN("STATIC_CONST_CHAR_ARRAY",
4702 "static char array declaration should probably be static const char\n" .
4706 # check for const <foo> const where <foo> is not a pointer or array type
4707 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
4709 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
4711 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
4712 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
4714 "'const $found const' should probably be 'const $found'\n" . $herecurr);
4718 # check for const static or static <non ptr type> const declarations
4719 # prefer 'static const <foo>' over 'const static <foo>' and 'static <foo> const'
4720 if ($sline =~ /^\+\s*const\s+static\s+($Type)\b/ ||
4721 $sline =~ /^\+\s*static\s+($BasicType)\s+const\b/) {
4722 if (WARN("STATIC_CONST",
4723 "Move const after static - use 'static const $1'\n" . $herecurr) &&
4725 $fixed[$fixlinenr] =~ s/\bconst\s+static\b/static const/;
4726 $fixed[$fixlinenr] =~ s/\bstatic\s+($BasicType)\s+const\b/static const $1/;
4730 # check for non-global char *foo[] = {"bar", ...} declarations.
4731 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
4732 WARN("STATIC_CONST_CHAR_ARRAY",
4733 "char * array declaration might be better as static const\n" .
4737 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
4738 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
4740 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
4742 if (WARN("ARRAY_SIZE",
4743 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
4745 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
4750 # check for function declarations without arguments like "int foo()"
4751 if ($line =~ /(\b$Type\s*$Ident)\s*\(\s*\)/) {
4752 if (ERROR("FUNCTION_WITHOUT_ARGS",
4753 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
4755 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
4759 # check for new typedefs, only function parameters and sparse annotations
4761 if ($line =~ /\btypedef\s/ &&
4762 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
4763 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
4764 $line !~ /\b$typeTypedefs\b/ &&
4765 $line !~ /\b__bitwise\b/) {
4766 WARN("NEW_TYPEDEFS",
4767 "do not add new typedefs\n" . $herecurr);
4770 # * goes on variable not on type
4772 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
4774 my ($ident, $from, $to) = ($1, $2, $2);
4776 # Should start with a space.
4777 $to =~ s/^(\S)/ $1/;
4778 # Should not end with a space.
4780 # '*'s should not have spaces between.
4781 while ($to =~ s/\*\s+\*/\*\*/) {
4784 ## print "1: from<$from> to<$to> ident<$ident>\n";
4786 if (ERROR("POINTER_LOCATION",
4787 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
4789 my $sub_from = $ident;
4790 my $sub_to = $ident;
4791 $sub_to =~ s/\Q$from\E/$to/;
4792 $fixed[$fixlinenr] =~
4793 s@\Q$sub_from\E@$sub_to@;
4797 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
4799 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
4801 # Should start with a space.
4802 $to =~ s/^(\S)/ $1/;
4803 # Should not end with a space.
4805 # '*'s should not have spaces between.
4806 while ($to =~ s/\*\s+\*/\*\*/) {
4808 # Modifiers should have spaces.
4809 $to =~ s/(\b$Modifier$)/$1 /;
4811 ## print "2: from<$from> to<$to> ident<$ident>\n";
4812 if ($from ne $to && $ident !~ /^$Modifier$/) {
4813 if (ERROR("POINTER_LOCATION",
4814 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
4817 my $sub_from = $match;
4818 my $sub_to = $match;
4819 $sub_to =~ s/\Q$from\E/$to/;
4820 $fixed[$fixlinenr] =~
4821 s@\Q$sub_from\E@$sub_to@;
4826 # do not use BUG() or variants
4827 if ($line =~ /\b(?!AA_|BUILD_|DCCP_|IDA_|KVM_|RWLOCK_|snd_|SPIN_)(?:[a-zA-Z_]*_)?BUG(?:_ON)?(?:_[A-Z_]+)?\s*\(/) {
4828 my $msg_level = \&WARN;
4829 $msg_level = \&CHK if ($file);
4830 &{$msg_level}("AVOID_BUG",
4831 "Do not crash the kernel unless it is absolutely unavoidable--use WARN_ON_ONCE() plus recovery code (if feasible) instead of BUG() or variants\n" . $herecurr);
4834 # avoid LINUX_VERSION_CODE
4835 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
4836 WARN("LINUX_VERSION_CODE",
4837 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
4840 # check for uses of printk_ratelimit
4841 if ($line =~ /\bprintk_ratelimit\s*\(/) {
4842 WARN("PRINTK_RATELIMITED",
4843 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
4846 # printk should use KERN_* levels
4847 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
4848 WARN("PRINTK_WITHOUT_KERN_LEVEL",
4849 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
4852 # prefer variants of (subsystem|netdev|dev|pr)_<level> to printk(KERN_<LEVEL>
4853 if ($line =~ /\b(printk(_once|_ratelimited)?)\s*\(\s*KERN_([A-Z]+)/) {
4857 $modifier = "" if (!defined($modifier));
4858 my $level = lc($orig);
4859 $level = "warn" if ($level eq "warning");
4860 my $level2 = $level;
4861 $level2 = "dbg" if ($level eq "debug");
4862 $level .= $modifier;
4863 $level2 .= $modifier;
4864 WARN("PREFER_PR_LEVEL",
4865 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to $printk(KERN_$orig ...\n" . $herecurr);
4868 # prefer dev_<level> to dev_printk(KERN_<LEVEL>
4869 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
4871 my $level = lc($orig);
4872 $level = "warn" if ($level eq "warning");
4873 $level = "dbg" if ($level eq "debug");
4874 WARN("PREFER_DEV_LEVEL",
4875 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
4878 # trace_printk should not be used in production code.
4879 if ($line =~ /\b(trace_printk|trace_puts|ftrace_vprintk)\s*\(/) {
4880 WARN("TRACE_PRINTK",
4881 "Do not use $1() in production code (this can be ignored if built only with a debug config option)\n" . $herecurr);
4884 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
4885 # number of false positives, but assembly files are not checked, so at
4886 # least the arch entry code will not trigger this warning.
4887 if ($line =~ /\bENOSYS\b/) {
4889 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
4892 # ENOTSUPP is not a standard error code and should be avoided in new patches.
4893 # Folks usually mean EOPNOTSUPP (also called ENOTSUP), when they type ENOTSUPP.
4894 # Similarly to ENOSYS warning a small number of false positives is expected.
4895 if (!$file && $line =~ /\bENOTSUPP\b/) {
4896 if (WARN("ENOTSUPP",
4897 "ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP\n" . $herecurr) &&
4899 $fixed[$fixlinenr] =~ s/\bENOTSUPP\b/EOPNOTSUPP/;
4903 # function brace can't be on same line, except for #defines of do while,
4904 # or if closed on same line
4905 if ($perl_version_ok &&
4906 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
4907 $sline !~ /\#\s*define\b.*do\s*\{/ &&
4909 if (ERROR("OPEN_BRACE",
4910 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
4912 fix_delete_line($fixlinenr, $rawline);
4913 my $fixed_line = $rawline;
4914 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*)\{(.*)$/;
4917 fix_insert_line($fixlinenr, ltrim($line1));
4918 fix_insert_line($fixlinenr, "\+{");
4919 if ($line2 !~ /^\s*$/) {
4920 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
4925 # open braces for enum, union and struct go on the same line.
4926 if ($line =~ /^.\s*{/ &&
4927 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
4928 if (ERROR("OPEN_BRACE",
4929 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
4930 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4931 fix_delete_line($fixlinenr - 1, $prevrawline);
4932 fix_delete_line($fixlinenr, $rawline);
4933 my $fixedline = rtrim($prevrawline) . " {";
4934 fix_insert_line($fixlinenr, $fixedline);
4935 $fixedline = $rawline;
4936 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
4937 if ($fixedline !~ /^\+\s*$/) {
4938 fix_insert_line($fixlinenr, $fixedline);
4943 # missing space after union, struct or enum definition
4944 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4946 "missing space after $1 definition\n" . $herecurr) &&
4948 $fixed[$fixlinenr] =~
4949 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4953 # Function pointer declarations
4954 # check spacing between type, funcptr, and args
4955 # canonical declaration is "type (*funcptr)(args...)"
4956 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4958 my $pre_pointer_space = $2;
4959 my $post_pointer_space = $3;
4961 my $post_funcname_space = $5;
4962 my $pre_args_space = $6;
4964 # the $Declare variable will capture all spaces after the type
4965 # so check it for a missing trailing missing space but pointer return types
4966 # don't need a space so don't warn for those.
4967 my $post_declare_space = "";
4968 if ($declare =~ /(\s+)$/) {
4969 $post_declare_space = $1;
4970 $declare = rtrim($declare);
4972 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4974 "missing space after return type\n" . $herecurr);
4975 $post_declare_space = " ";
4978 # unnecessary space "type (*funcptr)(args...)"
4979 # This test is not currently implemented because these declarations are
4981 # int foo(int bar, ...)
4982 # and this is form shouldn't/doesn't generate a checkpatch warning.
4984 # elsif ($declare =~ /\s{2,}$/) {
4986 # "Multiple spaces after return type\n" . $herecurr);
4989 # unnecessary space "type ( *funcptr)(args...)"
4990 if (defined $pre_pointer_space &&
4991 $pre_pointer_space =~ /^\s/) {
4993 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4996 # unnecessary space "type (* funcptr)(args...)"
4997 if (defined $post_pointer_space &&
4998 $post_pointer_space =~ /^\s/) {
5000 "Unnecessary space before function pointer name\n" . $herecurr);
5003 # unnecessary space "type (*funcptr )(args...)"
5004 if (defined $post_funcname_space &&
5005 $post_funcname_space =~ /^\s/) {
5007 "Unnecessary space after function pointer name\n" . $herecurr);
5010 # unnecessary space "type (*funcptr) (args...)"
5011 if (defined $pre_args_space &&
5012 $pre_args_space =~ /^\s/) {
5014 "Unnecessary space before function pointer arguments\n" . $herecurr);
5017 if (show_type("SPACING") && $fix) {
5018 $fixed[$fixlinenr] =~
5019 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
5023 # check for spacing round square brackets; allowed:
5024 # 1. with a type on the left -- int [] a;
5025 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
5026 # 3. inside a curly brace -- = { [0...10] = 5 }
5027 while ($line =~ /(.*?\s)\[/g) {
5028 my ($where, $prefix) = ($-[1], $1);
5029 if ($prefix !~ /$Type\s+$/ &&
5030 ($where != 0 || $prefix !~ /^.\s+$/) &&
5031 $prefix !~ /[{,:]\s+$/) {
5032 if (ERROR("BRACKET_SPACE",
5033 "space prohibited before open square bracket '['\n" . $herecurr) &&
5035 $fixed[$fixlinenr] =~
5036 s/^(\+.*?)\s+\[/$1\[/;
5041 # check for spaces between functions and their parentheses.
5042 while ($line =~ /($Ident)\s+\(/g) {
5044 my $ctx_before = substr($line, 0, $-[1]);
5045 my $ctx = "$ctx_before$name";
5047 # Ignore those directives where spaces _are_ permitted.
5049 if|for|while|switch|return|case|
5050 volatile|__volatile__|
5051 __attribute__|format|__extension__|
5052 asm|__asm__|scoped_guard)$/x)
5054 # cpp #define statements have non-optional spaces, ie
5055 # if there is a space between the name and the open
5056 # parenthesis it is simply not a parameter group.
5057 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
5059 # cpp #elif statement condition may start with a (
5060 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
5062 # If this whole things ends with a type its most
5063 # likely a typedef for a function.
5064 } elsif ($ctx =~ /$Type$/) {
5068 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
5070 $fixed[$fixlinenr] =~
5071 s/\b$name\s+\(/$name\(/;
5076 # Check operator spacing.
5077 if (!($line=~/\#\s*include/)) {
5078 my $fixed_line = "";
5082 <<=|>>=|<=|>=|==|!=|
5083 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
5084 =>|->|<<|>>|<|>|=|!|~|
5085 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
5088 my @elements = split(/($ops|;)/, $opline);
5090 ## print("element count: <" . $#elements . ">\n");
5091 ## foreach my $el (@elements) {
5092 ## print("el: <$el>\n");
5095 my @fix_elements = ();
5098 foreach my $el (@elements) {
5099 push(@fix_elements, substr($rawline, $off, length($el)));
5100 $off += length($el);
5105 my $blank = copy_spacing($opline);
5106 my $last_after = -1;
5108 for (my $n = 0; $n < $#elements; $n += 2) {
5110 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
5112 ## print("n: <$n> good: <$good>\n");
5114 $off += length($elements[$n]);
5116 # Pick up the preceding and succeeding characters.
5117 my $ca = substr($opline, 0, $off);
5119 if (length($opline) >= ($off + length($elements[$n + 1]))) {
5120 $cc = substr($opline, $off + length($elements[$n + 1]));
5122 my $cb = "$ca$;$cc";
5125 $a = 'V' if ($elements[$n] ne '');
5126 $a = 'W' if ($elements[$n] =~ /\s$/);
5127 $a = 'C' if ($elements[$n] =~ /$;$/);
5128 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
5129 $a = 'O' if ($elements[$n] eq '');
5130 $a = 'E' if ($ca =~ /^\s*$/);
5132 my $op = $elements[$n + 1];
5135 if (defined $elements[$n + 2]) {
5136 $c = 'V' if ($elements[$n + 2] ne '');
5137 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
5138 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
5139 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
5140 $c = 'O' if ($elements[$n + 2] eq '');
5141 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
5146 my $ctx = "${a}x${c}";
5148 my $at = "(ctx:$ctx)";
5150 my $ptr = substr($blank, 0, $off) . "^";
5151 my $hereptr = "$hereline$ptr\n";
5153 # Pull out the value of this operator.
5154 my $op_type = substr($curr_values, $off + 1, 1);
5156 # Get the full operator variant.
5157 my $opv = $op . substr($curr_vars, $off, 1);
5159 # Ignore operators passed as parameters.
5160 if ($op_type ne 'V' &&
5161 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
5164 # } elsif ($op =~ /^$;+$/) {
5166 # ; should have either the end of line or a space or \ after it
5167 } elsif ($op eq ';') {
5168 if ($ctx !~ /.x[WEBC]/ &&
5169 $cc !~ /^\\/ && $cc !~ /^;/) {
5170 if (ERROR("SPACING",
5171 "space required after that '$op' $at\n" . $hereptr)) {
5172 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5178 } elsif ($op eq '//') {
5180 # : when part of a bitfield
5181 } elsif ($opv eq ':B') {
5182 # skip the bitfield test for now
5186 } elsif ($op eq '->') {
5187 if ($ctx =~ /Wx.|.xW/) {
5188 if (ERROR("SPACING",
5189 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
5190 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5191 if (defined $fix_elements[$n + 2]) {
5192 $fix_elements[$n + 2] =~ s/^\s+//;
5198 # , must not have a space before and must have a space on the right.
5199 } elsif ($op eq ',') {
5200 my $rtrim_before = 0;
5201 my $space_after = 0;
5202 if ($ctx =~ /Wx./) {
5203 if (ERROR("SPACING",
5204 "space prohibited before that '$op' $at\n" . $hereptr)) {
5209 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
5210 if (ERROR("SPACING",
5211 "space required after that '$op' $at\n" . $hereptr)) {
5217 if ($rtrim_before || $space_after) {
5218 if ($rtrim_before) {
5219 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5221 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5228 # '*' as part of a type definition -- reported already.
5229 } elsif ($opv eq '*_') {
5230 #warn "'*' is part of type\n";
5232 # unary operators should have a space before and
5233 # none after. May be left adjacent to another
5234 # unary operator, or a cast
5235 } elsif ($op eq '!' || $op eq '~' ||
5236 $opv eq '*U' || $opv eq '-U' ||
5237 $opv eq '&U' || $opv eq '&&U') {
5238 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
5239 if (ERROR("SPACING",
5240 "space required before that '$op' $at\n" . $hereptr)) {
5241 if ($n != $last_after + 2) {
5242 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
5247 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
5248 # A unary '*' may be const
5250 } elsif ($ctx =~ /.xW/) {
5251 if (ERROR("SPACING",
5252 "space prohibited after that '$op' $at\n" . $hereptr)) {
5253 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
5254 if (defined $fix_elements[$n + 2]) {
5255 $fix_elements[$n + 2] =~ s/^\s+//;
5261 # unary ++ and unary -- are allowed no space on one side.
5262 } elsif ($op eq '++' or $op eq '--') {
5263 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
5264 if (ERROR("SPACING",
5265 "space required one side of that '$op' $at\n" . $hereptr)) {
5266 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5270 if ($ctx =~ /Wx[BE]/ ||
5271 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
5272 if (ERROR("SPACING",
5273 "space prohibited before that '$op' $at\n" . $hereptr)) {
5274 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5278 if ($ctx =~ /ExW/) {
5279 if (ERROR("SPACING",
5280 "space prohibited after that '$op' $at\n" . $hereptr)) {
5281 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5282 if (defined $fix_elements[$n + 2]) {
5283 $fix_elements[$n + 2] =~ s/^\s+//;
5289 # << and >> may either have or not have spaces both sides
5290 } elsif ($op eq '<<' or $op eq '>>' or
5291 $op eq '&' or $op eq '^' or $op eq '|' or
5292 $op eq '+' or $op eq '-' or
5293 $op eq '*' or $op eq '/' or
5297 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
5299 "spaces preferred around that '$op' $at\n" . $hereptr)) {
5300 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5301 $fix_elements[$n + 2] =~ s/^\s+//;
5304 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
5306 "space preferred before that '$op' $at\n" . $hereptr)) {
5307 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
5311 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
5312 if (ERROR("SPACING",
5313 "need consistent spacing around '$op' $at\n" . $hereptr)) {
5314 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5315 if (defined $fix_elements[$n + 2]) {
5316 $fix_elements[$n + 2] =~ s/^\s+//;
5322 # A colon needs no spaces before when it is
5323 # terminating a case value or a label.
5324 } elsif ($opv eq ':C' || $opv eq ':L') {
5325 if ($ctx =~ /Wx./ and $realfile !~ m@.*\.lds\.h$@) {
5326 if (ERROR("SPACING",
5327 "space prohibited before that '$op' $at\n" . $hereptr)) {
5328 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5333 # All the others need spaces both sides.
5334 } elsif ($ctx !~ /[EWC]x[CWE]/) {
5337 # Ignore email addresses <foo@bar>
5339 $cc =~ /^\S+\@\S+>/) ||
5341 $ca =~ /<\S+\@\S+$/))
5346 # for asm volatile statements
5347 # ignore a colon with another
5348 # colon immediately before or after
5350 ($ca =~ /:$/ || $cc =~ /^:/)) {
5354 # messages are ERROR, but ?: are CHK
5356 my $msg_level = \&ERROR;
5357 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
5359 if (&{$msg_level}("SPACING",
5360 "spaces required around that '$op' $at\n" . $hereptr)) {
5361 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5362 if (defined $fix_elements[$n + 2]) {
5363 $fix_elements[$n + 2] =~ s/^\s+//;
5369 $off += length($elements[$n + 1]);
5371 ## print("n: <$n> GOOD: <$good>\n");
5373 $fixed_line = $fixed_line . $good;
5376 if (($#elements % 2) == 0) {
5377 $fixed_line = $fixed_line . $fix_elements[$#elements];
5380 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
5381 $fixed[$fixlinenr] = $fixed_line;
5387 # check for whitespace before a non-naked semicolon
5388 if ($line =~ /^\+.*\S\s+;\s*$/) {
5390 "space prohibited before semicolon\n" . $herecurr) &&
5392 1 while $fixed[$fixlinenr] =~
5393 s/^(\+.*\S)\s+;/$1;/;
5397 # check for multiple assignments
5398 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
5399 CHK("MULTIPLE_ASSIGNMENTS",
5400 "multiple assignments should be avoided\n" . $herecurr);
5403 ## # check for multiple declarations, allowing for a function declaration
5405 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
5406 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
5408 ## # Remove any bracketed sections to ensure we do not
5409 ## # falsely report the parameters of functions.
5411 ## while ($ln =~ s/\([^\(\)]*\)//g) {
5413 ## if ($ln =~ /,/) {
5414 ## WARN("MULTIPLE_DECLARATION",
5415 ## "declaring multiple variables together should be avoided\n" . $herecurr);
5419 #need space before brace following if, while, etc
5420 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
5421 $line =~ /\b(?:else|do)\{/) {
5422 if (ERROR("SPACING",
5423 "space required before the open brace '{'\n" . $herecurr) &&
5425 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|else|\)))\{/$1 {/;
5429 ## # check for blank lines before declarations
5430 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
5431 ## $prevrawline =~ /^.\s*$/) {
5433 ## "No blank lines before declarations\n" . $hereprev);
5437 # closing brace should have a space following it when it has anything
5439 if ($line =~ /}(?!(?:,|;|\)|\}))\S/) {
5440 if (ERROR("SPACING",
5441 "space required after that close brace '}'\n" . $herecurr) &&
5443 $fixed[$fixlinenr] =~
5444 s/}((?!(?:,|;|\)))\S)/} $1/;
5448 # check spacing on square brackets
5449 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
5450 if (ERROR("SPACING",
5451 "space prohibited after that open square bracket '['\n" . $herecurr) &&
5453 $fixed[$fixlinenr] =~
5457 if ($line =~ /\s\]/) {
5458 if (ERROR("SPACING",
5459 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
5461 $fixed[$fixlinenr] =~
5466 # check spacing on parentheses
5467 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
5468 $line !~ /for\s*\(\s+;/) {
5469 if (ERROR("SPACING",
5470 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
5472 $fixed[$fixlinenr] =~
5476 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
5477 $line !~ /for\s*\(.*;\s+\)/ &&
5478 $line !~ /:\s+\)/) {
5479 if (ERROR("SPACING",
5480 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
5482 $fixed[$fixlinenr] =~
5487 # check unnecessary parentheses around addressof/dereference single $Lvals
5488 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
5490 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
5492 if (CHK("UNNECESSARY_PARENTHESES",
5493 "Unnecessary parentheses around $var\n" . $herecurr) &&
5495 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
5499 # check for unnecessary parentheses around function pointer uses
5500 # ie: (foo->bar)(); should be foo->bar();
5501 # but not "if (foo->bar) (" to avoid some false positives
5502 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
5504 if (CHK("UNNECESSARY_PARENTHESES",
5505 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
5507 my $var2 = deparenthesize($var);
5509 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
5513 # check for unnecessary parentheses around comparisons in if uses
5514 # when !drivers/staging or command-line uses --strict
5515 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
5516 $perl_version_ok && defined($stat) &&
5517 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
5519 my $test = substr($2, 1, -1);
5521 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
5523 # avoid parentheses around potential macro args
5524 next if ($match =~ /^\s*\w+\s*$/);
5525 if (!defined($herectx)) {
5526 $herectx = $here . "\n";
5527 my $cnt = statement_rawlines($if_stat);
5528 for (my $n = 0; $n < $cnt; $n++) {
5529 my $rl = raw_line($linenr, $n);
5530 $herectx .= $rl . "\n";
5531 last if $rl =~ /^[ \+].*\{/;
5534 CHK("UNNECESSARY_PARENTHESES",
5535 "Unnecessary parentheses around '$match'\n" . $herectx);
5539 # check that goto labels aren't indented (allow a single space indentation)
5540 # and ignore bitfield definitions like foo:1
5541 # Strictly, labels can have whitespace after the identifier and before the :
5542 # but this is not allowed here as many ?: uses would appear to be labels
5543 if ($sline =~ /^.\s+[A-Za-z_][A-Za-z\d_]*:(?!\s*\d+)/ &&
5544 $sline !~ /^. [A-Za-z\d_][A-Za-z\d_]*:/ &&
5545 $sline !~ /^.\s+default:/) {
5546 if (WARN("INDENTED_LABEL",
5547 "labels should not be indented\n" . $herecurr) &&
5549 $fixed[$fixlinenr] =~
5554 # check if a statement with a comma should be two statements like:
5555 # foo = bar(), /* comma should be semicolon */
5557 if (defined($stat) &&
5558 $stat =~ /^\+\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*,\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*;\s*$/) {
5559 my $cnt = statement_rawlines($stat);
5560 my $herectx = get_stat_here($linenr, $cnt, $here);
5561 WARN("SUSPECT_COMMA_SEMICOLON",
5562 "Possible comma where semicolon could be used\n" . $herectx);
5565 # return is not a function
5566 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
5568 if ($perl_version_ok &&
5569 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
5571 $value = deparenthesize($value);
5572 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
5573 ERROR("RETURN_PARENTHESES",
5574 "return is not a function, parentheses are not required\n" . $herecurr);
5576 } elsif ($spacing !~ /\s+/) {
5578 "space required before the open parenthesis '('\n" . $herecurr);
5582 # unnecessary return in a void function
5583 # at end-of-function, with the previous line a single leading tab, then return;
5584 # and the line before that not a goto label target like "out:"
5585 if ($sline =~ /^[ \+]}\s*$/ &&
5586 $prevline =~ /^\+\treturn\s*;\s*$/ &&
5588 $lines[$linenr - 3] =~ /^[ +]/ &&
5589 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
5591 "void function return statements are not generally useful\n" . $hereprev);
5594 # if statements using unnecessary parentheses - ie: if ((foo == bar))
5595 if ($perl_version_ok &&
5596 $line =~ /\bif\s*((?:\(\s*){2,})/) {
5597 my $openparens = $1;
5598 my $count = $openparens =~ tr@\(@\(@;
5600 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
5601 my $comp = $4; #Not $1 because of $LvalOrFunc
5602 $msg = " - maybe == should be = ?" if ($comp eq "==");
5603 WARN("UNNECESSARY_PARENTHESES",
5604 "Unnecessary parentheses$msg\n" . $herecurr);
5608 # comparisons with a constant or upper case identifier on the left
5609 # avoid cases like "foo + BAR < baz"
5610 # only fix matches surrounded by parentheses to avoid incorrect
5611 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
5612 if ($perl_version_ok &&
5613 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
5618 my $newcomp = $comp;
5619 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
5620 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
5621 WARN("CONSTANT_COMPARISON",
5622 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
5626 } elsif ($comp eq "<=") {
5628 } elsif ($comp eq ">") {
5630 } elsif ($comp eq ">=") {
5633 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
5637 # Return of what appears to be an errno should normally be negative
5638 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
5640 if ($name ne 'EOF' && $name ne 'ERROR' && $name !~ /^EPOLL/) {
5641 WARN("USE_NEGATIVE_ERRNO",
5642 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
5646 # Need a space before open parenthesis after if, while etc
5647 if ($line =~ /\b(if|while|for|switch)\(/) {
5648 if (ERROR("SPACING",
5649 "space required before the open parenthesis '('\n" . $herecurr) &&
5651 $fixed[$fixlinenr] =~
5652 s/\b(if|while|for|switch)\(/$1 \(/;
5656 # Check for illegal assignment in if conditional -- and check for trailing
5657 # statements after the conditional.
5658 if ($line =~ /do\s*(?!{)/) {
5659 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
5660 ctx_statement_block($linenr, $realcnt, 0)
5661 if (!defined $stat);
5662 my ($stat_next) = ctx_statement_block($line_nr_next,
5663 $remain_next, $off_next);
5664 $stat_next =~ s/\n./\n /g;
5665 ##print "stat<$stat> stat_next<$stat_next>\n";
5667 if ($stat_next =~ /^\s*while\b/) {
5668 # If the statement carries leading newlines,
5669 # then count those as offsets.
5671 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
5673 statement_rawlines($whitespace) - 1;
5675 $suppress_whiletrailers{$line_nr_next +
5679 if (!defined $suppress_whiletrailers{$linenr} &&
5680 defined($stat) && defined($cond) &&
5681 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
5682 my ($s, $c) = ($stat, $cond);
5683 my $fixed_assign_in_if = 0;
5685 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
5686 if (ERROR("ASSIGN_IN_IF",
5687 "do not use assignment in if condition\n" . $herecurr) &&
5688 $fix && $perl_version_ok) {
5689 if ($rawline =~ /^\+(\s+)if\s*\(\s*(\!)?\s*\(\s*(($Lval)\s*=\s*$LvalOrFunc)\s*\)\s*(?:($Compare)\s*($FuncArg))?\s*\)\s*(\{)?\s*$/) {
5697 fix_delete_line($fixlinenr, $rawline);
5698 fix_insert_line($fixlinenr, "$space$statement;");
5699 my $newline = "${space}if (";
5700 $newline .= '!' if defined($not);
5701 $newline .= '(' if (defined $not && defined($test) && defined($against));
5702 $newline .= "$assigned";
5703 $newline .= " $test $against" if (defined($test) && defined($against));
5704 $newline .= ')' if (defined $not && defined($test) && defined($against));
5706 $newline .= " {" if (defined($brace));
5707 fix_insert_line($fixlinenr + 1, $newline);
5708 $fixed_assign_in_if = 1;
5713 # Find out what is on the end of the line after the
5715 substr($s, 0, length($c), '');
5717 $s =~ s/$;//g; # Remove any comments
5718 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
5719 $c !~ /}\s*while\s*/)
5721 # Find out how long the conditional actually is.
5722 my @newlines = ($c =~ /\n/gs);
5723 my $cond_lines = 1 + $#newlines;
5726 $stat_real = raw_line($linenr, $cond_lines)
5727 . "\n" if ($cond_lines);
5728 if (defined($stat_real) && $cond_lines > 1) {
5729 $stat_real = "[...]\n$stat_real";
5732 if (ERROR("TRAILING_STATEMENTS",
5733 "trailing statements should be on next line\n" . $herecurr . $stat_real) &&
5734 !$fixed_assign_in_if &&
5736 $fix && $perl_version_ok &&
5737 $fixed[$fixlinenr] =~ /^\+(\s*)((?:if|while|for)\s*$balanced_parens)\s*(.*)$/) {
5740 my $rest = rtrim($4);
5741 if ($rest =~ /;$/) {
5742 $fixed[$fixlinenr] = "\+$indent$test";
5743 fix_insert_line($fixlinenr + 1, "$indent\t$rest");
5749 # Check for bitwise tests written as boolean
5761 WARN("HEXADECIMAL_BOOLEAN_TEST",
5762 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
5765 # if and else should not have general statements after it
5766 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
5768 $s =~ s/$;//g; # Remove any comments
5769 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
5770 ERROR("TRAILING_STATEMENTS",
5771 "trailing statements should be on next line\n" . $herecurr);
5774 # if should not continue a brace
5775 if ($line =~ /}\s*if\b/) {
5776 ERROR("TRAILING_STATEMENTS",
5777 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
5780 # case and default should not have general statements after them
5781 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
5783 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
5787 ERROR("TRAILING_STATEMENTS",
5788 "trailing statements should be on next line\n" . $herecurr);
5791 # Check for }<nl>else {, these must be at the same
5792 # indent level to be relevant to each other.
5793 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
5794 $previndent == $indent) {
5795 if (ERROR("ELSE_AFTER_BRACE",
5796 "else should follow close brace '}'\n" . $hereprev) &&
5797 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5798 fix_delete_line($fixlinenr - 1, $prevrawline);
5799 fix_delete_line($fixlinenr, $rawline);
5800 my $fixedline = $prevrawline;
5801 $fixedline =~ s/}\s*$//;
5802 if ($fixedline !~ /^\+\s*$/) {
5803 fix_insert_line($fixlinenr, $fixedline);
5805 $fixedline = $rawline;
5806 $fixedline =~ s/^(.\s*)else/$1} else/;
5807 fix_insert_line($fixlinenr, $fixedline);
5811 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
5812 $previndent == $indent) {
5813 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
5815 # Find out what is on the end of the line after the
5817 substr($s, 0, length($c), '');
5820 if ($s =~ /^\s*;/) {
5821 if (ERROR("WHILE_AFTER_BRACE",
5822 "while should follow close brace '}'\n" . $hereprev) &&
5823 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5824 fix_delete_line($fixlinenr - 1, $prevrawline);
5825 fix_delete_line($fixlinenr, $rawline);
5826 my $fixedline = $prevrawline;
5827 my $trailing = $rawline;
5828 $trailing =~ s/^\+//;
5829 $trailing = trim($trailing);
5830 $fixedline =~ s/}\s*$/} $trailing/;
5831 fix_insert_line($fixlinenr, $fixedline);
5836 #Specific variable tests
5837 while ($line =~ m{($Constant|$Lval)}g) {
5841 if ($var !~ /^$Constant$/ &&
5842 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
5843 #Ignore some autogenerated defines and enum values
5844 $var !~ /^(?:[A-Z]+_){1,5}[A-Z]{1,3}[a-z]/ &&
5845 #Ignore Page<foo> variants
5846 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
5847 #Ignore ETHTOOL_LINK_MODE_<foo> variants
5848 $var !~ /^ETHTOOL_LINK_MODE_/ &&
5849 #Ignore SI style variants like nS, mV and dB
5850 #(ie: max_uV, regulator_min_uA_show, RANGE_mA_VALUE)
5851 $var !~ /^(?:[a-z0-9_]*|[A-Z0-9_]*)?_?[a-z][A-Z](?:_[a-z0-9_]+|_[A-Z0-9_]+)?$/ &&
5852 #Ignore some three character SI units explicitly, like MiB and KHz
5853 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
5854 while ($var =~ m{\b($Ident)}g) {
5856 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
5858 seed_camelcase_includes();
5859 if (!$file && !$camelcase_file_seeded) {
5860 seed_camelcase_file($realfile);
5861 $camelcase_file_seeded = 1;
5864 if (!defined $camelcase{$word}) {
5865 $camelcase{$word} = 1;
5867 "Avoid CamelCase: <$word>\n" . $herecurr);
5873 #no spaces allowed after \ in define
5874 if ($line =~ /\#\s*define.*\\\s+$/) {
5875 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
5876 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
5878 $fixed[$fixlinenr] =~ s/\s+$//;
5882 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
5883 # itself <asm/foo.h> (uses RAW line)
5884 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
5886 my $checkfile = "include/linux/$file";
5887 if (-f "$root/$checkfile" &&
5888 $realfile ne $checkfile &&
5889 $1 !~ /$allowed_asm_includes/)
5891 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
5892 if ($asminclude > 0) {
5893 if ($realfile =~ m{^arch/}) {
5894 CHK("ARCH_INCLUDE_LINUX",
5895 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5897 WARN("INCLUDE_LINUX",
5898 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5904 # multi-statement macros should be enclosed in a do while loop, grab the
5905 # first statement and ensure its the whole macro if its not enclosed
5906 # in a known good container
5907 if ($realfile !~ m@/vmlinux.lds.h$@ &&
5908 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
5911 my ($off, $dstat, $dcond, $rest);
5913 my $has_flow_statement = 0;
5914 my $has_arg_concat = 0;
5915 ($dstat, $dcond, $ln, $cnt, $off) =
5916 ctx_statement_block($linenr, $realcnt, 0);
5918 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
5919 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
5921 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
5922 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
5924 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
5925 my $define_args = $1;
5926 my $define_stmt = $dstat;
5929 if (defined $define_args && $define_args ne "") {
5930 $define_args = substr($define_args, 1, length($define_args) - 2);
5931 $define_args =~ s/\s*//g;
5932 $define_args =~ s/\\\+?//g;
5933 @def_args = split(",", $define_args);
5937 $dstat =~ s/\\\n.//g;
5938 $dstat =~ s/^\s*//s;
5939 $dstat =~ s/\s*$//s;
5941 # Flatten any parentheses and braces
5942 while ($dstat =~ s/\([^\(\)]*\)/1u/ ||
5943 $dstat =~ s/\{[^\{\}]*\}/1u/ ||
5944 $dstat =~ s/.\[[^\[\]]*\]/1u/)
5948 # Flatten any obvious string concatenation.
5949 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
5950 $dstat =~ s/$Ident\s*($String)/$1/)
5954 # Make asm volatile uses seem like a generic function
5955 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
5957 my $exceptions = qr{
5970 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
5973 my $stmt_cnt = statement_rawlines($ctx);
5974 my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
5977 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
5978 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
5979 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
5980 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
5981 $dstat !~ /$exceptions/ &&
5982 $dstat !~ /^\.$Ident\s*=/ && # .foo =
5983 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
5984 $dstat !~ /^case\b/ && # case ...
5985 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
5986 $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ && # while (...) {...}
5987 $dstat !~ /^for\s*$Constant$/ && # for (...)
5988 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
5989 $dstat !~ /^do\s*{/ && # do {...
5990 $dstat !~ /^\(\{/ && # ({...
5991 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
5993 if ($dstat =~ /^\s*if\b/) {
5994 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5995 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5996 } elsif ($dstat =~ /;/) {
5997 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5998 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
6000 ERROR("COMPLEX_MACRO",
6001 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
6006 # Make $define_stmt single line, comment-free, etc
6007 my @stmt_array = split('\n', $define_stmt);
6010 foreach my $l (@stmt_array) {
6015 } elsif ($l =~ /^[\+ ]/) {
6016 $define_stmt .= substr($l, 1);
6019 $define_stmt =~ s/$;//g;
6020 $define_stmt =~ s/\s+/ /g;
6021 $define_stmt = trim($define_stmt);
6023 # check if any macro arguments are reused (ignore '...' and 'type')
6024 foreach my $arg (@def_args) {
6025 next if ($arg =~ /\.\.\./);
6026 next if ($arg =~ /^type$/i);
6027 my $tmp_stmt = $define_stmt;
6028 $tmp_stmt =~ s/\b(__must_be_array|offsetof|sizeof|sizeof_field|__stringify|typeof|__typeof__|__builtin\w+|typecheck\s*\(\s*$Type\s*,|\#+)\s*\(*\s*$arg\s*\)*\b//g;
6029 $tmp_stmt =~ s/\#+\s*$arg\b//g;
6030 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
6031 my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
6033 CHK("MACRO_ARG_REUSE",
6034 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
6036 # check if any macro arguments may have other precedence issues
6037 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
6038 ((defined($1) && $1 ne ',') ||
6039 (defined($2) && $2 ne ','))) {
6040 CHK("MACRO_ARG_PRECEDENCE",
6041 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
6045 # check for macros with flow control, but without ## concatenation
6046 # ## concatenation is commonly a macro that defines a function so ignore those
6047 if ($has_flow_statement && !$has_arg_concat) {
6048 my $cnt = statement_rawlines($ctx);
6049 my $herectx = get_stat_here($linenr, $cnt, $here);
6051 WARN("MACRO_WITH_FLOW_CONTROL",
6052 "Macros with flow control statements should be avoided\n" . "$herectx");
6055 # check for line continuations outside of #defines, preprocessor #, and asm
6057 } elsif ($realfile =~ m@/vmlinux.lds.h$@) {
6058 $line =~ s/(\w+)/$maybe_linker_symbol{$1}++/ge;
6059 #print "REAL: $realfile\nln: $line\nkeys:", sort keys %maybe_linker_symbol;
6061 if ($prevline !~ /^..*\\$/ &&
6062 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
6063 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
6064 $line =~ /^\+.*\\$/) {
6065 WARN("LINE_CONTINUATIONS",
6066 "Avoid unnecessary line continuations\n" . $herecurr);
6070 # do {} while (0) macro tests:
6071 # single-statement macros do not need to be enclosed in do while (0) loop,
6072 # macro should not end with a semicolon
6073 if ($perl_version_ok &&
6074 $realfile !~ m@/vmlinux.lds.h$@ &&
6075 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
6078 my ($off, $dstat, $dcond, $rest);
6080 ($dstat, $dcond, $ln, $cnt, $off) =
6081 ctx_statement_block($linenr, $realcnt, 0);
6084 $dstat =~ s/\\\n.//g;
6087 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
6092 my $cnt = statement_rawlines($ctx);
6093 my $herectx = get_stat_here($linenr, $cnt, $here);
6095 if (($stmts =~ tr/;/;/) == 1 &&
6096 $stmts !~ /^\s*(if|while|for|switch)\b/) {
6097 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
6098 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
6100 if (defined $semis && $semis ne "") {
6101 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
6102 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
6104 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
6106 my $cnt = statement_rawlines($ctx);
6107 my $herectx = get_stat_here($linenr, $cnt, $here);
6109 WARN("TRAILING_SEMICOLON",
6110 "macros should not use a trailing semicolon\n" . "$herectx");
6114 # check for redundant bracing round if etc
6115 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
6116 my ($level, $endln, @chunks) =
6117 ctx_statement_full($linenr, $realcnt, 1);
6118 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
6119 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
6120 if ($#chunks > 0 && $level == 0) {
6124 my $herectx = $here . "\n";
6125 my $ln = $linenr - 1;
6126 for my $chunk (@chunks) {
6127 my ($cond, $block) = @{$chunk};
6129 # If the condition carries leading newlines, then count those as offsets.
6130 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
6131 my $offset = statement_rawlines($whitespace) - 1;
6133 $allowed[$allow] = 0;
6134 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
6136 # We have looked at and allowed this specific line.
6137 $suppress_ifbraces{$ln + $offset} = 1;
6139 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
6140 $ln += statement_rawlines($block) - 1;
6142 substr($block, 0, length($cond), '');
6144 $seen++ if ($block =~ /^\s*{/);
6146 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
6147 if (statement_lines($cond) > 1) {
6148 #print "APW: ALLOWED: cond<$cond>\n";
6149 $allowed[$allow] = 1;
6151 if ($block =~/\b(?:if|for|while)\b/) {
6152 #print "APW: ALLOWED: block<$block>\n";
6153 $allowed[$allow] = 1;
6155 if (statement_block_size($block) > 1) {
6156 #print "APW: ALLOWED: lines block<$block>\n";
6157 $allowed[$allow] = 1;
6162 my $sum_allowed = 0;
6163 foreach (@allowed) {
6166 if ($sum_allowed == 0) {
6168 "braces {} are not necessary for any arm of this statement\n" . $herectx);
6169 } elsif ($sum_allowed != $allow &&
6172 "braces {} should be used on all arms of this statement\n" . $herectx);
6177 if (!defined $suppress_ifbraces{$linenr - 1} &&
6178 $line =~ /\b(if|while|for|else)\b/) {
6181 # Check the pre-context.
6182 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
6183 #print "APW: ALLOWED: pre<$1>\n";
6187 my ($level, $endln, @chunks) =
6188 ctx_statement_full($linenr, $realcnt, $-[0]);
6190 # Check the condition.
6191 my ($cond, $block) = @{$chunks[0]};
6192 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
6193 if (defined $cond) {
6194 substr($block, 0, length($cond), '');
6196 if (statement_lines($cond) > 1) {
6197 #print "APW: ALLOWED: cond<$cond>\n";
6200 if ($block =~/\b(?:if|for|while)\b/) {
6201 #print "APW: ALLOWED: block<$block>\n";
6204 if (statement_block_size($block) > 1) {
6205 #print "APW: ALLOWED: lines block<$block>\n";
6208 # Check the post-context.
6209 if (defined $chunks[1]) {
6210 my ($cond, $block) = @{$chunks[1]};
6211 if (defined $cond) {
6212 substr($block, 0, length($cond), '');
6214 if ($block =~ /^\s*\{/) {
6215 #print "APW: ALLOWED: chunk-1 block<$block>\n";
6219 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
6220 my $cnt = statement_rawlines($block);
6221 my $herectx = get_stat_here($linenr, $cnt, $here);
6224 "braces {} are not necessary for single statement blocks\n" . $herectx);
6228 # check for single line unbalanced braces
6229 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
6230 $sline =~ /^.\s*else\s*\{\s*$/) {
6231 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
6234 # check for unnecessary blank lines around braces
6235 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
6237 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
6238 $fix && $prevrawline =~ /^\+/) {
6239 fix_delete_line($fixlinenr - 1, $prevrawline);
6242 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
6244 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
6246 fix_delete_line($fixlinenr, $rawline);
6250 # no volatiles please
6251 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
6252 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
6254 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
6257 # Check for user-visible strings broken across lines, which breaks the ability
6258 # to grep for the string. Make exceptions when the previous string ends in a
6259 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
6260 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
6261 if ($line =~ /^\+\s*$String/ &&
6262 $prevline =~ /"\s*$/ &&
6263 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
6264 if (WARN("SPLIT_STRING",
6265 "quoted string split across lines\n" . $hereprev) &&
6267 $prevrawline =~ /^\+.*"\s*$/ &&
6268 $last_coalesced_string_linenr != $linenr - 1) {
6269 my $extracted_string = get_quoted_string($line, $rawline);
6270 my $comma_close = "";
6271 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
6275 fix_delete_line($fixlinenr - 1, $prevrawline);
6276 fix_delete_line($fixlinenr, $rawline);
6277 my $fixedline = $prevrawline;
6278 $fixedline =~ s/"\s*$//;
6279 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
6280 fix_insert_line($fixlinenr - 1, $fixedline);
6281 $fixedline = $rawline;
6282 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
6283 if ($fixedline !~ /\+\s*$/) {
6284 fix_insert_line($fixlinenr, $fixedline);
6286 $last_coalesced_string_linenr = $linenr;
6290 # check for missing a space in a string concatenation
6291 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
6292 WARN('MISSING_SPACE',
6293 "break quoted strings at a space character\n" . $hereprev);
6296 # check for an embedded function name in a string when the function is known
6297 # This does not work very well for -f --file checking as it depends on patch
6298 # context providing the function name or a single line form for in-file
6299 # function declarations
6300 if ($line =~ /^\+.*$String/ &&
6301 defined($context_function) &&
6302 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
6303 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
6304 WARN("EMBEDDED_FUNCTION_NAME",
6305 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
6308 # check for unnecessary function tracing like uses
6309 # This does not use $logFunctions because there are many instances like
6310 # 'dprintk(FOO, "%s()\n", __func__);' which do not match $logFunctions
6311 if ($rawline =~ /^\+.*\([^"]*"$tracing_logging_tags{0,3}%s(?:\s*\(\s*\)\s*)?$tracing_logging_tags{0,3}(?:\\n)?"\s*,\s*__func__\s*\)\s*;/) {
6312 if (WARN("TRACING_LOGGING",
6313 "Unnecessary ftrace-like logging - prefer using ftrace\n" . $herecurr) &&
6315 fix_delete_line($fixlinenr, $rawline);
6319 # check for spaces before a quoted newline
6320 if ($rawline =~ /^.*\".*\s\\n/) {
6321 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
6322 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
6324 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
6329 # concatenated string without spaces between elements
6330 if ($line =~ /$String[A-Z_]/ ||
6331 ($line =~ /([A-Za-z0-9_]+)$String/ && $1 !~ /^[Lu]$/)) {
6332 if (CHK("CONCATENATED_STRING",
6333 "Concatenated strings should use spaces between elements\n" . $herecurr) &&
6335 while ($line =~ /($String)/g) {
6336 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6337 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
6338 $fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
6343 # uncoalesced string fragments
6344 if ($line =~ /$String\s*[Lu]?"/) {
6345 if (WARN("STRING_FRAGMENTS",
6346 "Consecutive strings are generally better as a single string\n" . $herecurr) &&
6348 while ($line =~ /($String)(?=\s*")/g) {
6349 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6350 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
6355 # check for non-standard and hex prefixed decimal printf formats
6356 my $show_L = 1; #don't show the same defect twice
6358 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
6359 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
6360 $string =~ s/%%/__/g;
6362 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
6364 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
6368 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
6370 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
6373 # check for 0x<decimal>
6374 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
6375 ERROR("PRINTF_0XDECIMAL",
6376 "Prefixing 0x with decimal output is defective\n" . $herecurr);
6380 # check for line continuations in quoted strings with odd counts of "
6381 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
6382 WARN("LINE_CONTINUATIONS",
6383 "Avoid line continuations in quoted strings\n" . $herecurr);
6387 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
6389 "Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
6393 if ($line =~ /^.\s*\#\s*if\s+1\b/) {
6395 "Consider removing the #if 1 and its #endif\n" . $herecurr);
6398 # check for needless "if (<foo>) fn(<foo>)" uses
6399 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
6400 my $tested = quotemeta($1);
6401 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
6402 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
6404 if (WARN('NEEDLESS_IF',
6405 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
6408 my $leading_tabs = "";
6409 my $new_leading_tabs = "";
6410 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
6415 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
6416 $new_leading_tabs = $1;
6417 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
6424 fix_delete_line($fixlinenr - 1, $prevrawline);
6425 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
6431 # check for unnecessary "Out of Memory" messages
6432 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
6433 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
6434 (defined $1 || defined $3) &&
6437 my $testline = $lines[$linenr - 3];
6439 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
6440 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
6442 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
6443 $s !~ /\b__GFP_NOWARN\b/ ) {
6445 "Possible unnecessary 'out of memory' message\n" . $hereprev);
6449 # check for logging functions with KERN_<LEVEL>
6450 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
6451 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
6453 if (WARN("UNNECESSARY_KERN_LEVEL",
6454 "Possible unnecessary $level\n" . $herecurr) &&
6456 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
6460 # check for logging continuations
6461 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
6462 WARN("LOGGING_CONTINUATION",
6463 "Avoid logging continuation uses where feasible\n" . $herecurr);
6466 # check for unnecessary use of %h[xudi] and %hh[xudi] in logging functions
6467 if (defined $stat &&
6468 $line =~ /\b$logFunctions\s*\(/ &&
6469 index($stat, '"') >= 0) {
6470 my $lc = $stat =~ tr@\n@@;
6471 $lc = $lc + $linenr;
6472 my $stat_real = get_stat_real($linenr, $lc);
6473 pos($stat_real) = index($stat_real, '"');
6474 while ($stat_real =~ /[^\"%]*(%[\#\d\.\*\-]*(h+)[idux])/g) {
6477 my $lineoff = substr($stat_real, 0, $-[1]) =~ tr@\n@@;
6478 if (WARN("UNNECESSARY_MODIFIER",
6479 "Integer promotion: Using '$h' in '$pspec' is unnecessary\n" . "$here\n$stat_real\n") &&
6480 $fix && $fixed[$fixlinenr + $lineoff] =~ /^\+/) {
6483 $fixed[$fixlinenr + $lineoff] =~ s/\Q$pspec\E/$nspec/;
6488 # check for mask then right shift without a parentheses
6489 if ($perl_version_ok &&
6490 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
6491 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
6492 WARN("MASK_THEN_SHIFT",
6493 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
6496 # check for pointer comparisons to NULL
6497 if ($perl_version_ok) {
6498 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
6501 $equal = "" if ($4 eq "!=");
6502 if (CHK("COMPARISON_TO_NULL",
6503 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
6505 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
6510 # check for bad placement of section $InitAttribute (e.g.: __initdata)
6511 if ($line =~ /(\b$InitAttribute\b)/) {
6513 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
6516 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
6517 ERROR("MISPLACED_INIT",
6518 "$attr should be placed after $var\n" . $herecurr)) ||
6519 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
6520 WARN("MISPLACED_INIT",
6521 "$attr should be placed after $var\n" . $herecurr))) &&
6523 $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;
6528 # check for $InitAttributeData (ie: __initdata) with const
6529 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
6531 $attr =~ /($InitAttributePrefix)(.*)/;
6532 my $attr_prefix = $1;
6534 if (ERROR("INIT_ATTRIBUTE",
6535 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
6537 $fixed[$fixlinenr] =~
6538 s/$InitAttributeData/${attr_prefix}initconst/;
6542 # check for $InitAttributeConst (ie: __initconst) without const
6543 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
6545 if (ERROR("INIT_ATTRIBUTE",
6546 "Use of $attr requires a separate use of const\n" . $herecurr) &&
6548 my $lead = $fixed[$fixlinenr] =~
6549 /(^\+\s*(?:static\s+))/;
6551 $lead = "$lead " if ($lead !~ /^\+$/);
6552 $lead = "${lead}const ";
6553 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
6557 # check for __read_mostly with const non-pointer (should just be const)
6558 if ($line =~ /\b__read_mostly\b/ &&
6559 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
6560 if (ERROR("CONST_READ_MOSTLY",
6561 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
6563 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
6567 # don't use __constant_<foo> functions outside of include/uapi/
6568 if ($realfile !~ m@^include/uapi/@ &&
6569 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
6570 my $constant_func = $1;
6571 my $func = $constant_func;
6572 $func =~ s/^__constant_//;
6573 if (WARN("CONSTANT_CONVERSION",
6574 "$constant_func should be $func\n" . $herecurr) &&
6576 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
6580 # prefer usleep_range over udelay
6581 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
6583 # ignore udelay's < 10, however
6584 if (! ($delay < 10) ) {
6586 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6588 if ($delay > 2000) {
6590 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
6594 # warn about unexpectedly long msleep's
6595 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
6598 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6602 # check for comparisons of jiffies
6603 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
6604 WARN("JIFFIES_COMPARISON",
6605 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
6608 # check for comparisons of get_jiffies_64()
6609 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
6610 WARN("JIFFIES_COMPARISON",
6611 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
6614 # warn about #ifdefs in C files
6615 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
6616 # print "#ifdef in C files should be avoided\n";
6617 # print "$herecurr";
6621 # warn about spacing in #ifdefs
6622 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
6623 if (ERROR("SPACING",
6624 "exactly one space required after that #$1\n" . $herecurr) &&
6626 $fixed[$fixlinenr] =~
6627 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
6632 # check for spinlock_t definitions without a comment.
6633 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
6634 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
6636 if (!ctx_has_comment($first_line, $linenr)) {
6637 CHK("UNCOMMENTED_DEFINITION",
6638 "$1 definition without comment\n" . $herecurr);
6641 # check for memory barriers without a comment.
6648 my $barrier_stems = qr{
6656 my $all_barriers = qr{
6658 smp_(?:$barrier_stems)|
6659 virt_(?:$barrier_stems)
6662 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
6663 if (!ctx_has_comment($first_line, $linenr)) {
6664 WARN("MEMORY_BARRIER",
6665 "memory barrier without comment\n" . $herecurr);
6669 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
6671 if ($realfile !~ m@^include/asm-generic/@ &&
6672 $realfile !~ m@/barrier\.h$@ &&
6673 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
6674 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
6675 WARN("MEMORY_BARRIER",
6676 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6679 # check for waitqueue_active without a comment.
6680 if ($line =~ /\bwaitqueue_active\s*\(/) {
6681 if (!ctx_has_comment($first_line, $linenr)) {
6682 WARN("WAITQUEUE_ACTIVE",
6683 "waitqueue_active without comment\n" . $herecurr);
6687 # check for data_race without a comment.
6688 if ($line =~ /\bdata_race\s*\(/) {
6689 if (!ctx_has_comment($first_line, $linenr)) {
6691 "data_race without comment\n" . $herecurr);
6695 # check of hardware specific defines
6696 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
6698 "architecture specific defines should be avoided\n" . $herecurr);
6701 # check that the storage class is not after a type
6702 if ($line =~ /\b($Type)\s+($Storage)\b/) {
6703 WARN("STORAGE_CLASS",
6704 "storage class '$2' should be located before type '$1'\n" . $herecurr);
6706 # Check that the storage class is at the beginning of a declaration
6707 if ($line =~ /\b$Storage\b/ &&
6708 $line !~ /^.\s*$Storage/ &&
6709 $line =~ /^.\s*(.+?)\$Storage\s/ &&
6710 $1 !~ /[\,\)]\s*$/) {
6711 WARN("STORAGE_CLASS",
6712 "storage class should be at the beginning of the declaration\n" . $herecurr);
6715 # check the location of the inline attribute, that it is between
6716 # storage class and type.
6717 if ($line =~ /\b$Type\s+$Inline\b/ ||
6718 $line =~ /\b$Inline\s+$Storage\b/) {
6719 ERROR("INLINE_LOCATION",
6720 "inline keyword should sit between storage class and type\n" . $herecurr);
6723 # Check for __inline__ and __inline, prefer inline
6724 if ($realfile !~ m@\binclude/uapi/@ &&
6725 $line =~ /\b(__inline__|__inline)\b/) {
6727 "plain inline is preferred over $1\n" . $herecurr) &&
6729 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
6734 # Check for compiler attributes
6735 if ($realfile !~ m@\binclude/uapi/@ &&
6736 $rawline =~ /\b__attribute__\s*\(\s*($balanced_parens)\s*\)/) {
6738 $attr =~ s/\s*\(\s*(.*)\)\s*/$1/;
6741 "alias" => "__alias",
6742 "aligned" => "__aligned",
6743 "always_inline" => "__always_inline",
6744 "assume_aligned" => "__assume_aligned",
6746 "const" => "__attribute_const__",
6748 "designated_init" => "__designated_init",
6749 "externally_visible" => "__visible",
6750 "format" => "printf|scanf",
6751 "gnu_inline" => "__gnu_inline",
6752 "malloc" => "__malloc",
6754 "no_caller_saved_registers" => "__no_caller_saved_registers",
6755 "noclone" => "__noclone",
6756 "noinline" => "noinline",
6757 "nonstring" => "__nonstring",
6758 "noreturn" => "__noreturn",
6759 "packed" => "__packed",
6761 "section" => "__section",
6766 while ($attr =~ /\s*(\w+)\s*(${balanced_parens})?/g) {
6769 $params = $2 if defined($2);
6770 my $curr_attr = $orig_attr;
6771 $curr_attr =~ s/^[\s_]+|[\s_]+$//g;
6772 if (exists($attr_list{$curr_attr})) {
6773 my $new = $attr_list{$curr_attr};
6774 if ($curr_attr eq "format" && $params) {
6775 $params =~ /^\s*\(\s*(\w+)\s*,\s*(.*)/;
6778 $new = "$new$params";
6780 if (WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6781 "Prefer $new over __attribute__(($orig_attr$params))\n" . $herecurr) &&
6783 my $remove = "\Q$orig_attr\E" . '\s*' . "\Q$params\E" . '(?:\s*,\s*)?';
6784 $fixed[$fixlinenr] =~ s/$remove//;
6785 $fixed[$fixlinenr] =~ s/\b__attribute__/$new __attribute__/;
6786 $fixed[$fixlinenr] =~ s/\}\Q$new\E/} $new/;
6787 $fixed[$fixlinenr] =~ s/ __attribute__\s*\(\s*\(\s*\)\s*\)//;
6792 # Check for __attribute__ unused, prefer __always_unused or __maybe_unused
6793 if ($attr =~ /^_*unused/) {
6794 WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6795 "__always_unused or __maybe_unused is preferred over __attribute__((__unused__))\n" . $herecurr);
6799 # Check for __attribute__ weak, or __weak declarations (may have link issues)
6800 if ($perl_version_ok &&
6801 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
6802 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
6803 $line =~ /\b__weak\b/)) {
6804 ERROR("WEAK_DECLARATION",
6805 "Using weak declarations can have unintended link defects\n" . $herecurr);
6808 # check for c99 types like uint8_t used outside of uapi/ and tools/
6809 if ($realfile !~ m@\binclude/uapi/@ &&
6810 $realfile !~ m@\btools/@ &&
6811 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
6813 if ($type =~ /\b($typeC99Typedefs)\b/) {
6815 my $kernel_type = 'u';
6816 $kernel_type = 's' if ($type =~ /^_*[si]/);
6819 if (CHK("PREFER_KERNEL_TYPES",
6820 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6822 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6827 # check for cast of C90 native int or longer types constants
6828 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
6832 my $newconst = $const;
6833 $newconst =~ s/${Int_type}$//;
6834 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6835 if ($cast =~ /\blong\s+long\b/) {
6837 } elsif ($cast =~ /\blong\b/) {
6840 if (WARN("TYPECAST_INT_CONSTANT",
6841 "Unnecessary typecast of c90 int constant - '$cast$const' could be '$const$suffix'\n" . $herecurr) &&
6843 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6847 # check for sizeof(&)
6848 if ($line =~ /\bsizeof\s*\(\s*\&/) {
6849 WARN("SIZEOF_ADDRESS",
6850 "sizeof(& should be avoided\n" . $herecurr);
6853 # check for sizeof without parenthesis
6854 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
6855 if (WARN("SIZEOF_PARENTHESIS",
6856 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6858 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
6862 # check for struct spinlock declarations
6863 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
6864 WARN("USE_SPINLOCK_T",
6865 "struct spinlock should be spinlock_t\n" . $herecurr);
6868 # check for seq_printf uses that could be seq_puts
6869 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
6870 my $fmt = get_quoted_string($line, $rawline);
6873 if (WARN("PREFER_SEQ_PUTS",
6874 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
6876 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6881 # check for vsprintf extension %p<foo> misuses
6882 if ($perl_version_ok &&
6884 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
6885 $1 !~ /^_*volatile_*$/) {
6888 my $lc = $stat =~ tr@\n@@;
6889 $lc = $lc + $linenr;
6890 for (my $count = $linenr; $count <= $lc; $count++) {
6894 my $bad_specifier = "";
6895 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
6898 while ($fmt =~ /(\%[\*\d\.]*p(\w)(\w*))/g) {
6902 if ($extension !~ /[4SsBKRraEehMmIiUDdgVCbGNOxtf]/ ||
6903 ($extension eq "f" &&
6904 defined $qualifier && $qualifier !~ /^w/) ||
6905 ($extension eq "4" &&
6906 defined $qualifier && $qualifier !~ /^cc/)) {
6907 $bad_specifier = $specifier;
6910 if ($extension eq "x" && !defined($stat_real)) {
6911 if (!defined($stat_real)) {
6912 $stat_real = get_stat_real($linenr, $lc);
6914 WARN("VSPRINTF_SPECIFIER_PX",
6915 "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");
6918 if ($bad_specifier ne "") {
6919 my $stat_real = get_stat_real($linenr, $lc);
6920 my $msg_level = \&WARN;
6921 my $ext_type = "Invalid";
6923 if ($bad_specifier =~ /p[Ff]/) {
6924 $use = " - use %pS instead";
6925 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6926 } elsif ($bad_specifier =~ /pA/) {
6927 $use = " - '%pA' is only intended to be used from Rust code";
6928 $msg_level = \&ERROR;
6931 &{$msg_level}("VSPRINTF_POINTER_EXTENSION",
6932 "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6937 # Check for misused memsets
6938 if ($perl_version_ok &&
6940 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
6946 if ($ms_size =~ /^(0x|)0$/i) {
6948 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6949 } elsif ($ms_size =~ /^(0x|)1$/i) {
6951 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6955 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6956 # if ($perl_version_ok &&
6958 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6959 # if (WARN("PREFER_ETHER_ADDR_COPY",
6960 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6962 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
6966 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6967 # if ($perl_version_ok &&
6969 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6970 # WARN("PREFER_ETHER_ADDR_EQUAL",
6971 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6974 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6975 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
6976 # if ($perl_version_ok &&
6978 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6982 # if ($ms_val =~ /^(?:0x|)0+$/i) {
6983 # if (WARN("PREFER_ETH_ZERO_ADDR",
6984 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
6986 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
6988 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
6989 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
6990 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
6992 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
6997 # strcpy uses that should likely be strscpy
6998 if ($line =~ /\bstrcpy\s*\(/) {
7000 "Prefer strscpy over strcpy - see: https://github.com/KSPP/linux/issues/88\n" . $herecurr);
7003 # strlcpy uses that should likely be strscpy
7004 if ($line =~ /\bstrlcpy\s*\(/) {
7006 "Prefer strscpy over strlcpy - see: https://github.com/KSPP/linux/issues/89\n" . $herecurr);
7009 # strncpy uses that should likely be strscpy or strscpy_pad
7010 if ($line =~ /\bstrncpy\s*\(/) {
7012 "Prefer strscpy, strscpy_pad, or __nonstring over strncpy - see: https://github.com/KSPP/linux/issues/90\n" . $herecurr);
7015 # ethtool_sprintf uses that should likely be ethtool_puts
7016 if ($line =~ /\bethtool_sprintf\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
7017 if (WARN("PREFER_ETHTOOL_PUTS",
7018 "Prefer ethtool_puts over ethtool_sprintf with only two arguments\n" . $herecurr) &&
7020 $fixed[$fixlinenr] =~ s/\bethtool_sprintf\s*\(\s*($FuncArg)\s*,\s*($FuncArg)/ethtool_puts($1, $7)/;
7024 # use $rawline because $line loses %s via sanitization and thus we can't match against it.
7025 if ($rawline =~ /\bethtool_sprintf\s*\(\s*$FuncArg\s*,\s*\"\%s\"\s*,\s*$FuncArg\s*\)/) {
7026 if (WARN("PREFER_ETHTOOL_PUTS",
7027 "Prefer ethtool_puts over ethtool_sprintf with standalone \"%s\" specifier\n" . $herecurr) &&
7029 $fixed[$fixlinenr] =~ s/\bethtool_sprintf\s*\(\s*($FuncArg)\s*,\s*"\%s"\s*,\s*($FuncArg)/ethtool_puts($1, $7)/;
7034 # typecasts on min/max could be min_t/max_t
7035 if ($perl_version_ok &&
7037 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
7038 if (defined $2 || defined $7) {
7040 my $cast1 = deparenthesize($2);
7042 my $cast2 = deparenthesize($7);
7046 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
7047 $cast = "$cast1 or $cast2";
7048 } elsif ($cast1 ne "") {
7054 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
7058 # check usleep_range arguments
7059 if ($perl_version_ok &&
7061 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
7065 WARN("USLEEP_RANGE",
7066 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
7067 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
7069 WARN("USLEEP_RANGE",
7070 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
7074 # check for naked sscanf
7075 if ($perl_version_ok &&
7077 $line =~ /\bsscanf\b/ &&
7078 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
7079 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
7080 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
7081 my $lc = $stat =~ tr@\n@@;
7082 $lc = $lc + $linenr;
7083 my $stat_real = get_stat_real($linenr, $lc);
7084 WARN("NAKED_SSCANF",
7085 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
7088 # check for simple sscanf that should be kstrto<foo>
7089 if ($perl_version_ok &&
7091 $line =~ /\bsscanf\b/) {
7092 my $lc = $stat =~ tr@\n@@;
7093 $lc = $lc + $linenr;
7094 my $stat_real = get_stat_real($linenr, $lc);
7095 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
7097 my $count = $format =~ tr@%@%@;
7099 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
7100 WARN("SSCANF_TO_KSTRTO",
7101 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
7106 # check for new externs in .h files.
7107 if ($realfile =~ /\.h$/ &&
7108 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
7109 if (CHK("AVOID_EXTERNS",
7110 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
7112 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
7116 # check for new externs in .c files.
7117 if ($realfile =~ /\.c$/ && defined $stat &&
7118 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
7120 my $function_name = $1;
7121 my $paren_space = $2;
7124 if (defined $cond) {
7125 substr($s, 0, length($cond), '');
7129 WARN("AVOID_EXTERNS",
7130 "externs should be avoided in .c files\n" . $herecurr);
7133 if ($paren_space =~ /\n/) {
7134 WARN("FUNCTION_ARGUMENTS",
7135 "arguments for function declarations should follow identifier\n" . $herecurr);
7138 } elsif ($realfile =~ /\.c$/ && defined $stat &&
7139 $stat =~ /^\+extern struct\s+(\w+)\s+(\w+)\[\];/)
7141 my ($st_type, $st_name) = ($1, $2);
7143 for my $s (keys %maybe_linker_symbol) {
7144 #print "Linker symbol? $st_name : $s\n";
7145 goto LIKELY_LINKER_SYMBOL
7146 if $st_name =~ /$s/;
7148 WARN("AVOID_EXTERNS",
7149 "found a file-scoped extern type:$st_type name:$st_name in .c file\n"
7150 . "is this a linker symbol ?\n" . $herecurr);
7151 LIKELY_LINKER_SYMBOL:
7153 } elsif ($realfile =~ /\.c$/ && defined $stat &&
7154 $stat =~ /^.\s*extern\s+/)
7156 WARN("AVOID_EXTERNS",
7157 "externs should be avoided in .c files\n" . $herecurr);
7160 # check for function declarations that have arguments without identifier names
7161 if (defined $stat &&
7162 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
7164 my $args = trim($1);
7165 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
7167 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
7168 WARN("FUNCTION_ARGUMENTS",
7169 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
7174 # check for function definitions
7175 if ($perl_version_ok &&
7177 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
7178 $context_function = $1;
7180 # check for multiline function definition with misplaced open brace
7182 my $cnt = statement_rawlines($stat);
7183 my $herectx = $here . "\n";
7184 for (my $n = 0; $n < $cnt; $n++) {
7185 my $rl = raw_line($linenr, $n);
7186 $herectx .= $rl . "\n";
7187 $ok = 1 if ($rl =~ /^[ \+]\{/);
7188 $ok = 1 if ($rl =~ /\{/ && $n == 0);
7189 last if $rl =~ /^[ \+].*\{/;
7193 "open brace '{' following function definitions go on the next line\n" . $herectx);
7197 # checks for new __setup's
7198 if ($rawline =~ /\b__setup\("([^"]*)"/) {
7201 if (!grep(/$name/, @setup_docs)) {
7202 CHK("UNDOCUMENTED_SETUP",
7203 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
7207 # check for pointless casting of alloc functions
7208 if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
7209 WARN("UNNECESSARY_CASTS",
7210 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
7214 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
7215 if ($perl_version_ok &&
7216 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
7217 CHK("ALLOC_SIZEOF_STRUCT",
7218 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
7221 # check for (kv|k)[mz]alloc with multiplies that could be kmalloc_array/kvmalloc_array/kvcalloc/kcalloc
7222 if ($perl_version_ok &&
7224 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k)[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
7228 my $newfunc = "kmalloc_array";
7229 $newfunc = "kvmalloc_array" if ($oldfunc eq "kvmalloc");
7230 $newfunc = "kvcalloc" if ($oldfunc eq "kvzalloc");
7231 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
7234 if ($a1 =~ /^sizeof\s*\S/) {
7238 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
7239 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
7240 my $cnt = statement_rawlines($stat);
7241 my $herectx = get_stat_here($linenr, $cnt, $here);
7243 if (WARN("ALLOC_WITH_MULTIPLY",
7244 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
7247 $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k)[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
7252 # check for krealloc arg reuse
7253 if ($perl_version_ok &&
7254 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*($Lval)\s*,/ &&
7256 WARN("KREALLOC_ARG_REUSE",
7257 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
7260 # check for alloc argument mismatch
7261 if ($line =~ /\b((?:devm_)?((?:k|kv)?(calloc|malloc_array)(?:_node)?))\s*\(\s*sizeof\b/) {
7262 WARN("ALLOC_ARRAY_ARGS",
7263 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
7266 # check for multiple semicolons
7267 if ($line =~ /;\s*;\s*$/) {
7268 if (WARN("ONE_SEMICOLON",
7269 "Statements terminations use 1 semicolon\n" . $herecurr) &&
7271 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
7275 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
7276 if ($realfile !~ m@^include/uapi/@ &&
7277 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
7279 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
7280 if (CHK("BIT_MACRO",
7281 "Prefer using the BIT$ull macro\n" . $herecurr) &&
7283 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
7287 # check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
7288 if ($rawline =~ /\bIS_ENABLED\s*\(\s*(\w+)\s*\)/ && $1 !~ /^${CONFIG_}/) {
7289 WARN("IS_ENABLED_CONFIG",
7290 "IS_ENABLED($1) is normally used as IS_ENABLED(${CONFIG_}$1)\n" . $herecurr);
7293 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
7294 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(${CONFIG_}[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
7296 if (WARN("PREFER_IS_ENABLED",
7297 "Prefer IS_ENABLED(<FOO>) to ${CONFIG_}<FOO> || ${CONFIG_}<FOO>_MODULE\n" . $herecurr) &&
7299 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
7303 # check for /* fallthrough */ like comment, prefer fallthrough;
7304 my @fallthroughs = (
7307 'lint -fallthrough[ \t]*',
7308 'intentional(?:ly)?[ \t]*fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)',
7309 '(?:else,?\s*)?FALL(?:S | |-)?THR(?:OUGH|U|EW)[ \t.!]*(?:-[^\n\r]*)?',
7310 'Fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7311 'fall(?:s | |-)?thr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7313 if ($raw_comment ne '') {
7314 foreach my $ft (@fallthroughs) {
7315 if ($raw_comment =~ /$ft/) {
7316 my $msg_level = \&WARN;
7317 $msg_level = \&CHK if ($file);
7318 &{$msg_level}("PREFER_FALLTHROUGH",
7319 "Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
7325 # check for switch/default statements without a break;
7326 if ($perl_version_ok &&
7328 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
7329 my $cnt = statement_rawlines($stat);
7330 my $herectx = get_stat_here($linenr, $cnt, $here);
7332 WARN("DEFAULT_NO_BREAK",
7333 "switch default: should use break\n" . $herectx);
7336 # check for gcc specific __FUNCTION__
7337 if ($line =~ /\b__FUNCTION__\b/) {
7338 if (WARN("USE_FUNC",
7339 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
7341 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
7345 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
7346 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
7348 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
7351 # check for use of yield()
7352 if ($line =~ /\byield\s*\(\s*\)/) {
7354 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
7357 # check for comparisons against true and false
7358 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
7366 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
7368 my $type = lc($otype);
7369 if ($type =~ /^(?:true|false)$/) {
7370 if (("$test" eq "==" && "$type" eq "true") ||
7371 ("$test" eq "!=" && "$type" eq "false")) {
7375 CHK("BOOL_COMPARISON",
7376 "Using comparison to $otype is error prone\n" . $herecurr);
7378 ## maybe suggesting a correct construct would better
7379 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
7384 # check for semaphores initialized locked
7385 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
7386 WARN("CONSIDER_COMPLETION",
7387 "consider using a completion\n" . $herecurr);
7390 # recommend kstrto* over simple_strto* and strict_strto*
7391 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
7392 WARN("CONSIDER_KSTRTO",
7393 "$1 is obsolete, use k$3 instead\n" . $herecurr);
7396 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
7397 if ($line =~ /^.\s*__initcall\s*\(/) {
7398 WARN("USE_DEVICE_INITCALL",
7399 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
7402 # check for spin_is_locked(), suggest lockdep instead
7403 if ($line =~ /\bspin_is_locked\(/) {
7405 "Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
7408 # check for deprecated apis
7409 if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
7410 my $deprecated_api = $1;
7411 my $new_api = $deprecated_apis{$deprecated_api};
7412 WARN("DEPRECATED_API",
7413 "Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
7416 # check for various structs that are normally const (ops, kgdb, device_tree)
7417 # and avoid what seem like struct definitions 'struct foo {'
7418 if (defined($const_structs) &&
7419 $line !~ /\bconst\b/ &&
7420 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
7421 WARN("CONST_STRUCT",
7422 "struct $1 should normally be const\n" . $herecurr);
7425 # use of NR_CPUS is usually wrong
7426 # ignore definitions of NR_CPUS and usage to define arrays as likely right
7427 # ignore designated initializers using NR_CPUS
7428 if ($line =~ /\bNR_CPUS\b/ &&
7429 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
7430 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
7431 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
7432 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
7433 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/ &&
7434 $line !~ /^.\s*\.\w+\s*=\s*.*\bNR_CPUS\b/)
7437 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
7440 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
7441 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
7442 ERROR("DEFINE_ARCH_HAS",
7443 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
7446 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
7447 if ($perl_version_ok &&
7448 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
7449 WARN("LIKELY_MISUSE",
7450 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
7453 # return sysfs_emit(foo, fmt, ...) fmt without newline
7454 if ($line =~ /\breturn\s+sysfs_emit\s*\(\s*$FuncArg\s*,\s*($String)/ &&
7455 substr($rawline, $-[6], $+[6] - $-[6]) !~ /\\n"$/) {
7456 my $offset = $+[6] - 1;
7457 if (WARN("SYSFS_EMIT",
7458 "return sysfs_emit(...) formats should include a terminating newline\n" . $herecurr) &&
7460 substr($fixed[$fixlinenr], $offset, 0) = '\\n';
7464 # check for array definition/declarations that should use flexible arrays instead
7465 if ($sline =~ /^[\+ ]\s*\}(?:\s*__packed)?\s*;\s*$/ &&
7466 $prevline =~ /^\+\s*(?:\}(?:\s*__packed\s*)?|$Type)\s*$Ident\s*\[\s*(0|1)\s*\]\s*;\s*$/) {
7467 if (ERROR("FLEXIBLE_ARRAY",
7468 "Use C99 flexible arrays - see https://docs.kernel.org/process/deprecated.html#zero-length-and-one-element-arrays\n" . $hereprev) &&
7469 $1 == '0' && $fix) {
7470 $fixed[$fixlinenr - 1] =~ s/\[\s*0\s*\]/[]/;
7474 # nested likely/unlikely calls
7475 if ($line =~ /\b(?:(?:un)?likely)\s*\(\s*!?\s*(IS_ERR(?:_OR_NULL|_VALUE)?|WARN)/) {
7476 WARN("LIKELY_MISUSE",
7477 "nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
7480 # whine mightly about in_atomic
7481 if ($line =~ /\bin_atomic\s*\(/) {
7482 if ($realfile =~ m@^drivers/@) {
7484 "do not use in_atomic in drivers\n" . $herecurr);
7485 } elsif ($realfile !~ m@^kernel/@) {
7487 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
7491 # Complain about RCU Tasks Trace used outside of BPF (and of course, RCU).
7492 our $rcu_trace_funcs = qr{(?x:
7493 rcu_read_lock_trace |
7494 rcu_read_lock_trace_held |
7495 rcu_read_unlock_trace |
7496 call_rcu_tasks_trace |
7497 synchronize_rcu_tasks_trace |
7498 rcu_barrier_tasks_trace |
7499 rcu_request_urgent_qs_task
7501 our $rcu_trace_paths = qr{(?x:
7508 if ($line =~ /\b($rcu_trace_funcs)\s*\(/) {
7509 if ($realfile !~ m{^$rcu_trace_paths}) {
7510 WARN("RCU_TASKS_TRACE",
7511 "use of RCU tasks trace is incorrect outside BPF or core RCU code\n" . $herecurr);
7515 # check for lockdep_set_novalidate_class
7516 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
7517 $line =~ /__lockdep_no_validate__\s*\)/ ) {
7518 if ($realfile !~ m@^kernel/lockdep@ &&
7519 $realfile !~ m@^include/linux/lockdep@ &&
7520 $realfile !~ m@^drivers/base/core@) {
7522 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
7526 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
7527 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
7528 WARN("EXPORTED_WORLD_WRITABLE",
7529 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
7532 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
7533 # and whether or not function naming is typical and if
7534 # DEVICE_ATTR permissions uses are unusual too
7535 if ($perl_version_ok &&
7537 $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*\)/) {
7542 my $octal_perms = perms_to_octal($perms);
7543 if ($show =~ /^${var}_show$/ &&
7544 $store =~ /^${var}_store$/ &&
7545 $octal_perms eq "0644") {
7546 if (WARN("DEVICE_ATTR_RW",
7547 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
7549 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
7551 } elsif ($show =~ /^${var}_show$/ &&
7552 $store =~ /^NULL$/ &&
7553 $octal_perms eq "0444") {
7554 if (WARN("DEVICE_ATTR_RO",
7555 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
7557 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
7559 } elsif ($show =~ /^NULL$/ &&
7560 $store =~ /^${var}_store$/ &&
7561 $octal_perms eq "0200") {
7562 if (WARN("DEVICE_ATTR_WO",
7563 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
7565 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
7567 } elsif ($octal_perms eq "0644" ||
7568 $octal_perms eq "0444" ||
7569 $octal_perms eq "0200") {
7570 my $newshow = "$show";
7571 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
7572 my $newstore = $store;
7573 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
7575 if ($show ne $newshow) {
7576 $rename .= " '$show' to '$newshow'";
7578 if ($store ne $newstore) {
7579 $rename .= " '$store' to '$newstore'";
7581 WARN("DEVICE_ATTR_FUNCTIONS",
7582 "Consider renaming function(s)$rename\n" . $herecurr);
7584 WARN("DEVICE_ATTR_PERMS",
7585 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
7589 # Mode permission misuses where it seems decimal should be octal
7590 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
7591 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
7592 # specific definition of not visible in sysfs.
7593 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
7594 # use the default permissions
7595 if ($perl_version_ok &&
7597 $line =~ /$mode_perms_search/) {
7598 foreach my $entry (@mode_permission_funcs) {
7599 my $func = $entry->[0];
7600 my $arg_pos = $entry->[1];
7602 my $lc = $stat =~ tr@\n@@;
7603 $lc = $lc + $linenr;
7604 my $stat_real = get_stat_real($linenr, $lc);
7609 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
7611 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
7612 if ($stat =~ /$test/) {
7614 $val = $6 if ($skip_args ne "");
7615 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
7616 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
7617 ($val =~ /^$Octal$/ && length($val) ne 4))) {
7618 ERROR("NON_OCTAL_PERMISSIONS",
7619 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
7621 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
7622 ERROR("EXPORTED_WORLD_WRITABLE",
7623 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
7629 # check for uses of S_<PERMS> that could be octal for readability
7630 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
7632 my $octal = perms_to_octal($oval);
7633 if (WARN("SYMBOLIC_PERMS",
7634 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
7636 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
7640 # validate content of MODULE_LICENSE against list from include/linux/module.h
7641 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
7642 my $extracted_string = get_quoted_string($line, $rawline);
7643 my $valid_licenses = qr{
7646 GPL\ and\ additional\ rights|
7652 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
7653 WARN("MODULE_LICENSE",
7654 "unknown module license " . $extracted_string . "\n" . $herecurr);
7656 if (!$file && $extracted_string eq '"GPL v2"') {
7657 if (WARN("MODULE_LICENSE",
7658 "Prefer \"GPL\" over \"GPL v2\" - see commit bf7fbeeae6db (\"module: Cure the MODULE_LICENSE \"GPL\" vs. \"GPL v2\" bogosity\")\n" . $herecurr) &&
7660 $fixed[$fixlinenr] =~ s/\bMODULE_LICENSE\s*\(\s*"GPL v2"\s*\)/MODULE_LICENSE("GPL")/;
7665 # check for sysctl duplicate constants
7666 if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
7667 WARN("DUPLICATED_SYSCTL_CONST",
7668 "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
7672 # If we have no input at all, then there is nothing to report on
7673 # so just keep quiet.
7674 if ($#rawlines == -1) {
7678 # In mailback mode only produce a report in the negative, for
7679 # things that appear to be patches.
7680 if ($mailback && ($clean == 1 || !$is_patch)) {
7684 # This is not a patch, and we are in 'no-patch' mode so
7686 if (!$chk_patch && !$is_patch) {
7690 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
7691 ERROR("NOT_UNIFIED_DIFF",
7692 "Does not appear to be a unified-diff format patch\n");
7694 if ($is_patch && $has_commit_log && $chk_signoff) {
7695 if ($signoff == 0) {
7696 ERROR("MISSING_SIGN_OFF",
7697 "Missing Signed-off-by: line(s)\n");
7698 } elsif ($authorsignoff != 1) {
7699 # authorsignoff values:
7700 # 0 -> missing sign off
7701 # 1 -> sign off identical
7702 # 2 -> names and addresses match, comments mismatch
7703 # 3 -> addresses match, names different
7704 # 4 -> names match, addresses different
7705 # 5 -> names match, addresses excluding subaddress details (refer RFC 5233) match
7707 my $sob_msg = "'From: $author' != 'Signed-off-by: $author_sob'";
7709 if ($authorsignoff == 0) {
7710 ERROR("NO_AUTHOR_SIGN_OFF",
7711 "Missing Signed-off-by: line by nominal patch author '$author'\n");
7712 } elsif ($authorsignoff == 2) {
7713 CHK("FROM_SIGN_OFF_MISMATCH",
7714 "From:/Signed-off-by: email comments mismatch: $sob_msg\n");
7715 } elsif ($authorsignoff == 3) {
7716 WARN("FROM_SIGN_OFF_MISMATCH",
7717 "From:/Signed-off-by: email name mismatch: $sob_msg\n");
7718 } elsif ($authorsignoff == 4) {
7719 WARN("FROM_SIGN_OFF_MISMATCH",
7720 "From:/Signed-off-by: email address mismatch: $sob_msg\n");
7721 } elsif ($authorsignoff == 5) {
7722 WARN("FROM_SIGN_OFF_MISMATCH",
7723 "From:/Signed-off-by: email subaddress mismatch: $sob_msg\n");
7728 print report_dump();
7729 if ($summary && !($clean == 1 && $quiet == 1)) {
7730 print "$filename " if ($summary_file);
7731 print "total: $cnt_error errors, $cnt_warn warnings, " .
7732 (($check)? "$cnt_chk checks, " : "") .
7733 "$cnt_lines lines checked\n";
7737 # If there were any defects found and not already fixing them
7738 if (!$clean and !$fix) {
7741 NOTE: For some of the reported defects, checkpatch may be able to
7742 mechanically convert to the typical style using --fix or --fix-inplace.
7745 # If there were whitespace errors which cleanpatch can fix
7746 # then suggest that.
7747 if ($rpt_cleaners) {
7751 NOTE: Whitespace errors detected.
7752 You may wish to use scripts/cleanpatch or scripts/cleanfile
7757 if ($clean == 0 && $fix &&
7758 ("@rawlines" ne "@fixed" ||
7759 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
7760 my $newfile = $filename;
7761 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
7765 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
7767 open($f, '>', $newfile)
7768 or die "$P: Can't open $newfile for write\n";
7769 foreach my $fixed_line (@fixed) {
7772 if ($linecount > 3) {
7773 $fixed_line =~ s/^\+//;
7774 print $f $fixed_line . "\n";
7777 print $f $fixed_line . "\n";
7785 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
7787 Do _NOT_ trust the results written to this file.
7788 Do _NOT_ submit these changes without inspecting them for correctness.
7790 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
7791 No warranties, expressed or implied...
7799 print "$vname has no obvious style problems and is ready for submission.\n";
7801 print "$vname has style problems, please review.\n";