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);
25 # ATTENTION: easily track modification to this script for OpenOCD.
26 # When possible, don't modify the existing code, don't change its indentation,
27 # but remove it enclosing it within:
33 # Mark every addition within comments
34 # # OpenOCD specific: Begin[: additional comment]
35 # # OpenOCD specific: End
40 my %verbose_messages = ();
41 my %verbose_emitted = ();
62 my $gitroot = $ENV{'GIT_DIR'};
63 $gitroot = ".git" if !defined($gitroot);
71 my $configuration_file = ".checkpatch.conf";
72 my $max_line_length = 100;
73 my $ignore_perl_version = 0;
74 my $minimum_perl_version = 5.10.0;
75 my $min_conf_desc_length = 4;
76 my $spelling_file = "$D/spelling.txt";
78 my $codespellfile = "/usr/share/codespell/dictionary.txt";
79 my $user_codespellfile = "";
80 my $conststructsfile = "$D/const_structs.checkpatch";
81 my $docsfile = "$D/../Documentation/dev-tools/checkpatch.rst";
84 my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
85 # git output parsing needs US English output, so first set backtick child process LANGUAGE
86 my $git_command ='export LANGUAGE=en_US.UTF-8; git';
88 my ${CONFIG_
} = "CONFIG_";
94 Usage
: $P [OPTION
]... [FILE
]...
99 -v
, --verbose verbose mode
100 --no-tree run without a kernel tree
101 --no-signoff
do not check
for 'Signed-off-by' line
102 --patch treat FILE as patchfile
(default)
103 --emacs emacs compile window format
104 --terse one line per report
105 --showfile emit diffed file position
, not input file position
106 -g
, --git treat FILE as a single commit
or git revision range
107 single git commit with
:
111 multiple git commits with
:
115 git merges are ignored
116 -f
, --file treat FILE as regular source file
117 --subjective
, --strict enable more subjective tests
118 --list
-types list the possible message types
119 --types TYPE
(,TYPE2
...) show only these comma separated message types
120 --ignore TYPE
(,TYPE2
...) ignore various comma separated message types
121 --show
-types show the specific message type
in the output
122 --max
-line
-length=n set the maximum line
length, (default $max_line_length)
123 if exceeded
, warn on patches
124 requires
--strict
for use with
--file
125 --min
-conf
-desc
-length=n set the min description
length, if shorter
, warn
126 --tab
-size
=n set the number of spaces
for tab
(default $tabsize)
127 --root
=PATH PATH to the kernel tree root
128 --no-summary suppress the per
-file summary
129 --mailback only produce a report
in case of warnings
/errors
130 --summary
-file include the filename
in summary
131 --debug KEY
=[0|1] turn on
/off debugging of KEY
, where KEY is one of
132 'values', 'possible', 'type', and 'attr' (default
134 --test
-only
=WORD report only warnings
/errors containing WORD
136 --fix EXPERIMENTAL
- may create horrible results
137 If correctable single
-line errors exist
, create
138 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
139 with potential errors corrected to the preferred
141 --fix
-inplace EXPERIMENTAL
- may create horrible results
142 Is the same as
--fix
, but overwrites the input
143 file
. It
's your fault if there's
no backup
or git
144 --ignore
-perl
-version override checking of perl version
. expect
146 --codespell Use the codespell dictionary
for spelling
/typos
147 (default:$codespellfile)
148 --codespellfile Use this codespell dictionary
149 --typedefsfile Read additional types from this file
150 --color
[=WHEN
] Use colors
'always', 'never', or only
when output
151 is a terminal
('auto'). Default is
'auto'.
152 --kconfig
-prefix
=WORD
use WORD as a prefix
for Kconfig symbols
(default
154 -h
, --help
, --version display this help
and exit
156 When FILE is
- read standard input
.
164 return grep { !$seen{$_}++ } @_;
174 open(my $script, '<', abs_path
($P)) or
175 die "$P: Can't read '$P' $!\n";
177 my $text = <$script>;
181 # Also catch when type or level is passed through a variable
182 while ($text =~ /(?:(\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
184 if (exists($types{$2})) {
185 $types{$2} .= ",$1" if ($types{$2} ne $1);
190 $types{$2} = "UNDETERMINED";
194 print("#\tMessage type\n\n");
196 print(" ( Color coding: ");
197 print(RED
. "ERROR" . RESET
);
199 print(YELLOW
. "WARNING" . RESET
);
201 print(GREEN
. "CHECK" . RESET
);
203 print("Multiple levels / Undetermined");
207 foreach my $type (sort keys %types) {
208 my $orig_type = $type;
210 my $level = $types{$type};
211 if ($level eq "ERROR") {
212 $type = RED
. $type . RESET
;
213 } elsif ($level eq "WARN") {
214 $type = YELLOW
. $type . RESET
;
215 } elsif ($level eq "CHK") {
216 $type = GREEN
. $type . RESET
;
219 print(++$count . "\t" . $type . "\n");
220 if ($verbose && exists($verbose_messages{$orig_type})) {
221 my $message = $verbose_messages{$orig_type};
222 $message =~ s/\n/\n\t/g;
223 print("\t" . $message . "\n\n");
230 my $conf = which_conf
($configuration_file);
233 open(my $conffile, '<', "$conf")
234 or warn "$P: Can't find a readable $configuration_file file $!\n";
236 while (<$conffile>) {
239 $line =~ s/\s*\n?$//g;
243 next if ($line =~ m/^\s*#/);
244 next if ($line =~ m/^\s*$/);
246 my @words = split(" ", $line);
247 foreach my $word (@words) {
248 last if ($word =~ m/^#/);
249 push (@conf_args, $word);
253 unshift(@ARGV, @conf_args) if @conf_args;
257 open(my $docs, '<', "$docsfile")
258 or warn "$P: Can't read the documentation file $docsfile $!\n";
269 if ($line =~ /^\s*\*\*(.+)\*\*$/) {
271 $verbose_messages{$type} = trim
($desc);
277 if ($line =~ /^(?:\s{4,}|$)/) {
282 $verbose_messages{$type} = trim
($desc);
291 $verbose_messages{$type} = trim
($desc);
296 # Perl's Getopt::Long allows options to take optional arguments after a space.
297 # Prevent --color by itself from consuming other arguments
299 if ($_ eq "--color" || $_ eq "-color") {
300 $_ = "--color=$color";
305 'q|quiet+' => \
$quiet,
306 'v|verbose!' => \
$verbose,
308 'signoff!' => \
$chk_signoff,
309 'patch!' => \
$chk_patch,
312 'showfile!' => \
$showfile,
315 'subjective!' => \
$check,
316 'strict!' => \
$check,
317 'ignore=s' => \
@ignore,
319 'show-types!' => \
$show_types,
320 'list-types!' => \
$list_types,
321 'max-line-length=i' => \
$max_line_length,
322 'min-conf-desc-length=i' => \
$min_conf_desc_length,
323 'tab-size=i' => \
$tabsize,
325 'summary!' => \
$summary,
326 'mailback!' => \
$mailback,
327 'summary-file!' => \
$summary_file,
329 'fix-inplace!' => \
$fix_inplace,
330 'ignore-perl-version!' => \
$ignore_perl_version,
331 'debug=s' => \
%debug,
332 'test-only=s' => \
$tst_only,
333 'codespell!' => \
$codespell,
334 'codespellfile=s' => \
$user_codespellfile,
335 'typedefsfile=s' => \
$typedefsfile,
336 'color=s' => \
$color,
337 'no-color' => \
$color, #keep old behaviors of -nocolor
338 'nocolor' => \
$color, #keep old behaviors of -nocolor
339 'kconfig-prefix=s' => \
${CONFIG_
},
344 if ($user_codespellfile) {
345 # Use the user provided codespell file unconditionally
346 $codespellfile = $user_codespellfile;
347 } elsif (!(-f
$codespellfile)) {
348 # If /usr/share/codespell/dictionary.txt is not present, try to find it
349 # under codespell's install directory: <codespell_root>/data/dictionary.txt
350 if (($codespell || $help) && which
("python3") ne "") {
351 my $python_codespell_dict = << "EOF";
355 codespell_dir
= op
.dirname
(codespell_lib
.__file__
)
356 codespell_file
= op
.join(codespell_dir
, 'data', 'dictionary.txt')
357 print(codespell_file
, end
='')
360 my $codespell_dict = `python3 -c "$python_codespell_dict" 2> /dev/null`;
361 $codespellfile = $codespell_dict if (-f
$codespell_dict);
365 # $help is 1 if either -h, --help or --version is passed as option - exitcode: 0
366 # $help is 2 if invalid option is passed - exitcode: 1
367 help
($help - 1) if ($help);
369 die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file || $fix));
370 die "$P: --verbose cannot be used with --terse\n" if ($verbose && $terse);
372 if ($color =~ /^[01]$/) {
374 } elsif ($color =~ /^always$/i) {
376 } elsif ($color =~ /^never$/i) {
378 } elsif ($color =~ /^auto$/i) {
379 $color = (-t STDOUT
);
381 die "$P: Invalid color mode: $color\n";
384 load_docs
() if ($verbose);
385 list_types
(0) if ($list_types);
387 $fix = 1 if ($fix_inplace);
388 $check_orig = $check;
392 my $perl_version_ok = 1;
393 if ($^V
&& $^V
lt $minimum_perl_version) {
394 $perl_version_ok = 0;
395 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
396 exit(1) if (!$ignore_perl_version);
399 #if no filenames are given, push '-' to read patch from stdin
404 # skip TAB size 1 to avoid additional checks on $tabsize - 1
405 die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);
407 sub hash_save_array_words
{
408 my ($hashRef, $arrayRef) = @_;
410 my @array = split(/,/, join(',', @
$arrayRef));
411 foreach my $word (@array) {
412 $word =~ s/\s*\n?$//g;
415 $word =~ tr/[a-z]/[A-Z]/;
417 next if ($word =~ m/^\s*#/);
418 next if ($word =~ m/^\s*$/);
424 sub hash_show_words
{
425 my ($hashRef, $prefix) = @_;
427 if (keys %$hashRef) {
428 print "\nNOTE: $prefix message types:";
429 foreach my $word (sort keys %$hashRef) {
436 hash_save_array_words
(\
%ignore_type, \
@ignore);
437 hash_save_array_words
(\
%use_type, \
@use);
440 my $dbg_possible = 0;
443 for my $key (keys %debug) {
445 eval "\${dbg_$key} = '$debug{$key}';";
449 my $rpt_cleaners = 0;
458 if (!top_of_kernel_tree
($root)) {
459 die "$P: $root: --root does not point at a valid tree\n";
462 if (top_of_kernel_tree
('.')) {
464 } elsif ($0 =~ m@
(.*)/scripts/[^/]*$@
&&
465 top_of_kernel_tree
($1)) {
470 if (!defined $root) {
471 print "Must be run from the top-level dir. of a kernel tree\n";
476 my $emitted_corrupt = 0;
479 [A
-Za
-z_
][A
-Za
-z\d_
]*
480 (?
:\s
*\#\#\s
*[A
-Za
-z_
][A
-Za
-z\d_
]*)*
482 our $Storage = qr{extern|static|asmlinkage};
496 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
497 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
498 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
499 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
500 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
502 # Notes to $Attribute:
503 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
526 ____cacheline_aligned
|
527 ____cacheline_aligned_in_smp
|
528 ____cacheline_internodealigned_in_smp
|
530 __alloc_size\s
*\
(\s
*\d
+\s
*(?
:,\s
*\d
+\s
*)?\
)
533 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
534 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
535 our $Lval = qr{$Ident(?:$Member)*};
537 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
538 our $Binary = qr{(?i)0b[01]+$Int_type?};
539 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
540 our $Int = qr{[0-9]+$Int_type?};
541 our $Octal = qr{0[0-7]+$Int_type?};
542 our $String = qr{(?:\b[Lu])?"[X\t]*"};
543 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
544 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
545 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
546 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
547 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
548 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
549 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
550 our $Arithmetic = qr{\+|-|\*|\/|%};
554 &&|\
|\
||,|\
^|\
+\
+|--|&|\
||$Arithmetic
557 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
561 our $NonptrTypeMisordered;
562 our $NonptrTypeWithAttr;
566 our $DeclareMisordered;
568 our $NON_ASCII_UTF8 = qr{
569 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
570 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
571 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
572 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
573 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
574 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
575 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
579 [\x09\x0A\x0D\x20-\x7E] # ASCII
583 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
584 our $typeOtherOSTypedefs = qr{(?x
:
585 u_
(?
:char
|short
|int|long
) | # bsd
586 u
(?
:nchar
|short
|int|long
) # sysv
588 our $typeKernelTypedefs = qr{(?x
:
589 (?
:__
)?
(?
:u
|s
|be
|le)(?
:8|16|32|64)|
592 our $typeTypedefs = qr{(?x
:
594 $typeOtherOSTypedefs\b|
595 $typeKernelTypedefs\b
598 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
601 our $logFunctions = qr{(?x
:
602 printk
(?
:_ratelimited
|_once
|_deferred_once
|_deferred
|)|
603 (?
:[a
-z0
-9]+_
){1,2}(?
:printk
|emerg
|alert
|crit
|err
|warning
|warn|notice
|info
|debug
|dbg
|vdbg
|devel
|cont
|WARN
)(?
:_ratelimited
|_once
|)|
605 WARN
(?
:_RATELIMIT
|_ONCE
|)|
608 seq_vprintf
|seq_printf
|seq_puts
611 # OpenOCD specific: Begin: list log functions
612 our $logFunctions = qr{(?x
:
613 LOG_
(?
:TARGET_
|)(?
:DEBUG_IO
|DEBUG
|INFO
|WARNING
|ERROR
|USER
|USER_N
|OUTPUT
)
615 # OpenOCD specific: End
617 our $allocFunctions = qr{(?x
:
619 (?
:kv
|k
|v
)[czm
]alloc
(?
:_array
)?
(?
:_node
)?
|
622 (?
:\w
+)?alloc_skb
(?
:_ip_align
)?
|
623 # dev_alloc_skb/netdev_alloc_skb, et al
627 our $signature_tags = qr{(?xi
:
639 our $tracing_logging_tags = qr{(?xi
:
663 sub edit_distance_min
{
665 my $len = scalar @arr;
666 if ((scalar @arr) < 1) {
667 # if underflow, return
671 for my $i (0 .. ($len-1)) {
672 if ($arr[$i] < $min) {
679 sub get_edit_distance
{
680 my ($str1, $str2) = @_;
685 my $len1 = length($str1);
686 my $len2 = length($str2);
687 # two dimensional array storing minimum edit distance
689 for my $i (0 .. $len1) {
690 for my $j (0 .. $len2) {
692 $distance[$i][$j] = $j;
694 $distance[$i][$j] = $i;
695 } elsif (substr($str1, $i-1, 1) eq substr($str2, $j-1, 1)) {
696 $distance[$i][$j] = $distance[$i - 1][$j - 1];
698 my $dist1 = $distance[$i][$j - 1]; #insert distance
699 my $dist2 = $distance[$i - 1][$j]; # remove
700 my $dist3 = $distance[$i - 1][$j - 1]; #replace
701 $distance[$i][$j] = 1 + edit_distance_min
($dist1, $dist2, $dist3);
705 return $distance[$len1][$len2];
708 sub find_standard_signature
{
710 my @standard_signature_tags = (
711 'Signed-off-by:', 'Co-developed-by:', 'Acked-by:', 'Tested-by:',
712 'Reviewed-by:', 'Reported-by:', 'Suggested-by:'
714 foreach my $signature (@standard_signature_tags) {
715 return $signature if (get_edit_distance
($sign_off, $signature) <= 2);
721 our @typeListMisordered = (
722 qr{char\s+(?:un)?signed},
723 qr{int\s+(?:(?:un)?signed\s+)?short\s},
724 qr{int\s+short(?:\s+(?:un)?signed)},
725 qr{short\s+int(?:\s+(?:un)?signed)},
726 qr{(?:un)?signed\s+int\s+short},
727 qr{short\s+(?:un)?signed},
728 qr{long\s+int\s+(?:un)?signed},
729 qr{int\s+long\s+(?:un)?signed},
730 qr{long\s+(?:un)?signed\s+int},
731 qr{int\s+(?:un)?signed\s+long},
732 qr{int\s+(?:un)?signed},
733 qr{int\s+long\s+long\s+(?:un)?signed},
734 qr{long\s+long\s+int\s+(?:un)?signed},
735 qr{long\s+long\s+(?:un)?signed\s+int},
736 qr{long\s+long\s+(?:un)?signed},
737 qr{long\s+(?:un)?signed},
742 qr{(?:(?:un)?signed\s+)?char},
743 qr{(?:(?:un)?signed\s+)?short\s+int},
744 qr{(?:(?:un)?signed\s+)?short},
745 qr{(?:(?:un)?signed\s+)?int},
746 qr{(?:(?:un)?signed\s+)?long\s+int},
747 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
748 qr{(?:(?:un)?signed\s+)?long\s+long},
749 qr{(?:(?:un)?signed\s+)?long},
758 qr{${Ident}_handler
},
759 qr{${Ident}_handler_fn
},
763 our $C90_int_types = qr{(?x
:
764 long\s
+long\s
+int\s
+(?
:un
)?signed
|
765 long\s
+long\s
+(?
:un
)?signed\s
+int|
766 long\s
+long\s
+(?
:un
)?signed
|
767 (?
:(?
:un
)?signed\s
+)?long\s
+long\s
+int|
768 (?
:(?
:un
)?signed\s
+)?long\s
+long
|
769 int\s
+long\s
+long\s
+(?
:un
)?signed
|
770 int\s
+(?
:(?
:un
)?signed\s
+)?long\s
+long
|
772 long\s
+int\s
+(?
:un
)?signed
|
773 long\s
+(?
:un
)?signed\s
+int|
774 long\s
+(?
:un
)?signed
|
775 (?
:(?
:un
)?signed\s
+)?long\s
+int|
776 (?
:(?
:un
)?signed\s
+)?long
|
777 int\s
+long\s
+(?
:un
)?signed
|
778 int\s
+(?
:(?
:un
)?signed\s
+)?long
|
781 (?
:(?
:un
)?signed\s
+)?
int
784 our @typeListFile = ();
785 our @typeListWithAttr = (
787 qr{struct\s+$InitAttribute\s+$Ident},
788 qr{union\s+$InitAttribute\s+$Ident},
791 our @modifierList = (
794 our @modifierListFile = ();
796 our @mode_permission_funcs = (
798 ["module_param_(?:array|named|string)", 4],
799 ["module_param_array_named", 5],
800 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
801 ["proc_create(?:_data|)", 2],
802 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
803 ["IIO_DEV_ATTR_[A-Z_]+", 1],
804 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
805 ["SENSOR_TEMPLATE(?:_2|)", 3],
809 my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';
811 #Create a search pattern for all these functions to speed up a loop below
812 our $mode_perms_search = "";
813 foreach my $entry (@mode_permission_funcs) {
814 $mode_perms_search .= '|' if ($mode_perms_search ne "");
815 $mode_perms_search .= $entry->[0];
817 $mode_perms_search = "(?:${mode_perms_search})";
819 our %deprecated_apis = (
820 "synchronize_rcu_bh" => "synchronize_rcu",
821 "synchronize_rcu_bh_expedited" => "synchronize_rcu_expedited",
822 "call_rcu_bh" => "call_rcu",
823 "rcu_barrier_bh" => "rcu_barrier",
824 "synchronize_sched" => "synchronize_rcu",
825 "synchronize_sched_expedited" => "synchronize_rcu_expedited",
826 "call_rcu_sched" => "call_rcu",
827 "rcu_barrier_sched" => "rcu_barrier",
828 "get_state_synchronize_sched" => "get_state_synchronize_rcu",
829 "cond_synchronize_sched" => "cond_synchronize_rcu",
832 #Create a search pattern for all these strings to speed up a loop below
833 our $deprecated_apis_search = "";
834 foreach my $entry (keys %deprecated_apis) {
835 $deprecated_apis_search .= '|' if ($deprecated_apis_search ne "");
836 $deprecated_apis_search .= $entry;
838 $deprecated_apis_search = "(?:${deprecated_apis_search})";
840 our $mode_perms_world_writable = qr{
848 our %mode_permission_string_types = (
867 #Create a search pattern for all these strings to speed up a loop below
868 our $mode_perms_string_search = "";
869 foreach my $entry (keys %mode_permission_string_types) {
870 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
871 $mode_perms_string_search .= $entry;
873 our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
874 our $multi_mode_perms_string_search = qr{
875 ${single_mode_perms_string_search
}
876 (?
:\s
*\
|\s
*${single_mode_perms_string_search
})*
882 return trim
($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
889 while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
890 $curpos = pos($string);
893 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
895 $to |= $mode_permission_string_types{$match};
896 $val .= '\s*\|\s*' if ($val ne "");
900 $oval =~ s/^\s*\|\s*//;
901 $oval =~ s/\s*\|\s*$//;
902 return sprintf("%04o", $to);
905 our $allowed_asm_includes = qr{(?x
:
911 # memory.h: ARM has a custom one
913 # Load common spelling mistakes and build regular expression list.
917 if (open(my $spelling, '<', $spelling_file)) {
918 while (<$spelling>) {
921 $line =~ s/\s*\n?$//g;
924 next if ($line =~ m/^\s*#/);
925 next if ($line =~ m/^\s*$/);
927 my ($suspect, $fix) = split(/\|\|/, $line);
929 $spelling_fix{$suspect} = $fix;
933 warn "No typos will be found - file '$spelling_file': $!\n";
937 if (open(my $spelling, '<', $codespellfile)) {
938 while (<$spelling>) {
941 $line =~ s/\s*\n?$//g;
944 next if ($line =~ m/^\s*#/);
945 next if ($line =~ m/^\s*$/);
946 next if ($line =~ m/, disabled/i);
950 my ($suspect, $fix) = split(/->/, $line);
952 $spelling_fix{$suspect} = $fix;
956 warn "No codespell typos will be found - file '$codespellfile': $!\n";
960 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
963 my ($wordsRef, $file) = @_;
965 if (open(my $words, '<', $file)) {
969 $line =~ s/\s*\n?$//g;
972 next if ($line =~ m/^\s*#/);
973 next if ($line =~ m/^\s*$/);
975 print("$file: '$line' invalid - ignored\n");
979 $$wordsRef .= '|' if (defined $$wordsRef);
990 if (show_type
("CONST_STRUCT")) {
991 read_words
(\
$const_structs, $conststructsfile)
992 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
995 if (defined($typedefsfile)) {
996 my $typeOtherTypedefs;
997 read_words
(\
$typeOtherTypedefs, $typedefsfile)
998 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
999 $typeTypedefs .= '|' . $typeOtherTypedefs if (defined $typeOtherTypedefs);
1003 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
1004 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
1005 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
1006 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
1007 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
1009 (?
:$typeTypedefs\b)|
1013 (?
:$Modifier\s
+|const\s
+)*
1015 (?
:typeof
|__typeof__
)\s
*\
([^\
)]*\
)|
1016 (?
:$typeTypedefs\b)|
1019 (?
:\s
+$Modifier|\s
+const
)*
1021 $NonptrTypeMisordered = qr{
1022 (?
:$Modifier\s
+|const\s
+)*
1026 (?
:\s
+$Modifier|\s
+const
)*
1028 $NonptrTypeWithAttr = qr{
1029 (?
:$Modifier\s
+|const\s
+)*
1031 (?
:typeof
|__typeof__
)\s
*\
([^\
)]*\
)|
1032 (?
:$typeTypedefs\b)|
1033 (?
:${allWithAttr
}\b)
1035 (?
:\s
+$Modifier|\s
+const
)*
1039 (?
:(?
:\s
|\
*|\
[\
])+\s
*const
|(?
:\s
|\
*\s
*(?
:const\s
*)?
|\
[\
])+|(?
:\s
*\
[\s
*\
])+){0,4}
1040 (?
:\s
+$Inline|\s
+$Modifier)*
1042 $TypeMisordered = qr{
1043 $NonptrTypeMisordered
1044 (?
:(?
:\s
|\
*|\
[\
])+\s
*const
|(?
:\s
|\
*\s
*(?
:const\s
*)?
|\
[\
])+|(?
:\s
*\
[\s
*\
])+){0,4}
1045 (?
:\s
+$Inline|\s
+$Modifier)*
1047 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
1048 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
1052 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s
*};
1054 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
1055 # requires at least perl version v5.10.0
1056 # Any use must be runtime checked with $^V
1058 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
1059 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s
*};
1060 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
1062 our $declaration_macros = qr{(?x
:
1063 (?
:$Storage\s
+)?
(?
:[A
-Z_
][A
-Z0
-9]*_
){0,2}(?
:DEFINE
|DECLARE
)(?
:_
[A
-Z0
-9]+){1,6}\s
*\
(|
1064 (?
:$Storage\s
+)?
[HLP
]?LIST_HEAD\s
*\
(|
1065 (?
:SKCIPHER_REQUEST
|SHASH_DESC
|AHASH_REQUEST
)_ON_STACK\s
*\
(|
1066 (?
:$Storage\s
+)?
(?
:XA_STATE
|XA_STATE_ORDER
)\s
*\
(
1069 our %allow_repeated_words = (
1076 sub deparenthesize
{
1078 return "" if (!defined($string));
1080 while ($string =~ /^\s*\(.*\)\s*$/) {
1081 $string =~ s@
^\s
*\
(\s
*@@
;
1082 $string =~ s@\s
*\
)\s
*$@@
;
1085 $string =~ s@\s
+@
@g;
1090 sub seed_camelcase_file
{
1093 return if (!(-f
$file));
1097 open(my $include_file, '<', "$file")
1098 or warn "$P: Can't read '$file' $!\n";
1099 my $text = <$include_file>;
1100 close($include_file);
1102 my @lines = split('\n', $text);
1104 foreach my $line (@lines) {
1105 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
1106 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
1108 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
1110 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
1116 our %maintained_status = ();
1118 sub is_maintained_obsolete
{
1119 my ($filename) = @_;
1121 return 0 if (!$tree || !(-e
"$root/scripts/get_maintainer.pl"));
1123 if (!exists($maintained_status{$filename})) {
1124 $maintained_status{$filename} = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
1127 return $maintained_status{$filename} =~ /obsolete/i;
1130 sub is_SPDX_License_valid
{
1133 return 1 if (!$tree || which
("python3") eq "" || !(-x
"$root/scripts/spdxcheck.py") || !(-e
"$gitroot"));
1135 my $root_path = abs_path
($root);
1136 my $status = `cd "$root_path"; echo "$license" | scripts/spdxcheck.py -`;
1137 return 0 if ($status ne "");
1141 my $camelcase_seeded = 0;
1142 sub seed_camelcase_includes
{
1143 return if ($camelcase_seeded);
1146 my $camelcase_cache = "";
1147 my @include_files = ();
1149 $camelcase_seeded = 1;
1151 if (-e
"$gitroot") {
1152 my $git_last_include_commit = `${git_command} log --no-merges --pretty=format:"%h%n" -1 -- include`;
1153 chomp $git_last_include_commit;
1154 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
1156 my $last_mod_date = 0;
1157 $files = `find $root/include -name "*.h"`;
1158 @include_files = split('\n', $files);
1159 foreach my $file (@include_files) {
1160 my $date = POSIX
::strftime
("%Y%m%d%H%M",
1161 localtime((stat $file)[9]));
1162 $last_mod_date = $date if ($last_mod_date < $date);
1164 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
1167 if ($camelcase_cache ne "" && -f
$camelcase_cache) {
1168 open(my $camelcase_file, '<', "$camelcase_cache")
1169 or warn "$P: Can't read '$camelcase_cache' $!\n";
1170 while (<$camelcase_file>) {
1174 close($camelcase_file);
1179 if (-e
"$gitroot") {
1180 $files = `${git_command} ls-files "include/*.h"`;
1181 @include_files = split('\n', $files);
1184 foreach my $file (@include_files) {
1185 seed_camelcase_file
($file);
1188 if ($camelcase_cache ne "") {
1189 unlink glob ".checkpatch-camelcase.*";
1190 open(my $camelcase_file, '>', "$camelcase_cache")
1191 or warn "$P: Can't write '$camelcase_cache' $!\n";
1192 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
1193 print $camelcase_file ("$_\n");
1195 close($camelcase_file);
1199 sub git_is_single_file
{
1200 my ($filename) = @_;
1202 return 0 if ((which
("git") eq "") || !(-e
"$gitroot"));
1204 my $output = `${git_command} ls-files -- $filename 2>/dev/null`;
1205 my $count = $output =~ tr/\n//;
1206 return $count eq 1 && $output =~ m{^${filename}$};
1209 sub git_commit_info
{
1210 my ($commit, $id, $desc) = @_;
1212 return ($id, $desc) if ((which
("git") eq "") || !(-e
"$gitroot"));
1214 my $output = `${git_command} log --no-color --format='%H %s' -1 $commit 2>&1`;
1215 $output =~ s/^\s*//gm;
1216 my @lines = split("\n", $output);
1218 return ($id, $desc) if ($#lines < 0);
1220 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous/) {
1221 # Maybe one day convert this block of bash into something that returns
1222 # all matching commit ids, but it's very slow...
1224 # echo "checking commits $1..."
1225 # git rev-list --remotes | grep -i "^$1" |
1226 # while read line ; do
1227 # git log --format='%H %s' -1 $line |
1228 # echo "commit $(cut -c 1-12,41-)"
1230 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./ ||
1231 $lines[0] =~ /^fatal: bad object $commit/) {
1234 $id = substr($lines[0], 0, 12);
1235 $desc = substr($lines[0], 41);
1238 return ($id, $desc);
1241 $chk_signoff = 0 if ($file);
1246 my @fixed_inserted = ();
1247 my @fixed_deleted = ();
1250 # If input is git commits, extract all commits from the commit expressions.
1251 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
1252 die "$P: No git repository found\n" if ($git && !-e
"$gitroot");
1256 foreach my $commit_expr (@ARGV) {
1258 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
1259 $git_range = "-$2 $1";
1260 } elsif ($commit_expr =~ m/\.\./) {
1261 $git_range = "$commit_expr";
1263 $git_range = "-1 $commit_expr";
1265 my $lines = `${git_command} log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
1266 foreach my $line (split(/\n/, $lines)) {
1267 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
1268 next if (!defined($1) || !defined($2));
1271 unshift(@commits, $sha1);
1272 $git_commits{$sha1} = $subject;
1275 die "$P: no git commits after extraction!\n" if (@commits == 0);
1280 $allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
1281 for my $filename (@ARGV) {
1283 my $is_git_file = git_is_single_file
($filename);
1284 my $oldfile = $file;
1285 $file = 1 if ($is_git_file);
1287 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
1288 die "$P: $filename: git format-patch failed - $!\n";
1290 open($FILE, '-|', "diff -u /dev/null $filename") ||
1291 die "$P: $filename: diff failed - $!\n";
1292 } elsif ($filename eq '-') {
1293 open($FILE, '<&STDIN');
1295 open($FILE, '<', "$filename") ||
1296 die "$P: $filename: open failed - $!\n";
1298 if ($filename eq '-') {
1299 $vname = 'Your patch';
1301 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1307 push(@rawlines, $_);
1308 $vname = qq("$1") if ($filename eq '-' && $_ =~ m/^Subject:\s+(.+)/i);
1312 if ($#ARGV > 0 && $quiet == 0) {
1313 print '-' x
length($vname) . "\n";
1315 print '-' x
length($vname) . "\n";
1318 if (!process
($filename)) {
1324 @fixed_inserted = ();
1325 @fixed_deleted = ();
1327 @modifierListFile = ();
1330 $file = $oldfile if ($is_git_file);
1334 hash_show_words
(\
%use_type, "Used");
1335 hash_show_words
(\
%ignore_type, "Ignored");
1337 if (!$perl_version_ok) {
1340 NOTE
: perl
$^V is
not modern enough to detect all possible issues
.
1341 An upgrade to at least perl
$minimum_perl_version is suggested
.
1348 NOTE
: If any of the errors are false positives
, please report
1349 them to the maintainer
, see CHECKPATCH
in MAINTAINERS
.
1352 # OpenOCD specific: Begin
1355 NOTE
: If any of the errors are false positives
, please report
1356 them to the openocd
-devel mailing list
or prepare a patch
1357 and send it to Gerrit
for review
.
1359 # OpenOCD specific: End
1365 sub top_of_kernel_tree
{
1369 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1370 "README", "Documentation", "arch", "include", "drivers",
1371 "fs", "init", "ipc", "kernel", "lib", "scripts",
1374 foreach my $check (@tree_check) {
1375 if (! -e
$root . '/' . $check) {
1383 my ($formatted_email) = @_;
1387 my $name_comment = "";
1391 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1394 $comment = $3 if defined $3;
1395 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1397 $comment = $2 if defined $2;
1398 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1400 $comment = $2 if defined $2;
1401 $formatted_email =~ s/\Q$address\E.*$//;
1402 $name = $formatted_email;
1403 $name = trim
($name);
1404 $name =~ s/^\"|\"$//g;
1405 # If there's a name left after stripping spaces and
1406 # leading quotes, and the address doesn't have both
1407 # leading and trailing angle brackets, the address
1409 # "joe smith joe@smith.com" bad
1410 # "joe smith <joe@smith.com" bad
1411 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1416 # OpenOCD specific: Begin: handle jenkins as valid email
1417 } elsif ($formatted_email eq "jenkins") {
1418 $address = "jenkins";
1419 # OpenOCD specific: End
1422 # Extract comments from names excluding quoted parts
1423 # "John D. (Doe)" - Do not extract
1424 if ($name =~ s/\"(.+)\"//) {
1427 while ($name =~ s/\s*($balanced_parens)\s*/ /) {
1428 $name_comment .= trim
($1);
1430 $name =~ s/^[ \"]+|[ \"]+$//g;
1431 $name = trim
("$quoted $name");
1433 $address = trim
($address);
1434 $address =~ s/^\<|\>$//g;
1435 $comment = trim
($comment);
1437 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1438 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1439 $name = "\"$name\"";
1442 return ($name, $name_comment, $address, $comment);
1446 my ($name, $name_comment, $address, $comment) = @_;
1448 my $formatted_email;
1450 $name =~ s/^[ \"]+|[ \"]+$//g;
1451 $address = trim
($address);
1452 $address =~ s/(?:\.|\,|\")+$//; ##trailing commas, dots or quotes
1454 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1455 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1456 $name = "\"$name\"";
1459 $name_comment = trim
($name_comment);
1460 $name_comment = " $name_comment" if ($name_comment ne "");
1461 $comment = trim
($comment);
1462 $comment = " $comment" if ($comment ne "");
1464 if ("$name" eq "") {
1465 $formatted_email = "$address";
1467 $formatted_email = "$name$name_comment <$address>";
1469 $formatted_email .= "$comment";
1470 return $formatted_email;
1473 sub reformat_email
{
1476 my ($email_name, $name_comment, $email_address, $comment) = parse_email
($email);
1477 return format_email
($email_name, $name_comment, $email_address, $comment);
1480 sub same_email_addresses
{
1481 my ($email1, $email2) = @_;
1483 my ($email1_name, $name1_comment, $email1_address, $comment1) = parse_email
($email1);
1484 my ($email2_name, $name2_comment, $email2_address, $comment2) = parse_email
($email2);
1486 return $email1_name eq $email2_name &&
1487 $email1_address eq $email2_address &&
1488 $name1_comment eq $name2_comment &&
1489 $comment1 eq $comment2;
1495 foreach my $path (split(/:/, $ENV{PATH
})) {
1496 if (-e
"$path/$bin") {
1497 return "$path/$bin";
1507 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1508 if (-e
"$path/$conf") {
1509 return "$path/$conf";
1521 for my $c (split(//, $str)) {
1525 for (; ($n % $tabsize) != 0; $n++) {
1537 (my $res = shift) =~ tr/\t/ /c;
1544 # Drop the diff line leader and expand tabs
1546 $line = expand_tabs
($line);
1548 # Pick the indent from the front of the line.
1549 my ($white) = ($line =~ /^(\s*)/);
1551 return (length($line), length($white));
1554 my $sanitise_quote = '';
1556 sub sanitise_line_reset
{
1557 my ($in_comment) = @_;
1560 $sanitise_quote = '*/';
1562 $sanitise_quote = '';
1575 # Always copy over the diff marker.
1576 $res = substr($line, 0, 1);
1578 for ($off = 1; $off < length($line); $off++) {
1579 $c = substr($line, $off, 1);
1581 # Comments we are whacking completely including the begin
1582 # and end, all to $;.
1583 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1584 $sanitise_quote = '*/';
1586 substr($res, $off, 2, "$;$;");
1590 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1591 $sanitise_quote = '';
1592 substr($res, $off, 2, "$;$;");
1596 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1597 $sanitise_quote = '//';
1599 substr($res, $off, 2, $sanitise_quote);
1604 # A \ in a string means ignore the next character.
1605 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1607 substr($res, $off, 2, 'XX');
1612 if ($c eq "'" || $c eq '"') {
1613 if ($sanitise_quote eq '') {
1614 $sanitise_quote = $c;
1616 substr($res, $off, 1, $c);
1618 } elsif ($sanitise_quote eq $c) {
1619 $sanitise_quote = '';
1623 #print "c<$c> SQ<$sanitise_quote>\n";
1624 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1625 substr($res, $off, 1, $;);
1626 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1627 substr($res, $off, 1, $;);
1628 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1629 substr($res, $off, 1, 'X');
1631 substr($res, $off, 1, $c);
1635 if ($sanitise_quote eq '//') {
1636 $sanitise_quote = '';
1639 # The pathname on a #include may be surrounded by '<' and '>'.
1640 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1641 my $clean = 'X' x
length($1);
1642 $res =~ s@\
<.*\
>@
<$clean>@
;
1644 # The whole of a #error is a string.
1645 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1646 my $clean = 'X' x
length($1);
1647 $res =~ s@
(\#\s
*(?
:error
|warning
)\s
+).*@
$1$clean@
;
1650 if ($allow_c99_comments && $res =~ m@
(//.*$)@
) {
1652 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1658 sub get_quoted_string
{
1659 my ($line, $rawline) = @_;
1661 return "" if (!defined($line) || !defined($rawline));
1662 return "" if ($line !~ m/($String)/g);
1663 return substr($rawline, $-[0], $+[0] - $-[0]);
1666 sub ctx_statement_block
{
1667 my ($linenr, $remain, $off) = @_;
1668 my $line = $linenr - 1;
1671 my $coff = $off - 1;
1685 @stack = (['', 0]) if ($#stack == -1);
1687 #warn "CSB: blk<$blk> remain<$remain>\n";
1688 # If we are about to drop off the end, pull in more
1691 for (; $remain > 0; $line++) {
1692 last if (!defined $lines[$line]);
1693 next if ($lines[$line] =~ /^-/);
1696 $blk .= $lines[$line] . "\n";
1697 $len = length($blk);
1701 # Bail if there is no further context.
1702 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1706 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1712 $c = substr($blk, $off, 1);
1713 $remainder = substr($blk, $off);
1715 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1717 # Handle nested #if/#else.
1718 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1719 push(@stack, [ $type, $level ]);
1720 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1721 ($type, $level) = @
{$stack[$#stack - 1]};
1722 } elsif ($remainder =~ /^#\s*endif\b/) {
1723 ($type, $level) = @
{pop(@stack)};
1726 # Statement ends at the ';' or a close '}' at the
1728 if ($level == 0 && $c eq ';') {
1732 # An else is really a conditional as long as its not else if
1733 if ($level == 0 && $coff_set == 0 &&
1734 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1735 $remainder =~ /^(else)(?:\s|{)/ &&
1736 $remainder !~ /^else\s+if\b/) {
1737 $coff = $off + length($1) - 1;
1739 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1740 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1743 if (($type eq '' || $type eq '(') && $c eq '(') {
1747 if ($type eq '(' && $c eq ')') {
1749 $type = ($level != 0)?
'(' : '';
1751 if ($level == 0 && $coff < $soff) {
1754 #warn "CSB: mark coff<$coff>\n";
1757 if (($type eq '' || $type eq '{') && $c eq '{') {
1761 if ($type eq '{' && $c eq '}') {
1763 $type = ($level != 0)?
'{' : '';
1766 if (substr($blk, $off + 1, 1) eq ';') {
1772 # Preprocessor commands end at the newline unless escaped.
1773 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1781 # We are truly at the end, so shuffle to the next line.
1788 my $statement = substr($blk, $soff, $off - $soff + 1);
1789 my $condition = substr($blk, $soff, $coff - $soff + 1);
1791 #warn "STATEMENT<$statement>\n";
1792 #warn "CONDITION<$condition>\n";
1794 #print "coff<$coff> soff<$off> loff<$loff>\n";
1796 return ($statement, $condition,
1797 $line, $remain + 1, $off - $loff + 1, $level);
1800 sub statement_lines
{
1803 # Strip the diff line prefixes and rip blank lines at start and end.
1804 $stmt =~ s/(^|\n)./$1/g;
1808 my @stmt_lines = ($stmt =~ /\n/g);
1810 return $#stmt_lines + 2;
1813 sub statement_rawlines
{
1816 my @stmt_lines = ($stmt =~ /\n/g);
1818 return $#stmt_lines + 2;
1821 sub statement_block_size
{
1824 $stmt =~ s/(^|\n)./$1/g;
1830 my @stmt_lines = ($stmt =~ /\n/g);
1831 my @stmt_statements = ($stmt =~ /;/g);
1833 my $stmt_lines = $#stmt_lines + 2;
1834 my $stmt_statements = $#stmt_statements + 1;
1836 if ($stmt_lines > $stmt_statements) {
1839 return $stmt_statements;
1843 sub ctx_statement_full
{
1844 my ($linenr, $remain, $off) = @_;
1845 my ($statement, $condition, $level);
1849 # Grab the first conditional/block pair.
1850 ($statement, $condition, $linenr, $remain, $off, $level) =
1851 ctx_statement_block
($linenr, $remain, $off);
1852 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1853 push(@chunks, [ $condition, $statement ]);
1854 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1855 return ($level, $linenr, @chunks);
1858 # Pull in the following conditional/block pairs and see if they
1859 # could continue the statement.
1861 ($statement, $condition, $linenr, $remain, $off, $level) =
1862 ctx_statement_block
($linenr, $remain, $off);
1863 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1864 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1866 push(@chunks, [ $condition, $statement ]);
1869 return ($level, $linenr, @chunks);
1873 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1875 my $start = $linenr - 1;
1882 my @stack = ($level);
1883 for ($line = $start; $remain > 0; $line++) {
1884 next if ($rawlines[$line] =~ /^-/);
1887 $blk .= $rawlines[$line];
1889 # Handle nested #if/#else.
1890 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1891 push(@stack, $level);
1892 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1893 $level = $stack[$#stack - 1];
1894 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1895 $level = pop(@stack);
1898 foreach my $c (split(//, $lines[$line])) {
1899 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1905 if ($c eq $close && $level > 0) {
1907 last if ($level == 0);
1908 } elsif ($c eq $open) {
1913 if (!$outer || $level <= 1) {
1914 push(@res, $rawlines[$line]);
1917 last if ($level == 0);
1920 return ($level, @res);
1922 sub ctx_block_outer
{
1923 my ($linenr, $remain) = @_;
1925 my ($level, @r) = ctx_block_get
($linenr, $remain, 1, '{', '}', 0);
1929 my ($linenr, $remain) = @_;
1931 my ($level, @r) = ctx_block_get
($linenr, $remain, 0, '{', '}', 0);
1935 my ($linenr, $remain, $off) = @_;
1937 my ($level, @r) = ctx_block_get
($linenr, $remain, 0, '(', ')', $off);
1940 sub ctx_block_level
{
1941 my ($linenr, $remain) = @_;
1943 return ctx_block_get
($linenr, $remain, 0, '{', '}', 0);
1945 sub ctx_statement_level
{
1946 my ($linenr, $remain, $off) = @_;
1948 return ctx_block_get
($linenr, $remain, 0, '(', ')', $off);
1951 sub ctx_locate_comment
{
1952 my ($first_line, $end_line) = @_;
1954 # If c99 comment on the current line, or the line before or after
1955 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@
^\
+.*(//.*$)@
);
1956 return $current_comment if (defined $current_comment);
1957 ($current_comment) = ($rawlines[$end_line - 2] =~ m@
^[\
+ ].*(//.*$)@
);
1958 return $current_comment if (defined $current_comment);
1959 ($current_comment) = ($rawlines[$end_line] =~ m@
^[\
+ ].*(//.*$)@
);
1960 return $current_comment if (defined $current_comment);
1962 # Catch a comment on the end of the line itself.
1963 ($current_comment) = ($rawlines[$end_line - 1] =~ m@
.*(/\*.*\*/)\s
*(?
:\\\s
*)?
$@
);
1964 return $current_comment if (defined $current_comment);
1966 # Look through the context and try and figure out if there is a
1969 $current_comment = '';
1970 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1971 my $line = $rawlines[$linenr - 1];
1973 if ($linenr == $first_line and $line =~ m@
^.\s
*\
*@
) {
1976 if ($line =~ m@
/\
*@
) {
1979 if (!$in_comment && $current_comment ne '') {
1980 $current_comment = '';
1982 $current_comment .= $line . "\n" if ($in_comment);
1983 if ($line =~ m@\
*/@
) {
1988 chomp($current_comment);
1989 return($current_comment);
1991 sub ctx_has_comment
{
1992 my ($first_line, $end_line) = @_;
1993 my $cmt = ctx_locate_comment
($first_line, $end_line);
1995 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1996 ##print "CMMT: $cmt\n";
1998 return ($cmt ne '');
2002 my ($linenr, $cnt) = @_;
2004 my $offset = $linenr - 1;
2009 $line = $rawlines[$offset++];
2010 next if (defined($line) && $line =~ /^-/);
2018 my ($linenr, $lc) = @_;
2020 my $stat_real = raw_line
($linenr, 0);
2021 for (my $count = $linenr + 1; $count <= $lc; $count++) {
2022 $stat_real = $stat_real . "\n" . raw_line
($count, 0);
2029 my ($linenr, $cnt, $here) = @_;
2031 my $herectx = $here . "\n";
2032 for (my $n = 0; $n < $cnt; $n++) {
2033 $herectx .= raw_line
($linenr, $n) . "\n";
2044 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
2047 $coded = sprintf("^%c", unpack('C', $2) + 64);
2056 my $av_preprocessor = 0;
2061 sub annotate_reset
{
2062 $av_preprocessor = 0;
2064 @av_paren_type = ('E');
2065 $av_pend_colon = 'O';
2068 sub annotate_values
{
2069 my ($stream, $type) = @_;
2072 my $var = '_' x
length($stream);
2075 print "$stream\n" if ($dbg_values > 1);
2077 while (length($cur)) {
2078 @av_paren_type = ('E') if ($#av_paren_type < 0);
2079 print " <" . join('', @av_paren_type) .
2080 "> <$type> <$av_pending>" if ($dbg_values > 1);
2081 if ($cur =~ /^(\s+)/o) {
2082 print "WS($1)\n" if ($dbg_values > 1);
2083 if ($1 =~ /\n/ && $av_preprocessor) {
2084 $type = pop(@av_paren_type);
2085 $av_preprocessor = 0;
2088 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
2089 print "CAST($1)\n" if ($dbg_values > 1);
2090 push(@av_paren_type, $type);
2093 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
2094 print "DECLARE($1)\n" if ($dbg_values > 1);
2097 } elsif ($cur =~ /^($Modifier)\s*/) {
2098 print "MODIFIER($1)\n" if ($dbg_values > 1);
2101 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
2102 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
2103 $av_preprocessor = 1;
2104 push(@av_paren_type, $type);
2110 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
2111 print "UNDEF($1)\n" if ($dbg_values > 1);
2112 $av_preprocessor = 1;
2113 push(@av_paren_type, $type);
2115 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
2116 print "PRE_START($1)\n" if ($dbg_values > 1);
2117 $av_preprocessor = 1;
2119 push(@av_paren_type, $type);
2120 push(@av_paren_type, $type);
2123 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
2124 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
2125 $av_preprocessor = 1;
2127 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
2131 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
2132 print "PRE_END($1)\n" if ($dbg_values > 1);
2134 $av_preprocessor = 1;
2136 # Assume all arms of the conditional end as this
2137 # one does, and continue as if the #endif was not here.
2138 pop(@av_paren_type);
2139 push(@av_paren_type, $type);
2142 } elsif ($cur =~ /^(\\\n)/o) {
2143 print "PRECONT($1)\n" if ($dbg_values > 1);
2145 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
2146 print "ATTR($1)\n" if ($dbg_values > 1);
2147 $av_pending = $type;
2150 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
2151 print "SIZEOF($1)\n" if ($dbg_values > 1);
2157 } elsif ($cur =~ /^(if|while|for)\b/o) {
2158 print "COND($1)\n" if ($dbg_values > 1);
2162 } elsif ($cur =~/^(case)/o) {
2163 print "CASE($1)\n" if ($dbg_values > 1);
2164 $av_pend_colon = 'C';
2167 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
2168 print "KEYWORD($1)\n" if ($dbg_values > 1);
2171 } elsif ($cur =~ /^(\()/o) {
2172 print "PAREN('$1')\n" if ($dbg_values > 1);
2173 push(@av_paren_type, $av_pending);
2177 } elsif ($cur =~ /^(\))/o) {
2178 my $new_type = pop(@av_paren_type);
2179 if ($new_type ne '_') {
2181 print "PAREN('$1') -> $type\n"
2182 if ($dbg_values > 1);
2184 print "PAREN('$1')\n" if ($dbg_values > 1);
2187 } elsif ($cur =~ /^($Ident)\s*\(/o) {
2188 print "FUNC($1)\n" if ($dbg_values > 1);
2192 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
2193 if (defined $2 && $type eq 'C' || $type eq 'T') {
2194 $av_pend_colon = 'B';
2195 } elsif ($type eq 'E') {
2196 $av_pend_colon = 'L';
2198 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
2201 } elsif ($cur =~ /^($Ident|$Constant)/o) {
2202 print "IDENT($1)\n" if ($dbg_values > 1);
2205 } elsif ($cur =~ /^($Assignment)/o) {
2206 print "ASSIGN($1)\n" if ($dbg_values > 1);
2209 } elsif ($cur =~/^(;|{|})/) {
2210 print "END($1)\n" if ($dbg_values > 1);
2212 $av_pend_colon = 'O';
2214 } elsif ($cur =~/^(,)/) {
2215 print "COMMA($1)\n" if ($dbg_values > 1);
2218 } elsif ($cur =~ /^(\?)/o) {
2219 print "QUESTION($1)\n" if ($dbg_values > 1);
2222 } elsif ($cur =~ /^(:)/o) {
2223 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
2225 substr($var, length($res), 1, $av_pend_colon);
2226 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
2231 $av_pend_colon = 'O';
2233 } elsif ($cur =~ /^(\[)/o) {
2234 print "CLOSE($1)\n" if ($dbg_values > 1);
2237 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
2240 print "OPV($1)\n" if ($dbg_values > 1);
2247 substr($var, length($res), 1, $variant);
2250 } elsif ($cur =~ /^($Operators)/o) {
2251 print "OP($1)\n" if ($dbg_values > 1);
2252 if ($1 ne '++' && $1 ne '--') {
2256 } elsif ($cur =~ /(^.)/o) {
2257 print "C($1)\n" if ($dbg_values > 1);
2260 $cur = substr($cur, length($1));
2261 $res .= $type x
length($1);
2265 return ($res, $var);
2269 my ($possible, $line) = @_;
2270 my $notPermitted = qr{(?
:
2287 ^(?
:typedef
|struct
|enum
)\b
2289 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
2290 if ($possible !~ $notPermitted) {
2291 # Check for modifiers.
2292 $possible =~ s/\s*$Storage\s*//g;
2293 $possible =~ s/\s*$Sparse\s*//g;
2294 if ($possible =~ /^\s*$/) {
2296 } elsif ($possible =~ /\s/) {
2297 $possible =~ s/\s*$Type\s*//g;
2298 for my $modifier (split(' ', $possible)) {
2299 if ($modifier !~ $notPermitted) {
2300 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
2301 push(@modifierListFile, $modifier);
2306 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
2307 push(@typeListFile, $possible);
2311 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
2320 $type =~ tr/[a-z]/[A-Z]/;
2322 return defined $use_type{$type} if (scalar keys %use_type > 0);
2324 return !defined $ignore_type{$type};
2328 my ($level, $type, $msg) = @_;
2330 if (!show_type
($type) ||
2331 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
2336 if ($level eq 'ERROR') {
2338 } elsif ($level eq 'WARNING') {
2344 $output .= $prefix . $level . ':';
2346 $output .= BLUE
if ($color);
2347 $output .= "$type:";
2349 $output .= RESET
if ($color);
2350 $output .= ' ' . $msg . "\n";
2353 my @lines = split("\n", $output, -1);
2354 splice(@lines, 1, 1);
2355 $output = join("\n", @lines);
2359 $output = (split('\n', $output))[0] . "\n";
2362 if ($verbose && exists($verbose_messages{$type}) &&
2363 !exists($verbose_emitted{$type})) {
2364 $output .= $verbose_messages{$type} . "\n\n";
2365 $verbose_emitted{$type} = 1;
2368 push(our @report, $output);
2377 sub fixup_current_range
{
2378 my ($lineRef, $offset, $length) = @_;
2380 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2383 my $no = $o + $offset;
2384 my $nl = $l + $length;
2385 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2389 sub fix_inserted_deleted_lines
{
2390 my ($linesRef, $insertedRef, $deletedRef) = @_;
2392 my $range_last_linenr = 0;
2393 my $delta_offset = 0;
2398 my $next_insert = 0;
2399 my $next_delete = 0;
2403 my $inserted = @
{$insertedRef}[$next_insert++];
2404 my $deleted = @
{$deletedRef}[$next_delete++];
2406 foreach my $old_line (@
{$linesRef}) {
2408 my $line = $old_line; #don't modify the array
2409 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
2411 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2412 $range_last_linenr = $new_linenr;
2413 fixup_current_range
(\
$line, $delta_offset, 0);
2416 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2417 $deleted = @
{$deletedRef}[$next_delete++];
2419 fixup_current_range
(\
$lines[$range_last_linenr], $delta_offset--, -1);
2422 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2423 push(@lines, ${$inserted}{'LINE'});
2424 $inserted = @
{$insertedRef}[$next_insert++];
2426 fixup_current_range
(\
$lines[$range_last_linenr], $delta_offset++, 1);
2430 push(@lines, $line);
2440 sub fix_insert_line
{
2441 my ($linenr, $line) = @_;
2447 push(@fixed_inserted, $inserted);
2450 sub fix_delete_line
{
2451 my ($linenr, $line) = @_;
2458 push(@fixed_deleted, $deleted);
2462 my ($type, $msg) = @_;
2464 if (report
("ERROR", $type, $msg)) {
2472 my ($type, $msg) = @_;
2474 if (report
("WARNING", $type, $msg)) {
2482 my ($type, $msg) = @_;
2484 if ($check && report
("CHECK", $type, $msg)) {
2492 sub check_absolute_file
{
2493 my ($absolute, $herecurr) = @_;
2494 my $file = $absolute;
2496 ##print "absolute<$absolute>\n";
2498 # See if any suffix of this path is a path within the tree.
2499 while ($file =~ s@
^[^/]*/@@
) {
2500 if (-f
"$root/$file") {
2501 ##print "file<$file>\n";
2509 # It is, so see if the prefix is acceptable.
2510 my $prefix = $absolute;
2511 substr($prefix, -length($file)) = '';
2513 ##print "prefix<$prefix>\n";
2514 if ($prefix ne ".../") {
2515 WARN
("USE_RELATIVE_PATH",
2516 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2523 $string =~ s/^\s+|\s+$//g;
2531 $string =~ s/^\s+//;
2539 $string =~ s/\s+$//;
2544 sub string_find_replace
{
2545 my ($string, $find, $replace) = @_;
2547 $string =~ s/$find/$replace/g;
2555 my $source_indent = $tabsize;
2556 my $max_spaces_before_tab = $source_indent - 1;
2557 my $spaces_to_tab = " " x
$source_indent;
2559 #convert leading spaces to tabs
2560 1 while $leading =~ s@
^([\t]*)$spaces_to_tab@
$1\t@g;
2561 #Remove spaces before a tab
2562 1 while $leading =~ s@
^([\t]*)( {1,$max_spaces_before_tab})\t@
$1\t@g;
2567 sub pos_last_openparen
{
2572 my $opens = $line =~ tr/\(/\(/;
2573 my $closes = $line =~ tr/\)/\)/;
2575 my $last_openparen = 0;
2577 if (($opens == 0) || ($closes >= $opens)) {
2581 my $len = length($line);
2583 for ($pos = 0; $pos < $len; $pos++) {
2584 my $string = substr($line, $pos);
2585 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2586 $pos += length($1) - 1;
2587 } elsif (substr($line, $pos, 1) eq '(') {
2588 $last_openparen = $pos;
2589 } elsif (index($string, '(') == -1) {
2594 return length(expand_tabs
(substr($line, 0, $last_openparen))) + 1;
2597 sub get_raw_comment
{
2598 my ($line, $rawline) = @_;
2601 for my $i (0 .. (length($line) - 1)) {
2602 if (substr($line, $i, 1) eq "$;") {
2603 $comment .= substr($rawline, $i, 1);
2610 sub exclude_global_initialisers
{
2611 my ($realfile) = @_;
2613 # Do not check for BPF programs (tools/testing/selftests/bpf/progs/*.c, samples/bpf/*_kern.c, *.bpf.c).
2614 return $realfile =~ m@
^tools
/testing
/selftests
/bpf
/progs/.*\
.c
$@
||
2615 $realfile =~ m@
^samples
/bpf/.*_kern\
.c
$@
||
2616 $realfile =~ m@
/bpf/.*\
.bpf\
.c
$@
;
2620 my $filename = shift;
2626 my $stashrawline="";
2636 my $authorsignoff = 0;
2637 my $author_sob = '';
2639 my $is_binding_patch = -1;
2640 my $in_header_lines = $file ?
0 : 1;
2641 my $in_commit_log = 0; #Scanning lines before patch
2642 my $has_patch_separator = 0; #Found a --- line
2643 my $has_commit_log = 0; #Encountered lines before patch
2644 my $commit_log_lines = 0; #Number of commit log lines
2645 my $commit_log_possible_stack_dump = 0;
2646 my $commit_log_long_line = 0;
2647 my $commit_log_has_diff = 0;
2648 my $reported_maintainer_file = 0;
2649 my $non_utf8_charset = 0;
2651 my $last_git_commit_id_linenr = -1;
2653 my $last_blank_line = 0;
2654 my $last_coalesced_string_linenr = -1;
2662 # Trace the real file/line as we go.
2667 my $context_function; #undef'd unless there's a known function
2669 my $comment_edge = 0;
2673 my $prev_values = 'E';
2676 my %suppress_ifbraces;
2677 my %suppress_whiletrailers;
2678 my %suppress_export;
2679 my $suppress_statement = 0;
2681 my %signatures = ();
2683 # Pre-scan the patch sanitizing the lines.
2684 # Pre-scan the patch looking for any __setup documentation.
2686 my @setup_docs = ();
2689 my $camelcase_file_seeded = 0;
2691 my $checklicenseline = 1;
2693 sanitise_line_reset
();
2695 foreach my $rawline (@rawlines) {
2699 push(@fixed, $rawline) if ($fix);
2701 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2703 if ($1 =~ m
@Documentation/admin-guide/kernel
-parameters
.txt
$@
) {
2708 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2717 # Guestimate if this is a continuing comment. Run
2718 # the context looking for a comment "edge". If this
2719 # edge is a close comment then we must be in a comment
2723 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2724 next if (defined $rawlines[$ln - 1] &&
2725 $rawlines[$ln - 1] =~ /^-/);
2727 #print "RAW<$rawlines[$ln - 1]>\n";
2728 last if (!defined $rawlines[$ln - 1]);
2729 if ($rawlines[$ln - 1] =~ m@
(/\*|\*/)@
&&
2730 $rawlines[$ln - 1] !~ m@
"[^"]*(?
:/\*|\*/)[^"]*"@
) {
2735 if (defined $edge && $edge eq '*/') {
2739 # Guestimate if this is a continuing comment. If this
2740 # is the start of a diff block and this line starts
2741 # ' *' then it is very likely a comment.
2742 if (!defined $edge &&
2743 $rawlines[$linenr] =~ m@
^.\s
*(?
:\
*\
*+| \
*)(?
:\s
|$)@
)
2748 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2749 sanitise_line_reset
($in_comment);
2751 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2752 # Standardise the strings and chars within the input to
2753 # simplify matching -- only bother with positive lines.
2754 $line = sanitise_line
($rawline);
2756 push(@lines, $line);
2759 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2764 #print "==>$rawline\n";
2765 #print "-->$line\n";
2767 if ($setup_docs && $line =~ /^\+/) {
2768 push(@setup_docs, $line);
2777 foreach my $line (@lines) {
2780 my $sline = $line; #copy of $line
2781 $sline =~ s/$;/ /g; #with comments as spaces
2783 my $rawline = $rawlines[$linenr - 1];
2784 my $raw_comment = get_raw_comment
($line, $rawline);
2786 # check if it's a mode change, rename or start of a patch
2787 if (!$in_commit_log &&
2788 ($line =~ /^ mode change [0-7]+ => [0-7]+ \S+\s*$/ ||
2789 ($line =~ /^rename (?:from|to) \S+\s*$/ ||
2790 $line =~ /^diff --git a\/[\w\
/\.\_\-]+ b\/\S
+\s
*$/))) {
2794 #extract the line range in the file after the patch is applied
2795 if (!$in_commit_log &&
2796 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2799 $first_line = $linenr + 1;
2809 %suppress_ifbraces = ();
2810 %suppress_whiletrailers = ();
2811 %suppress_export = ();
2812 $suppress_statement = 0;
2813 if ($context =~ /\b(\w+)\s*\(/) {
2814 $context_function = $1;
2816 undef $context_function;
2820 # track the line number as we move through the hunk, note that
2821 # new versions of GNU diff omit the leading space on completely
2822 # blank context lines so we need to count that too.
2823 } elsif ($line =~ /^( |\+|$)/) {
2825 $realcnt-- if ($realcnt != 0);
2827 # Measure the line length and indent.
2828 ($length, $indent) = line_stats
($rawline);
2830 # Track the previous line.
2831 ($prevline, $stashline) = ($stashline, $line);
2832 ($previndent, $stashindent) = ($stashindent, $indent);
2833 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2835 #warn "line<$line>\n";
2837 } elsif ($realcnt == 1) {
2841 my $hunk_line = ($realcnt != 0);
2843 $here = "#$linenr: " if (!$file);
2844 $here = "#$realline: " if ($file);
2847 # extract the filename as it passes
2848 if ($line =~ /^diff --git.*?(\S+)$/) {
2850 $realfile =~ s@
^([^/]*)/@@
if (!$file);
2853 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2855 $realfile =~ s@
^([^/]*)/@@
if (!$file);
2859 if (!$file && $tree && $p1_prefix ne '' &&
2860 -e
"$root/$p1_prefix") {
2861 WARN
("PATCH_PREFIX",
2862 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2865 if ($realfile =~ m@
^include
/asm/@
) {
2866 ERROR
("MODIFIED_INCLUDE_ASM",
2867 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2872 #make up the handle for any error we report on this line
2874 $prefix = "$realfile:$realline: "
2877 $prefix = "$filename:$realline: ";
2879 $prefix = "$filename:$linenr: ";
2884 if (is_maintained_obsolete
($realfile)) {
2886 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2888 if ($realfile =~ m@
^(?
:drivers
/net
/|net
/|drivers
/staging/)@
) {
2891 $check = $check_orig;
2893 $checklicenseline = 1;
2895 if ($realfile !~ /^MAINTAINERS/) {
2896 my $last_binding_patch = $is_binding_patch;
2898 $is_binding_patch = () = $realfile =~ m@
^(?
:Documentation
/devicetree/|include
/dt-bindings/)@
;
2900 if (($last_binding_patch != -1) &&
2901 ($last_binding_patch ^ $is_binding_patch)) {
2902 WARN
("DT_SPLIT_BINDING_PATCH",
2903 "DT binding docs and includes should be a separate patch. See: Documentation/devicetree/bindings/submitting-patches.rst\n");
2910 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2912 my $hereline = "$here\n$rawline\n";
2913 my $herecurr = "$here\n$rawline\n";
2914 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2916 $cnt_lines++ if ($realcnt != 0);
2918 # Verify the existence of a commit log if appropriate
2919 # 2 is used because a $signature is counted in $commit_log_lines
2920 if ($in_commit_log) {
2921 if ($line !~ /^\s*$/) {
2922 $commit_log_lines++; #could be a $signature
2924 } elsif ($has_commit_log && $commit_log_lines < 2) {
2925 WARN
("COMMIT_MESSAGE",
2926 "Missing commit description - Add an appropriate one\n");
2927 $commit_log_lines = 2; #warn only once
2930 # Check if the commit log has what seems like a diff which can confuse patch
2931 if ($in_commit_log && !$commit_log_has_diff &&
2932 (($line =~ m@
^\s
+diff
\b.*a
/([\w/]+)@
&&
2933 $line =~ m@
^\s
+diff
\b.*a
/[\w/]+\s
+b
/$1\b@
) ||
2934 $line =~ m@
^\s
*(?
:\
-\
-\
-\s
+a
/|\+\+\+\s+b/)@
||
2935 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2936 ERROR
("DIFF_IN_COMMIT_MSG",
2937 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2938 $commit_log_has_diff = 1;
2941 # Check for incorrect file permissions
2942 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2943 my $permhere = $here . "FILE: $realfile\n";
2944 if ($realfile !~ m
@scripts/@
&&
2945 $realfile !~ /\.(py|pl|awk|sh)$/) {
2946 ERROR
("EXECUTE_PERMISSIONS",
2947 "do not set execute permissions for source files\n" . $permhere);
2951 # Check the patch for a From:
2952 if (decode
("MIME-Header", $line) =~ /^From:\s*(.*)/) {
2954 my $curline = $linenr;
2955 while(defined($rawlines[$curline]) && ($rawlines[$curline++] =~ /^[ \t]\s*(.*)/)) {
2958 $author = encode
("utf8", $author) if ($line =~ /=\?utf-8\?/i);
2960 $author = reformat_email
($author);
2963 # Check the patch for a signoff:
2964 if ($line =~ /^\s*signed-off-by:\s*(.*)/i) {
2967 if ($author ne '' && $authorsignoff != 1) {
2968 if (same_email_addresses
($1, $author)) {
2972 my ($email_name, $email_comment, $email_address, $comment1) = parse_email
($ctx);
2973 my ($author_name, $author_comment, $author_address, $comment2) = parse_email
($author);
2975 if (lc $email_address eq lc $author_address && $email_name eq $author_name) {
2978 } elsif (lc $email_address eq lc $author_address) {
2981 } elsif ($email_name eq $author_name) {
2985 my $address1 = $email_address;
2986 my $address2 = $author_address;
2988 if ($address1 =~ /(\S+)\+\S+(\@.*)/) {
2991 if ($address2 =~ /(\S+)\+\S+(\@.*)/) {
2994 if ($address1 eq $address2) {
3002 # Check for patch separator
3003 if ($line =~ /^---$/) {
3004 $has_patch_separator = 1;
3008 # Check if MAINTAINERS is being updated. If so, there's probably no need to
3009 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
3010 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
3011 $reported_maintainer_file = 1;
3014 # Check signature styles
3015 if (!$in_header_lines &&
3016 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
3017 my $space_before = $1;
3019 my $space_after = $3;
3021 my $ucfirst_sign_off = ucfirst(lc($sign_off));
3023 if ($sign_off !~ /$signature_tags/) {
3024 my $suggested_signature = find_standard_signature
($sign_off);
3025 if ($suggested_signature eq "") {
3026 WARN
("BAD_SIGN_OFF",
3027 "Non-standard signature: $sign_off\n" . $herecurr);
3029 if (WARN
("BAD_SIGN_OFF",
3030 "Non-standard signature: '$sign_off' - perhaps '$suggested_signature'?\n" . $herecurr) &&
3032 $fixed[$fixlinenr] =~ s/$sign_off/$suggested_signature/;
3036 if (defined $space_before && $space_before ne "") {
3037 if (WARN
("BAD_SIGN_OFF",
3038 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
3040 $fixed[$fixlinenr] =
3041 "$ucfirst_sign_off $email";
3044 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
3045 if (WARN
("BAD_SIGN_OFF",
3046 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
3048 $fixed[$fixlinenr] =
3049 "$ucfirst_sign_off $email";
3053 if (!defined $space_after || $space_after ne " ") {
3054 if (WARN
("BAD_SIGN_OFF",
3055 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
3057 $fixed[$fixlinenr] =
3058 "$ucfirst_sign_off $email";
3062 my ($email_name, $name_comment, $email_address, $comment) = parse_email
($email);
3063 my $suggested_email = format_email
(($email_name, $name_comment, $email_address, $comment));
3064 if ($suggested_email eq "") {
3065 ERROR
("BAD_SIGN_OFF",
3066 "Unrecognized email address: '$email'\n" . $herecurr);
3068 my $dequoted = $suggested_email;
3069 $dequoted =~ s/^"//;
3070 $dequoted =~ s/" </ </;
3071 # Don't force email to have quotes
3072 # Allow just an angle bracketed address
3073 if (!same_email_addresses
($email, $suggested_email)) {
3074 if (WARN
("BAD_SIGN_OFF",
3075 "email address '$email' might be better as '$suggested_email'\n" . $herecurr) &&
3077 $fixed[$fixlinenr] =~ s/\Q$email\E/$suggested_email/;
3081 # Address part shouldn't have comments
3082 my $stripped_address = $email_address;
3083 $stripped_address =~ s/\([^\(\)]*\)//g;
3084 if ($email_address ne $stripped_address) {
3085 if (WARN
("BAD_SIGN_OFF",
3086 "address part of email should not have comments: '$email_address'\n" . $herecurr) &&
3088 $fixed[$fixlinenr] =~ s/\Q$email_address\E/$stripped_address/;
3092 # Only one name comment should be allowed
3093 my $comment_count = () = $name_comment =~ /\([^\)]+\)/g;
3094 if ($comment_count > 1) {
3095 WARN
("BAD_SIGN_OFF",
3096 "Use a single name comment in email: '$email'\n" . $herecurr);
3100 # stable@vger.kernel.org or stable@kernel.org shouldn't
3101 # have an email name. In addition comments should strictly
3103 if ($email =~ /^.*stable\@(?:vger\.)?kernel\.org/i) {
3104 if (($comment ne "" && $comment !~ /^#.+/) ||
3105 ($email_name ne "")) {
3106 my $cur_name = $email_name;
3107 my $new_comment = $comment;
3108 $cur_name =~ s/[a-zA-Z\s\-\"]+//g;
3110 # Remove brackets enclosing comment text
3111 # and # from start of comments to get comment text
3112 $new_comment =~ s/^\((.*)\)$/$1/;
3113 $new_comment =~ s/^\[(.*)\]$/$1/;
3114 $new_comment =~ s/^[\s\#]+|\s+$//g;
3116 $new_comment = trim
("$new_comment $cur_name") if ($cur_name ne $new_comment);
3117 $new_comment = " # $new_comment" if ($new_comment ne "");
3118 my $new_email = "$email_address$new_comment";
3120 if (WARN
("BAD_STABLE_ADDRESS_STYLE",
3121 "Invalid email format for stable: '$email', prefer '$new_email'\n" . $herecurr) &&
3123 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3126 } elsif ($comment ne "" && $comment !~ /^(?:#.+|\(.+\))$/) {
3127 my $new_comment = $comment;
3129 # Extract comment text from within brackets or
3130 # c89 style /*...*/ comments
3131 $new_comment =~ s/^\[(.*)\]$/$1/;
3132 $new_comment =~ s/^\/\*(.*)\*\/$/$1/;
3134 $new_comment = trim
($new_comment);
3135 $new_comment =~ s/^[^\w]$//; # Single lettered comment with non word character is usually a typo
3136 $new_comment = "($new_comment)" if ($new_comment ne "");
3137 my $new_email = format_email
($email_name, $name_comment, $email_address, $new_comment);
3139 if (WARN
("BAD_SIGN_OFF",
3140 "Unexpected content after email: '$email', should be: '$new_email'\n" . $herecurr) &&
3142 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3147 # Check for duplicate signatures
3148 my $sig_nospace = $line;
3149 $sig_nospace =~ s/\s//g;
3150 $sig_nospace = lc($sig_nospace);
3151 if (defined $signatures{$sig_nospace}) {
3152 WARN
("BAD_SIGN_OFF",
3153 "Duplicate signature\n" . $herecurr);
3155 $signatures{$sig_nospace} = 1;
3158 # Check Co-developed-by: immediately followed by Signed-off-by: with same name and email
3159 if ($sign_off =~ /^co-developed-by:$/i) {
3160 if ($email eq $author) {
3161 WARN
("BAD_SIGN_OFF",
3162 "Co-developed-by: should not be used to attribute nominal patch author '$author'\n" . "$here\n" . $rawline);
3164 if (!defined $lines[$linenr]) {
3165 WARN
("BAD_SIGN_OFF",
3166 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline);
3167 } elsif ($rawlines[$linenr] !~ /^\s*signed-off-by:\s*(.*)/i) {
3168 WARN
("BAD_SIGN_OFF",
3169 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3170 } elsif ($1 ne $email) {
3171 WARN
("BAD_SIGN_OFF",
3172 "Co-developed-by and Signed-off-by: name/email do not match \n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3177 # Check email subject for common tools that don't need to be mentioned
3178 if ($in_header_lines &&
3179 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
3180 WARN
("EMAIL_SUBJECT",
3181 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
3184 # Check for Gerrit Change-Ids not in any patch context
3185 if ($realfile eq '' && !$has_patch_separator && $line =~ /^\s*change-id:/i) {
3186 if (ERROR
("GERRIT_CHANGE_ID",
3187 "Remove Gerrit Change-Id's before submitting upstream\n" . $herecurr) &&
3189 fix_delete_line
($fixlinenr, $rawline);
3193 # Check if the commit log is in a possible stack dump
3194 if ($in_commit_log && !$commit_log_possible_stack_dump &&
3195 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
3196 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
3198 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/) ||
3199 $line =~ /^(?:\s+\w+:\s+[0-9a-fA-F]+){3,3}/ ||
3200 $line =~ /^\s*\#\d+\s*\[[0-9a-fA-F]+\]\s*\w+ at [0-9a-fA-F]+/) {
3201 # stack dump address styles
3202 $commit_log_possible_stack_dump = 1;
3205 # Check for line lengths > 75 in commit log, warn once
3206 if ($in_commit_log && !$commit_log_long_line &&
3207 length($line) > 75 &&
3208 !($line =~ /^\s*[a-zA-Z0-9_\/\
.]+\s
+\
|\s
+\d
+/ ||
3209 # file delta changes
3210 $line =~ /^\s*(?:[\w\.\-\+]*\/)++[\w\
.\
-\
+]+:/ ||
3212 $line =~ /^\s*(?:Fixes:|Link:|$signature_tags)/i ||
3213 # A Fixes: or Link: line or signature tag line
3214 $commit_log_possible_stack_dump)) {
3215 WARN
("COMMIT_LOG_LONG_LINE",
3216 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
3217 $commit_log_long_line = 1;
3220 # Reset possible stack dump if a blank line is found
3221 if ($in_commit_log && $commit_log_possible_stack_dump &&
3223 $commit_log_possible_stack_dump = 0;
3226 # Check for lines starting with a #
3227 if ($in_commit_log && $line =~ /^#/) {
3228 if (WARN
("COMMIT_COMMENT_SYMBOL",
3229 "Commit log lines starting with '#' are dropped by git as comments\n" . $herecurr) &&
3231 $fixed[$fixlinenr] =~ s/^/ /;
3235 # Check for git id commit length and improperly formed commit descriptions
3236 # A correctly formed commit description is:
3237 # commit <SHA-1 hash length 12+ chars> ("Complete commit subject")
3238 # with the commit subject '("' prefix and '")' suffix
3239 # This is a fairly compilicated block as it tests for what appears to be
3240 # bare SHA-1 hash with minimum length of 5. It also avoids several types of
3241 # possible SHA-1 matches.
3242 # A commit match can span multiple lines so this block attempts to find a
3243 # complete typical commit on a maximum of 3 lines
3244 if ($perl_version_ok &&
3245 $in_commit_log && !$commit_log_possible_stack_dump &&
3246 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink|base-commit):/i &&
3247 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
3248 (($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
3249 ($line =~ /\bcommit\s*$/i && defined($rawlines[$linenr]) && $rawlines[$linenr] =~ /^\s*[0-9a-f]{5,}\b/i)) ||
3250 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
3251 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
3252 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
3253 my $init_char = "c";
3254 my $orig_commit = "";
3259 my $id = '0123456789ab';
3260 my $orig_desc = "commit description";
3261 my $description = "";
3262 my $herectx = $herecurr;
3267 if ($line =~ /(?:\bcommit\s+[0-9a-f]{5,}|\bcommit\s*$)/i) {
3268 for (my $n = 0; $n < 2; $n++) {
3269 if ($input =~ /\bcommit\s+[0-9a-f]{5,}\s*($balanced_parens)/i) {
3272 # Always strip leading/trailing parens then double quotes if existing
3273 $orig_desc = substr($orig_desc, 1, -1);
3274 if ($orig_desc =~ /^".*"$/) {
3275 $orig_desc = substr($orig_desc, 1, -1);
3280 last if ($#lines < $linenr + $n);
3281 $input .= " " . trim
($rawlines[$linenr + $n]);
3282 $herectx .= "$rawlines[$linenr + $n]\n";
3284 $herectx = $herecurr if (!$has_parens);
3287 if ($input =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
3289 $orig_commit = lc($2);
3290 $short = 0 if ($input =~ /\bcommit\s+[0-9a-f]{12,40}/i);
3291 $long = 1 if ($input =~ /\bcommit\s+[0-9a-f]{41,}/i);
3292 $space = 0 if ($input =~ /\bcommit [0-9a-f]/i);
3293 $case = 0 if ($input =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
3294 } elsif ($input =~ /\b([0-9a-f]{12,40})\b/i) {
3295 $orig_commit = lc($1);
3298 ($id, $description) = git_commit_info
($orig_commit,
3302 ($short || $long || $space || $case || ($orig_desc ne $description) || !$has_quotes) &&
3303 $last_git_commit_id_linenr != $linenr - 1) {
3304 ERROR
("GIT_COMMIT_ID",
3305 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herectx);
3307 #don't report the next line if this line ends in commit and the sha1 hash is the next line
3308 $last_git_commit_id_linenr = $linenr if ($line =~ /\bcommit\s*$/i);
3311 # Check for added, moved or deleted files
3312 if (!$reported_maintainer_file && !$in_commit_log &&
3313 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
3314 $line =~ /^rename (?:from|to) [\w\/\
.\
-]+\s
*$/ ||
3315 ($line =~ /\{\s*([\w\/\
.\
-]*)\s
*\
=\
>\s
*([\w\
/\.\-]*)\s*\}/ &&
3316 (defined($1) || defined($2))))) {
3318 $reported_maintainer_file = 1;
3319 WARN
("FILE_PATH_CHANGES",
3320 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
3323 # Check for adding new DT bindings not in schema format
3324 if (!$in_commit_log &&
3325 ($line =~ /^new file mode\s*\d+\s*$/) &&
3326 ($realfile =~ m@
^Documentation
/devicetree/bindings
/.*\
.txt
$@
)) {
3327 WARN
("DT_SCHEMA_BINDING_PATCH",
3328 "DT bindings should be in DT schema format. See: Documentation/devicetree/bindings/writing-schema.rst\n");
3331 # Check for wrappage within a valid hunk of the file
3332 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
3333 ERROR
("CORRUPTED_PATCH",
3334 "patch seems to be corrupt (line wrapped?)\n" .
3335 $herecurr) if (!$emitted_corrupt++);
3338 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
3339 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
3340 $rawline !~ m/^$UTF8*$/) {
3341 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
3343 my $blank = copy_spacing
($rawline);
3344 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
3345 my $hereptr = "$hereline$ptr\n";
3348 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
3351 # Check if it's the start of a commit log
3352 # (not a header line and we haven't seen the patch filename)
3353 if ($in_header_lines && $realfile =~ /^$/ &&
3354 !($rawline =~ /^\s+(?:\S|$)/ ||
3355 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
3356 $in_header_lines = 0;
3358 $has_commit_log = 1;
3361 # Check if there is UTF-8 in a commit log when a mail header has explicitly
3362 # declined it, i.e defined some charset where it is missing.
3363 if ($in_header_lines &&
3364 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
3366 $non_utf8_charset = 1;
3369 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
3370 $rawline =~ /$NON_ASCII_UTF8/) {
3371 WARN
("UTF8_BEFORE_PATCH",
3372 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
3375 # Check for absolute kernel paths in commit message
3376 if ($tree && $in_commit_log) {
3377 while ($line =~ m{(?:^|\s)(/\S*)}g) {
3380 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
3381 check_absolute_file
($1, $herecurr)) {
3384 check_absolute_file
($file, $herecurr);
3389 # Check for various typo / spelling mistakes
3390 if (defined($misspellings) &&
3391 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
3392 while ($rawline =~ /(?:^|[^\w\-'`])($misspellings)(?:[^\w\-'`]|$)/gi) {
3394 my $blank = copy_spacing
($rawline);
3395 my $ptr = substr($blank, 0, $-[1]) . "^" x
length($typo);
3396 my $hereptr = "$hereline$ptr\n";
3397 my $typo_fix = $spelling_fix{lc($typo)};
3398 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
3399 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
3400 my $msg_level = \
&WARN
;
3401 $msg_level = \
&CHK
if ($file);
3402 if (&{$msg_level}("TYPO_SPELLING",
3403 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $hereptr) &&
3405 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
3410 # check for invalid commit id
3411 if ($in_commit_log && $line =~ /(^fixes:|\bcommit)\s+([0-9a-f]{6,40})\b/i) {
3414 ($id, $description) = git_commit_info
($2, undef, undef);
3415 if (!defined($id)) {
3416 WARN
("UNKNOWN_COMMIT_ID",
3417 "Unknown commit id '$2', maybe rebased or not pulled?\n" . $herecurr);
3421 # check for repeated words separated by a single space
3422 # avoid false positive from list command eg, '-rw-r--r-- 1 root root'
3423 if (($rawline =~ /^\+/ || $in_commit_log) &&
3424 $rawline !~ /[bcCdDlMnpPs\?-][rwxsStT-]{9}/) {
3425 pos($rawline) = 1 if (!$in_commit_log);
3426 while ($rawline =~ /\b($word_pattern) (?=($word_pattern))/g) {
3430 my $start_pos = $-[1];
3431 my $end_pos = $+[2];
3432 if ($first =~ /(?:struct|union|enum)/) {
3433 pos($rawline) += length($first) + length($second) + 1;
3437 next if (lc($first) ne lc($second));
3438 next if ($first eq 'long');
3440 # check for character before and after the word matches
3441 my $start_char = '';
3443 $start_char = substr($rawline, $start_pos - 1, 1) if ($start_pos > ($in_commit_log ?
0 : 1));
3444 $end_char = substr($rawline, $end_pos, 1) if ($end_pos < length($rawline));
3446 next if ($start_char =~ /^\S$/);
3447 next if (index(" \t.,;?!", $end_char) == -1);
3449 # avoid repeating hex occurrences like 'ff ff fe 09 ...'
3450 if ($first =~ /\b[0-9a-f]{2,}\b/i) {
3451 next if (!exists($allow_repeated_words{lc($first)}));
3454 if (WARN
("REPEATED_WORD",
3455 "Possible repeated word: '$first'\n" . $herecurr) &&
3457 $fixed[$fixlinenr] =~ s/\b$first $second\b/$first/;
3461 # if it's a repeated word on consecutive lines in a comment block
3462 if ($prevline =~ /$;+\s*$/ &&
3463 $prevrawline =~ /($word_pattern)\s*$/) {
3465 if ($rawline =~ /^\+\s*\*\s*$last_word /) {
3466 if (WARN
("REPEATED_WORD",
3467 "Possible repeated word: '$last_word'\n" . $hereprev) &&
3469 $fixed[$fixlinenr] =~ s/(\+\s*\*\s*)$last_word /$1/;
3475 # ignore non-hunk lines and lines being removed
3476 next if (!$hunk_line || $line =~ /^-/);
3478 #trailing whitespace
3479 if ($line =~ /^\+.*\015/) {
3480 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
3481 if (ERROR
("DOS_LINE_ENDINGS",
3482 "DOS line endings\n" . $herevet) &&
3484 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
3486 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
3487 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
3488 if (ERROR
("TRAILING_WHITESPACE",
3489 "trailing whitespace\n" . $herevet) &&
3491 $fixed[$fixlinenr] =~ s/\s+$//;
3497 # Check for FSF mailing addresses.
3498 if ($rawline =~ /\bwrite to the Free/i ||
3499 $rawline =~ /\b675\s+Mass\s+Ave/i ||
3500 $rawline =~ /\b59\s+Temple\s+Pl/i ||
3501 $rawline =~ /\b51\s+Franklin\s+St/i) {
3502 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
3503 my $msg_level = \
&ERROR
;
3504 $msg_level = \
&CHK
if ($file);
3505 &{$msg_level}("FSF_MAILING_ADDRESS",
3506 "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)
3509 # check for Kconfig help text having a real description
3510 # Only applies when adding the entry originally, after that we do not have
3511 # sufficient context to determine whether it is indeed long enough.
3512 if ($realfile =~ /Kconfig/ &&
3513 # 'choice' is usually the last thing on the line (though
3514 # Kconfig supports named choices), so use a word boundary
3515 # (\b) rather than a whitespace character (\s)
3516 $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
3520 my $help_length = 0;
3521 while (defined $lines[$ln]) {
3522 my $f = $lines[$ln++];
3524 next if ($f =~ /^-/);
3525 last if ($f !~ /^[\+ ]/); # !patch context
3527 if ($f =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
3531 if ($f =~ /^\+\s*help\s*$/) {
3536 $f =~ s/^.//; # strip patch context [+ ]
3537 $f =~ s/#.*//; # strip # directives
3538 $f =~ s/^\s+//; # strip leading blanks
3539 next if ($f =~ /^$/); # skip blank lines
3541 # At the end of this Kconfig block:
3542 # This only checks context lines in the patch
3543 # and so hopefully shouldn't trigger false
3544 # positives, even though some of these are
3545 # common words in help texts
3546 if ($f =~ /^(?
:config
|menuconfig
|choice
|endchoice
|
3547 if|endif
|menu
|endmenu
|source
)\b/x
) {
3550 $help_length++ if ($has_help);
3553 $help_length < $min_conf_desc_length) {
3554 my $stat_real = get_stat_real
($linenr, $ln - 1);
3555 WARN
("CONFIG_DESCRIPTION",
3556 "please write a help paragraph that fully describes the config symbol\n" . "$here\n$stat_real\n");
3560 # check MAINTAINERS entries
3561 if ($realfile =~ /^MAINTAINERS$/) {
3562 # check MAINTAINERS entries for the right form
3563 if ($rawline =~ /^\+[A-Z]:/ &&
3564 $rawline !~ /^\+[A-Z]:\t\S/) {
3565 if (WARN
("MAINTAINERS_STYLE",
3566 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
3568 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
3571 # check MAINTAINERS entries for the right ordering too
3572 my $preferred_order = 'MRLSWQBCPTFXNK';
3573 if ($rawline =~ /^\+[A-Z]:/ &&
3574 $prevrawline =~ /^[\+ ][A-Z]:/) {
3575 $rawline =~ /^\+([A-Z]):\s*(.*)/;
3578 $prevrawline =~ /^[\+ ]([A-Z]):\s*(.*)/;
3581 my $curindex = index($preferred_order, $cur);
3582 my $previndex = index($preferred_order, $prev);
3583 if ($curindex < 0) {
3584 WARN
("MAINTAINERS_STYLE",
3585 "Unknown MAINTAINERS entry type: '$cur'\n" . $herecurr);
3587 if ($previndex >= 0 && $curindex < $previndex) {
3588 WARN
("MAINTAINERS_STYLE",
3589 "Misordered MAINTAINERS entry - list '$cur:' before '$prev:'\n" . $hereprev);
3590 } elsif ((($prev eq 'F' && $cur eq 'F') ||
3591 ($prev eq 'X' && $cur eq 'X')) &&
3592 ($prevval cmp $curval) > 0) {
3593 WARN
("MAINTAINERS_STYLE",
3594 "Misordered MAINTAINERS entry - list file patterns in alphabetic order\n" . $hereprev);
3600 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
3601 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
3604 'EXTRA_AFLAGS' => 'asflags-y',
3605 'EXTRA_CFLAGS' => 'ccflags-y',
3606 'EXTRA_CPPFLAGS' => 'cppflags-y',
3607 'EXTRA_LDFLAGS' => 'ldflags-y',
3610 WARN
("DEPRECATED_VARIABLE",
3611 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
3614 # check for DT compatible documentation
3615 if (defined $root &&
3616 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
3617 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
3619 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
3621 my $dt_path = $root . "/Documentation/devicetree/bindings/";
3622 my $vp_file = $dt_path . "vendor-prefixes.yaml";
3624 foreach my $compat (@compats) {
3625 my $compat2 = $compat;
3626 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
3627 my $compat3 = $compat;
3628 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
3629 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
3631 WARN
("UNDOCUMENTED_DT_STRING",
3632 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
3635 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
3637 `grep -Eq "\\"\\^\Q$vendor\E,\\.\\*\\":" $vp_file`;
3639 WARN
("UNDOCUMENTED_DT_STRING",
3640 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
3645 # check for using SPDX license tag at beginning of files
3646 if ($realline == $checklicenseline) {
3647 if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
3648 $checklicenseline = 2;
3649 } elsif ($rawline =~ /^\+/) {
3651 if ($realfile =~ /\.(h|s|S)$/) {
3653 } elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
3655 } elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc|yaml)$/) {
3657 } elsif ($realfile =~ /\.rst$/) {
3661 # check SPDX comment style for .[chsS] files
3662 if ($realfile =~ /\.[chsS]$/ &&
3663 $rawline =~ /SPDX-License-Identifier:/ &&
3664 $rawline !~ m@
^\
+\s
*\Q
$comment\E\s
*@
) {
3665 WARN
("SPDX_LICENSE_TAG",
3666 "Improper SPDX comment style for '$realfile', please use '$comment' instead\n" . $herecurr);
3669 if ($comment !~ /^$/ &&
3670 $rawline !~ m@
^\
+\Q
$comment\E SPDX
-License
-Identifier
: @
) {
3671 WARN
("SPDX_LICENSE_TAG",
3672 "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
3673 } elsif ($rawline =~ /(SPDX-License-Identifier: .*)/) {
3674 my $spdx_license = $1;
3675 if (!is_SPDX_License_valid
($spdx_license)) {
3676 WARN
("SPDX_LICENSE_TAG",
3677 "'$spdx_license' is not supported in LICENSES/...\n" . $herecurr);
3679 if ($realfile =~ m@
^Documentation
/devicetree/bindings
/@
&&
3680 not $spdx_license =~ /GPL-2\.0.*BSD-2-Clause/) {
3681 my $msg_level = \
&WARN
;
3682 $msg_level = \
&CHK
if ($file);
3683 if (&{$msg_level}("SPDX_LICENSE_TAG",
3685 "DT binding documents should be licensed (GPL-2.0-only OR BSD-2-Clause)\n" . $herecurr) &&
3687 $fixed[$fixlinenr] =~ s/SPDX-License-Identifier: .*/SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)/;
3694 # check for embedded filenames
3695 if ($rawline =~ /^\+.*\Q$realfile\E/) {
3696 WARN
("EMBEDDED_FILENAME",
3697 "It's generally not useful to have the filename in the file\n" . $herecurr);
3700 # check we are in a valid source file if not then ignore this hunk
3701 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
3703 # check for using SPDX-License-Identifier on the wrong line number
3704 if ($realline != $checklicenseline &&
3705 $rawline =~ /\bSPDX-License-Identifier:/ &&
3706 substr($line, @
-, @
+ - @
-) eq "$;" x
(@
+ - @
-)) {
3707 WARN
("SPDX_LICENSE_TAG",
3708 "Misplaced SPDX-License-Identifier tag - use line $checklicenseline instead\n" . $herecurr);
3711 # line length limit (with some exclusions)
3713 # There are a few types of lines that may extend beyond $max_line_length:
3714 # logging functions like pr_info that end in a string
3715 # lines with a single string
3716 # #defines that are a single string
3717 # lines with an RFC3986 like URL
3719 # There are 3 different line length message types:
3720 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
3721 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
3722 # LONG_LINE all other lines longer than $max_line_length
3724 # if LONG_LINE is ignored, the other 2 types are also ignored
3727 if ($line =~ /^\+/ && $length > $max_line_length) {
3728 my $msg_type = "LONG_LINE";
3730 # Check the allowed long line types first
3732 # logging functions that end in a string that starts
3733 # before $max_line_length
3734 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
3735 length(expand_tabs
(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3738 # lines with only strings (w/ possible termination)
3739 # #defines with only strings
3740 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
3741 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
3744 # More special cases
3745 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3746 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3749 # URL ($rawline is used in case the URL is in a comment)
3750 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\
/\S+/i) {
3753 # Otherwise set the alternate message types
3755 # a comment starts before $max_line_length
3756 } elsif ($line =~ /($;[\s$;]*)$/ &&
3757 length(expand_tabs
(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3758 $msg_type = "LONG_LINE_COMMENT"
3760 # a quoted string starts before $max_line_length
3761 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3762 length(expand_tabs
(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3763 $msg_type = "LONG_LINE_STRING"
3766 if ($msg_type ne "" &&
3767 (show_type
("LONG_LINE") || show_type
($msg_type))) {
3768 my $msg_level = \
&WARN
;
3769 $msg_level = \
&CHK
if ($file);
3770 &{$msg_level}($msg_type,
3771 "line length of $length exceeds $max_line_length columns\n" . $herecurr);
3775 # check for adding lines without a newline.
3776 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3777 if (WARN
("MISSING_EOF_NEWLINE",
3778 "adding a line without newline at end of file\n" . $herecurr) &&
3780 fix_delete_line
($fixlinenr+1, "No newline at end of file");
3784 # check for .L prefix local symbols in .S files
3785 if ($realfile =~ /\.S$/ &&
3786 $line =~ /^\+\s*(?:[A-Z]+_)?SYM_[A-Z]+_(?:START|END)(?:_[A-Z_]+)?\s*\(\s*\.L/) {
3787 WARN
("AVOID_L_PREFIX",
3788 "Avoid using '.L' prefixed local symbol names for denoting a range of code via 'SYM_*_START/END' annotations; see Documentation/asm-annotations.rst\n" . $herecurr);
3791 # check we are in a valid source file C or perl if not then ignore this hunk
3792 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3794 # at the beginning of a line any tabs must come first and anything
3795 # more than $tabsize must use tabs.
3796 if ($rawline =~ /^\+\s* \t\s*\S/ ||
3797 $rawline =~ /^\+\s* \s*/) {
3798 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
3800 if (ERROR
("CODE_INDENT",
3801 "code indent should use tabs where possible\n" . $herevet) &&
3803 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3807 # check for space before tabs.
3808 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3809 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
3810 if (WARN
("SPACE_BEFORE_TAB",
3811 "please, no space before tabs\n" . $herevet) &&
3813 while ($fixed[$fixlinenr] =~
3814 s/(^\+.*) {$tabsize,$tabsize}\t/$1\t\t/) {}
3815 while ($fixed[$fixlinenr] =~
3816 s/(^\+.*) +\t/$1\t/) {}
3820 # check for assignments on the start of a line
3821 if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3823 if (CHK
("ASSIGNMENT_CONTINUATIONS",
3824 "Assignment operator '$1' should be on the previous line\n" . $hereprev) &&
3825 $fix && $prevrawline =~ /^\+/) {
3826 # add assignment operator to the previous line, remove from current line
3827 $fixed[$fixlinenr - 1] .= " $operator";
3828 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3832 # check for && or || at the start of a line
3833 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3835 if (CHK
("LOGICAL_CONTINUATIONS",
3836 "Logical continuations should be on the previous line\n" . $hereprev) &&
3837 $fix && $prevrawline =~ /^\+/) {
3838 # insert logical operator at last non-comment, non-whitepsace char on previous line
3839 $prevline =~ /[\s$;]*$/;
3840 my $line_end = substr($prevrawline, $-[0]);
3841 $fixed[$fixlinenr - 1] =~ s/\Q$line_end\E$/ $operator$line_end/;
3842 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3846 # check indentation starts on a tab stop
3847 if ($perl_version_ok &&
3848 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3849 my $indent = length($1);
3850 if ($indent % $tabsize) {
3852 "Statements should start on a tabstop\n" . $herecurr) &&
3854 $fixed[$fixlinenr] =~ s@
(^\
+\t+) +@
$1 . "\t" x
($indent/$tabsize)@e;
3859 # check multi-line statement indentation matches previous line
3860 if ($perl_version_ok &&
3861 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3862 $prevline =~ /^\+(\t*)(.*)$/;
3866 my $pos = pos_last_openparen
($rest);
3868 $line =~ /^(\+| )([ \t]*)/;
3871 my $goodtabindent = $oldindent .
3872 "\t" x
($pos / $tabsize) .
3873 " " x
($pos % $tabsize);
3874 my $goodspaceindent = $oldindent . " " x
$pos;
3876 if ($newindent ne $goodtabindent &&
3877 $newindent ne $goodspaceindent) {
3879 if (CHK
("PARENTHESIS_ALIGNMENT",
3880 "Alignment should match open parenthesis\n" . $hereprev) &&
3881 $fix && $line =~ /^\+/) {
3882 $fixed[$fixlinenr] =~
3883 s/^\+[ \t]*/\+$goodtabindent/;
3889 # check for space after cast like "(int) foo" or "(struct foo) bar"
3890 # avoid checking a few false positives:
3891 # "sizeof(<type>)" or "__alignof__(<type>)"
3892 # function pointer declarations like "(*foo)(int) = bar;"
3893 # structure definitions like "(struct foo) { 0 };"
3894 # multiline macros that define functions
3895 # known attributes or the __attribute__ keyword
3896 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3897 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3899 "No space is necessary after a cast\n" . $herecurr) &&
3901 $fixed[$fixlinenr] =~
3902 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3906 # Block comment styles
3907 # Networking with an initial /*
3908 if ($realfile =~ m@
^(drivers
/net
/|net
/)@
&&
3909 $prevrawline =~ /^\+[ \t]*\/\
*[ \t]*$/ &&
3910 $rawline =~ /^\+[ \t]*\*/ &&
3911 $realline > 3) { # Do not warn about the initial copyright comment block after SPDX-License-Identifier
3912 WARN
("NETWORKING_BLOCK_COMMENT_STYLE",
3913 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3916 # Block comments use * on subsequent lines
3917 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3918 $prevrawline =~ /^\+.*?\/\
*/ && #starting /*
3919 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
3920 $rawline =~ /^\+/ && #line is new
3921 $rawline !~ /^\+[ \t]*\*/) { #no leading *
3922 WARN
("BLOCK_COMMENT_STYLE",
3923 "Block comments use * on subsequent lines\n" . $hereprev);
3926 # Block comments use */ on trailing lines
3927 if ($rawline !~ m@
^\
+[ \t]*\
*/[ \t]*$@ && #trailing */
3928 $rawline !~ m@
^\
+.*/\*.*\*/[ \t]*$@
&& #inline /*...*/
3929 $rawline !~ m@
^\
+.*\
*{2,}/[ \t]*$@ && #trailing **/
3930 $rawline =~ m@
^\
+[ \t]*.+\
*\
/[ \t]*$@) { #non blank */
3931 WARN
("BLOCK_COMMENT_STYLE",
3932 "Block comments use a trailing */ on a separate line\n" . $herecurr);
3935 # Block comment * alignment
3936 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
3937 $line =~ /^\+[ \t]*$;/ && #leading comment
3938 $rawline =~ /^\+[ \t]*\*/ && #leading *
3939 (($prevrawline =~ /^\+.*?\/\
*/ && #leading /*
3940 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
3941 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
3943 $prevrawline =~ m@
^\
+([ \t]*/?
)\
*@
;
3945 $oldindent = expand_tabs
($1);
3947 $prevrawline =~ m@
^\
+(.*/?
)\
*@
;
3948 $oldindent = expand_tabs
($1);
3950 $rawline =~ m@
^\
+([ \t]*)\
*@
;
3952 $newindent = expand_tabs
($newindent);
3953 if (length($oldindent) ne length($newindent)) {
3954 WARN
("BLOCK_COMMENT_STYLE",
3955 "Block comments should align the * on each line\n" . $hereprev);
3959 # check for missing blank lines after struct/union declarations
3960 # with exceptions for various attributes and macros
3961 if ($prevline =~ /^[\+ ]};?\s*$/ &&
3963 !($line =~ /^\+\s*$/ ||
3964 $line =~ /^\+\s*(?:EXPORT_SYMBOL|early_param)/ ||
3965 $line =~ /^\+\s*MODULE_/i ||
3966 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
3967 $line =~ /^\+[a-z_]*init/ ||
3968 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
3969 $line =~ /^\+\s*DECLARE/ ||
3970 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
3971 $line =~ /^\+\s*__setup/)) {
3972 if (CHK
("LINE_SPACING",
3973 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
3975 fix_insert_line
($fixlinenr, "\+");
3979 # check for multiple consecutive blank lines
3980 if ($prevline =~ /^[\+ ]\s*$/ &&
3981 $line =~ /^\+\s*$/ &&
3982 $last_blank_line != ($linenr - 1)) {
3983 if (CHK
("LINE_SPACING",
3984 "Please don't use multiple blank lines\n" . $hereprev) &&
3986 fix_delete_line
($fixlinenr, $rawline);
3989 $last_blank_line = $linenr;
3992 # check for missing blank lines after declarations
3993 # (declarations must have the same indentation and not be at the start of line)
3994 if (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/) {
3998 # remove $Attribute/$Sparse uses to simplify comparisons
3999 $sl =~ s/\b(?:$Attribute|$Sparse)\b//g;
4000 $pl =~ s/\b(?:$Attribute|$Sparse)\b//g;
4001 if (($pl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
4002 # function pointer declarations
4003 $pl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
4004 # foo bar; where foo is some local typedef or #define
4005 $pl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
4006 # known declaration macros
4007 $pl =~ /^\+\s+$declaration_macros/) &&
4008 # for "else if" which can look like "$Ident $Ident"
4009 !($pl =~ /^\+\s+$c90_Keywords\b/ ||
4010 # other possible extensions of declaration lines
4011 $pl =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
4012 # not starting a section or a macro "\" extended line
4013 $pl =~ /(?:\{\s*|\\)$/) &&
4014 # looks like a declaration
4015 !($sl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
4016 # function pointer declarations
4017 $sl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
4018 # foo bar; where foo is some local typedef or #define
4019 $sl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
4020 # known declaration macros
4021 $sl =~ /^\+\s+$declaration_macros/ ||
4022 # start of struct or union or enum
4023 $sl =~ /^\+\s+(?:static\s+)?(?:const\s+)?(?:union|struct|enum|typedef)\b/ ||
4024 # start or end of block or continuation of declaration
4025 $sl =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
4026 # bitfield continuation
4027 $sl =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
4028 # other possible extensions of declaration lines
4029 $sl =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/)) {
4030 if (WARN
("LINE_SPACING",
4031 "Missing a blank line after declarations\n" . $hereprev) &&
4033 fix_insert_line
($fixlinenr, "\+");
4038 # check for spaces at the beginning of a line.
4040 # 1) within comments
4041 # 2) indented preprocessor commands
4043 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
4044 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
4045 if (WARN
("LEADING_SPACE",
4046 "please, no spaces at the start of a line\n" . $herevet) &&
4048 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
4052 # check we are in a valid C source file if not then ignore this hunk
4053 next if ($realfile !~ /\.(h|c)$/);
4055 # check for unusual line ending [ or (
4056 if ($line =~ /^\+.*([\[\(])\s*$/) {
4057 CHK
("OPEN_ENDED_LINE",
4058 "Lines should not end with a '$1'\n" . $herecurr);
4061 # check if this appears to be the start function declaration, save the name
4062 if ($sline =~ /^\+\{\s*$/ &&
4063 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
4064 $context_function = $1;
4067 # check if this appears to be the end of function declaration
4068 if ($sline =~ /^\+\}\s*$/) {
4069 undef $context_function;
4072 # check indentation of any line with a bare else
4073 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
4074 # if the previous line is a break or return and is indented 1 tab more...
4075 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
4076 my $tabs = length($1) + 1;
4077 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
4078 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
4079 defined $lines[$linenr] &&
4080 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
4081 WARN
("UNNECESSARY_ELSE",
4082 "else is not generally useful after a break or return\n" . $hereprev);
4086 # check indentation of a line with a break;
4087 # if the previous line is a goto, return or break
4088 # and is indented the same # of tabs
4089 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
4091 if ($prevline =~ /^\+$tabs(goto|return|break)\b/) {
4092 if (WARN
("UNNECESSARY_BREAK",
4093 "break is not useful after a $1\n" . $hereprev) &&
4095 fix_delete_line
($fixlinenr, $rawline);
4100 # check for RCS/CVS revision markers
4101 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
4103 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
4106 # check for old HOTPLUG __dev<foo> section markings
4107 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
4108 WARN
("HOTPLUG_SECTION",
4109 "Using $1 is unnecessary\n" . $herecurr);
4112 # Check for potential 'bare' types
4113 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
4115 #print "LINE<$line>\n";
4116 if ($linenr > $suppress_statement &&
4117 $realcnt && $sline =~ /.\s*\S/) {
4118 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4119 ctx_statement_block
($linenr, $realcnt, 0);
4120 $stat =~ s/\n./\n /g;
4121 $cond =~ s/\n./\n /g;
4123 #print "linenr<$linenr> <$stat>\n";
4124 # If this statement has no statement boundaries within
4125 # it there is no point in retrying a statement scan
4126 # until we hit end of it.
4127 my $frag = $stat; $frag =~ s/;+\s*$//;
4128 if ($frag !~ /(?:{|;)/) {
4129 #print "skip<$line_nr_next>\n";
4130 $suppress_statement = $line_nr_next;
4133 # Find the real next line.
4134 $realline_next = $line_nr_next;
4135 if (defined $realline_next &&
4136 (!defined $lines[$realline_next - 1] ||
4137 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
4144 # Ignore goto labels.
4145 if ($s =~ /$Ident:\*$/s) {
4147 # Ignore functions being called
4148 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
4150 } elsif ($s =~ /^.\s*else\b/s) {
4152 # declarations always start with types
4153 } 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) {
4156 possible
($type, "A:" . $s);
4158 # definitions in global scope can only start with types
4159 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
4160 possible
($1, "B:" . $s);
4163 # any (foo ... *) is a pointer cast, and foo is a type
4164 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
4165 possible
($1, "C:" . $s);
4168 # Check for any sort of function declaration.
4169 # int foo(something bar, other baz);
4170 # void (*store_gdt)(x86_descr_ptr *);
4171 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
4172 my ($name_len) = length($1);
4175 substr($ctx, 0, $name_len + 1, '');
4176 $ctx =~ s/\)[^\)]*$//;
4178 for my $arg (split(/\s*,\s*/, $ctx)) {
4179 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
4181 possible
($1, "D:" . $s);
4189 # Checks which may be anchored in the context.
4192 # Check for switch () and associated case and default
4193 # statements should be at the same indent.
4194 if ($line=~/\bswitch\s*\(.*\)/) {
4197 my @ctx = ctx_block_outer
($linenr, $realcnt);
4199 for my $ctx (@ctx) {
4200 my ($clen, $cindent) = line_stats
($ctx);
4201 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
4202 $indent != $cindent) {
4203 $err .= "$sep$ctx\n";
4210 ERROR
("SWITCH_CASE_INDENT_LEVEL",
4211 "switch and case should be at the same indent\n$hereline$err");
4215 # if/while/etc brace do not go on next line, unless defining a do while loop,
4216 # or if that brace on the next line is for something else
4217 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
4218 my $pre_ctx = "$1$2";
4220 my ($level, @ctx) = ctx_statement_level
($linenr, $realcnt, 0);
4222 if ($line =~ /^\+\t{6,}/) {
4223 WARN
("DEEP_INDENTATION",
4224 "Too many leading tabs - consider code refactoring\n" . $herecurr);
4227 my $ctx_cnt = $realcnt - $#ctx - 1;
4228 my $ctx = join("\n", @ctx);
4230 my $ctx_ln = $linenr;
4231 my $ctx_skip = $realcnt;
4233 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
4234 defined $lines[$ctx_ln - 1] &&
4235 $lines[$ctx_ln - 1] =~ /^-/)) {
4236 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
4237 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
4241 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
4242 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
4244 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
4246 "that open brace { should be on the previous line\n" .
4247 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4249 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
4250 $ctx =~ /\)\s*\;\s*$/ &&
4251 defined $lines[$ctx_ln - 1])
4253 my ($nlength, $nindent) = line_stats
($lines[$ctx_ln - 1]);
4254 if ($nindent > $indent) {
4255 WARN
("TRAILING_SEMICOLON",
4256 "trailing semicolon indicates no statements, indent implies otherwise\n" .
4257 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4262 # Check relative indent for conditionals and blocks.
4263 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
4264 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4265 ctx_statement_block
($linenr, $realcnt, 0)
4266 if (!defined $stat);
4267 my ($s, $c) = ($stat, $cond);
4269 substr($s, 0, length($c), '');
4271 # remove inline comments
4275 # Find out how long the conditional actually is.
4276 my @newlines = ($c =~ /\n/gs);
4277 my $cond_lines = 1 + $#newlines;
4279 # Make sure we remove the line prefixes as we have
4280 # none on the first line, and are going to readd them
4283 while ($s =~ /\n\s+\\\n/) {
4284 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
4287 # We want to check the first line inside the block
4288 # starting at the end of the conditional, so remove:
4289 # 1) any blank line termination
4290 # 2) any opening brace { on end of the line
4292 my $continuation = 0;
4294 $s =~ s/^.*\bdo\b//;
4296 if ($s =~ s/^\s*\\//) {
4299 if ($s =~ s/^\s*?\n//) {
4304 # Also ignore a loop construct at the end of a
4305 # preprocessor statement.
4306 if (($prevline =~ /^.\s*#\s*define\s/ ||
4307 $prevline =~ /\\\s*$/) && $continuation == 0) {
4313 while ($cond_ptr != $cond_lines) {
4314 $cond_ptr = $cond_lines;
4316 # If we see an #else/#elif then the code
4318 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
4323 # 1) blank lines, they should be at 0,
4324 # 2) preprocessor lines, and
4326 if ($continuation ||
4328 $s =~ /^\s*#\s*?/ ||
4329 $s =~ /^\s*$Ident\s*:/) {
4330 $continuation = ($s =~ /^.*?\\\n/) ?
1 : 0;
4331 if ($s =~ s/^.*?\n//) {
4337 my (undef, $sindent) = line_stats
("+" . $s);
4338 my $stat_real = raw_line
($linenr, $cond_lines);
4340 # Check if either of these lines are modified, else
4341 # this is not this patch's fault.
4342 if (!defined($stat_real) ||
4343 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
4346 if (defined($stat_real) && $cond_lines > 1) {
4347 $stat_real = "[...]\n$stat_real";
4350 #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";
4352 if ($check && $s ne '' &&
4353 (($sindent % $tabsize) != 0 ||
4354 ($sindent < $indent) ||
4355 ($sindent == $indent &&
4356 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
4357 ($sindent > $indent + $tabsize))) {
4358 WARN
("SUSPECT_CODE_INDENT",
4359 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
4363 # Track the 'values' across context and added lines.
4364 my $opline = $line; $opline =~ s/^./ /;
4365 my ($curr_values, $curr_vars) =
4366 annotate_values
($opline . "\n", $prev_values);
4367 $curr_values = $prev_values . $curr_values;
4369 my $outline = $opline; $outline =~ s/\t/ /g;
4370 print "$linenr > .$outline\n";
4371 print "$linenr > $curr_values\n";
4372 print "$linenr > $curr_vars\n";
4374 $prev_values = substr($curr_values, -1);
4376 #ignore lines not being added
4377 next if ($line =~ /^[^\+]/);
4379 # check for self assignments used to avoid compiler warnings
4380 # e.g.: int foo = foo, *bar = NULL;
4381 # struct foo bar = *(&(bar));
4382 if ($line =~ /^\+\s*(?:$Declare)?([A-Za-z_][A-Za-z\d_]*)\s*=/) {
4384 if ($line =~ /^\+\s*(?:$Declare)?$var\s*=\s*(?:$var|\*\s*\(?\s*&\s*\(?\s*$var\s*\)?\s*\)?)\s*[;,]/) {
4385 WARN
("SELF_ASSIGNMENT",
4386 "Do not use self-assignments to avoid compiler warnings\n" . $herecurr);
4390 # check for dereferences that span multiple lines
4391 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
4392 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
4393 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
4395 $line =~ /^.\s*($Lval)/;
4398 WARN
("MULTILINE_DEREFERENCE",
4399 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
4402 # check for declarations of signed or unsigned without int
4403 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
4406 $var = "" if (!defined $var);
4407 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
4411 $pointer = "" if (!defined $pointer);
4413 if (WARN
("UNSPECIFIED_INT",
4414 "Prefer '" . trim
($sign) . " int" . rtrim
($pointer) . "' to bare use of '$sign" . rtrim
($pointer) . "'\n" . $herecurr) &&
4416 my $decl = trim
($sign) . " int ";
4417 my $comp_pointer = $pointer;
4418 $comp_pointer =~ s/\s//g;
4419 $decl .= $comp_pointer;
4420 $decl = rtrim
($decl) if ($var eq "");
4421 $fixed[$fixlinenr] =~ s@
\b$sign\s
*\Q
$pointer\E\s
*$var\b@
$decl$var@
;
4426 # TEST: allow direct testing of the type matcher.
4428 if ($line =~ /^.\s*$Declare\s*$/) {
4430 "TEST: is type\n" . $herecurr);
4431 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
4432 ERROR
("TEST_NOT_TYPE",
4433 "TEST: is not type ($1 is)\n". $herecurr);
4437 # TEST: allow direct testing of the attribute matcher.
4439 if ($line =~ /^.\s*$Modifier\s*$/) {
4441 "TEST: is attr\n" . $herecurr);
4442 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
4443 ERROR
("TEST_NOT_ATTR",
4444 "TEST: is not attr ($1 is)\n". $herecurr);
4449 # check for initialisation to aggregates open brace on the next line
4450 if ($line =~ /^.\s*{/ &&
4451 $prevline =~ /(?:^|[^=])=\s*$/) {
4452 if (ERROR
("OPEN_BRACE",
4453 "that open brace { should be on the previous line\n" . $hereprev) &&
4454 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4455 fix_delete_line
($fixlinenr - 1, $prevrawline);
4456 fix_delete_line
($fixlinenr, $rawline);
4457 my $fixedline = $prevrawline;
4458 $fixedline =~ s/\s*=\s*$/ = {/;
4459 fix_insert_line
($fixlinenr, $fixedline);
4461 $fixedline =~ s/^(.\s*)\{\s*/$1/;
4462 fix_insert_line
($fixlinenr, $fixedline);
4467 # Checks which are anchored on the added line.
4470 # check for malformed paths in #include statements (uses RAW line)
4471 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
4473 if ($path =~ m{//}) {
4474 ERROR
("MALFORMED_INCLUDE",
4475 "malformed #include filename\n" . $herecurr);
4477 if ($path =~ "^uapi/" && $realfile =~ m@
\binclude
/uapi
/@
) {
4478 ERROR
("UAPI_INCLUDE",
4479 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
4483 # no C99 // comments
4484 if ($line =~ m{//}) {
4485 if (ERROR
("C99_COMMENTS",
4486 "do not use C99 // comments\n" . $herecurr) &&
4488 my $line = $fixed[$fixlinenr];
4489 if ($line =~ /\/\
/(.*)$/) {
4490 my $comment = trim
($1);
4491 $fixed[$fixlinenr] =~ s@\
/\/(.*)$@
/\* $comment \*/@
;
4495 # Remove C99 comments.
4497 $opline =~ s@
//.*@@
;
4499 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
4500 # the whole statement.
4501 #print "APW <$lines[$realline_next - 1]>\n";
4502 if (defined $realline_next &&
4503 exists $lines[$realline_next - 1] &&
4504 !defined $suppress_export{$realline_next} &&
4505 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4506 # Handle definitions which produce identifiers with
4509 # EXPORT_SYMBOL(something_foo);
4511 $name =~ s/^\s*($Ident).*/$1/;
4512 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
4513 $name =~ /^${Ident}_$2/) {
4514 #print "FOO C name<$name>\n";
4515 $suppress_export{$realline_next} = 1;
4517 } elsif ($stat !~ /(?
:
4519 ^.DEFINE_
$Ident\
(\Q
$name\E\
)|
4520 ^.DECLARE_
$Ident\
(\Q
$name\E\
)|
4521 ^.LIST_HEAD\
(\Q
$name\E\
)|
4522 ^.(?
:$Storage\s
+)?
$Type\s
*\
(\s
*\
*\s
*\Q
$name\E\s
*\
)\s
*\
(|
4523 \b\Q
$name\E
(?
:\s
+$Attribute)*\s
*(?
:;|=|\
[|\
()
4525 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
4526 $suppress_export{$realline_next} = 2;
4528 $suppress_export{$realline_next} = 1;
4531 if (!defined $suppress_export{$linenr} &&
4532 $prevline =~ /^.\s*$/ &&
4533 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4534 #print "FOO B <$lines[$linenr - 1]>\n";
4535 $suppress_export{$linenr} = 2;
4537 if (defined $suppress_export{$linenr} &&
4538 $suppress_export{$linenr} == 2) {
4539 WARN
("EXPORT_SYMBOL",
4540 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
4543 # check for global initialisers.
4544 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/ &&
4545 !exclude_global_initialisers
($realfile)) {
4546 if (ERROR
("GLOBAL_INITIALISERS",
4547 "do not initialise globals to $1\n" . $herecurr) &&
4549 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
4552 # check for static initialisers.
4553 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
4554 if (ERROR
("INITIALISED_STATIC",
4555 "do not initialise statics to $1\n" .
4558 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
4562 # check for misordered declarations of char/short/int/long with signed/unsigned
4563 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
4565 WARN
("MISORDERED_TYPE",
4566 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
4569 # check for unnecessary <signed> int declarations of short/long/long long
4570 while ($sline =~ m{\b($TypeMisordered(\s*\*)*|$C90_int_types)\b}g) {
4571 my $type = trim
($1);
4572 next if ($type !~ /\bint\b/);
4573 next if ($type !~ /\b(?:short|long\s+long|long)\b/);
4574 my $new_type = $type;
4575 $new_type =~ s/\b\s*int\s*\b/ /;
4576 $new_type =~ s/\b\s*(?:un)?signed\b\s*/ /;
4577 $new_type =~ s/^const\s+//;
4578 $new_type = "unsigned $new_type" if ($type =~ /\bunsigned\b/);
4579 $new_type = "const $new_type" if ($type =~ /^const\b/);
4580 $new_type =~ s/\s+/ /g;
4581 $new_type = trim
($new_type);
4582 if (WARN
("UNNECESSARY_INT",
4583 "Prefer '$new_type' over '$type' as the int is unnecessary\n" . $herecurr) &&
4585 $fixed[$fixlinenr] =~ s/\b\Q$type\E\b/$new_type/;
4589 # check for static const char * arrays.
4590 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
4591 WARN
("STATIC_CONST_CHAR_ARRAY",
4592 "static const char * array should probably be static const char * const\n" .
4596 # check for initialized const char arrays that should be static const
4597 if ($line =~ /^\+\s*const\s+(char|unsigned\s+char|_*u8|(?:[us]_)?int8_t)\s+\w+\s*\[\s*(?:\w+\s*)?\]\s*=\s*"/) {
4598 if (WARN
("STATIC_CONST_CHAR_ARRAY",
4599 "const array should probably be static const\n" . $herecurr) &&
4601 $fixed[$fixlinenr] =~ s/(^.\s*)const\b/${1}static const/;
4605 # check for static char foo[] = "bar" declarations.
4606 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
4607 WARN
("STATIC_CONST_CHAR_ARRAY",
4608 "static char array declaration should probably be static const char\n" .
4612 # check for const <foo> const where <foo> is not a pointer or array type
4613 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
4615 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
4617 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
4618 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
4620 "'const $found const' should probably be 'const $found'\n" . $herecurr);
4624 # check for const static or static <non ptr type> const declarations
4625 # prefer 'static const <foo>' over 'const static <foo>' and 'static <foo> const'
4626 if ($sline =~ /^\+\s*const\s+static\s+($Type)\b/ ||
4627 $sline =~ /^\+\s*static\s+($BasicType)\s+const\b/) {
4628 if (WARN
("STATIC_CONST",
4629 "Move const after static - use 'static const $1'\n" . $herecurr) &&
4631 $fixed[$fixlinenr] =~ s/\bconst\s+static\b/static const/;
4632 $fixed[$fixlinenr] =~ s/\bstatic\s+($BasicType)\s+const\b/static const $1/;
4636 # check for non-global char *foo[] = {"bar", ...} declarations.
4637 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
4638 WARN
("STATIC_CONST_CHAR_ARRAY",
4639 "char * array declaration might be better as static const\n" .
4643 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
4644 if ($line =~ m@
\bsizeof\s
*\
(\s
*($Lval)\s
*\
)@
) {
4646 if ($line =~ m@
\b(sizeof\s
*\
(\s
*\Q
$array\E\s
*\
)\s
*/\s
*sizeof\s
*\
(\s
*\Q
$array\E\s
*\
[\s
*0\s
*\
]\s
*\
))@
) {
4648 if (WARN
("ARRAY_SIZE",
4649 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
4651 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
4656 # check for function declarations without arguments like "int foo()"
4657 if ($line =~ /(\b$Type\s*$Ident)\s*\(\s*\)/) {
4658 if (ERROR
("FUNCTION_WITHOUT_ARGS",
4659 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
4661 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
4665 # check for new typedefs, only function parameters and sparse annotations
4667 if ($line =~ /\btypedef\s/ &&
4668 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
4669 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
4670 $line !~ /\b$typeTypedefs\b/ &&
4671 $line !~ /\b__bitwise\b/) {
4672 WARN
("NEW_TYPEDEFS",
4673 "do not add new typedefs\n" . $herecurr);
4676 # * goes on variable not on type
4678 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
4680 my ($ident, $from, $to) = ($1, $2, $2);
4682 # Should start with a space.
4683 $to =~ s/^(\S)/ $1/;
4684 # Should not end with a space.
4686 # '*'s should not have spaces between.
4687 while ($to =~ s/\*\s+\*/\*\*/) {
4690 ## print "1: from<$from> to<$to> ident<$ident>\n";
4692 if (ERROR
("POINTER_LOCATION",
4693 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
4695 my $sub_from = $ident;
4696 my $sub_to = $ident;
4697 $sub_to =~ s/\Q$from\E/$to/;
4698 $fixed[$fixlinenr] =~
4699 s@\Q
$sub_from\E@
$sub_to@
;
4703 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
4705 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
4707 # Should start with a space.
4708 $to =~ s/^(\S)/ $1/;
4709 # Should not end with a space.
4711 # '*'s should not have spaces between.
4712 while ($to =~ s/\*\s+\*/\*\*/) {
4714 # Modifiers should have spaces.
4715 $to =~ s/(\b$Modifier$)/$1 /;
4717 ## print "2: from<$from> to<$to> ident<$ident>\n";
4718 if ($from ne $to && $ident !~ /^$Modifier$/) {
4719 if (ERROR
("POINTER_LOCATION",
4720 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
4723 my $sub_from = $match;
4724 my $sub_to = $match;
4725 $sub_to =~ s/\Q$from\E/$to/;
4726 $fixed[$fixlinenr] =~
4727 s@\Q
$sub_from\E@
$sub_to@
;
4732 # avoid BUG() or BUG_ON()
4733 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
4734 my $msg_level = \
&WARN
;
4735 $msg_level = \
&CHK
if ($file);
4736 &{$msg_level}("AVOID_BUG",
4737 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
4740 # avoid LINUX_VERSION_CODE
4741 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
4742 WARN
("LINUX_VERSION_CODE",
4743 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
4746 # check for uses of printk_ratelimit
4747 if ($line =~ /\bprintk_ratelimit\s*\(/) {
4748 WARN
("PRINTK_RATELIMITED",
4749 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
4752 # printk should use KERN_* levels
4753 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
4754 WARN
("PRINTK_WITHOUT_KERN_LEVEL",
4755 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
4758 # prefer variants of (subsystem|netdev|dev|pr)_<level> to printk(KERN_<LEVEL>
4759 if ($line =~ /\b(printk(_once|_ratelimited)?)\s*\(\s*KERN_([A-Z]+)/) {
4763 $modifier = "" if (!defined($modifier));
4764 my $level = lc($orig);
4765 $level = "warn" if ($level eq "warning");
4766 my $level2 = $level;
4767 $level2 = "dbg" if ($level eq "debug");
4768 $level .= $modifier;
4769 $level2 .= $modifier;
4770 WARN
("PREFER_PR_LEVEL",
4771 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to $printk(KERN_$orig ...\n" . $herecurr);
4774 # prefer dev_<level> to dev_printk(KERN_<LEVEL>
4775 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
4777 my $level = lc($orig);
4778 $level = "warn" if ($level eq "warning");
4779 $level = "dbg" if ($level eq "debug");
4780 WARN
("PREFER_DEV_LEVEL",
4781 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
4784 # trace_printk should not be used in production code.
4785 if ($line =~ /\b(trace_printk|trace_puts|ftrace_vprintk)\s*\(/) {
4786 WARN
("TRACE_PRINTK",
4787 "Do not use $1() in production code (this can be ignored if built only with a debug config option)\n" . $herecurr);
4790 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
4791 # number of false positives, but assembly files are not checked, so at
4792 # least the arch entry code will not trigger this warning.
4793 if ($line =~ /\bENOSYS\b/) {
4795 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
4798 # ENOTSUPP is not a standard error code and should be avoided in new patches.
4799 # Folks usually mean EOPNOTSUPP (also called ENOTSUP), when they type ENOTSUPP.
4800 # Similarly to ENOSYS warning a small number of false positives is expected.
4801 if (!$file && $line =~ /\bENOTSUPP\b/) {
4802 if (WARN
("ENOTSUPP",
4803 "ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP\n" . $herecurr) &&
4805 $fixed[$fixlinenr] =~ s/\bENOTSUPP\b/EOPNOTSUPP/;
4809 # function brace can't be on same line, except for #defines of do while,
4810 # or if closed on same line
4811 if ($perl_version_ok &&
4812 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
4813 $sline !~ /\#\s*define\b.*do\s*\{/ &&
4815 if (ERROR
("OPEN_BRACE",
4816 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
4818 fix_delete_line
($fixlinenr, $rawline);
4819 my $fixed_line = $rawline;
4820 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*)\{(.*)$/;
4823 fix_insert_line
($fixlinenr, ltrim
($line1));
4824 fix_insert_line
($fixlinenr, "\+{");
4825 if ($line2 !~ /^\s*$/) {
4826 fix_insert_line
($fixlinenr, "\+\t" . trim
($line2));
4831 # open braces for enum, union and struct go on the same line.
4832 if ($line =~ /^.\s*{/ &&
4833 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
4834 if (ERROR
("OPEN_BRACE",
4835 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
4836 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4837 fix_delete_line
($fixlinenr - 1, $prevrawline);
4838 fix_delete_line
($fixlinenr, $rawline);
4839 my $fixedline = rtrim
($prevrawline) . " {";
4840 fix_insert_line
($fixlinenr, $fixedline);
4841 $fixedline = $rawline;
4842 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
4843 if ($fixedline !~ /^\+\s*$/) {
4844 fix_insert_line
($fixlinenr, $fixedline);
4849 # missing space after union, struct or enum definition
4850 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4852 "missing space after $1 definition\n" . $herecurr) &&
4854 $fixed[$fixlinenr] =~
4855 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4859 # Function pointer declarations
4860 # check spacing between type, funcptr, and args
4861 # canonical declaration is "type (*funcptr)(args...)"
4862 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4864 my $pre_pointer_space = $2;
4865 my $post_pointer_space = $3;
4867 my $post_funcname_space = $5;
4868 my $pre_args_space = $6;
4870 # the $Declare variable will capture all spaces after the type
4871 # so check it for a missing trailing missing space but pointer return types
4872 # don't need a space so don't warn for those.
4873 my $post_declare_space = "";
4874 if ($declare =~ /(\s+)$/) {
4875 $post_declare_space = $1;
4876 $declare = rtrim
($declare);
4878 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4880 "missing space after return type\n" . $herecurr);
4881 $post_declare_space = " ";
4884 # unnecessary space "type (*funcptr)(args...)"
4885 # This test is not currently implemented because these declarations are
4887 # int foo(int bar, ...)
4888 # and this is form shouldn't/doesn't generate a checkpatch warning.
4890 # elsif ($declare =~ /\s{2,}$/) {
4892 # "Multiple spaces after return type\n" . $herecurr);
4895 # unnecessary space "type ( *funcptr)(args...)"
4896 if (defined $pre_pointer_space &&
4897 $pre_pointer_space =~ /^\s/) {
4899 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4902 # unnecessary space "type (* funcptr)(args...)"
4903 if (defined $post_pointer_space &&
4904 $post_pointer_space =~ /^\s/) {
4906 "Unnecessary space before function pointer name\n" . $herecurr);
4909 # unnecessary space "type (*funcptr )(args...)"
4910 if (defined $post_funcname_space &&
4911 $post_funcname_space =~ /^\s/) {
4913 "Unnecessary space after function pointer name\n" . $herecurr);
4916 # unnecessary space "type (*funcptr) (args...)"
4917 if (defined $pre_args_space &&
4918 $pre_args_space =~ /^\s/) {
4920 "Unnecessary space before function pointer arguments\n" . $herecurr);
4923 if (show_type
("SPACING") && $fix) {
4924 $fixed[$fixlinenr] =~
4925 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
4929 # check for spacing round square brackets; allowed:
4930 # 1. with a type on the left -- int [] a;
4931 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
4932 # 3. inside a curly brace -- = { [0...10] = 5 }
4933 while ($line =~ /(.*?\s)\[/g) {
4934 my ($where, $prefix) = ($-[1], $1);
4935 if ($prefix !~ /$Type\s+$/ &&
4936 ($where != 0 || $prefix !~ /^.\s+$/) &&
4937 $prefix !~ /[{,:]\s+$/) {
4938 if (ERROR
("BRACKET_SPACE",
4939 "space prohibited before open square bracket '['\n" . $herecurr) &&
4941 $fixed[$fixlinenr] =~
4942 s/^(\+.*?)\s+\[/$1\[/;
4947 # check for spaces between functions and their parentheses.
4948 while ($line =~ /($Ident)\s+\(/g) {
4950 my $ctx_before = substr($line, 0, $-[1]);
4951 my $ctx = "$ctx_before$name";
4953 # Ignore those directives where spaces _are_ permitted.
4955 if|for|while|switch
|return|case
|
4956 volatile
|__volatile__
|
4957 __attribute__
|format
|__extension__
|
4960 # cpp #define statements have non-optional spaces, ie
4961 # if there is a space between the name and the open
4962 # parenthesis it is simply not a parameter group.
4963 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
4965 # cpp #elif statement condition may start with a (
4966 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
4968 # If this whole things ends with a type its most
4969 # likely a typedef for a function.
4970 } elsif ($ctx =~ /$Type$/) {
4974 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
4976 $fixed[$fixlinenr] =~
4977 s/\b$name\s+\(/$name\(/;
4982 # Check operator spacing.
4983 if (!($line=~/\#\s*include/)) {
4984 my $fixed_line = "";
4988 <<=|>>=|<=|>=|==|!=|
4989 \
+=|-=|\
*=|\
/=|%=|\
^=|\
|=|&=|
4990 =>|->|<<|>>|<|>|=|!|~|
4991 &&|\
|\
||,|\
^|\
+\
+|--|&|\
||\
+|-|\
*|\
/|%|
4994 my @elements = split(/($ops|;)/, $opline);
4996 ## print("element count: <" . $#elements . ">\n");
4997 ## foreach my $el (@elements) {
4998 ## print("el: <$el>\n");
5001 my @fix_elements = ();
5004 foreach my $el (@elements) {
5005 push(@fix_elements, substr($rawline, $off, length($el)));
5006 $off += length($el);
5011 my $blank = copy_spacing
($opline);
5012 my $last_after = -1;
5014 for (my $n = 0; $n < $#elements; $n += 2) {
5016 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
5018 ## print("n: <$n> good: <$good>\n");
5020 $off += length($elements[$n]);
5022 # Pick up the preceding and succeeding characters.
5023 my $ca = substr($opline, 0, $off);
5025 if (length($opline) >= ($off + length($elements[$n + 1]))) {
5026 $cc = substr($opline, $off + length($elements[$n + 1]));
5028 my $cb = "$ca$;$cc";
5031 $a = 'V' if ($elements[$n] ne '');
5032 $a = 'W' if ($elements[$n] =~ /\s$/);
5033 $a = 'C' if ($elements[$n] =~ /$;$/);
5034 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
5035 $a = 'O' if ($elements[$n] eq '');
5036 $a = 'E' if ($ca =~ /^\s*$/);
5038 my $op = $elements[$n + 1];
5041 if (defined $elements[$n + 2]) {
5042 $c = 'V' if ($elements[$n + 2] ne '');
5043 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
5044 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
5045 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
5046 $c = 'O' if ($elements[$n + 2] eq '');
5047 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
5052 my $ctx = "${a}x${c}";
5054 my $at = "(ctx:$ctx)";
5056 my $ptr = substr($blank, 0, $off) . "^";
5057 my $hereptr = "$hereline$ptr\n";
5059 # Pull out the value of this operator.
5060 my $op_type = substr($curr_values, $off + 1, 1);
5062 # Get the full operator variant.
5063 my $opv = $op . substr($curr_vars, $off, 1);
5065 # Ignore operators passed as parameters.
5066 if ($op_type ne 'V' &&
5067 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
5070 # } elsif ($op =~ /^$;+$/) {
5072 # ; should have either the end of line or a space or \ after it
5073 } elsif ($op eq ';') {
5074 if ($ctx !~ /.x[WEBC]/ &&
5075 $cc !~ /^\\/ && $cc !~ /^;/) {
5076 if (ERROR
("SPACING",
5077 "space required after that '$op' $at\n" . $hereptr)) {
5078 $good = $fix_elements[$n] . trim
($fix_elements[$n + 1]) . " ";
5084 } elsif ($op eq '//') {
5086 # : when part of a bitfield
5087 } elsif ($opv eq ':B') {
5088 # skip the bitfield test for now
5092 } elsif ($op eq '->') {
5093 if ($ctx =~ /Wx.|.xW/) {
5094 if (ERROR
("SPACING",
5095 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
5096 $good = rtrim
($fix_elements[$n]) . trim
($fix_elements[$n + 1]);
5097 if (defined $fix_elements[$n + 2]) {
5098 $fix_elements[$n + 2] =~ s/^\s+//;
5104 # , must not have a space before and must have a space on the right.
5105 } elsif ($op eq ',') {
5106 my $rtrim_before = 0;
5107 my $space_after = 0;
5108 if ($ctx =~ /Wx./) {
5109 if (ERROR
("SPACING",
5110 "space prohibited before that '$op' $at\n" . $hereptr)) {
5115 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
5116 if (ERROR
("SPACING",
5117 "space required after that '$op' $at\n" . $hereptr)) {
5123 if ($rtrim_before || $space_after) {
5124 if ($rtrim_before) {
5125 $good = rtrim
($fix_elements[$n]) . trim
($fix_elements[$n + 1]);
5127 $good = $fix_elements[$n] . trim
($fix_elements[$n + 1]);
5134 # '*' as part of a type definition -- reported already.
5135 } elsif ($opv eq '*_') {
5136 #warn "'*' is part of type\n";
5138 # unary operators should have a space before and
5139 # none after. May be left adjacent to another
5140 # unary operator, or a cast
5141 } elsif ($op eq '!' || $op eq '~' ||
5142 $opv eq '*U' || $opv eq '-U' ||
5143 $opv eq '&U' || $opv eq '&&U') {
5144 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
5145 if (ERROR
("SPACING",
5146 "space required before that '$op' $at\n" . $hereptr)) {
5147 if ($n != $last_after + 2) {
5148 $good = $fix_elements[$n] . " " . ltrim
($fix_elements[$n + 1]);
5153 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
5154 # A unary '*' may be const
5156 } elsif ($ctx =~ /.xW/) {
5157 if (ERROR
("SPACING",
5158 "space prohibited after that '$op' $at\n" . $hereptr)) {
5159 $good = $fix_elements[$n] . rtrim
($fix_elements[$n + 1]);
5160 if (defined $fix_elements[$n + 2]) {
5161 $fix_elements[$n + 2] =~ s/^\s+//;
5167 # unary ++ and unary -- are allowed no space on one side.
5168 } elsif ($op eq '++' or $op eq '--') {
5169 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
5170 if (ERROR
("SPACING",
5171 "space required one side of that '$op' $at\n" . $hereptr)) {
5172 $good = $fix_elements[$n] . trim
($fix_elements[$n + 1]) . " ";
5176 if ($ctx =~ /Wx[BE]/ ||
5177 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
5178 if (ERROR
("SPACING",
5179 "space prohibited before that '$op' $at\n" . $hereptr)) {
5180 $good = rtrim
($fix_elements[$n]) . trim
($fix_elements[$n + 1]);
5184 if ($ctx =~ /ExW/) {
5185 if (ERROR
("SPACING",
5186 "space prohibited after that '$op' $at\n" . $hereptr)) {
5187 $good = $fix_elements[$n] . trim
($fix_elements[$n + 1]);
5188 if (defined $fix_elements[$n + 2]) {
5189 $fix_elements[$n + 2] =~ s/^\s+//;
5195 # << and >> may either have or not have spaces both sides
5196 } elsif ($op eq '<<' or $op eq '>>' or
5197 $op eq '&' or $op eq '^' or $op eq '|' or
5198 $op eq '+' or $op eq '-' or
5199 $op eq '*' or $op eq '/' or
5203 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
5205 "spaces preferred around that '$op' $at\n" . $hereptr)) {
5206 $good = rtrim
($fix_elements[$n]) . " " . trim
($fix_elements[$n + 1]) . " ";
5207 $fix_elements[$n + 2] =~ s/^\s+//;
5210 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
5212 "space preferred before that '$op' $at\n" . $hereptr)) {
5213 $good = rtrim
($fix_elements[$n]) . " " . trim
($fix_elements[$n + 1]);
5217 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
5218 if (ERROR
("SPACING",
5219 "need consistent spacing around '$op' $at\n" . $hereptr)) {
5220 $good = rtrim
($fix_elements[$n]) . " " . trim
($fix_elements[$n + 1]) . " ";
5221 if (defined $fix_elements[$n + 2]) {
5222 $fix_elements[$n + 2] =~ s/^\s+//;
5228 # A colon needs no spaces before when it is
5229 # terminating a case value or a label.
5230 } elsif ($opv eq ':C' || $opv eq ':L') {
5231 if ($ctx =~ /Wx./ and $realfile !~ m@
.*\
.lds\
.h
$@
) {
5232 if (ERROR
("SPACING",
5233 "space prohibited before that '$op' $at\n" . $hereptr)) {
5234 $good = rtrim
($fix_elements[$n]) . trim
($fix_elements[$n + 1]);
5239 # All the others need spaces both sides.
5240 } elsif ($ctx !~ /[EWC]x[CWE]/) {
5243 # Ignore email addresses <foo@bar>
5245 $cc =~ /^\S+\@\S+>/) ||
5247 $ca =~ /<\S+\@\S+$/))
5252 # for asm volatile statements
5253 # ignore a colon with another
5254 # colon immediately before or after
5256 ($ca =~ /:$/ || $cc =~ /^:/)) {
5260 # messages are ERROR, but ?: are CHK
5262 my $msg_level = \
&ERROR
;
5263 $msg_level = \
&CHK
if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
5265 if (&{$msg_level}("SPACING",
5266 "spaces required around that '$op' $at\n" . $hereptr)) {
5267 $good = rtrim
($fix_elements[$n]) . " " . trim
($fix_elements[$n + 1]) . " ";
5268 if (defined $fix_elements[$n + 2]) {
5269 $fix_elements[$n + 2] =~ s/^\s+//;
5275 $off += length($elements[$n + 1]);
5277 ## print("n: <$n> GOOD: <$good>\n");
5279 $fixed_line = $fixed_line . $good;
5282 if (($#elements % 2) == 0) {
5283 $fixed_line = $fixed_line . $fix_elements[$#elements];
5286 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
5287 $fixed[$fixlinenr] = $fixed_line;
5293 # check for whitespace before a non-naked semicolon
5294 if ($line =~ /^\+.*\S\s+;\s*$/) {
5296 "space prohibited before semicolon\n" . $herecurr) &&
5298 1 while $fixed[$fixlinenr] =~
5299 s/^(\+.*\S)\s+;/$1;/;
5303 # check for multiple assignments
5304 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
5305 CHK
("MULTIPLE_ASSIGNMENTS",
5306 "multiple assignments should be avoided\n" . $herecurr);
5309 ## # check for multiple declarations, allowing for a function declaration
5311 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
5312 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
5314 ## # Remove any bracketed sections to ensure we do not
5315 ## # falsely report the parameters of functions.
5317 ## while ($ln =~ s/\([^\(\)]*\)//g) {
5319 ## if ($ln =~ /,/) {
5320 ## WARN("MULTIPLE_DECLARATION",
5321 ## "declaring multiple variables together should be avoided\n" . $herecurr);
5325 #need space before brace following if, while, etc
5326 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
5327 $line =~ /\b(?:else|do)\{/) {
5328 if (ERROR
("SPACING",
5329 "space required before the open brace '{'\n" . $herecurr) &&
5331 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|else|\)))\{/$1 {/;
5335 ## # check for blank lines before declarations
5336 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
5337 ## $prevrawline =~ /^.\s*$/) {
5339 ## "No blank lines before declarations\n" . $hereprev);
5343 # closing brace should have a space following it when it has anything
5345 if ($line =~ /}(?!(?:,|;|\)|\}))\S/) {
5346 if (ERROR
("SPACING",
5347 "space required after that close brace '}'\n" . $herecurr) &&
5349 $fixed[$fixlinenr] =~
5350 s/}((?!(?:,|;|\)))\S)/} $1/;
5354 # check spacing on square brackets
5355 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
5356 if (ERROR
("SPACING",
5357 "space prohibited after that open square bracket '['\n" . $herecurr) &&
5359 $fixed[$fixlinenr] =~
5363 if ($line =~ /\s\]/) {
5364 if (ERROR
("SPACING",
5365 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
5367 $fixed[$fixlinenr] =~
5372 # check spacing on parentheses
5373 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
5374 $line !~ /for\s*\(\s+;/) {
5375 if (ERROR
("SPACING",
5376 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
5378 $fixed[$fixlinenr] =~
5382 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
5383 $line !~ /for\s*\(.*;\s+\)/ &&
5384 $line !~ /:\s+\)/) {
5385 if (ERROR
("SPACING",
5386 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
5388 $fixed[$fixlinenr] =~
5393 # check unnecessary parentheses around addressof/dereference single $Lvals
5394 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
5396 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
5398 if (CHK
("UNNECESSARY_PARENTHESES",
5399 "Unnecessary parentheses around $var\n" . $herecurr) &&
5401 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
5405 # check for unnecessary parentheses around function pointer uses
5406 # ie: (foo->bar)(); should be foo->bar();
5407 # but not "if (foo->bar) (" to avoid some false positives
5408 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
5410 if (CHK
("UNNECESSARY_PARENTHESES",
5411 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
5413 my $var2 = deparenthesize
($var);
5415 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
5419 # check for unnecessary parentheses around comparisons in if uses
5420 # when !drivers/staging or command-line uses --strict
5421 if (($realfile !~ m@
^(?
:drivers
/staging/)@
|| $check_orig) &&
5422 $perl_version_ok && defined($stat) &&
5423 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
5425 my $test = substr($2, 1, -1);
5427 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
5429 # avoid parentheses around potential macro args
5430 next if ($match =~ /^\s*\w+\s*$/);
5431 if (!defined($herectx)) {
5432 $herectx = $here . "\n";
5433 my $cnt = statement_rawlines
($if_stat);
5434 for (my $n = 0; $n < $cnt; $n++) {
5435 my $rl = raw_line
($linenr, $n);
5436 $herectx .= $rl . "\n";
5437 last if $rl =~ /^[ \+].*\{/;
5440 CHK
("UNNECESSARY_PARENTHESES",
5441 "Unnecessary parentheses around '$match'\n" . $herectx);
5445 # check that goto labels aren't indented (allow a single space indentation)
5446 # and ignore bitfield definitions like foo:1
5447 # Strictly, labels can have whitespace after the identifier and before the :
5448 # but this is not allowed here as many ?: uses would appear to be labels
5449 if ($sline =~ /^.\s+[A-Za-z_][A-Za-z\d_]*:(?!\s*\d+)/ &&
5450 $sline !~ /^. [A-Za-z\d_][A-Za-z\d_]*:/ &&
5451 $sline !~ /^.\s+default:/) {
5452 if (WARN
("INDENTED_LABEL",
5453 "labels should not be indented\n" . $herecurr) &&
5455 $fixed[$fixlinenr] =~
5460 # check if a statement with a comma should be two statements like:
5461 # foo = bar(), /* comma should be semicolon */
5463 if (defined($stat) &&
5464 $stat =~ /^\+\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*,\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*;\s*$/) {
5465 my $cnt = statement_rawlines
($stat);
5466 my $herectx = get_stat_here
($linenr, $cnt, $here);
5467 WARN
("SUSPECT_COMMA_SEMICOLON",
5468 "Possible comma where semicolon could be used\n" . $herectx);
5471 # return is not a function
5472 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
5474 if ($perl_version_ok &&
5475 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
5477 $value = deparenthesize
($value);
5478 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
5479 ERROR
("RETURN_PARENTHESES",
5480 "return is not a function, parentheses are not required\n" . $herecurr);
5482 } elsif ($spacing !~ /\s+/) {
5484 "space required before the open parenthesis '('\n" . $herecurr);
5488 # unnecessary return in a void function
5489 # at end-of-function, with the previous line a single leading tab, then return;
5490 # and the line before that not a goto label target like "out:"
5491 if ($sline =~ /^[ \+]}\s*$/ &&
5492 $prevline =~ /^\+\treturn\s*;\s*$/ &&
5494 $lines[$linenr - 3] =~ /^[ +]/ &&
5495 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
5497 "void function return statements are not generally useful\n" . $hereprev);
5500 # if statements using unnecessary parentheses - ie: if ((foo == bar))
5501 if ($perl_version_ok &&
5502 $line =~ /\bif\s*((?:\(\s*){2,})/) {
5503 my $openparens = $1;
5504 my $count = $openparens =~ tr@\
(@\
(@
;
5506 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
5507 my $comp = $4; #Not $1 because of $LvalOrFunc
5508 $msg = " - maybe == should be = ?" if ($comp eq "==");
5509 WARN
("UNNECESSARY_PARENTHESES",
5510 "Unnecessary parentheses$msg\n" . $herecurr);
5514 # comparisons with a constant or upper case identifier on the left
5515 # avoid cases like "foo + BAR < baz"
5516 # only fix matches surrounded by parentheses to avoid incorrect
5517 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
5518 if ($perl_version_ok &&
5519 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
5524 my $newcomp = $comp;
5525 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
5526 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
5527 WARN
("CONSTANT_COMPARISON",
5528 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
5532 } elsif ($comp eq "<=") {
5534 } elsif ($comp eq ">") {
5536 } elsif ($comp eq ">=") {
5539 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
5543 # Return of what appears to be an errno should normally be negative
5544 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
5546 if ($name ne 'EOF' && $name ne 'ERROR' && $name !~ /^EPOLL/) {
5547 WARN
("USE_NEGATIVE_ERRNO",
5548 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
5552 # Need a space before open parenthesis after if, while etc
5553 if ($line =~ /\b(if|while|for|switch)\(/) {
5554 if (ERROR
("SPACING",
5555 "space required before the open parenthesis '('\n" . $herecurr) &&
5557 $fixed[$fixlinenr] =~
5558 s/\b(if|while|for|switch)\(/$1 \(/;
5562 # Check for illegal assignment in if conditional -- and check for trailing
5563 # statements after the conditional.
5564 if ($line =~ /do\s*(?!{)/) {
5565 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
5566 ctx_statement_block
($linenr, $realcnt, 0)
5567 if (!defined $stat);
5568 my ($stat_next) = ctx_statement_block
($line_nr_next,
5569 $remain_next, $off_next);
5570 $stat_next =~ s/\n./\n /g;
5571 ##print "stat<$stat> stat_next<$stat_next>\n";
5573 if ($stat_next =~ /^\s*while\b/) {
5574 # If the statement carries leading newlines,
5575 # then count those as offsets.
5577 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
5579 statement_rawlines
($whitespace) - 1;
5581 $suppress_whiletrailers{$line_nr_next +
5585 if (!defined $suppress_whiletrailers{$linenr} &&
5586 defined($stat) && defined($cond) &&
5587 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
5588 my ($s, $c) = ($stat, $cond);
5589 my $fixed_assign_in_if = 0;
5591 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
5592 if (ERROR
("ASSIGN_IN_IF",
5593 "do not use assignment in if condition\n" . $herecurr) &&
5594 $fix && $perl_version_ok) {
5595 if ($rawline =~ /^\+(\s+)if\s*\(\s*(\!)?\s*\(\s*(($Lval)\s*=\s*$LvalOrFunc)\s*\)\s*(?:($Compare)\s*($FuncArg))?\s*\)\s*(\{)?\s*$/) {
5603 fix_delete_line
($fixlinenr, $rawline);
5604 fix_insert_line
($fixlinenr, "$space$statement;");
5605 my $newline = "${space}if (";
5606 $newline .= '!' if defined($not);
5607 $newline .= '(' if (defined $not && defined($test) && defined($against));
5608 $newline .= "$assigned";
5609 $newline .= " $test $against" if (defined($test) && defined($against));
5610 $newline .= ')' if (defined $not && defined($test) && defined($against));
5612 $newline .= " {" if (defined($brace));
5613 fix_insert_line
($fixlinenr + 1, $newline);
5614 $fixed_assign_in_if = 1;
5619 # Find out what is on the end of the line after the
5621 substr($s, 0, length($c), '');
5623 $s =~ s/$;//g; # Remove any comments
5624 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
5625 $c !~ /}\s*while\s*/)
5627 # Find out how long the conditional actually is.
5628 my @newlines = ($c =~ /\n/gs);
5629 my $cond_lines = 1 + $#newlines;
5632 $stat_real = raw_line
($linenr, $cond_lines)
5633 . "\n" if ($cond_lines);
5634 if (defined($stat_real) && $cond_lines > 1) {
5635 $stat_real = "[...]\n$stat_real";
5638 if (ERROR
("TRAILING_STATEMENTS",
5639 "trailing statements should be on next line\n" . $herecurr . $stat_real) &&
5640 !$fixed_assign_in_if &&
5642 $fix && $perl_version_ok &&
5643 $fixed[$fixlinenr] =~ /^\+(\s*)((?:if|while|for)\s*$balanced_parens)\s*(.*)$/) {
5646 my $rest = rtrim
($4);
5647 if ($rest =~ /;$/) {
5648 $fixed[$fixlinenr] = "\+$indent$test";
5649 fix_insert_line
($fixlinenr + 1, "$indent\t$rest");
5655 # Check for bitwise tests written as boolean
5667 WARN
("HEXADECIMAL_BOOLEAN_TEST",
5668 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
5671 # if and else should not have general statements after it
5672 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
5674 $s =~ s/$;//g; # Remove any comments
5675 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
5676 ERROR
("TRAILING_STATEMENTS",
5677 "trailing statements should be on next line\n" . $herecurr);
5680 # if should not continue a brace
5681 if ($line =~ /}\s*if\b/) {
5682 ERROR
("TRAILING_STATEMENTS",
5683 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
5686 # case and default should not have general statements after them
5687 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
5689 (?
:\s
*$;*)(?
:\s
*{)?
(?
:\s
*$;*)(?
:\s
*\\)?\s
*$|
5693 ERROR
("TRAILING_STATEMENTS",
5694 "trailing statements should be on next line\n" . $herecurr);
5697 # Check for }<nl>else {, these must be at the same
5698 # indent level to be relevant to each other.
5699 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
5700 $previndent == $indent) {
5701 if (ERROR
("ELSE_AFTER_BRACE",
5702 "else should follow close brace '}'\n" . $hereprev) &&
5703 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5704 fix_delete_line
($fixlinenr - 1, $prevrawline);
5705 fix_delete_line
($fixlinenr, $rawline);
5706 my $fixedline = $prevrawline;
5707 $fixedline =~ s/}\s*$//;
5708 if ($fixedline !~ /^\+\s*$/) {
5709 fix_insert_line
($fixlinenr, $fixedline);
5711 $fixedline = $rawline;
5712 $fixedline =~ s/^(.\s*)else/$1} else/;
5713 fix_insert_line
($fixlinenr, $fixedline);
5717 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
5718 $previndent == $indent) {
5719 my ($s, $c) = ctx_statement_block
($linenr, $realcnt, 0);
5721 # Find out what is on the end of the line after the
5723 substr($s, 0, length($c), '');
5726 if ($s =~ /^\s*;/) {
5727 if (ERROR
("WHILE_AFTER_BRACE",
5728 "while should follow close brace '}'\n" . $hereprev) &&
5729 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5730 fix_delete_line
($fixlinenr - 1, $prevrawline);
5731 fix_delete_line
($fixlinenr, $rawline);
5732 my $fixedline = $prevrawline;
5733 my $trailing = $rawline;
5734 $trailing =~ s/^\+//;
5735 $trailing = trim
($trailing);
5736 $fixedline =~ s/}\s*$/} $trailing/;
5737 fix_insert_line
($fixlinenr, $fixedline);
5742 #Specific variable tests
5743 while ($line =~ m{($Constant|$Lval)}g) {
5747 if ($var !~ /^$Constant$/ &&
5748 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
5749 #Ignore some autogenerated defines and enum values
5750 $var !~ /^(?:[A-Z]+_){1,5}[A-Z]{1,3}[a-z]/ &&
5751 #Ignore Page<foo> variants
5752 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
5753 #Ignore SI style variants like nS, mV and dB
5754 #(ie: max_uV, regulator_min_uA_show, RANGE_mA_VALUE)
5755 $var !~ /^(?:[a-z0-9_]*|[A-Z0-9_]*)?_?[a-z][A-Z](?:_[a-z0-9_]+|_[A-Z0-9_]+)?$/ &&
5756 #Ignore some three character SI units explicitly, like MiB and KHz
5757 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
5758 while ($var =~ m{\b($Ident)}g) {
5760 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
5762 seed_camelcase_includes
();
5763 if (!$file && !$camelcase_file_seeded) {
5764 seed_camelcase_file
($realfile);
5765 $camelcase_file_seeded = 1;
5768 if (!defined $camelcase{$word}) {
5769 $camelcase{$word} = 1;
5771 "Avoid CamelCase: <$word>\n" . $herecurr);
5777 #no spaces allowed after \ in define
5778 if ($line =~ /\#\s*define.*\\\s+$/) {
5779 if (WARN
("WHITESPACE_AFTER_LINE_CONTINUATION",
5780 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
5782 $fixed[$fixlinenr] =~ s/\s+$//;
5786 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
5787 # itself <asm/foo.h> (uses RAW line)
5788 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
5790 my $checkfile = "include/linux/$file";
5791 if (-f
"$root/$checkfile" &&
5792 $realfile ne $checkfile &&
5793 $1 !~ /$allowed_asm_includes/)
5795 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
5796 if ($asminclude > 0) {
5797 if ($realfile =~ m{^arch/}) {
5798 CHK
("ARCH_INCLUDE_LINUX",
5799 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5801 WARN
("INCLUDE_LINUX",
5802 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5808 # multi-statement macros should be enclosed in a do while loop, grab the
5809 # first statement and ensure its the whole macro if its not enclosed
5810 # in a known good container
5811 if ($realfile !~ m@
/vmlinux
.lds
.h
$@
&&
5812 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
5815 my ($off, $dstat, $dcond, $rest);
5817 my $has_flow_statement = 0;
5818 my $has_arg_concat = 0;
5819 ($dstat, $dcond, $ln, $cnt, $off) =
5820 ctx_statement_block
($linenr, $realcnt, 0);
5822 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
5823 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
5825 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
5826 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
5828 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
5829 my $define_args = $1;
5830 my $define_stmt = $dstat;
5833 if (defined $define_args && $define_args ne "") {
5834 $define_args = substr($define_args, 1, length($define_args) - 2);
5835 $define_args =~ s/\s*//g;
5836 $define_args =~ s/\\\+?//g;
5837 @def_args = split(",", $define_args);
5841 $dstat =~ s/\\\n.//g;
5842 $dstat =~ s/^\s*//s;
5843 $dstat =~ s/\s*$//s;
5845 # Flatten any parentheses and braces
5846 while ($dstat =~ s/\([^\(\)]*\)/1u/ ||
5847 $dstat =~ s/\{[^\{\}]*\}/1u/ ||
5848 $dstat =~ s/.\[[^\[\]]*\]/1u/)
5852 # Flatten any obvious string concatenation.
5853 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
5854 $dstat =~ s/$Ident\s*($String)/$1/)
5858 # Make asm volatile uses seem like a generic function
5859 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
5861 my $exceptions = qr{
5874 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
5877 my $stmt_cnt = statement_rawlines
($ctx);
5878 my $herectx = get_stat_here
($linenr, $stmt_cnt, $here);
5881 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
5882 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
5883 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
5884 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
5885 $dstat !~ /$exceptions/ &&
5886 $dstat !~ /^\.$Ident\s*=/ && # .foo =
5887 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
5888 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
5889 $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ && # while (...) {...}
5890 $dstat !~ /^for\s*$Constant$/ && # for (...)
5891 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
5892 $dstat !~ /^do\s*{/ && # do {...
5893 $dstat !~ /^\(\{/ && # ({...
5894 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
5896 if ($dstat =~ /^\s*if\b/) {
5897 ERROR
("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5898 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5899 } elsif ($dstat =~ /;/) {
5900 ERROR
("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5901 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5903 ERROR
("COMPLEX_MACRO",
5904 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5909 # Make $define_stmt single line, comment-free, etc
5910 my @stmt_array = split('\n', $define_stmt);
5913 foreach my $l (@stmt_array) {
5918 } elsif ($l =~ /^[\+ ]/) {
5919 $define_stmt .= substr($l, 1);
5922 $define_stmt =~ s/$;//g;
5923 $define_stmt =~ s/\s+/ /g;
5924 $define_stmt = trim
($define_stmt);
5926 # check if any macro arguments are reused (ignore '...' and 'type')
5927 foreach my $arg (@def_args) {
5928 next if ($arg =~ /\.\.\./);
5929 next if ($arg =~ /^type$/i);
5930 my $tmp_stmt = $define_stmt;
5931 $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;
5932 $tmp_stmt =~ s/\#+\s*$arg\b//g;
5933 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
5934 my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
5936 CHK
("MACRO_ARG_REUSE",
5937 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
5939 # check if any macro arguments may have other precedence issues
5940 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
5941 ((defined($1) && $1 ne ',') ||
5942 (defined($2) && $2 ne ','))) {
5943 CHK
("MACRO_ARG_PRECEDENCE",
5944 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
5948 # check for macros with flow control, but without ## concatenation
5949 # ## concatenation is commonly a macro that defines a function so ignore those
5950 if ($has_flow_statement && !$has_arg_concat) {
5951 my $cnt = statement_rawlines
($ctx);
5952 my $herectx = get_stat_here
($linenr, $cnt, $here);
5954 WARN
("MACRO_WITH_FLOW_CONTROL",
5955 "Macros with flow control statements should be avoided\n" . "$herectx");
5958 # check for line continuations outside of #defines, preprocessor #, and asm
5961 if ($prevline !~ /^..*\\$/ &&
5962 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
5963 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
5964 $line =~ /^\+.*\\$/) {
5965 WARN
("LINE_CONTINUATIONS",
5966 "Avoid unnecessary line continuations\n" . $herecurr);
5970 # do {} while (0) macro tests:
5971 # single-statement macros do not need to be enclosed in do while (0) loop,
5972 # macro should not end with a semicolon
5973 if ($perl_version_ok &&
5974 $realfile !~ m@
/vmlinux
.lds
.h
$@
&&
5975 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
5978 my ($off, $dstat, $dcond, $rest);
5980 ($dstat, $dcond, $ln, $cnt, $off) =
5981 ctx_statement_block
($linenr, $realcnt, 0);
5984 $dstat =~ s/\\\n.//g;
5987 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
5992 my $cnt = statement_rawlines
($ctx);
5993 my $herectx = get_stat_here
($linenr, $cnt, $here);
5995 if (($stmts =~ tr/;/;/) == 1 &&
5996 $stmts !~ /^\s*(if|while|for|switch)\b/) {
5997 WARN
("SINGLE_STATEMENT_DO_WHILE_MACRO",
5998 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
6000 if (defined $semis && $semis ne "") {
6001 WARN
("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
6002 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
6004 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
6006 my $cnt = statement_rawlines
($ctx);
6007 my $herectx = get_stat_here
($linenr, $cnt, $here);
6009 WARN
("TRAILING_SEMICOLON",
6010 "macros should not use a trailing semicolon\n" . "$herectx");
6014 # check for redundant bracing round if etc
6015 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
6016 my ($level, $endln, @chunks) =
6017 ctx_statement_full
($linenr, $realcnt, 1);
6018 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
6019 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
6020 if ($#chunks > 0 && $level == 0) {
6024 my $herectx = $here . "\n";
6025 my $ln = $linenr - 1;
6026 for my $chunk (@chunks) {
6027 my ($cond, $block) = @
{$chunk};
6029 # If the condition carries leading newlines, then count those as offsets.
6030 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
6031 my $offset = statement_rawlines
($whitespace) - 1;
6033 $allowed[$allow] = 0;
6034 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
6036 # We have looked at and allowed this specific line.
6037 $suppress_ifbraces{$ln + $offset} = 1;
6039 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
6040 $ln += statement_rawlines
($block) - 1;
6042 substr($block, 0, length($cond), '');
6044 $seen++ if ($block =~ /^\s*{/);
6046 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
6047 if (statement_lines
($cond) > 1) {
6048 #print "APW: ALLOWED: cond<$cond>\n";
6049 $allowed[$allow] = 1;
6051 if ($block =~/\b(?:if|for|while)\b/) {
6052 #print "APW: ALLOWED: block<$block>\n";
6053 $allowed[$allow] = 1;
6055 if (statement_block_size
($block) > 1) {
6056 #print "APW: ALLOWED: lines block<$block>\n";
6057 $allowed[$allow] = 1;
6062 my $sum_allowed = 0;
6063 foreach (@allowed) {
6066 if ($sum_allowed == 0) {
6068 "braces {} are not necessary for any arm of this statement\n" . $herectx);
6069 } elsif ($sum_allowed != $allow &&
6072 "braces {} should be used on all arms of this statement\n" . $herectx);
6077 if (!defined $suppress_ifbraces{$linenr - 1} &&
6078 $line =~ /\b(if|while|for|else)\b/) {
6081 # Check the pre-context.
6082 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
6083 #print "APW: ALLOWED: pre<$1>\n";
6087 my ($level, $endln, @chunks) =
6088 ctx_statement_full
($linenr, $realcnt, $-[0]);
6090 # Check the condition.
6091 my ($cond, $block) = @
{$chunks[0]};
6092 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
6093 if (defined $cond) {
6094 substr($block, 0, length($cond), '');
6096 if (statement_lines
($cond) > 1) {
6097 #print "APW: ALLOWED: cond<$cond>\n";
6100 if ($block =~/\b(?:if|for|while)\b/) {
6101 #print "APW: ALLOWED: block<$block>\n";
6104 if (statement_block_size
($block) > 1) {
6105 #print "APW: ALLOWED: lines block<$block>\n";
6108 # Check the post-context.
6109 if (defined $chunks[1]) {
6110 my ($cond, $block) = @
{$chunks[1]};
6111 if (defined $cond) {
6112 substr($block, 0, length($cond), '');
6114 if ($block =~ /^\s*\{/) {
6115 #print "APW: ALLOWED: chunk-1 block<$block>\n";
6119 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
6120 my $cnt = statement_rawlines
($block);
6121 my $herectx = get_stat_here
($linenr, $cnt, $here);
6124 "braces {} are not necessary for single statement blocks\n" . $herectx);
6128 # check for single line unbalanced braces
6129 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
6130 $sline =~ /^.\s*else\s*\{\s*$/) {
6131 CHK
("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
6134 # check for unnecessary blank lines around braces
6135 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
6137 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
6138 $fix && $prevrawline =~ /^\+/) {
6139 fix_delete_line
($fixlinenr - 1, $prevrawline);
6142 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
6144 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
6146 fix_delete_line
($fixlinenr, $rawline);
6150 # no volatiles please
6151 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
6152 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
6154 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
6157 # Check for user-visible strings broken across lines, which breaks the ability
6158 # to grep for the string. Make exceptions when the previous string ends in a
6159 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
6160 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
6161 if ($line =~ /^\+\s*$String/ &&
6162 $prevline =~ /"\s*$/ &&
6163 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
6164 if (WARN
("SPLIT_STRING",
6165 "quoted string split across lines\n" . $hereprev) &&
6167 $prevrawline =~ /^\+.*"\s*$/ &&
6168 $last_coalesced_string_linenr != $linenr - 1) {
6169 my $extracted_string = get_quoted_string
($line, $rawline);
6170 my $comma_close = "";
6171 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
6175 fix_delete_line
($fixlinenr - 1, $prevrawline);
6176 fix_delete_line
($fixlinenr, $rawline);
6177 my $fixedline = $prevrawline;
6178 $fixedline =~ s/"\s*$//;
6179 $fixedline .= substr($extracted_string, 1) . trim
($comma_close);
6180 fix_insert_line
($fixlinenr - 1, $fixedline);
6181 $fixedline = $rawline;
6182 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
6183 if ($fixedline !~ /\+\s*$/) {
6184 fix_insert_line
($fixlinenr, $fixedline);
6186 $last_coalesced_string_linenr = $linenr;
6190 # check for missing a space in a string concatenation
6191 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
6192 WARN
('MISSING_SPACE',
6193 "break quoted strings at a space character\n" . $hereprev);
6196 # check for an embedded function name in a string when the function is known
6197 # This does not work very well for -f --file checking as it depends on patch
6198 # context providing the function name or a single line form for in-file
6199 # function declarations
6200 if ($line =~ /^\+.*$String/ &&
6201 defined($context_function) &&
6202 get_quoted_string
($line, $rawline) =~ /\b$context_function\b/ &&
6203 length(get_quoted_string
($line, $rawline)) != (length($context_function) + 2)) {
6204 WARN
("EMBEDDED_FUNCTION_NAME",
6205 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
6208 # check for unnecessary function tracing like uses
6209 # This does not use $logFunctions because there are many instances like
6210 # 'dprintk(FOO, "%s()\n", __func__);' which do not match $logFunctions
6211 if ($rawline =~ /^\+.*\([^"]*"$tracing_logging_tags{0,3}%s(?:\s*\(\s*\)\s*)?$tracing_logging_tags{0,3}(?:\\n)?"\s*,\s*__func__\s*\)\s*;/) {
6212 if (WARN
("TRACING_LOGGING",
6213 "Unnecessary ftrace-like logging - prefer using ftrace\n" . $herecurr) &&
6215 fix_delete_line
($fixlinenr, $rawline);
6219 # check for spaces before a quoted newline
6220 if ($rawline =~ /^.*\".*\s\\n/) {
6221 if (WARN
("QUOTED_WHITESPACE_BEFORE_NEWLINE",
6222 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
6224 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
6229 # concatenated string without spaces between elements
6230 if ($line =~ /$String[A-Z_]/ ||
6231 ($line =~ /([A-Za-z0-9_]+)$String/ && $1 !~ /^[Lu]$/)) {
6232 if (CHK
("CONCATENATED_STRING",
6233 "Concatenated strings should use spaces between elements\n" . $herecurr) &&
6235 while ($line =~ /($String)/g) {
6236 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6237 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
6238 $fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
6243 # uncoalesced string fragments
6244 if ($line =~ /$String\s*[Lu]?"/) {
6245 if (WARN
("STRING_FRAGMENTS",
6246 "Consecutive strings are generally better as a single string\n" . $herecurr) &&
6248 while ($line =~ /($String)(?=\s*")/g) {
6249 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6250 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
6255 # check for non-standard and hex prefixed decimal printf formats
6256 my $show_L = 1; #don't show the same defect twice
6258 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
6259 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
6260 $string =~ s/%%/__/g;
6262 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
6264 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
6268 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
6270 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
6273 # check for 0x<decimal>
6274 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
6275 ERROR
("PRINTF_0XDECIMAL",
6276 "Prefixing 0x with decimal output is defective\n" . $herecurr);
6280 # check for line continuations in quoted strings with odd counts of "
6281 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
6282 WARN
("LINE_CONTINUATIONS",
6283 "Avoid line continuations in quoted strings\n" . $herecurr);
6287 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
6289 "Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
6293 if ($line =~ /^.\s*\#\s*if\s+1\b/) {
6295 "Consider removing the #if 1 and its #endif\n" . $herecurr);
6298 # check for needless "if (<foo>) fn(<foo>)" uses
6299 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
6300 my $tested = quotemeta($1);
6301 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
6302 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
6304 if (WARN
('NEEDLESS_IF',
6305 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
6308 my $leading_tabs = "";
6309 my $new_leading_tabs = "";
6310 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
6315 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
6316 $new_leading_tabs = $1;
6317 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
6324 fix_delete_line
($fixlinenr - 1, $prevrawline);
6325 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
6331 # check for unnecessary "Out of Memory" messages
6332 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
6333 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
6334 (defined $1 || defined $3) &&
6337 my $testline = $lines[$linenr - 3];
6339 my ($s, $c) = ctx_statement_block
($linenr - 3, $realcnt, 0);
6340 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
6342 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
6343 $s !~ /\b__GFP_NOWARN\b/ ) {
6345 "Possible unnecessary 'out of memory' message\n" . $hereprev);
6349 # check for logging functions with KERN_<LEVEL>
6350 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
6351 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
6353 if (WARN
("UNNECESSARY_KERN_LEVEL",
6354 "Possible unnecessary $level\n" . $herecurr) &&
6356 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
6360 # check for logging continuations
6361 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
6362 WARN
("LOGGING_CONTINUATION",
6363 "Avoid logging continuation uses where feasible\n" . $herecurr);
6366 # check for unnecessary use of %h[xudi] and %hh[xudi] in logging functions
6367 if (defined $stat &&
6368 $line =~ /\b$logFunctions\s*\(/ &&
6369 index($stat, '"') >= 0) {
6370 my $lc = $stat =~ tr@
\n@@
;
6371 $lc = $lc + $linenr;
6372 my $stat_real = get_stat_real
($linenr, $lc);
6373 pos($stat_real) = index($stat_real, '"');
6374 while ($stat_real =~ /[^\"%]*(%[\#\d\.\*\-]*(h+)[idux])/g) {
6377 my $lineoff = substr($stat_real, 0, $-[1]) =~ tr@
\n@@
;
6378 if (WARN
("UNNECESSARY_MODIFIER",
6379 "Integer promotion: Using '$h' in '$pspec' is unnecessary\n" . "$here\n$stat_real\n") &&
6380 $fix && $fixed[$fixlinenr + $lineoff] =~ /^\+/) {
6383 $fixed[$fixlinenr + $lineoff] =~ s/\Q$pspec\E/$nspec/;
6388 # check for mask then right shift without a parentheses
6389 if ($perl_version_ok &&
6390 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
6391 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
6392 WARN
("MASK_THEN_SHIFT",
6393 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
6396 # check for pointer comparisons to NULL
6397 if ($perl_version_ok) {
6398 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
6401 $equal = "" if ($4 eq "!=");
6402 if (CHK
("COMPARISON_TO_NULL",
6403 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
6405 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
6410 # check for bad placement of section $InitAttribute (e.g.: __initdata)
6411 if ($line =~ /(\b$InitAttribute\b)/) {
6413 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
6416 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
6417 ERROR
("MISPLACED_INIT",
6418 "$attr should be placed after $var\n" . $herecurr)) ||
6419 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
6420 WARN
("MISPLACED_INIT",
6421 "$attr should be placed after $var\n" . $herecurr))) &&
6423 $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;
6428 # check for $InitAttributeData (ie: __initdata) with const
6429 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
6431 $attr =~ /($InitAttributePrefix)(.*)/;
6432 my $attr_prefix = $1;
6434 if (ERROR
("INIT_ATTRIBUTE",
6435 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
6437 $fixed[$fixlinenr] =~
6438 s/$InitAttributeData/${attr_prefix}initconst/;
6442 # check for $InitAttributeConst (ie: __initconst) without const
6443 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
6445 if (ERROR
("INIT_ATTRIBUTE",
6446 "Use of $attr requires a separate use of const\n" . $herecurr) &&
6448 my $lead = $fixed[$fixlinenr] =~
6449 /(^\+\s*(?:static\s+))/;
6451 $lead = "$lead " if ($lead !~ /^\+$/);
6452 $lead = "${lead}const ";
6453 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
6457 # check for __read_mostly with const non-pointer (should just be const)
6458 if ($line =~ /\b__read_mostly\b/ &&
6459 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
6460 if (ERROR
("CONST_READ_MOSTLY",
6461 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
6463 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
6467 # don't use __constant_<foo> functions outside of include/uapi/
6468 if ($realfile !~ m@
^include
/uapi/@
&&
6469 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
6470 my $constant_func = $1;
6471 my $func = $constant_func;
6472 $func =~ s/^__constant_//;
6473 if (WARN
("CONSTANT_CONVERSION",
6474 "$constant_func should be $func\n" . $herecurr) &&
6476 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
6480 # prefer usleep_range over udelay
6481 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
6483 # ignore udelay's < 10, however
6484 if (! ($delay < 10) ) {
6486 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6488 if ($delay > 2000) {
6490 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
6494 # warn about unexpectedly long msleep's
6495 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
6498 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6502 # check for comparisons of jiffies
6503 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
6504 WARN
("JIFFIES_COMPARISON",
6505 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
6508 # check for comparisons of get_jiffies_64()
6509 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
6510 WARN
("JIFFIES_COMPARISON",
6511 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
6514 # warn about #ifdefs in C files
6515 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
6516 # print "#ifdef in C files should be avoided\n";
6517 # print "$herecurr";
6521 # warn about spacing in #ifdefs
6522 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
6523 if (ERROR
("SPACING",
6524 "exactly one space required after that #$1\n" . $herecurr) &&
6526 $fixed[$fixlinenr] =~
6527 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
6532 # check for spinlock_t definitions without a comment.
6533 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
6534 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
6536 if (!ctx_has_comment
($first_line, $linenr)) {
6537 CHK
("UNCOMMENTED_DEFINITION",
6538 "$1 definition without comment\n" . $herecurr);
6541 # check for memory barriers without a comment.
6548 my $barrier_stems = qr{
6556 my $all_barriers = qr{
6558 smp_
(?
:$barrier_stems)|
6559 virt_
(?
:$barrier_stems)
6562 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
6563 if (!ctx_has_comment
($first_line, $linenr)) {
6564 WARN
("MEMORY_BARRIER",
6565 "memory barrier without comment\n" . $herecurr);
6569 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
6571 if ($realfile !~ m@
^include
/asm-generic/@
&&
6572 $realfile !~ m@
/barrier\
.h
$@
&&
6573 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
6574 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
6575 WARN
("MEMORY_BARRIER",
6576 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6579 # check for waitqueue_active without a comment.
6580 if ($line =~ /\bwaitqueue_active\s*\(/) {
6581 if (!ctx_has_comment
($first_line, $linenr)) {
6582 WARN
("WAITQUEUE_ACTIVE",
6583 "waitqueue_active without comment\n" . $herecurr);
6587 # check for data_race without a comment.
6588 if ($line =~ /\bdata_race\s*\(/) {
6589 if (!ctx_has_comment
($first_line, $linenr)) {
6591 "data_race without comment\n" . $herecurr);
6595 # check of hardware specific defines
6596 if ($line =~ m@
^.\s
*\#\s
*if.*\b(__i386__
|__powerpc64__
|__sun__
|__s390x__
)\b@
&& $realfile !~ m
@include/asm
-@
) {
6598 "architecture specific defines should be avoided\n" . $herecurr);
6601 # check that the storage class is not after a type
6602 if ($line =~ /\b($Type)\s+($Storage)\b/) {
6603 WARN
("STORAGE_CLASS",
6604 "storage class '$2' should be located before type '$1'\n" . $herecurr);
6606 # Check that the storage class is at the beginning of a declaration
6607 if ($line =~ /\b$Storage\b/ &&
6608 $line !~ /^.\s*$Storage/ &&
6609 $line =~ /^.\s*(.+?)\$Storage\s/ &&
6610 $1 !~ /[\,\)]\s*$/) {
6611 WARN
("STORAGE_CLASS",
6612 "storage class should be at the beginning of the declaration\n" . $herecurr);
6615 # check the location of the inline attribute, that it is between
6616 # storage class and type.
6617 if ($line =~ /\b$Type\s+$Inline\b/ ||
6618 $line =~ /\b$Inline\s+$Storage\b/) {
6619 ERROR
("INLINE_LOCATION",
6620 "inline keyword should sit between storage class and type\n" . $herecurr);
6623 # Check for __inline__ and __inline, prefer inline
6624 if ($realfile !~ m@
\binclude
/uapi/@
&&
6625 $line =~ /\b(__inline__|__inline)\b/) {
6627 "plain inline is preferred over $1\n" . $herecurr) &&
6629 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
6634 # Check for compiler attributes
6635 if ($realfile !~ m@
\binclude
/uapi/@
&&
6636 $rawline =~ /\b__attribute__\s*\(\s*($balanced_parens)\s*\)/) {
6638 $attr =~ s/\s*\(\s*(.*)\)\s*/$1/;
6641 "alias" => "__alias",
6642 "aligned" => "__aligned",
6643 "always_inline" => "__always_inline",
6644 "assume_aligned" => "__assume_aligned",
6646 "const" => "__attribute_const__",
6648 "designated_init" => "__designated_init",
6649 "externally_visible" => "__visible",
6650 "format" => "printf|scanf",
6651 "gnu_inline" => "__gnu_inline",
6652 "malloc" => "__malloc",
6654 "no_caller_saved_registers" => "__no_caller_saved_registers",
6655 "noclone" => "__noclone",
6656 "noinline" => "noinline",
6657 "nonstring" => "__nonstring",
6658 "noreturn" => "__noreturn",
6659 "packed" => "__packed",
6661 "section" => "__section",
6666 while ($attr =~ /\s*(\w+)\s*(${balanced_parens})?/g) {
6669 $params = $2 if defined($2);
6670 my $curr_attr = $orig_attr;
6671 $curr_attr =~ s/^[\s_]+|[\s_]+$//g;
6672 if (exists($attr_list{$curr_attr})) {
6673 my $new = $attr_list{$curr_attr};
6674 if ($curr_attr eq "format" && $params) {
6675 $params =~ /^\s*\(\s*(\w+)\s*,\s*(.*)/;
6678 $new = "$new$params";
6680 if (WARN
("PREFER_DEFINED_ATTRIBUTE_MACRO",
6681 "Prefer $new over __attribute__(($orig_attr$params))\n" . $herecurr) &&
6683 my $remove = "\Q$orig_attr\E" . '\s*' . "\Q$params\E" . '(?:\s*,\s*)?';
6684 $fixed[$fixlinenr] =~ s/$remove//;
6685 $fixed[$fixlinenr] =~ s/\b__attribute__/$new __attribute__/;
6686 $fixed[$fixlinenr] =~ s/\}\Q$new\E/} $new/;
6687 $fixed[$fixlinenr] =~ s/ __attribute__\s*\(\s*\(\s*\)\s*\)//;
6692 # Check for __attribute__ unused, prefer __always_unused or __maybe_unused
6693 if ($attr =~ /^_*unused/) {
6694 WARN
("PREFER_DEFINED_ATTRIBUTE_MACRO",
6695 "__always_unused or __maybe_unused is preferred over __attribute__((__unused__))\n" . $herecurr);
6699 # Check for __attribute__ weak, or __weak declarations (may have link issues)
6700 if ($perl_version_ok &&
6701 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
6702 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
6703 $line =~ /\b__weak\b/)) {
6704 ERROR
("WEAK_DECLARATION",
6705 "Using weak declarations can have unintended link defects\n" . $herecurr);
6708 # check for c99 types like uint8_t used outside of uapi/ and tools/
6709 if ($realfile !~ m@
\binclude
/uapi/@
&&
6710 $realfile !~ m@
\btools
/@
&&
6711 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
6713 if ($type =~ /\b($typeC99Typedefs)\b/) {
6715 my $kernel_type = 'u';
6716 $kernel_type = 's' if ($type =~ /^_*[si]/);
6719 if (CHK
("PREFER_KERNEL_TYPES",
6720 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6722 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6727 # check for cast of C90 native int or longer types constants
6728 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
6732 my $newconst = $const;
6733 $newconst =~ s/${Int_type}$//;
6734 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6735 if ($cast =~ /\blong\s+long\b/) {
6737 } elsif ($cast =~ /\blong\b/) {
6740 if (WARN
("TYPECAST_INT_CONSTANT",
6741 "Unnecessary typecast of c90 int constant - '$cast$const' could be '$const$suffix'\n" . $herecurr) &&
6743 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6747 # check for sizeof(&)
6748 if ($line =~ /\bsizeof\s*\(\s*\&/) {
6749 WARN
("SIZEOF_ADDRESS",
6750 "sizeof(& should be avoided\n" . $herecurr);
6753 # check for sizeof without parenthesis
6754 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
6755 if (WARN
("SIZEOF_PARENTHESIS",
6756 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6758 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
6762 # check for struct spinlock declarations
6763 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
6764 WARN
("USE_SPINLOCK_T",
6765 "struct spinlock should be spinlock_t\n" . $herecurr);
6768 # check for seq_printf uses that could be seq_puts
6769 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
6770 my $fmt = get_quoted_string
($line, $rawline);
6773 if (WARN
("PREFER_SEQ_PUTS",
6774 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
6776 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6781 # check for vsprintf extension %p<foo> misuses
6782 if ($perl_version_ok &&
6784 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
6785 $1 !~ /^_*volatile_*$/) {
6788 my $lc = $stat =~ tr@
\n@@
;
6789 $lc = $lc + $linenr;
6790 for (my $count = $linenr; $count <= $lc; $count++) {
6794 my $bad_specifier = "";
6795 my $fmt = get_quoted_string
($lines[$count - 1], raw_line
($count, 0));
6798 while ($fmt =~ /(\%[\*\d\.]*p(\w)(\w*))/g) {
6802 if ($extension !~ /[4SsBKRraEehMmIiUDdgVCbGNOxtf]/ ||
6803 ($extension eq "f" &&
6804 defined $qualifier && $qualifier !~ /^w/) ||
6805 ($extension eq "4" &&
6806 defined $qualifier && $qualifier !~ /^cc/)) {
6807 $bad_specifier = $specifier;
6810 if ($extension eq "x" && !defined($stat_real)) {
6811 if (!defined($stat_real)) {
6812 $stat_real = get_stat_real
($linenr, $lc);
6814 WARN
("VSPRINTF_SPECIFIER_PX",
6815 "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");
6818 if ($bad_specifier ne "") {
6819 my $stat_real = get_stat_real
($linenr, $lc);
6820 my $ext_type = "Invalid";
6822 if ($bad_specifier =~ /p[Ff]/) {
6823 $use = " - use %pS instead";
6824 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6827 WARN
("VSPRINTF_POINTER_EXTENSION",
6828 "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6833 # Check for misused memsets
6834 if ($perl_version_ok &&
6836 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
6842 if ($ms_size =~ /^(0x|)0$/i) {
6844 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6845 } elsif ($ms_size =~ /^(0x|)1$/i) {
6847 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6851 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6852 # if ($perl_version_ok &&
6854 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6855 # if (WARN("PREFER_ETHER_ADDR_COPY",
6856 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6858 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
6862 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6863 # if ($perl_version_ok &&
6865 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6866 # WARN("PREFER_ETHER_ADDR_EQUAL",
6867 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6870 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6871 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
6872 # if ($perl_version_ok &&
6874 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6878 # if ($ms_val =~ /^(?:0x|)0+$/i) {
6879 # if (WARN("PREFER_ETH_ZERO_ADDR",
6880 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
6882 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
6884 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
6885 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
6886 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
6888 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
6893 # strlcpy uses that should likely be strscpy
6894 if ($line =~ /\bstrlcpy\s*\(/) {
6896 "Prefer strscpy over strlcpy - see: https://lore.kernel.org/r/CAHk-=wgfRnXz0W3D37d01q3JFkr_i_uTL=V6A6G1oUZcprmknw\@mail.gmail.com/\n" . $herecurr);
6899 # typecasts on min/max could be min_t/max_t
6900 if ($perl_version_ok &&
6902 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
6903 if (defined $2 || defined $7) {
6905 my $cast1 = deparenthesize
($2);
6907 my $cast2 = deparenthesize
($7);
6911 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
6912 $cast = "$cast1 or $cast2";
6913 } elsif ($cast1 ne "") {
6919 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
6923 # check usleep_range arguments
6924 if ($perl_version_ok &&
6926 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
6930 WARN
("USLEEP_RANGE",
6931 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6932 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
6934 WARN
("USLEEP_RANGE",
6935 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
6939 # check for naked sscanf
6940 if ($perl_version_ok &&
6942 $line =~ /\bsscanf\b/ &&
6943 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
6944 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
6945 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
6946 my $lc = $stat =~ tr@
\n@@
;
6947 $lc = $lc + $linenr;
6948 my $stat_real = get_stat_real
($linenr, $lc);
6949 WARN
("NAKED_SSCANF",
6950 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
6953 # check for simple sscanf that should be kstrto<foo>
6954 if ($perl_version_ok &&
6956 $line =~ /\bsscanf\b/) {
6957 my $lc = $stat =~ tr@
\n@@
;
6958 $lc = $lc + $linenr;
6959 my $stat_real = get_stat_real
($linenr, $lc);
6960 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
6962 my $count = $format =~ tr@
%@
%@
;
6964 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
6965 WARN
("SSCANF_TO_KSTRTO",
6966 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
6971 # check for new externs in .h files.
6972 if ($realfile =~ /\.h$/ &&
6973 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
6974 if (CHK
("AVOID_EXTERNS",
6975 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
6977 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
6981 # check for new externs in .c files.
6982 if ($realfile =~ /\.c$/ && defined $stat &&
6983 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
6985 my $function_name = $1;
6986 my $paren_space = $2;
6989 if (defined $cond) {
6990 substr($s, 0, length($cond), '');
6994 WARN
("AVOID_EXTERNS",
6995 "externs should be avoided in .c files\n" . $herecurr);
6998 if ($paren_space =~ /\n/) {
6999 WARN
("FUNCTION_ARGUMENTS",
7000 "arguments for function declarations should follow identifier\n" . $herecurr);
7003 } elsif ($realfile =~ /\.c$/ && defined $stat &&
7004 $stat =~ /^.\s*extern\s+/)
7006 WARN
("AVOID_EXTERNS",
7007 "externs should be avoided in .c files\n" . $herecurr);
7010 # check for function declarations that have arguments without identifier names
7011 if (defined $stat &&
7012 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
7014 my $args = trim
($1);
7015 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
7017 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
7018 WARN
("FUNCTION_ARGUMENTS",
7019 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
7024 # check for function definitions
7025 if ($perl_version_ok &&
7027 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
7028 $context_function = $1;
7030 # check for multiline function definition with misplaced open brace
7032 my $cnt = statement_rawlines
($stat);
7033 my $herectx = $here . "\n";
7034 for (my $n = 0; $n < $cnt; $n++) {
7035 my $rl = raw_line
($linenr, $n);
7036 $herectx .= $rl . "\n";
7037 $ok = 1 if ($rl =~ /^[ \+]\{/);
7038 $ok = 1 if ($rl =~ /\{/ && $n == 0);
7039 last if $rl =~ /^[ \+].*\{/;
7043 "open brace '{' following function definitions go on the next line\n" . $herectx);
7047 # checks for new __setup's
7048 if ($rawline =~ /\b__setup\("([^"]*)"/) {
7051 if (!grep(/$name/, @setup_docs)) {
7052 CHK
("UNDOCUMENTED_SETUP",
7053 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
7057 # check for pointless casting of alloc functions
7058 if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
7059 WARN
("UNNECESSARY_CASTS",
7060 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
7064 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
7065 if ($perl_version_ok &&
7066 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
7067 CHK
("ALLOC_SIZEOF_STRUCT",
7068 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
7071 # check for (kv|k)[mz]alloc with multiplies that could be kmalloc_array/kvmalloc_array/kvcalloc/kcalloc
7072 if ($perl_version_ok &&
7074 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k)[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
7078 my $newfunc = "kmalloc_array";
7079 $newfunc = "kvmalloc_array" if ($oldfunc eq "kvmalloc");
7080 $newfunc = "kvcalloc" if ($oldfunc eq "kvzalloc");
7081 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
7084 if ($a1 =~ /^sizeof\s*\S/) {
7088 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
7089 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
7090 my $cnt = statement_rawlines
($stat);
7091 my $herectx = get_stat_here
($linenr, $cnt, $here);
7093 if (WARN
("ALLOC_WITH_MULTIPLY",
7094 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
7097 $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;
7102 # check for krealloc arg reuse
7103 if ($perl_version_ok &&
7104 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*($Lval)\s*,/ &&
7106 WARN
("KREALLOC_ARG_REUSE",
7107 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
7110 # check for alloc argument mismatch
7111 if ($line =~ /\b((?:devm_)?(?:kcalloc|kmalloc_array))\s*\(\s*sizeof\b/) {
7112 WARN
("ALLOC_ARRAY_ARGS",
7113 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
7116 # check for multiple semicolons
7117 if ($line =~ /;\s*;\s*$/) {
7118 if (WARN
("ONE_SEMICOLON",
7119 "Statements terminations use 1 semicolon\n" . $herecurr) &&
7121 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
7125 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
7126 if ($realfile !~ m@
^include
/uapi/@
&&
7127 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
7129 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
7130 if (CHK
("BIT_MACRO",
7131 "Prefer using the BIT$ull macro\n" . $herecurr) &&
7133 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
7137 # check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
7138 if ($rawline =~ /\bIS_ENABLED\s*\(\s*(\w+)\s*\)/ && $1 !~ /^${CONFIG_}/) {
7139 WARN
("IS_ENABLED_CONFIG",
7140 "IS_ENABLED($1) is normally used as IS_ENABLED(${CONFIG_}$1)\n" . $herecurr);
7143 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
7144 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(${CONFIG_}[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
7146 if (WARN
("PREFER_IS_ENABLED",
7147 "Prefer IS_ENABLED(<FOO>) to ${CONFIG_}<FOO> || ${CONFIG_}<FOO>_MODULE\n" . $herecurr) &&
7149 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
7153 # check for /* fallthrough */ like comment, prefer fallthrough;
7154 my @fallthroughs = (
7157 'lint -fallthrough[ \t]*',
7158 'intentional(?:ly)?[ \t]*fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)',
7159 '(?:else,?\s*)?FALL(?:S | |-)?THR(?:OUGH|U|EW)[ \t.!]*(?:-[^\n\r]*)?',
7160 'Fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7161 'fall(?:s | |-)?thr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7163 if ($raw_comment ne '') {
7164 foreach my $ft (@fallthroughs) {
7165 if ($raw_comment =~ /$ft/) {
7166 my $msg_level = \
&WARN
;
7167 $msg_level = \
&CHK
if ($file);
7168 &{$msg_level}("PREFER_FALLTHROUGH",
7169 "Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
7175 # check for switch/default statements without a break;
7176 if ($perl_version_ok &&
7178 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
7179 my $cnt = statement_rawlines
($stat);
7180 my $herectx = get_stat_here
($linenr, $cnt, $here);
7182 WARN
("DEFAULT_NO_BREAK",
7183 "switch default: should use break\n" . $herectx);
7186 # check for gcc specific __FUNCTION__
7187 if ($line =~ /\b__FUNCTION__\b/) {
7188 if (WARN
("USE_FUNC",
7189 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
7191 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
7195 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
7196 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
7198 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
7201 # check for use of yield()
7202 if ($line =~ /\byield\s*\(\s*\)/) {
7204 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
7207 # check for comparisons against true and false
7208 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
7216 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
7218 my $type = lc($otype);
7219 if ($type =~ /^(?:true|false)$/) {
7220 if (("$test" eq "==" && "$type" eq "true") ||
7221 ("$test" eq "!=" && "$type" eq "false")) {
7225 CHK
("BOOL_COMPARISON",
7226 "Using comparison to $otype is error prone\n" . $herecurr);
7228 ## maybe suggesting a correct construct would better
7229 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
7234 # check for semaphores initialized locked
7235 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
7236 WARN
("CONSIDER_COMPLETION",
7237 "consider using a completion\n" . $herecurr);
7240 # recommend kstrto* over simple_strto* and strict_strto*
7241 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
7242 WARN
("CONSIDER_KSTRTO",
7243 "$1 is obsolete, use k$3 instead\n" . $herecurr);
7246 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
7247 if ($line =~ /^.\s*__initcall\s*\(/) {
7248 WARN
("USE_DEVICE_INITCALL",
7249 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
7252 # check for spin_is_locked(), suggest lockdep instead
7253 if ($line =~ /\bspin_is_locked\(/) {
7255 "Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
7258 # check for deprecated apis
7259 if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
7260 my $deprecated_api = $1;
7261 my $new_api = $deprecated_apis{$deprecated_api};
7262 WARN
("DEPRECATED_API",
7263 "Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
7266 # check for various structs that are normally const (ops, kgdb, device_tree)
7267 # and avoid what seem like struct definitions 'struct foo {'
7268 if (defined($const_structs) &&
7269 $line !~ /\bconst\b/ &&
7270 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
7271 WARN
("CONST_STRUCT",
7272 "struct $1 should normally be const\n" . $herecurr);
7275 # use of NR_CPUS is usually wrong
7276 # ignore definitions of NR_CPUS and usage to define arrays as likely right
7277 # ignore designated initializers using NR_CPUS
7278 if ($line =~ /\bNR_CPUS\b/ &&
7279 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
7280 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
7281 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
7282 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
7283 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/ &&
7284 $line !~ /^.\s*\.\w+\s*=\s*.*\bNR_CPUS\b/)
7287 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
7290 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
7291 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
7292 ERROR
("DEFINE_ARCH_HAS",
7293 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
7296 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
7297 if ($perl_version_ok &&
7298 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
7299 WARN
("LIKELY_MISUSE",
7300 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
7303 # return sysfs_emit(foo, fmt, ...) fmt without newline
7304 if ($line =~ /\breturn\s+sysfs_emit\s*\(\s*$FuncArg\s*,\s*($String)/ &&
7305 substr($rawline, $-[6], $+[6] - $-[6]) !~ /\\n"$/) {
7306 my $offset = $+[6] - 1;
7307 if (WARN
("SYSFS_EMIT",
7308 "return sysfs_emit(...) formats should include a terminating newline\n" . $herecurr) &&
7310 substr($fixed[$fixlinenr], $offset, 0) = '\\n';
7314 # nested likely/unlikely calls
7315 if ($line =~ /\b(?:(?:un)?likely)\s*\(\s*!?\s*(IS_ERR(?:_OR_NULL|_VALUE)?|WARN)/) {
7316 WARN
("LIKELY_MISUSE",
7317 "nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
7320 # whine mightly about in_atomic
7321 if ($line =~ /\bin_atomic\s*\(/) {
7322 if ($realfile =~ m@
^drivers
/@
) {
7324 "do not use in_atomic in drivers\n" . $herecurr);
7325 } elsif ($realfile !~ m@
^kernel
/@
) {
7327 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
7331 # check for lockdep_set_novalidate_class
7332 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
7333 $line =~ /__lockdep_no_validate__\s*\)/ ) {
7334 if ($realfile !~ m@
^kernel
/lockdep@
&&
7335 $realfile !~ m@
^include
/linux/lockdep@
&&
7336 $realfile !~ m@
^drivers
/base/core@
) {
7338 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
7342 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
7343 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
7344 WARN
("EXPORTED_WORLD_WRITABLE",
7345 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
7348 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
7349 # and whether or not function naming is typical and if
7350 # DEVICE_ATTR permissions uses are unusual too
7351 if ($perl_version_ok &&
7353 $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*\)/) {
7358 my $octal_perms = perms_to_octal
($perms);
7359 if ($show =~ /^${var}_show$/ &&
7360 $store =~ /^${var}_store$/ &&
7361 $octal_perms eq "0644") {
7362 if (WARN
("DEVICE_ATTR_RW",
7363 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
7365 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
7367 } elsif ($show =~ /^${var}_show$/ &&
7368 $store =~ /^NULL$/ &&
7369 $octal_perms eq "0444") {
7370 if (WARN
("DEVICE_ATTR_RO",
7371 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
7373 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
7375 } elsif ($show =~ /^NULL$/ &&
7376 $store =~ /^${var}_store$/ &&
7377 $octal_perms eq "0200") {
7378 if (WARN
("DEVICE_ATTR_WO",
7379 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
7381 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
7383 } elsif ($octal_perms eq "0644" ||
7384 $octal_perms eq "0444" ||
7385 $octal_perms eq "0200") {
7386 my $newshow = "$show";
7387 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
7388 my $newstore = $store;
7389 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
7391 if ($show ne $newshow) {
7392 $rename .= " '$show' to '$newshow'";
7394 if ($store ne $newstore) {
7395 $rename .= " '$store' to '$newstore'";
7397 WARN
("DEVICE_ATTR_FUNCTIONS",
7398 "Consider renaming function(s)$rename\n" . $herecurr);
7400 WARN
("DEVICE_ATTR_PERMS",
7401 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
7405 # Mode permission misuses where it seems decimal should be octal
7406 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
7407 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
7408 # specific definition of not visible in sysfs.
7409 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
7410 # use the default permissions
7411 if ($perl_version_ok &&
7413 $line =~ /$mode_perms_search/) {
7414 foreach my $entry (@mode_permission_funcs) {
7415 my $func = $entry->[0];
7416 my $arg_pos = $entry->[1];
7418 my $lc = $stat =~ tr@
\n@@
;
7419 $lc = $lc + $linenr;
7420 my $stat_real = get_stat_real
($linenr, $lc);
7425 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
7427 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
7428 if ($stat =~ /$test/) {
7430 $val = $6 if ($skip_args ne "");
7431 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
7432 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
7433 ($val =~ /^$Octal$/ && length($val) ne 4))) {
7434 ERROR
("NON_OCTAL_PERMISSIONS",
7435 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
7437 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
7438 ERROR
("EXPORTED_WORLD_WRITABLE",
7439 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
7445 # check for uses of S_<PERMS> that could be octal for readability
7446 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
7448 my $octal = perms_to_octal
($oval);
7449 if (WARN
("SYMBOLIC_PERMS",
7450 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
7452 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
7456 # validate content of MODULE_LICENSE against list from include/linux/module.h
7457 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
7458 my $extracted_string = get_quoted_string
($line, $rawline);
7459 my $valid_licenses = qr{
7462 GPL\
and\ additional\ rights
|
7468 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
7469 WARN
("MODULE_LICENSE",
7470 "unknown module license " . $extracted_string . "\n" . $herecurr);
7472 if (!$file && $extracted_string eq '"GPL v2"') {
7473 if (WARN
("MODULE_LICENSE",
7474 "Prefer \"GPL\" over \"GPL v2\" - see commit bf7fbeeae6db (\"module: Cure the MODULE_LICENSE \"GPL\" vs. \"GPL v2\" bogosity\")\n" . $herecurr) &&
7476 $fixed[$fixlinenr] =~ s/\bMODULE_LICENSE\s*\(\s*"GPL v2"\s*\)/MODULE_LICENSE("GPL")/;
7481 # check for sysctl duplicate constants
7482 if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
7483 WARN
("DUPLICATED_SYSCTL_CONST",
7484 "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
7488 # If we have no input at all, then there is nothing to report on
7489 # so just keep quiet.
7490 if ($#rawlines == -1) {
7494 # In mailback mode only produce a report in the negative, for
7495 # things that appear to be patches.
7496 if ($mailback && ($clean == 1 || !$is_patch)) {
7500 # This is not a patch, and we are in 'no-patch' mode so
7502 if (!$chk_patch && !$is_patch) {
7506 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
7507 ERROR
("NOT_UNIFIED_DIFF",
7508 "Does not appear to be a unified-diff format patch\n");
7510 if ($is_patch && $has_commit_log && $chk_signoff) {
7511 if ($signoff == 0) {
7512 ERROR
("MISSING_SIGN_OFF",
7513 "Missing Signed-off-by: line(s)\n");
7514 } elsif ($authorsignoff != 1) {
7515 # authorsignoff values:
7516 # 0 -> missing sign off
7517 # 1 -> sign off identical
7518 # 2 -> names and addresses match, comments mismatch
7519 # 3 -> addresses match, names different
7520 # 4 -> names match, addresses different
7521 # 5 -> names match, addresses excluding subaddress details (refer RFC 5233) match
7523 my $sob_msg = "'From: $author' != 'Signed-off-by: $author_sob'";
7525 if ($authorsignoff == 0) {
7526 ERROR
("NO_AUTHOR_SIGN_OFF",
7527 "Missing Signed-off-by: line by nominal patch author '$author'\n");
7528 } elsif ($authorsignoff == 2) {
7529 CHK
("FROM_SIGN_OFF_MISMATCH",
7530 "From:/Signed-off-by: email comments mismatch: $sob_msg\n");
7531 } elsif ($authorsignoff == 3) {
7532 WARN
("FROM_SIGN_OFF_MISMATCH",
7533 "From:/Signed-off-by: email name mismatch: $sob_msg\n");
7534 } elsif ($authorsignoff == 4) {
7535 WARN
("FROM_SIGN_OFF_MISMATCH",
7536 "From:/Signed-off-by: email address mismatch: $sob_msg\n");
7537 } elsif ($authorsignoff == 5) {
7538 WARN
("FROM_SIGN_OFF_MISMATCH",
7539 "From:/Signed-off-by: email subaddress mismatch: $sob_msg\n");
7544 print report_dump
();
7545 if ($summary && !($clean == 1 && $quiet == 1)) {
7546 print "$filename " if ($summary_file);
7547 print "total: $cnt_error errors, $cnt_warn warnings, " .
7548 (($check)?
"$cnt_chk checks, " : "") .
7549 "$cnt_lines lines checked\n";
7553 # If there were any defects found and not already fixing them
7554 if (!$clean and !$fix) {
7557 NOTE
: For some of the reported defects
, checkpatch may be able to
7558 mechanically convert to the typical style using
--fix
or --fix
-inplace
.
7561 # If there were whitespace errors which cleanpatch can fix
7562 # then suggest that.
7563 if ($rpt_cleaners) {
7567 NOTE
: Whitespace errors detected
.
7568 You may wish to
use scripts
/cleanpatch or scripts/cleanfile
7573 if ($clean == 0 && $fix &&
7574 ("@rawlines" ne "@fixed" ||
7575 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
7576 my $newfile = $filename;
7577 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
7581 @fixed = fix_inserted_deleted_lines
(\
@fixed, \
@fixed_inserted, \
@fixed_deleted);
7583 open($f, '>', $newfile)
7584 or die "$P: Can't open $newfile for write\n";
7585 foreach my $fixed_line (@fixed) {
7588 if ($linecount > 3) {
7589 $fixed_line =~ s/^\+//;
7590 print $f $fixed_line . "\n";
7593 print $f $fixed_line . "\n";
7601 Wrote EXPERIMENTAL
--fix correction
(s
) to
'$newfile'
7603 Do _NOT_ trust the results written to this file
.
7604 Do _NOT_ submit these changes without inspecting them
for correctness
.
7606 This EXPERIMENTAL file is simply a convenience to help rewrite patches
.
7607 No warranties
, expressed
or implied
...
7615 print "$vname has no obvious style problems and is ready for submission.\n";
7617 print "$vname has style problems, please review.\n";
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)