]> git.ipfire.org Git - thirdparty/u-boot.git/blame_incremental - scripts/checkpatch.pl
Merge branch 'master' of https://source.denx.de/u-boot/custodians/u-boot-samsung
[thirdparty/u-boot.git] / scripts / checkpatch.pl
... / ...
CommitLineData
1#!/usr/bin/env perl
2# SPDX-License-Identifier: GPL-2.0
3#
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>
9
10use strict;
11use warnings;
12use POSIX;
13use File::Basename;
14use Cwd 'abs_path';
15use Term::ANSIColor qw(:constants);
16use Encode qw(decode encode);
17
18my $P = $0;
19my $D = dirname(abs_path($P));
20
21my $V = '0.32';
22
23use Getopt::Long qw(:config no_auto_abbrev);
24
25my $quiet = 0;
26my $verbose = 0;
27my %verbose_messages = ();
28my %verbose_emitted = ();
29my $tree = 1;
30my $chk_signoff = 1;
31my $chk_patch = 1;
32my $tst_only;
33my $emacs = 0;
34my $terse = 0;
35my $showfile = 0;
36my $file = 0;
37my $git = 0;
38my %git_commits = ();
39my $check = 0;
40my $check_orig = 0;
41my $summary = 1;
42my $mailback = 0;
43my $summary_file = 0;
44my $show_types = 0;
45my $list_types = 0;
46my $fix = 0;
47my $fix_inplace = 0;
48my $root;
49my $gitroot = $ENV{'GIT_DIR'};
50$gitroot = ".git" if !defined($gitroot);
51my %debug;
52my %camelcase = ();
53my %use_type = ();
54my @use = ();
55my %ignore_type = ();
56my @ignore = ();
57my $help = 0;
58my $configuration_file = ".checkpatch.conf";
59my $max_line_length = 100;
60my $ignore_perl_version = 0;
61my $minimum_perl_version = 5.10.0;
62my $min_conf_desc_length = 4;
63my $spelling_file = "$D/spelling.txt";
64my $codespell = 0;
65my $codespellfile = "/usr/share/codespell/dictionary.txt";
66my $user_codespellfile = "";
67my $conststructsfile = "$D/const_structs.checkpatch";
68my $u_boot = 0;
69my $docsfile = "$D/../doc/develop/checkpatch.rst";
70my $typedefsfile;
71my $color = "auto";
72my $allow_c99_comments = 1; # Can be overridden by --ignore C99_COMMENT_TOLERANCE
73# git output parsing needs US English output, so first set backtick child process LANGUAGE
74my $git_command ='export LANGUAGE=en_US.UTF-8; git';
75my $tabsize = 8;
76my ${CONFIG_} = "CONFIG_";
77
78sub help {
79 my ($exitcode) = @_;
80
81 print << "EOM";
82Usage: $P [OPTION]... [FILE]...
83Version: $V
84
85Options:
86 -q, --quiet quiet
87 -v, --verbose verbose mode
88 --no-tree run without a kernel tree
89 --no-signoff do not check for 'Signed-off-by' line
90 --patch treat FILE as patchfile (default)
91 --emacs emacs compile window format
92 --terse one line per report
93 --showfile emit diffed file position, not input file position
94 -g, --git treat FILE as a single commit or git revision range
95 single git commit with:
96 <rev>
97 <rev>^
98 <rev>~n
99 multiple git commits with:
100 <rev1>..<rev2>
101 <rev1>...<rev2>
102 <rev>-<count>
103 git merges are ignored
104 -f, --file treat FILE as regular source file
105 --subjective, --strict enable more subjective tests
106 --list-types list the possible message types
107 --types TYPE(,TYPE2...) show only these comma separated message types
108 --ignore TYPE(,TYPE2...) ignore various comma separated message types
109 --show-types show the specific message type in the output
110 --max-line-length=n set the maximum line length, (default $max_line_length)
111 if exceeded, warn on patches
112 requires --strict for use with --file
113 --min-conf-desc-length=n set the min description length, if shorter, warn
114 --tab-size=n set the number of spaces for tab (default $tabsize)
115 --root=PATH PATH to the kernel tree root
116 --no-summary suppress the per-file summary
117 --mailback only produce a report in case of warnings/errors
118 --summary-file include the filename in summary
119 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
120 'values', 'possible', 'type', and 'attr' (default
121 is all off)
122 --test-only=WORD report only warnings/errors containing WORD
123 literally
124 --fix EXPERIMENTAL - may create horrible results
125 If correctable single-line errors exist, create
126 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
127 with potential errors corrected to the preferred
128 checkpatch style
129 --fix-inplace EXPERIMENTAL - may create horrible results
130 Is the same as --fix, but overwrites the input
131 file. It's your fault if there's no backup or git
132 --ignore-perl-version override checking of perl version. expect
133 runtime errors.
134 --codespell Use the codespell dictionary for spelling/typos
135 (default:$codespellfile)
136 --codespellfile Use this codespell dictionary
137 --typedefsfile Read additional types from this file
138 --color[=WHEN] Use colors 'always', 'never', or only when output
139 is a terminal ('auto'). Default is 'auto'.
140 --u-boot Run additional checks for U-Boot
141 --kconfig-prefix=WORD use WORD as a prefix for Kconfig symbols (default
142 ${CONFIG_})
143 -h, --help, --version display this help and exit
144
145When FILE is - read standard input.
146EOM
147
148 exit($exitcode);
149}
150
151sub uniq {
152 my %seen;
153 return grep { !$seen{$_}++ } @_;
154}
155
156sub list_types {
157 my ($exitcode) = @_;
158
159 my $count = 0;
160
161 local $/ = undef;
162
163 open(my $script, '<', abs_path($P)) or
164 die "$P: Can't read '$P' $!\n";
165
166 my $text = <$script>;
167 close($script);
168
169 my %types = ();
170 # Also catch when type or level is passed through a variable
171 while ($text =~ /(?:(\bCHK|\bWARN|\bERROR|&\{\$msg_level})\s*\(|\$msg_type\s*=)\s*"([^"]+)"/g) {
172 if (defined($1)) {
173 if (exists($types{$2})) {
174 $types{$2} .= ",$1" if ($types{$2} ne $1);
175 } else {
176 $types{$2} = $1;
177 }
178 } else {
179 $types{$2} = "UNDETERMINED";
180 }
181 }
182
183 print("#\tMessage type\n\n");
184 if ($color) {
185 print(" ( Color coding: ");
186 print(RED . "ERROR" . RESET);
187 print(" | ");
188 print(YELLOW . "WARNING" . RESET);
189 print(" | ");
190 print(GREEN . "CHECK" . RESET);
191 print(" | ");
192 print("Multiple levels / Undetermined");
193 print(" )\n\n");
194 }
195
196 foreach my $type (sort keys %types) {
197 my $orig_type = $type;
198 if ($color) {
199 my $level = $types{$type};
200 if ($level eq "ERROR") {
201 $type = RED . $type . RESET;
202 } elsif ($level eq "WARN") {
203 $type = YELLOW . $type . RESET;
204 } elsif ($level eq "CHK") {
205 $type = GREEN . $type . RESET;
206 }
207 }
208 print(++$count . "\t" . $type . "\n");
209 if ($verbose && exists($verbose_messages{$orig_type})) {
210 my $message = $verbose_messages{$orig_type};
211 $message =~ s/\n/\n\t/g;
212 print("\t" . $message . "\n\n");
213 }
214 }
215
216 exit($exitcode);
217}
218
219my $conf = which_conf($configuration_file);
220if (-f $conf) {
221 my @conf_args;
222 open(my $conffile, '<', "$conf")
223 or warn "$P: Can't find a readable $configuration_file file $!\n";
224
225 while (<$conffile>) {
226 my $line = $_;
227
228 $line =~ s/\s*\n?$//g;
229 $line =~ s/^\s*//g;
230 $line =~ s/\s+/ /g;
231
232 next if ($line =~ m/^\s*#/);
233 next if ($line =~ m/^\s*$/);
234
235 my @words = split(" ", $line);
236 foreach my $word (@words) {
237 last if ($word =~ m/^#/);
238 push (@conf_args, $word);
239 }
240 }
241 close($conffile);
242 unshift(@ARGV, @conf_args) if @conf_args;
243}
244
245sub load_docs {
246 open(my $docs, '<', "$docsfile")
247 or warn "$P: Can't read the documentation file $docsfile $!\n";
248
249 my $type = '';
250 my $desc = '';
251 my $in_desc = 0;
252
253 while (<$docs>) {
254 chomp;
255 my $line = $_;
256 $line =~ s/\s+$//;
257
258 if ($line =~ /^\s*\*\*(.+)\*\*$/) {
259 if ($desc ne '') {
260 $verbose_messages{$type} = trim($desc);
261 }
262 $type = $1;
263 $desc = '';
264 $in_desc = 1;
265 } elsif ($in_desc) {
266 if ($line =~ /^(?:\s{4,}|$)/) {
267 $line =~ s/^\s{4}//;
268 $desc .= $line;
269 $desc .= "\n";
270 } else {
271 $verbose_messages{$type} = trim($desc);
272 $type = '';
273 $desc = '';
274 $in_desc = 0;
275 }
276 }
277 }
278
279 if ($desc ne '') {
280 $verbose_messages{$type} = trim($desc);
281 }
282 close($docs);
283}
284
285# Perl's Getopt::Long allows options to take optional arguments after a space.
286# Prevent --color by itself from consuming other arguments
287foreach (@ARGV) {
288 if ($_ eq "--color" || $_ eq "-color") {
289 $_ = "--color=$color";
290 }
291}
292
293GetOptions(
294 'q|quiet+' => \$quiet,
295 'v|verbose!' => \$verbose,
296 'tree!' => \$tree,
297 'signoff!' => \$chk_signoff,
298 'patch!' => \$chk_patch,
299 'emacs!' => \$emacs,
300 'terse!' => \$terse,
301 'showfile!' => \$showfile,
302 'f|file!' => \$file,
303 'g|git!' => \$git,
304 'subjective!' => \$check,
305 'strict!' => \$check,
306 'ignore=s' => \@ignore,
307 'types=s' => \@use,
308 'show-types!' => \$show_types,
309 'list-types!' => \$list_types,
310 'max-line-length=i' => \$max_line_length,
311 'min-conf-desc-length=i' => \$min_conf_desc_length,
312 'tab-size=i' => \$tabsize,
313 'root=s' => \$root,
314 'summary!' => \$summary,
315 'mailback!' => \$mailback,
316 'summary-file!' => \$summary_file,
317 'fix!' => \$fix,
318 'fix-inplace!' => \$fix_inplace,
319 'ignore-perl-version!' => \$ignore_perl_version,
320 'debug=s' => \%debug,
321 'test-only=s' => \$tst_only,
322 'codespell!' => \$codespell,
323 'codespellfile=s' => \$user_codespellfile,
324 'typedefsfile=s' => \$typedefsfile,
325 'u-boot' => \$u_boot,
326 'color=s' => \$color,
327 'no-color' => \$color, #keep old behaviors of -nocolor
328 'nocolor' => \$color, #keep old behaviors of -nocolor
329 'kconfig-prefix=s' => \${CONFIG_},
330 'h|help' => \$help,
331 'version' => \$help
332) or $help = 2;
333
334if ($user_codespellfile) {
335 # Use the user provided codespell file unconditionally
336 $codespellfile = $user_codespellfile;
337} elsif (!(-f $codespellfile)) {
338 # If /usr/share/codespell/dictionary.txt is not present, try to find it
339 # under codespell's install directory: <codespell_root>/data/dictionary.txt
340 if (($codespell || $help) && which("codespell") ne "" && which("python") ne "") {
341 my $python_codespell_dict = << "EOF";
342
343import os.path as op
344import codespell_lib
345codespell_dir = op.dirname(codespell_lib.__file__)
346codespell_file = op.join(codespell_dir, 'data', 'dictionary.txt')
347print(codespell_file, end='')
348EOF
349
350 my $codespell_dict = `python -c "$python_codespell_dict" 2> /dev/null`;
351 $codespellfile = $codespell_dict if (-f $codespell_dict);
352 }
353}
354
355# $help is 1 if either -h, --help or --version is passed as option - exitcode: 0
356# $help is 2 if invalid option is passed - exitcode: 1
357help($help - 1) if ($help);
358
359die "$P: --git cannot be used with --file or --fix\n" if ($git && ($file || $fix));
360die "$P: --verbose cannot be used with --terse\n" if ($verbose && $terse);
361
362if ($color =~ /^[01]$/) {
363 $color = !$color;
364} elsif ($color =~ /^always$/i) {
365 $color = 1;
366} elsif ($color =~ /^never$/i) {
367 $color = 0;
368} elsif ($color =~ /^auto$/i) {
369 $color = (-t STDOUT);
370} else {
371 die "$P: Invalid color mode: $color\n";
372}
373
374load_docs() if ($verbose);
375list_types(0) if ($list_types);
376
377$fix = 1 if ($fix_inplace);
378$check_orig = $check;
379
380my $exit = 0;
381
382my $perl_version_ok = 1;
383if ($^V && $^V lt $minimum_perl_version) {
384 $perl_version_ok = 0;
385 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
386 exit(1) if (!$ignore_perl_version);
387}
388
389#if no filenames are given, push '-' to read patch from stdin
390if ($#ARGV < 0) {
391 push(@ARGV, '-');
392}
393
394# skip TAB size 1 to avoid additional checks on $tabsize - 1
395die "$P: Invalid TAB size: $tabsize\n" if ($tabsize < 2);
396
397sub hash_save_array_words {
398 my ($hashRef, $arrayRef) = @_;
399
400 my @array = split(/,/, join(',', @$arrayRef));
401 foreach my $word (@array) {
402 $word =~ s/\s*\n?$//g;
403 $word =~ s/^\s*//g;
404 $word =~ s/\s+/ /g;
405 $word =~ tr/[a-z]/[A-Z]/;
406
407 next if ($word =~ m/^\s*#/);
408 next if ($word =~ m/^\s*$/);
409
410 $hashRef->{$word}++;
411 }
412}
413
414sub hash_show_words {
415 my ($hashRef, $prefix) = @_;
416
417 if (keys %$hashRef) {
418 print "\nNOTE: $prefix message types:";
419 foreach my $word (sort keys %$hashRef) {
420 print " $word";
421 }
422 print "\n";
423 }
424}
425
426hash_save_array_words(\%ignore_type, \@ignore);
427hash_save_array_words(\%use_type, \@use);
428
429my $dbg_values = 0;
430my $dbg_possible = 0;
431my $dbg_type = 0;
432my $dbg_attr = 0;
433for my $key (keys %debug) {
434 ## no critic
435 eval "\${dbg_$key} = '$debug{$key}';";
436 die "$@" if ($@);
437}
438
439my $rpt_cleaners = 0;
440
441if ($terse) {
442 $emacs = 1;
443 $quiet++;
444}
445
446if ($tree) {
447 if (defined $root) {
448 if (!top_of_kernel_tree($root)) {
449 die "$P: $root: --root does not point at a valid tree\n";
450 }
451 } else {
452 if (top_of_kernel_tree('.')) {
453 $root = '.';
454 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
455 top_of_kernel_tree($1)) {
456 $root = $1;
457 }
458 }
459
460 if (!defined $root) {
461 print "Must be run from the top-level dir. of a kernel tree\n";
462 exit(2);
463 }
464}
465
466my $emitted_corrupt = 0;
467
468our $Ident = qr{
469 [A-Za-z_][A-Za-z\d_]*
470 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
471 }x;
472our $Storage = qr{extern|static|asmlinkage};
473our $Sparse = qr{
474 __user|
475 __kernel|
476 __force|
477 __iomem|
478 __must_check|
479 __kprobes|
480 __ref|
481 __refconst|
482 __refdata|
483 __rcu|
484 __private
485 }x;
486our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
487our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
488our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
489our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
490our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
491
492# Notes to $Attribute:
493# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
494our $Attribute = qr{
495 const|
496 volatile|
497 __percpu|
498 __nocast|
499 __safe|
500 __bitwise|
501 __packed__|
502 __packed2__|
503 __naked|
504 __maybe_unused|
505 __always_unused|
506 __noreturn|
507 __used|
508 __cold|
509 __pure|
510 __noclone|
511 __deprecated|
512 __read_mostly|
513 __ro_after_init|
514 __kprobes|
515 $InitAttribute|
516 ____cacheline_aligned|
517 ____cacheline_aligned_in_smp|
518 ____cacheline_internodealigned_in_smp|
519 __weak|
520 __alloc_size\s*\(\s*\d+\s*(?:,\s*\d+\s*)?\)
521 }x;
522our $Modifier;
523our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
524our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
525our $Lval = qr{$Ident(?:$Member)*};
526
527our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
528our $Binary = qr{(?i)0b[01]+$Int_type?};
529our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
530our $Int = qr{[0-9]+$Int_type?};
531our $Octal = qr{0[0-7]+$Int_type?};
532our $String = qr{(?:\b[Lu])?"[X\t]*"};
533our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
534our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
535our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
536our $Float = qr{$Float_hex|$Float_dec|$Float_int};
537our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
538our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
539our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
540our $Arithmetic = qr{\+|-|\*|\/|%};
541our $Operators = qr{
542 <=|>=|==|!=|
543 =>|->|<<|>>|<|>|!|~|
544 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
545 }x;
546
547our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
548
549our $BasicType;
550our $NonptrType;
551our $NonptrTypeMisordered;
552our $NonptrTypeWithAttr;
553our $Type;
554our $TypeMisordered;
555our $Declare;
556our $DeclareMisordered;
557
558our $NON_ASCII_UTF8 = qr{
559 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
560 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
561 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
562 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
563 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
564 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
565 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
566}x;
567
568our $UTF8 = qr{
569 [\x09\x0A\x0D\x20-\x7E] # ASCII
570 | $NON_ASCII_UTF8
571}x;
572
573our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
574our $typeOtherOSTypedefs = qr{(?x:
575 u_(?:char|short|int|long) | # bsd
576 u(?:nchar|short|int|long) # sysv
577)};
578our $typeKernelTypedefs = qr{(?x:
579 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
580 atomic_t
581)};
582our $typeTypedefs = qr{(?x:
583 $typeC99Typedefs\b|
584 $typeOtherOSTypedefs\b|
585 $typeKernelTypedefs\b
586)};
587
588our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
589
590our $logFunctions = qr{(?x:
591 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
592 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
593 TP_printk|
594 WARN(?:_RATELIMIT|_ONCE|)|
595 panic|
596 debug|
597 printf|
598 MODULE_[A-Z_]+|
599 seq_vprintf|seq_printf|seq_puts
600)};
601
602our $allocFunctions = qr{(?x:
603 (?:(?:devm_)?
604 (?:kv|k|v)[czm]alloc(?:_array)?(?:_node)? |
605 kstrdup(?:_const)? |
606 kmemdup(?:_nul)?) |
607 (?:\w+)?alloc_skb(?:_ip_align)? |
608 # dev_alloc_skb/netdev_alloc_skb, et al
609 dma_alloc_coherent
610)};
611
612our $signature_tags = qr{(?xi:
613 Signed-off-by:|
614 Co-developed-by:|
615 Acked-by:|
616 Tested-by:|
617 Reviewed-by:|
618 Reported-by:|
619 Suggested-by:|
620 To:|
621 Cc:
622)};
623
624our $tracing_logging_tags = qr{(?xi:
625 [=-]*> |
626 <[=-]* |
627 \[ |
628 \] |
629 start |
630 called |
631 entered |
632 entry |
633 enter |
634 in |
635 inside |
636 here |
637 begin |
638 exit |
639 end |
640 done |
641 leave |
642 completed |
643 out |
644 return |
645 [\.\!:\s]*
646)};
647
648sub edit_distance_min {
649 my (@arr) = @_;
650 my $len = scalar @arr;
651 if ((scalar @arr) < 1) {
652 # if underflow, return
653 return;
654 }
655 my $min = $arr[0];
656 for my $i (0 .. ($len-1)) {
657 if ($arr[$i] < $min) {
658 $min = $arr[$i];
659 }
660 }
661 return $min;
662}
663
664sub get_edit_distance {
665 my ($str1, $str2) = @_;
666 $str1 = lc($str1);
667 $str2 = lc($str2);
668 $str1 =~ s/-//g;
669 $str2 =~ s/-//g;
670 my $len1 = length($str1);
671 my $len2 = length($str2);
672 # two dimensional array storing minimum edit distance
673 my @distance;
674 for my $i (0 .. $len1) {
675 for my $j (0 .. $len2) {
676 if ($i == 0) {
677 $distance[$i][$j] = $j;
678 } elsif ($j == 0) {
679 $distance[$i][$j] = $i;
680 } elsif (substr($str1, $i-1, 1) eq substr($str2, $j-1, 1)) {
681 $distance[$i][$j] = $distance[$i - 1][$j - 1];
682 } else {
683 my $dist1 = $distance[$i][$j - 1]; #insert distance
684 my $dist2 = $distance[$i - 1][$j]; # remove
685 my $dist3 = $distance[$i - 1][$j - 1]; #replace
686 $distance[$i][$j] = 1 + edit_distance_min($dist1, $dist2, $dist3);
687 }
688 }
689 }
690 return $distance[$len1][$len2];
691}
692
693sub find_standard_signature {
694 my ($sign_off) = @_;
695 my @standard_signature_tags = (
696 'Signed-off-by:', 'Co-developed-by:', 'Acked-by:', 'Tested-by:',
697 'Reviewed-by:', 'Reported-by:', 'Suggested-by:'
698 );
699 foreach my $signature (@standard_signature_tags) {
700 return $signature if (get_edit_distance($sign_off, $signature) <= 2);
701 }
702
703 return "";
704}
705
706our @typeListMisordered = (
707 qr{char\s+(?:un)?signed},
708 qr{int\s+(?:(?:un)?signed\s+)?short\s},
709 qr{int\s+short(?:\s+(?:un)?signed)},
710 qr{short\s+int(?:\s+(?:un)?signed)},
711 qr{(?:un)?signed\s+int\s+short},
712 qr{short\s+(?:un)?signed},
713 qr{long\s+int\s+(?:un)?signed},
714 qr{int\s+long\s+(?:un)?signed},
715 qr{long\s+(?:un)?signed\s+int},
716 qr{int\s+(?:un)?signed\s+long},
717 qr{int\s+(?:un)?signed},
718 qr{int\s+long\s+long\s+(?:un)?signed},
719 qr{long\s+long\s+int\s+(?:un)?signed},
720 qr{long\s+long\s+(?:un)?signed\s+int},
721 qr{long\s+long\s+(?:un)?signed},
722 qr{long\s+(?:un)?signed},
723);
724
725our @typeList = (
726 qr{void},
727 qr{(?:(?:un)?signed\s+)?char},
728 qr{(?:(?:un)?signed\s+)?short\s+int},
729 qr{(?:(?:un)?signed\s+)?short},
730 qr{(?:(?:un)?signed\s+)?int},
731 qr{(?:(?:un)?signed\s+)?long\s+int},
732 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
733 qr{(?:(?:un)?signed\s+)?long\s+long},
734 qr{(?:(?:un)?signed\s+)?long},
735 qr{(?:un)?signed},
736 qr{float},
737 qr{double},
738 qr{bool},
739 qr{struct\s+$Ident},
740 qr{union\s+$Ident},
741 qr{enum\s+$Ident},
742 qr{${Ident}_t},
743 qr{${Ident}_handler},
744 qr{${Ident}_handler_fn},
745 @typeListMisordered,
746);
747
748our $C90_int_types = qr{(?x:
749 long\s+long\s+int\s+(?:un)?signed|
750 long\s+long\s+(?:un)?signed\s+int|
751 long\s+long\s+(?:un)?signed|
752 (?:(?:un)?signed\s+)?long\s+long\s+int|
753 (?:(?:un)?signed\s+)?long\s+long|
754 int\s+long\s+long\s+(?:un)?signed|
755 int\s+(?:(?:un)?signed\s+)?long\s+long|
756
757 long\s+int\s+(?:un)?signed|
758 long\s+(?:un)?signed\s+int|
759 long\s+(?:un)?signed|
760 (?:(?:un)?signed\s+)?long\s+int|
761 (?:(?:un)?signed\s+)?long|
762 int\s+long\s+(?:un)?signed|
763 int\s+(?:(?:un)?signed\s+)?long|
764
765 int\s+(?:un)?signed|
766 (?:(?:un)?signed\s+)?int
767)};
768
769our @typeListFile = ();
770our @typeListWithAttr = (
771 @typeList,
772 qr{struct\s+$InitAttribute\s+$Ident},
773 qr{union\s+$InitAttribute\s+$Ident},
774);
775
776our @modifierList = (
777 qr{fastcall},
778);
779our @modifierListFile = ();
780
781our @mode_permission_funcs = (
782 ["module_param", 3],
783 ["module_param_(?:array|named|string)", 4],
784 ["module_param_array_named", 5],
785 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
786 ["proc_create(?:_data|)", 2],
787 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
788 ["IIO_DEV_ATTR_[A-Z_]+", 1],
789 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
790 ["SENSOR_TEMPLATE(?:_2|)", 3],
791 ["__ATTR", 2],
792);
793
794my $word_pattern = '\b[A-Z]?[a-z]{2,}\b';
795
796#Create a search pattern for all these functions to speed up a loop below
797our $mode_perms_search = "";
798foreach my $entry (@mode_permission_funcs) {
799 $mode_perms_search .= '|' if ($mode_perms_search ne "");
800 $mode_perms_search .= $entry->[0];
801}
802$mode_perms_search = "(?:${mode_perms_search})";
803
804our %deprecated_apis = (
805 "synchronize_rcu_bh" => "synchronize_rcu",
806 "synchronize_rcu_bh_expedited" => "synchronize_rcu_expedited",
807 "call_rcu_bh" => "call_rcu",
808 "rcu_barrier_bh" => "rcu_barrier",
809 "synchronize_sched" => "synchronize_rcu",
810 "synchronize_sched_expedited" => "synchronize_rcu_expedited",
811 "call_rcu_sched" => "call_rcu",
812 "rcu_barrier_sched" => "rcu_barrier",
813 "get_state_synchronize_sched" => "get_state_synchronize_rcu",
814 "cond_synchronize_sched" => "cond_synchronize_rcu",
815);
816
817#Create a search pattern for all these strings to speed up a loop below
818our $deprecated_apis_search = "";
819foreach my $entry (keys %deprecated_apis) {
820 $deprecated_apis_search .= '|' if ($deprecated_apis_search ne "");
821 $deprecated_apis_search .= $entry;
822}
823$deprecated_apis_search = "(?:${deprecated_apis_search})";
824
825our $mode_perms_world_writable = qr{
826 S_IWUGO |
827 S_IWOTH |
828 S_IRWXUGO |
829 S_IALLUGO |
830 0[0-7][0-7][2367]
831}x;
832
833our %mode_permission_string_types = (
834 "S_IRWXU" => 0700,
835 "S_IRUSR" => 0400,
836 "S_IWUSR" => 0200,
837 "S_IXUSR" => 0100,
838 "S_IRWXG" => 0070,
839 "S_IRGRP" => 0040,
840 "S_IWGRP" => 0020,
841 "S_IXGRP" => 0010,
842 "S_IRWXO" => 0007,
843 "S_IROTH" => 0004,
844 "S_IWOTH" => 0002,
845 "S_IXOTH" => 0001,
846 "S_IRWXUGO" => 0777,
847 "S_IRUGO" => 0444,
848 "S_IWUGO" => 0222,
849 "S_IXUGO" => 0111,
850);
851
852#Create a search pattern for all these strings to speed up a loop below
853our $mode_perms_string_search = "";
854foreach my $entry (keys %mode_permission_string_types) {
855 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
856 $mode_perms_string_search .= $entry;
857}
858our $single_mode_perms_string_search = "(?:${mode_perms_string_search})";
859our $multi_mode_perms_string_search = qr{
860 ${single_mode_perms_string_search}
861 (?:\s*\|\s*${single_mode_perms_string_search})*
862}x;
863
864sub perms_to_octal {
865 my ($string) = @_;
866
867 return trim($string) if ($string =~ /^\s*0[0-7]{3,3}\s*$/);
868
869 my $val = "";
870 my $oval = "";
871 my $to = 0;
872 my $curpos = 0;
873 my $lastpos = 0;
874 while ($string =~ /\b(($single_mode_perms_string_search)\b(?:\s*\|\s*)?\s*)/g) {
875 $curpos = pos($string);
876 my $match = $2;
877 my $omatch = $1;
878 last if ($lastpos > 0 && ($curpos - length($omatch) != $lastpos));
879 $lastpos = $curpos;
880 $to |= $mode_permission_string_types{$match};
881 $val .= '\s*\|\s*' if ($val ne "");
882 $val .= $match;
883 $oval .= $omatch;
884 }
885 $oval =~ s/^\s*\|\s*//;
886 $oval =~ s/\s*\|\s*$//;
887 return sprintf("%04o", $to);
888}
889
890our $allowed_asm_includes = qr{(?x:
891 irq|
892 memory|
893 time|
894 reboot
895)};
896# memory.h: ARM has a custom one
897
898# Load common spelling mistakes and build regular expression list.
899my $misspellings;
900my %spelling_fix;
901
902if (open(my $spelling, '<', $spelling_file)) {
903 while (<$spelling>) {
904 my $line = $_;
905
906 $line =~ s/\s*\n?$//g;
907 $line =~ s/^\s*//g;
908
909 next if ($line =~ m/^\s*#/);
910 next if ($line =~ m/^\s*$/);
911
912 my ($suspect, $fix) = split(/\|\|/, $line);
913
914 $spelling_fix{$suspect} = $fix;
915 }
916 close($spelling);
917} else {
918 warn "No typos will be found - file '$spelling_file': $!\n";
919}
920
921if ($codespell) {
922 if (open(my $spelling, '<', $codespellfile)) {
923 while (<$spelling>) {
924 my $line = $_;
925
926 $line =~ s/\s*\n?$//g;
927 $line =~ s/^\s*//g;
928
929 next if ($line =~ m/^\s*#/);
930 next if ($line =~ m/^\s*$/);
931 next if ($line =~ m/, disabled/i);
932
933 $line =~ s/,.*$//;
934
935 my ($suspect, $fix) = split(/->/, $line);
936
937 $spelling_fix{$suspect} = $fix;
938 }
939 close($spelling);
940 } else {
941 warn "No codespell typos will be found - file '$codespellfile': $!\n";
942 }
943}
944
945$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
946
947sub read_words {
948 my ($wordsRef, $file) = @_;
949
950 if (open(my $words, '<', $file)) {
951 while (<$words>) {
952 my $line = $_;
953
954 $line =~ s/\s*\n?$//g;
955 $line =~ s/^\s*//g;
956
957 next if ($line =~ m/^\s*#/);
958 next if ($line =~ m/^\s*$/);
959 if ($line =~ /\s/) {
960 print("$file: '$line' invalid - ignored\n");
961 next;
962 }
963
964 $$wordsRef .= '|' if (defined $$wordsRef);
965 $$wordsRef .= $line;
966 }
967 close($file);
968 return 1;
969 }
970
971 return 0;
972}
973
974my $const_structs;
975if (show_type("CONST_STRUCT")) {
976 read_words(\$const_structs, $conststructsfile)
977 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
978}
979
980if (defined($typedefsfile)) {
981 my $typeOtherTypedefs;
982 read_words(\$typeOtherTypedefs, $typedefsfile)
983 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
984 $typeTypedefs .= '|' . $typeOtherTypedefs if (defined $typeOtherTypedefs);
985}
986
987sub build_types {
988 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
989 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
990 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
991 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
992 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
993 $BasicType = qr{
994 (?:$typeTypedefs\b)|
995 (?:${all}\b)
996 }x;
997 $NonptrType = qr{
998 (?:$Modifier\s+|const\s+)*
999 (?:
1000 (?:typeof|__typeof__)\s*\([^\)]*\)|
1001 (?:$typeTypedefs\b)|
1002 (?:${all}\b)
1003 )
1004 (?:\s+$Modifier|\s+const)*
1005 }x;
1006 $NonptrTypeMisordered = qr{
1007 (?:$Modifier\s+|const\s+)*
1008 (?:
1009 (?:${Misordered}\b)
1010 )
1011 (?:\s+$Modifier|\s+const)*
1012 }x;
1013 $NonptrTypeWithAttr = qr{
1014 (?:$Modifier\s+|const\s+)*
1015 (?:
1016 (?:typeof|__typeof__)\s*\([^\)]*\)|
1017 (?:$typeTypedefs\b)|
1018 (?:${allWithAttr}\b)
1019 )
1020 (?:\s+$Modifier|\s+const)*
1021 }x;
1022 $Type = qr{
1023 $NonptrType
1024 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
1025 (?:\s+$Inline|\s+$Modifier)*
1026 }x;
1027 $TypeMisordered = qr{
1028 $NonptrTypeMisordered
1029 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+){0,4}
1030 (?:\s+$Inline|\s+$Modifier)*
1031 }x;
1032 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
1033 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
1034}
1035build_types();
1036
1037our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
1038
1039# Using $balanced_parens, $LvalOrFunc, or $FuncArg
1040# requires at least perl version v5.10.0
1041# Any use must be runtime checked with $^V
1042
1043our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
1044our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
1045our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
1046
1047our $declaration_macros = qr{(?x:
1048 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
1049 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
1050 (?:SKCIPHER_REQUEST|SHASH_DESC|AHASH_REQUEST)_ON_STACK\s*\(
1051)};
1052
1053our %allow_repeated_words = (
1054 add => '',
1055 added => '',
1056 bad => '',
1057 be => '',
1058);
1059
1060sub deparenthesize {
1061 my ($string) = @_;
1062 return "" if (!defined($string));
1063
1064 while ($string =~ /^\s*\(.*\)\s*$/) {
1065 $string =~ s@^\s*\(\s*@@;
1066 $string =~ s@\s*\)\s*$@@;
1067 }
1068
1069 $string =~ s@\s+@ @g;
1070
1071 return $string;
1072}
1073
1074sub seed_camelcase_file {
1075 my ($file) = @_;
1076
1077 return if (!(-f $file));
1078
1079 local $/;
1080
1081 open(my $include_file, '<', "$file")
1082 or warn "$P: Can't read '$file' $!\n";
1083 my $text = <$include_file>;
1084 close($include_file);
1085
1086 my @lines = split('\n', $text);
1087
1088 foreach my $line (@lines) {
1089 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
1090 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
1091 $camelcase{$1} = 1;
1092 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
1093 $camelcase{$1} = 1;
1094 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
1095 $camelcase{$1} = 1;
1096 }
1097 }
1098}
1099
1100our %maintained_status = ();
1101
1102sub is_maintained_obsolete {
1103 my ($filename) = @_;
1104
1105 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
1106
1107 if (!exists($maintained_status{$filename})) {
1108 $maintained_status{$filename} = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
1109 }
1110
1111 return $maintained_status{$filename} =~ /obsolete/i;
1112}
1113
1114sub is_SPDX_License_valid {
1115 my ($license) = @_;
1116
1117 return 1 if (!$tree || which("python3") eq "" || !(-x "$root/scripts/spdxcheck.py") || !(-e "$gitroot"));
1118
1119 my $root_path = abs_path($root);
1120 my $status = `cd "$root_path"; echo "$license" | scripts/spdxcheck.py -`;
1121 return 0 if ($status ne "");
1122 return 1;
1123}
1124
1125my $camelcase_seeded = 0;
1126sub seed_camelcase_includes {
1127 return if ($camelcase_seeded);
1128
1129 my $files;
1130 my $camelcase_cache = "";
1131 my @include_files = ();
1132
1133 $camelcase_seeded = 1;
1134
1135 if (-e "$gitroot") {
1136 my $git_last_include_commit = `${git_command} log --no-merges --pretty=format:"%h%n" -1 -- include`;
1137 chomp $git_last_include_commit;
1138 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
1139 } else {
1140 my $last_mod_date = 0;
1141 $files = `find $root/include -name "*.h"`;
1142 @include_files = split('\n', $files);
1143 foreach my $file (@include_files) {
1144 my $date = POSIX::strftime("%Y%m%d%H%M",
1145 localtime((stat $file)[9]));
1146 $last_mod_date = $date if ($last_mod_date < $date);
1147 }
1148 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
1149 }
1150
1151 if ($camelcase_cache ne "" && -f $camelcase_cache) {
1152 open(my $camelcase_file, '<', "$camelcase_cache")
1153 or warn "$P: Can't read '$camelcase_cache' $!\n";
1154 while (<$camelcase_file>) {
1155 chomp;
1156 $camelcase{$_} = 1;
1157 }
1158 close($camelcase_file);
1159
1160 return;
1161 }
1162
1163 if (-e "$gitroot") {
1164 $files = `${git_command} ls-files "include/*.h"`;
1165 @include_files = split('\n', $files);
1166 }
1167
1168 foreach my $file (@include_files) {
1169 seed_camelcase_file($file);
1170 }
1171
1172 if ($camelcase_cache ne "") {
1173 unlink glob ".checkpatch-camelcase.*";
1174 open(my $camelcase_file, '>', "$camelcase_cache")
1175 or warn "$P: Can't write '$camelcase_cache' $!\n";
1176 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
1177 print $camelcase_file ("$_\n");
1178 }
1179 close($camelcase_file);
1180 }
1181}
1182
1183sub git_is_single_file {
1184 my ($filename) = @_;
1185
1186 return 0 if ((which("git") eq "") || !(-e "$gitroot"));
1187
1188 my $output = `${git_command} ls-files -- $filename 2>/dev/null`;
1189 my $count = $output =~ tr/\n//;
1190 return $count eq 1 && $output =~ m{^${filename}$};
1191}
1192
1193sub git_commit_info {
1194 my ($commit, $id, $desc) = @_;
1195
1196 return ($id, $desc) if ((which("git") eq "") || !(-e "$gitroot"));
1197
1198 my $output = `${git_command} log --no-color --format='%H %s' -1 $commit 2>&1`;
1199 $output =~ s/^\s*//gm;
1200 my @lines = split("\n", $output);
1201
1202 return ($id, $desc) if ($#lines < 0);
1203
1204 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous/) {
1205# Maybe one day convert this block of bash into something that returns
1206# all matching commit ids, but it's very slow...
1207#
1208# echo "checking commits $1..."
1209# git rev-list --remotes | grep -i "^$1" |
1210# while read line ; do
1211# git log --format='%H %s' -1 $line |
1212# echo "commit $(cut -c 1-12,41-)"
1213# done
1214 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./ ||
1215 $lines[0] =~ /^fatal: bad object $commit/) {
1216 $id = undef;
1217 } else {
1218 $id = substr($lines[0], 0, 12);
1219 $desc = substr($lines[0], 41);
1220 }
1221
1222 return ($id, $desc);
1223}
1224
1225$chk_signoff = 0 if ($file);
1226
1227my @rawlines = ();
1228my @lines = ();
1229my @fixed = ();
1230my @fixed_inserted = ();
1231my @fixed_deleted = ();
1232my $fixlinenr = -1;
1233
1234# If input is git commits, extract all commits from the commit expressions.
1235# For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
1236die "$P: No git repository found\n" if ($git && !-e "$gitroot");
1237
1238if ($git) {
1239 my @commits = ();
1240 foreach my $commit_expr (@ARGV) {
1241 my $git_range;
1242 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
1243 $git_range = "-$2 $1";
1244 } elsif ($commit_expr =~ m/\.\./) {
1245 $git_range = "$commit_expr";
1246 } else {
1247 $git_range = "-1 $commit_expr";
1248 }
1249 my $lines = `${git_command} log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
1250 foreach my $line (split(/\n/, $lines)) {
1251 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
1252 next if (!defined($1) || !defined($2));
1253 my $sha1 = $1;
1254 my $subject = $2;
1255 unshift(@commits, $sha1);
1256 $git_commits{$sha1} = $subject;
1257 }
1258 }
1259 die "$P: no git commits after extraction!\n" if (@commits == 0);
1260 @ARGV = @commits;
1261}
1262
1263my $vname;
1264$allow_c99_comments = !defined $ignore_type{"C99_COMMENT_TOLERANCE"};
1265for my $filename (@ARGV) {
1266 my $FILE;
1267 my $is_git_file = git_is_single_file($filename);
1268 my $oldfile = $file;
1269 $file = 1 if ($is_git_file);
1270 if ($git) {
1271 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
1272 die "$P: $filename: git format-patch failed - $!\n";
1273 } elsif ($file) {
1274 open($FILE, '-|', "diff -u /dev/null $filename") ||
1275 die "$P: $filename: diff failed - $!\n";
1276 } elsif ($filename eq '-') {
1277 open($FILE, '<&STDIN');
1278 } else {
1279 open($FILE, '<', "$filename") ||
1280 die "$P: $filename: open failed - $!\n";
1281 }
1282 if ($filename eq '-') {
1283 $vname = 'Your patch';
1284 } elsif ($git) {
1285 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
1286 } else {
1287 $vname = $filename;
1288 }
1289 while (<$FILE>) {
1290 chomp;
1291 push(@rawlines, $_);
1292 $vname = qq("$1") if ($filename eq '-' && $_ =~ m/^Subject:\s+(.+)/i);
1293 }
1294 close($FILE);
1295
1296 if ($#ARGV > 0 && $quiet == 0) {
1297 print '-' x length($vname) . "\n";
1298 print "$vname\n";
1299 print '-' x length($vname) . "\n";
1300 }
1301
1302 if (!process($filename)) {
1303 $exit = 1;
1304 }
1305 @rawlines = ();
1306 @lines = ();
1307 @fixed = ();
1308 @fixed_inserted = ();
1309 @fixed_deleted = ();
1310 $fixlinenr = -1;
1311 @modifierListFile = ();
1312 @typeListFile = ();
1313 build_types();
1314 $file = $oldfile if ($is_git_file);
1315}
1316
1317if (!$quiet) {
1318 hash_show_words(\%use_type, "Used");
1319 hash_show_words(\%ignore_type, "Ignored");
1320
1321 if (!$perl_version_ok) {
1322 print << "EOM"
1323
1324NOTE: perl $^V is not modern enough to detect all possible issues.
1325 An upgrade to at least perl $minimum_perl_version is suggested.
1326EOM
1327 }
1328 if ($exit) {
1329 print << "EOM"
1330
1331NOTE: If any of the errors are false positives, please report
1332 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1333EOM
1334 }
1335}
1336
1337exit($exit);
1338
1339sub top_of_kernel_tree {
1340 my ($root) = @_;
1341
1342 my @tree_check = (
1343 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1344 "README", "Documentation", "arch", "include", "drivers",
1345 "fs", "init", "ipc", "kernel", "lib", "scripts",
1346 );
1347
1348 foreach my $check (@tree_check) {
1349 if (! -e $root . '/' . $check) {
1350 return 0;
1351 }
1352 }
1353 return 1;
1354}
1355
1356sub parse_email {
1357 my ($formatted_email) = @_;
1358
1359 my $name = "";
1360 my $quoted = "";
1361 my $name_comment = "";
1362 my $address = "";
1363 my $comment = "";
1364
1365 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1366 $name = $1;
1367 $address = $2;
1368 $comment = $3 if defined $3;
1369 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1370 $address = $1;
1371 $comment = $2 if defined $2;
1372 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1373 $address = $1;
1374 $comment = $2 if defined $2;
1375 $formatted_email =~ s/\Q$address\E.*$//;
1376 $name = $formatted_email;
1377 $name = trim($name);
1378 $name =~ s/^\"|\"$//g;
1379 # If there's a name left after stripping spaces and
1380 # leading quotes, and the address doesn't have both
1381 # leading and trailing angle brackets, the address
1382 # is invalid. ie:
1383 # "joe smith joe@smith.com" bad
1384 # "joe smith <joe@smith.com" bad
1385 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1386 $name = "";
1387 $address = "";
1388 $comment = "";
1389 }
1390 }
1391
1392 # Extract comments from names excluding quoted parts
1393 # "John D. (Doe)" - Do not extract
1394 if ($name =~ s/\"(.+)\"//) {
1395 $quoted = $1;
1396 }
1397 while ($name =~ s/\s*($balanced_parens)\s*/ /) {
1398 $name_comment .= trim($1);
1399 }
1400 $name =~ s/^[ \"]+|[ \"]+$//g;
1401 $name = trim("$quoted $name");
1402
1403 $address = trim($address);
1404 $address =~ s/^\<|\>$//g;
1405 $comment = trim($comment);
1406
1407 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1408 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1409 $name = "\"$name\"";
1410 }
1411
1412 return ($name, $name_comment, $address, $comment);
1413}
1414
1415sub format_email {
1416 my ($name, $name_comment, $address, $comment) = @_;
1417
1418 my $formatted_email;
1419
1420 $name =~ s/^[ \"]+|[ \"]+$//g;
1421 $address = trim($address);
1422 $address =~ s/(?:\.|\,|\")+$//; ##trailing commas, dots or quotes
1423
1424 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1425 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1426 $name = "\"$name\"";
1427 }
1428
1429 $name_comment = trim($name_comment);
1430 $name_comment = " $name_comment" if ($name_comment ne "");
1431 $comment = trim($comment);
1432 $comment = " $comment" if ($comment ne "");
1433
1434 if ("$name" eq "") {
1435 $formatted_email = "$address";
1436 } else {
1437 $formatted_email = "$name$name_comment <$address>";
1438 }
1439 $formatted_email .= "$comment";
1440 return $formatted_email;
1441}
1442
1443sub reformat_email {
1444 my ($email) = @_;
1445
1446 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
1447 return format_email($email_name, $name_comment, $email_address, $comment);
1448}
1449
1450sub same_email_addresses {
1451 my ($email1, $email2) = @_;
1452
1453 my ($email1_name, $name1_comment, $email1_address, $comment1) = parse_email($email1);
1454 my ($email2_name, $name2_comment, $email2_address, $comment2) = parse_email($email2);
1455
1456 return $email1_name eq $email2_name &&
1457 $email1_address eq $email2_address &&
1458 $name1_comment eq $name2_comment &&
1459 $comment1 eq $comment2;
1460}
1461
1462sub which {
1463 my ($bin) = @_;
1464
1465 foreach my $path (split(/:/, $ENV{PATH})) {
1466 if (-e "$path/$bin") {
1467 return "$path/$bin";
1468 }
1469 }
1470
1471 return "";
1472}
1473
1474sub which_conf {
1475 my ($conf) = @_;
1476
1477 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1478 if (-e "$path/$conf") {
1479 return "$path/$conf";
1480 }
1481 }
1482
1483 return "";
1484}
1485
1486sub expand_tabs {
1487 my ($str) = @_;
1488
1489 my $res = '';
1490 my $n = 0;
1491 for my $c (split(//, $str)) {
1492 if ($c eq "\t") {
1493 $res .= ' ';
1494 $n++;
1495 for (; ($n % $tabsize) != 0; $n++) {
1496 $res .= ' ';
1497 }
1498 next;
1499 }
1500 $res .= $c;
1501 $n++;
1502 }
1503
1504 return $res;
1505}
1506sub copy_spacing {
1507 (my $res = shift) =~ tr/\t/ /c;
1508 return $res;
1509}
1510
1511sub line_stats {
1512 my ($line) = @_;
1513
1514 # Drop the diff line leader and expand tabs
1515 $line =~ s/^.//;
1516 $line = expand_tabs($line);
1517
1518 # Pick the indent from the front of the line.
1519 my ($white) = ($line =~ /^(\s*)/);
1520
1521 return (length($line), length($white));
1522}
1523
1524my $sanitise_quote = '';
1525
1526sub sanitise_line_reset {
1527 my ($in_comment) = @_;
1528
1529 if ($in_comment) {
1530 $sanitise_quote = '*/';
1531 } else {
1532 $sanitise_quote = '';
1533 }
1534}
1535sub sanitise_line {
1536 my ($line) = @_;
1537
1538 my $res = '';
1539 my $l = '';
1540
1541 my $qlen = 0;
1542 my $off = 0;
1543 my $c;
1544
1545 # Always copy over the diff marker.
1546 $res = substr($line, 0, 1);
1547
1548 for ($off = 1; $off < length($line); $off++) {
1549 $c = substr($line, $off, 1);
1550
1551 # Comments we are whacking completely including the begin
1552 # and end, all to $;.
1553 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1554 $sanitise_quote = '*/';
1555
1556 substr($res, $off, 2, "$;$;");
1557 $off++;
1558 next;
1559 }
1560 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1561 $sanitise_quote = '';
1562 substr($res, $off, 2, "$;$;");
1563 $off++;
1564 next;
1565 }
1566 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1567 $sanitise_quote = '//';
1568
1569 substr($res, $off, 2, $sanitise_quote);
1570 $off++;
1571 next;
1572 }
1573
1574 # A \ in a string means ignore the next character.
1575 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1576 $c eq "\\") {
1577 substr($res, $off, 2, 'XX');
1578 $off++;
1579 next;
1580 }
1581 # Regular quotes.
1582 if ($c eq "'" || $c eq '"') {
1583 if ($sanitise_quote eq '') {
1584 $sanitise_quote = $c;
1585
1586 substr($res, $off, 1, $c);
1587 next;
1588 } elsif ($sanitise_quote eq $c) {
1589 $sanitise_quote = '';
1590 }
1591 }
1592
1593 #print "c<$c> SQ<$sanitise_quote>\n";
1594 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1595 substr($res, $off, 1, $;);
1596 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1597 substr($res, $off, 1, $;);
1598 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1599 substr($res, $off, 1, 'X');
1600 } else {
1601 substr($res, $off, 1, $c);
1602 }
1603 }
1604
1605 if ($sanitise_quote eq '//') {
1606 $sanitise_quote = '';
1607 }
1608
1609 # The pathname on a #include may be surrounded by '<' and '>'.
1610 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1611 my $clean = 'X' x length($1);
1612 $res =~ s@\<.*\>@<$clean>@;
1613
1614 # The whole of a #error is a string.
1615 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1616 my $clean = 'X' x length($1);
1617 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1618 }
1619
1620 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1621 my $match = $1;
1622 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1623 }
1624
1625 return $res;
1626}
1627
1628sub get_quoted_string {
1629 my ($line, $rawline) = @_;
1630
1631 return "" if (!defined($line) || !defined($rawline));
1632 return "" if ($line !~ m/($String)/g);
1633 return substr($rawline, $-[0], $+[0] - $-[0]);
1634}
1635
1636sub ctx_statement_block {
1637 my ($linenr, $remain, $off) = @_;
1638 my $line = $linenr - 1;
1639 my $blk = '';
1640 my $soff = $off;
1641 my $coff = $off - 1;
1642 my $coff_set = 0;
1643
1644 my $loff = 0;
1645
1646 my $type = '';
1647 my $level = 0;
1648 my @stack = ();
1649 my $p;
1650 my $c;
1651 my $len = 0;
1652
1653 my $remainder;
1654 while (1) {
1655 @stack = (['', 0]) if ($#stack == -1);
1656
1657 #warn "CSB: blk<$blk> remain<$remain>\n";
1658 # If we are about to drop off the end, pull in more
1659 # context.
1660 if ($off >= $len) {
1661 for (; $remain > 0; $line++) {
1662 last if (!defined $lines[$line]);
1663 next if ($lines[$line] =~ /^-/);
1664 $remain--;
1665 $loff = $len;
1666 $blk .= $lines[$line] . "\n";
1667 $len = length($blk);
1668 $line++;
1669 last;
1670 }
1671 # Bail if there is no further context.
1672 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1673 if ($off >= $len) {
1674 last;
1675 }
1676 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1677 $level++;
1678 $type = '#';
1679 }
1680 }
1681 $p = $c;
1682 $c = substr($blk, $off, 1);
1683 $remainder = substr($blk, $off);
1684
1685 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1686
1687 # Handle nested #if/#else.
1688 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1689 push(@stack, [ $type, $level ]);
1690 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1691 ($type, $level) = @{$stack[$#stack - 1]};
1692 } elsif ($remainder =~ /^#\s*endif\b/) {
1693 ($type, $level) = @{pop(@stack)};
1694 }
1695
1696 # Statement ends at the ';' or a close '}' at the
1697 # outermost level.
1698 if ($level == 0 && $c eq ';') {
1699 last;
1700 }
1701
1702 # An else is really a conditional as long as its not else if
1703 if ($level == 0 && $coff_set == 0 &&
1704 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1705 $remainder =~ /^(else)(?:\s|{)/ &&
1706 $remainder !~ /^else\s+if\b/) {
1707 $coff = $off + length($1) - 1;
1708 $coff_set = 1;
1709 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1710 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1711 }
1712
1713 if (($type eq '' || $type eq '(') && $c eq '(') {
1714 $level++;
1715 $type = '(';
1716 }
1717 if ($type eq '(' && $c eq ')') {
1718 $level--;
1719 $type = ($level != 0)? '(' : '';
1720
1721 if ($level == 0 && $coff < $soff) {
1722 $coff = $off;
1723 $coff_set = 1;
1724 #warn "CSB: mark coff<$coff>\n";
1725 }
1726 }
1727 if (($type eq '' || $type eq '{') && $c eq '{') {
1728 $level++;
1729 $type = '{';
1730 }
1731 if ($type eq '{' && $c eq '}') {
1732 $level--;
1733 $type = ($level != 0)? '{' : '';
1734
1735 if ($level == 0) {
1736 if (substr($blk, $off + 1, 1) eq ';') {
1737 $off++;
1738 }
1739 last;
1740 }
1741 }
1742 # Preprocessor commands end at the newline unless escaped.
1743 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1744 $level--;
1745 $type = '';
1746 $off++;
1747 last;
1748 }
1749 $off++;
1750 }
1751 # We are truly at the end, so shuffle to the next line.
1752 if ($off == $len) {
1753 $loff = $len + 1;
1754 $line++;
1755 $remain--;
1756 }
1757
1758 my $statement = substr($blk, $soff, $off - $soff + 1);
1759 my $condition = substr($blk, $soff, $coff - $soff + 1);
1760
1761 #warn "STATEMENT<$statement>\n";
1762 #warn "CONDITION<$condition>\n";
1763
1764 #print "coff<$coff> soff<$off> loff<$loff>\n";
1765
1766 return ($statement, $condition,
1767 $line, $remain + 1, $off - $loff + 1, $level);
1768}
1769
1770sub statement_lines {
1771 my ($stmt) = @_;
1772
1773 # Strip the diff line prefixes and rip blank lines at start and end.
1774 $stmt =~ s/(^|\n)./$1/g;
1775 $stmt =~ s/^\s*//;
1776 $stmt =~ s/\s*$//;
1777
1778 my @stmt_lines = ($stmt =~ /\n/g);
1779
1780 return $#stmt_lines + 2;
1781}
1782
1783sub statement_rawlines {
1784 my ($stmt) = @_;
1785
1786 my @stmt_lines = ($stmt =~ /\n/g);
1787
1788 return $#stmt_lines + 2;
1789}
1790
1791sub statement_block_size {
1792 my ($stmt) = @_;
1793
1794 $stmt =~ s/(^|\n)./$1/g;
1795 $stmt =~ s/^\s*{//;
1796 $stmt =~ s/}\s*$//;
1797 $stmt =~ s/^\s*//;
1798 $stmt =~ s/\s*$//;
1799
1800 my @stmt_lines = ($stmt =~ /\n/g);
1801 my @stmt_statements = ($stmt =~ /;/g);
1802
1803 my $stmt_lines = $#stmt_lines + 2;
1804 my $stmt_statements = $#stmt_statements + 1;
1805
1806 if ($stmt_lines > $stmt_statements) {
1807 return $stmt_lines;
1808 } else {
1809 return $stmt_statements;
1810 }
1811}
1812
1813sub ctx_statement_full {
1814 my ($linenr, $remain, $off) = @_;
1815 my ($statement, $condition, $level);
1816
1817 my (@chunks);
1818
1819 # Grab the first conditional/block pair.
1820 ($statement, $condition, $linenr, $remain, $off, $level) =
1821 ctx_statement_block($linenr, $remain, $off);
1822 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1823 push(@chunks, [ $condition, $statement ]);
1824 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1825 return ($level, $linenr, @chunks);
1826 }
1827
1828 # Pull in the following conditional/block pairs and see if they
1829 # could continue the statement.
1830 for (;;) {
1831 ($statement, $condition, $linenr, $remain, $off, $level) =
1832 ctx_statement_block($linenr, $remain, $off);
1833 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1834 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1835 #print "C: push\n";
1836 push(@chunks, [ $condition, $statement ]);
1837 }
1838
1839 return ($level, $linenr, @chunks);
1840}
1841
1842sub ctx_block_get {
1843 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1844 my $line;
1845 my $start = $linenr - 1;
1846 my $blk = '';
1847 my @o;
1848 my @c;
1849 my @res = ();
1850
1851 my $level = 0;
1852 my @stack = ($level);
1853 for ($line = $start; $remain > 0; $line++) {
1854 next if ($rawlines[$line] =~ /^-/);
1855 $remain--;
1856
1857 $blk .= $rawlines[$line];
1858
1859 # Handle nested #if/#else.
1860 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1861 push(@stack, $level);
1862 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1863 $level = $stack[$#stack - 1];
1864 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1865 $level = pop(@stack);
1866 }
1867
1868 foreach my $c (split(//, $lines[$line])) {
1869 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1870 if ($off > 0) {
1871 $off--;
1872 next;
1873 }
1874
1875 if ($c eq $close && $level > 0) {
1876 $level--;
1877 last if ($level == 0);
1878 } elsif ($c eq $open) {
1879 $level++;
1880 }
1881 }
1882
1883 if (!$outer || $level <= 1) {
1884 push(@res, $rawlines[$line]);
1885 }
1886
1887 last if ($level == 0);
1888 }
1889
1890 return ($level, @res);
1891}
1892sub ctx_block_outer {
1893 my ($linenr, $remain) = @_;
1894
1895 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1896 return @r;
1897}
1898sub ctx_block {
1899 my ($linenr, $remain) = @_;
1900
1901 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1902 return @r;
1903}
1904sub ctx_statement {
1905 my ($linenr, $remain, $off) = @_;
1906
1907 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1908 return @r;
1909}
1910sub ctx_block_level {
1911 my ($linenr, $remain) = @_;
1912
1913 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1914}
1915sub ctx_statement_level {
1916 my ($linenr, $remain, $off) = @_;
1917
1918 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1919}
1920
1921sub ctx_locate_comment {
1922 my ($first_line, $end_line) = @_;
1923
1924 # If c99 comment on the current line, or the line before or after
1925 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@^\+.*(//.*$)@);
1926 return $current_comment if (defined $current_comment);
1927 ($current_comment) = ($rawlines[$end_line - 2] =~ m@^[\+ ].*(//.*$)@);
1928 return $current_comment if (defined $current_comment);
1929 ($current_comment) = ($rawlines[$end_line] =~ m@^[\+ ].*(//.*$)@);
1930 return $current_comment if (defined $current_comment);
1931
1932 # Catch a comment on the end of the line itself.
1933 ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1934 return $current_comment if (defined $current_comment);
1935
1936 # Look through the context and try and figure out if there is a
1937 # comment.
1938 my $in_comment = 0;
1939 $current_comment = '';
1940 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1941 my $line = $rawlines[$linenr - 1];
1942 #warn " $line\n";
1943 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1944 $in_comment = 1;
1945 }
1946 if ($line =~ m@/\*@) {
1947 $in_comment = 1;
1948 }
1949 if (!$in_comment && $current_comment ne '') {
1950 $current_comment = '';
1951 }
1952 $current_comment .= $line . "\n" if ($in_comment);
1953 if ($line =~ m@\*/@) {
1954 $in_comment = 0;
1955 }
1956 }
1957
1958 chomp($current_comment);
1959 return($current_comment);
1960}
1961sub ctx_has_comment {
1962 my ($first_line, $end_line) = @_;
1963 my $cmt = ctx_locate_comment($first_line, $end_line);
1964
1965 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1966 ##print "CMMT: $cmt\n";
1967
1968 return ($cmt ne '');
1969}
1970
1971sub raw_line {
1972 my ($linenr, $cnt) = @_;
1973
1974 my $offset = $linenr - 1;
1975 $cnt++;
1976
1977 my $line;
1978 while ($cnt) {
1979 $line = $rawlines[$offset++];
1980 next if (defined($line) && $line =~ /^-/);
1981 $cnt--;
1982 }
1983
1984 return $line;
1985}
1986
1987sub get_stat_real {
1988 my ($linenr, $lc) = @_;
1989
1990 my $stat_real = raw_line($linenr, 0);
1991 for (my $count = $linenr + 1; $count <= $lc; $count++) {
1992 $stat_real = $stat_real . "\n" . raw_line($count, 0);
1993 }
1994
1995 return $stat_real;
1996}
1997
1998sub get_stat_here {
1999 my ($linenr, $cnt, $here) = @_;
2000
2001 my $herectx = $here . "\n";
2002 for (my $n = 0; $n < $cnt; $n++) {
2003 $herectx .= raw_line($linenr, $n) . "\n";
2004 }
2005
2006 return $herectx;
2007}
2008
2009sub cat_vet {
2010 my ($vet) = @_;
2011 my ($res, $coded);
2012
2013 $res = '';
2014 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
2015 $res .= $1;
2016 if ($2 ne '') {
2017 $coded = sprintf("^%c", unpack('C', $2) + 64);
2018 $res .= $coded;
2019 }
2020 }
2021 $res =~ s/$/\$/;
2022
2023 return $res;
2024}
2025
2026my $av_preprocessor = 0;
2027my $av_pending;
2028my @av_paren_type;
2029my $av_pend_colon;
2030
2031sub annotate_reset {
2032 $av_preprocessor = 0;
2033 $av_pending = '_';
2034 @av_paren_type = ('E');
2035 $av_pend_colon = 'O';
2036}
2037
2038sub annotate_values {
2039 my ($stream, $type) = @_;
2040
2041 my $res;
2042 my $var = '_' x length($stream);
2043 my $cur = $stream;
2044
2045 print "$stream\n" if ($dbg_values > 1);
2046
2047 while (length($cur)) {
2048 @av_paren_type = ('E') if ($#av_paren_type < 0);
2049 print " <" . join('', @av_paren_type) .
2050 "> <$type> <$av_pending>" if ($dbg_values > 1);
2051 if ($cur =~ /^(\s+)/o) {
2052 print "WS($1)\n" if ($dbg_values > 1);
2053 if ($1 =~ /\n/ && $av_preprocessor) {
2054 $type = pop(@av_paren_type);
2055 $av_preprocessor = 0;
2056 }
2057
2058 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
2059 print "CAST($1)\n" if ($dbg_values > 1);
2060 push(@av_paren_type, $type);
2061 $type = 'c';
2062
2063 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
2064 print "DECLARE($1)\n" if ($dbg_values > 1);
2065 $type = 'T';
2066
2067 } elsif ($cur =~ /^($Modifier)\s*/) {
2068 print "MODIFIER($1)\n" if ($dbg_values > 1);
2069 $type = 'T';
2070
2071 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
2072 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
2073 $av_preprocessor = 1;
2074 push(@av_paren_type, $type);
2075 if ($2 ne '') {
2076 $av_pending = 'N';
2077 }
2078 $type = 'E';
2079
2080 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
2081 print "UNDEF($1)\n" if ($dbg_values > 1);
2082 $av_preprocessor = 1;
2083 push(@av_paren_type, $type);
2084
2085 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
2086 print "PRE_START($1)\n" if ($dbg_values > 1);
2087 $av_preprocessor = 1;
2088
2089 push(@av_paren_type, $type);
2090 push(@av_paren_type, $type);
2091 $type = 'E';
2092
2093 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
2094 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
2095 $av_preprocessor = 1;
2096
2097 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
2098
2099 $type = 'E';
2100
2101 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
2102 print "PRE_END($1)\n" if ($dbg_values > 1);
2103
2104 $av_preprocessor = 1;
2105
2106 # Assume all arms of the conditional end as this
2107 # one does, and continue as if the #endif was not here.
2108 pop(@av_paren_type);
2109 push(@av_paren_type, $type);
2110 $type = 'E';
2111
2112 } elsif ($cur =~ /^(\\\n)/o) {
2113 print "PRECONT($1)\n" if ($dbg_values > 1);
2114
2115 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
2116 print "ATTR($1)\n" if ($dbg_values > 1);
2117 $av_pending = $type;
2118 $type = 'N';
2119
2120 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
2121 print "SIZEOF($1)\n" if ($dbg_values > 1);
2122 if (defined $2) {
2123 $av_pending = 'V';
2124 }
2125 $type = 'N';
2126
2127 } elsif ($cur =~ /^(if|while|for)\b/o) {
2128 print "COND($1)\n" if ($dbg_values > 1);
2129 $av_pending = 'E';
2130 $type = 'N';
2131
2132 } elsif ($cur =~/^(case)/o) {
2133 print "CASE($1)\n" if ($dbg_values > 1);
2134 $av_pend_colon = 'C';
2135 $type = 'N';
2136
2137 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
2138 print "KEYWORD($1)\n" if ($dbg_values > 1);
2139 $type = 'N';
2140
2141 } elsif ($cur =~ /^(\()/o) {
2142 print "PAREN('$1')\n" if ($dbg_values > 1);
2143 push(@av_paren_type, $av_pending);
2144 $av_pending = '_';
2145 $type = 'N';
2146
2147 } elsif ($cur =~ /^(\))/o) {
2148 my $new_type = pop(@av_paren_type);
2149 if ($new_type ne '_') {
2150 $type = $new_type;
2151 print "PAREN('$1') -> $type\n"
2152 if ($dbg_values > 1);
2153 } else {
2154 print "PAREN('$1')\n" if ($dbg_values > 1);
2155 }
2156
2157 } elsif ($cur =~ /^($Ident)\s*\(/o) {
2158 print "FUNC($1)\n" if ($dbg_values > 1);
2159 $type = 'V';
2160 $av_pending = 'V';
2161
2162 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
2163 if (defined $2 && $type eq 'C' || $type eq 'T') {
2164 $av_pend_colon = 'B';
2165 } elsif ($type eq 'E') {
2166 $av_pend_colon = 'L';
2167 }
2168 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
2169 $type = 'V';
2170
2171 } elsif ($cur =~ /^($Ident|$Constant)/o) {
2172 print "IDENT($1)\n" if ($dbg_values > 1);
2173 $type = 'V';
2174
2175 } elsif ($cur =~ /^($Assignment)/o) {
2176 print "ASSIGN($1)\n" if ($dbg_values > 1);
2177 $type = 'N';
2178
2179 } elsif ($cur =~/^(;|{|})/) {
2180 print "END($1)\n" if ($dbg_values > 1);
2181 $type = 'E';
2182 $av_pend_colon = 'O';
2183
2184 } elsif ($cur =~/^(,)/) {
2185 print "COMMA($1)\n" if ($dbg_values > 1);
2186 $type = 'C';
2187
2188 } elsif ($cur =~ /^(\?)/o) {
2189 print "QUESTION($1)\n" if ($dbg_values > 1);
2190 $type = 'N';
2191
2192 } elsif ($cur =~ /^(:)/o) {
2193 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
2194
2195 substr($var, length($res), 1, $av_pend_colon);
2196 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
2197 $type = 'E';
2198 } else {
2199 $type = 'N';
2200 }
2201 $av_pend_colon = 'O';
2202
2203 } elsif ($cur =~ /^(\[)/o) {
2204 print "CLOSE($1)\n" if ($dbg_values > 1);
2205 $type = 'N';
2206
2207 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
2208 my $variant;
2209
2210 print "OPV($1)\n" if ($dbg_values > 1);
2211 if ($type eq 'V') {
2212 $variant = 'B';
2213 } else {
2214 $variant = 'U';
2215 }
2216
2217 substr($var, length($res), 1, $variant);
2218 $type = 'N';
2219
2220 } elsif ($cur =~ /^($Operators)/o) {
2221 print "OP($1)\n" if ($dbg_values > 1);
2222 if ($1 ne '++' && $1 ne '--') {
2223 $type = 'N';
2224 }
2225
2226 } elsif ($cur =~ /(^.)/o) {
2227 print "C($1)\n" if ($dbg_values > 1);
2228 }
2229 if (defined $1) {
2230 $cur = substr($cur, length($1));
2231 $res .= $type x length($1);
2232 }
2233 }
2234
2235 return ($res, $var);
2236}
2237
2238sub possible {
2239 my ($possible, $line) = @_;
2240 my $notPermitted = qr{(?:
2241 ^(?:
2242 $Modifier|
2243 $Storage|
2244 $Type|
2245 DEFINE_\S+
2246 )$|
2247 ^(?:
2248 goto|
2249 return|
2250 case|
2251 else|
2252 asm|__asm__|
2253 do|
2254 \#|
2255 \#\#|
2256 )(?:\s|$)|
2257 ^(?:typedef|struct|enum)\b
2258 )}x;
2259 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
2260 if ($possible !~ $notPermitted) {
2261 # Check for modifiers.
2262 $possible =~ s/\s*$Storage\s*//g;
2263 $possible =~ s/\s*$Sparse\s*//g;
2264 if ($possible =~ /^\s*$/) {
2265
2266 } elsif ($possible =~ /\s/) {
2267 $possible =~ s/\s*$Type\s*//g;
2268 for my $modifier (split(' ', $possible)) {
2269 if ($modifier !~ $notPermitted) {
2270 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
2271 push(@modifierListFile, $modifier);
2272 }
2273 }
2274
2275 } else {
2276 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
2277 push(@typeListFile, $possible);
2278 }
2279 build_types();
2280 } else {
2281 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
2282 }
2283}
2284
2285my $prefix = '';
2286
2287sub show_type {
2288 my ($type) = @_;
2289
2290 $type =~ tr/[a-z]/[A-Z]/;
2291
2292 return defined $use_type{$type} if (scalar keys %use_type > 0);
2293
2294 return !defined $ignore_type{$type};
2295}
2296
2297sub report {
2298 my ($level, $type, $msg) = @_;
2299
2300 if (!show_type($type) ||
2301 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
2302 return 0;
2303 }
2304 my $output = '';
2305 if ($color) {
2306 if ($level eq 'ERROR') {
2307 $output .= RED;
2308 } elsif ($level eq 'WARNING') {
2309 $output .= YELLOW;
2310 } else {
2311 $output .= GREEN;
2312 }
2313 }
2314 $output .= $prefix . $level . ':';
2315 if ($show_types) {
2316 $output .= BLUE if ($color);
2317 $output .= "$type:";
2318 }
2319 $output .= RESET if ($color);
2320 $output .= ' ' . $msg . "\n";
2321
2322 if ($showfile) {
2323 my @lines = split("\n", $output, -1);
2324 splice(@lines, 1, 1);
2325 $output = join("\n", @lines);
2326 }
2327
2328 if ($terse) {
2329 $output = (split('\n', $output))[0] . "\n";
2330 }
2331
2332 if ($verbose && exists($verbose_messages{$type}) &&
2333 !exists($verbose_emitted{$type})) {
2334 $output .= $verbose_messages{$type} . "\n\n";
2335 $verbose_emitted{$type} = 1;
2336 }
2337
2338 push(our @report, $output);
2339
2340 return 1;
2341}
2342
2343sub report_dump {
2344 our @report;
2345}
2346
2347sub fixup_current_range {
2348 my ($lineRef, $offset, $length) = @_;
2349
2350 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
2351 my $o = $1;
2352 my $l = $2;
2353 my $no = $o + $offset;
2354 my $nl = $l + $length;
2355 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
2356 }
2357}
2358
2359sub fix_inserted_deleted_lines {
2360 my ($linesRef, $insertedRef, $deletedRef) = @_;
2361
2362 my $range_last_linenr = 0;
2363 my $delta_offset = 0;
2364
2365 my $old_linenr = 0;
2366 my $new_linenr = 0;
2367
2368 my $next_insert = 0;
2369 my $next_delete = 0;
2370
2371 my @lines = ();
2372
2373 my $inserted = @{$insertedRef}[$next_insert++];
2374 my $deleted = @{$deletedRef}[$next_delete++];
2375
2376 foreach my $old_line (@{$linesRef}) {
2377 my $save_line = 1;
2378 my $line = $old_line; #don't modify the array
2379 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
2380 $delta_offset = 0;
2381 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
2382 $range_last_linenr = $new_linenr;
2383 fixup_current_range(\$line, $delta_offset, 0);
2384 }
2385
2386 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
2387 $deleted = @{$deletedRef}[$next_delete++];
2388 $save_line = 0;
2389 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
2390 }
2391
2392 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
2393 push(@lines, ${$inserted}{'LINE'});
2394 $inserted = @{$insertedRef}[$next_insert++];
2395 $new_linenr++;
2396 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
2397 }
2398
2399 if ($save_line) {
2400 push(@lines, $line);
2401 $new_linenr++;
2402 }
2403
2404 $old_linenr++;
2405 }
2406
2407 return @lines;
2408}
2409
2410sub fix_insert_line {
2411 my ($linenr, $line) = @_;
2412
2413 my $inserted = {
2414 LINENR => $linenr,
2415 LINE => $line,
2416 };
2417 push(@fixed_inserted, $inserted);
2418}
2419
2420sub fix_delete_line {
2421 my ($linenr, $line) = @_;
2422
2423 my $deleted = {
2424 LINENR => $linenr,
2425 LINE => $line,
2426 };
2427
2428 push(@fixed_deleted, $deleted);
2429}
2430
2431sub ERROR {
2432 my ($type, $msg) = @_;
2433
2434 if (report("ERROR", $type, $msg)) {
2435 our $clean = 0;
2436 our $cnt_error++;
2437 return 1;
2438 }
2439 return 0;
2440}
2441sub WARN {
2442 my ($type, $msg) = @_;
2443
2444 if (report("WARNING", $type, $msg)) {
2445 our $clean = 0;
2446 our $cnt_warn++;
2447 return 1;
2448 }
2449 return 0;
2450}
2451sub CHK {
2452 my ($type, $msg) = @_;
2453
2454 if ($check && report("CHECK", $type, $msg)) {
2455 our $clean = 0;
2456 our $cnt_chk++;
2457 return 1;
2458 }
2459 return 0;
2460}
2461
2462sub check_absolute_file {
2463 my ($absolute, $herecurr) = @_;
2464 my $file = $absolute;
2465
2466 ##print "absolute<$absolute>\n";
2467
2468 # See if any suffix of this path is a path within the tree.
2469 while ($file =~ s@^[^/]*/@@) {
2470 if (-f "$root/$file") {
2471 ##print "file<$file>\n";
2472 last;
2473 }
2474 }
2475 if (! -f _) {
2476 return 0;
2477 }
2478
2479 # It is, so see if the prefix is acceptable.
2480 my $prefix = $absolute;
2481 substr($prefix, -length($file)) = '';
2482
2483 ##print "prefix<$prefix>\n";
2484 if ($prefix ne ".../") {
2485 WARN("USE_RELATIVE_PATH",
2486 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2487 }
2488}
2489
2490sub trim {
2491 my ($string) = @_;
2492
2493 $string =~ s/^\s+|\s+$//g;
2494
2495 return $string;
2496}
2497
2498sub ltrim {
2499 my ($string) = @_;
2500
2501 $string =~ s/^\s+//;
2502
2503 return $string;
2504}
2505
2506sub rtrim {
2507 my ($string) = @_;
2508
2509 $string =~ s/\s+$//;
2510
2511 return $string;
2512}
2513
2514sub string_find_replace {
2515 my ($string, $find, $replace) = @_;
2516
2517 $string =~ s/$find/$replace/g;
2518
2519 return $string;
2520}
2521
2522sub tabify {
2523 my ($leading) = @_;
2524
2525 my $source_indent = $tabsize;
2526 my $max_spaces_before_tab = $source_indent - 1;
2527 my $spaces_to_tab = " " x $source_indent;
2528
2529 #convert leading spaces to tabs
2530 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2531 #Remove spaces before a tab
2532 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2533
2534 return "$leading";
2535}
2536
2537sub pos_last_openparen {
2538 my ($line) = @_;
2539
2540 my $pos = 0;
2541
2542 my $opens = $line =~ tr/\(/\(/;
2543 my $closes = $line =~ tr/\)/\)/;
2544
2545 my $last_openparen = 0;
2546
2547 if (($opens == 0) || ($closes >= $opens)) {
2548 return -1;
2549 }
2550
2551 my $len = length($line);
2552
2553 for ($pos = 0; $pos < $len; $pos++) {
2554 my $string = substr($line, $pos);
2555 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2556 $pos += length($1) - 1;
2557 } elsif (substr($line, $pos, 1) eq '(') {
2558 $last_openparen = $pos;
2559 } elsif (index($string, '(') == -1) {
2560 last;
2561 }
2562 }
2563
2564 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2565}
2566
2567sub get_raw_comment {
2568 my ($line, $rawline) = @_;
2569 my $comment = '';
2570
2571 for my $i (0 .. (length($line) - 1)) {
2572 if (substr($line, $i, 1) eq "$;") {
2573 $comment .= substr($rawline, $i, 1);
2574 }
2575 }
2576
2577 return $comment;
2578}
2579
2580# Args:
2581# line: Patch line to check
2582# auto: Auto variable name, e.g. "per_child_auto"
2583# suffix: Suffix to expect on member, e.g. "_priv"
2584# warning: Warning name, e.g. "PRIV_AUTO"
2585sub u_boot_struct_name {
2586 my ($line, $auto, $suffix, $warning, $herecurr) = @_;
2587
2588 # Use _priv as a suffix for the device-private data struct
2589 if ($line =~ /^\+\s*\.${auto}\s*=\s*sizeof\(struct\((\w+)\).*/) {
2590 my $struct_name = $1;
2591 if ($struct_name !~ /^\w+${suffix}/) {
2592 WARN($warning,
2593 "struct \'$struct_name\' should have a ${suffix} suffix\n"
2594 . $herecurr);
2595 }
2596 }
2597}
2598
2599# Checks specific to U-Boot
2600sub u_boot_line {
2601 my ($realfile, $line, $rawline, $herecurr) = @_;
2602
2603 # ask for a test if a new uclass ID is added
2604 if ($realfile =~ /uclass-id.h/ && $line =~ /^\+/) {
2605 WARN("NEW_UCLASS",
2606 "Possible new uclass - make sure to add a sandbox driver, plus a test in test/dm/<name>.c\n" . $herecurr);
2607 }
2608
2609 # try to get people to use the livetree API, except when changing tooling
2610 if ($line =~ /^\+.*fdtdec_/ && $realfile !~ /^tools\//) {
2611 WARN("LIVETREE",
2612 "Use the livetree API (dev_read_...)\n" . $herecurr);
2613 }
2614
2615 # add tests for new commands
2616 if ($line =~ /^\+.*do_($Ident)\(struct cmd_tbl.*/) {
2617 WARN("CMD_TEST",
2618 "Possible new command - make sure you add a test\n" . $herecurr);
2619 }
2620
2621 # use if instead of #if
2622 if ($realfile =~ /\.c$/ && $line =~ /^\+#if.*CONFIG.*/) {
2623 WARN("PREFER_IF",
2624 "Use 'if (IS_ENABLED(CONFIG...))' instead of '#if or #ifdef' where possible\n" . $herecurr);
2625 }
2626
2627 # prefer strl(cpy|cat) over strn(cpy|cat)
2628 if ($line =~ /\bstrn(cpy|cat)\s*\(/) {
2629 WARN("STRL",
2630 "strl$1 is preferred over strn$1 because it always produces a nul-terminated string\n" . $herecurr);
2631 }
2632
2633 # use Kconfig for all CONFIG symbols
2634 if ($line =~ /\+\s*#\s*(define|undef)\s+(CONFIG_\w*)\b/) {
2635 ERROR("DEFINE_CONFIG_SYM",
2636 "All CONFIG symbols are managed by Kconfig\n" . $herecurr);
2637 }
2638
2639 # Don't put dm.h in header files
2640 if ($realfile =~ /\.h$/ && $rawline =~ /^\+#include\s*<dm\.h>*/) {
2641 ERROR("BARRED_INCLUDE_IN_HDR",
2642 "Avoid including common.h and dm.h in header files\n" . $herecurr);
2643 }
2644
2645 # Don't add common.h to files
2646 if ($rawline =~ /^\+#include\s*<common\.h>*/) {
2647 ERROR("BARRED_INCLUDE_COMMON_H",
2648 "Do not add common.h to files\n" . $herecurr);
2649 }
2650
2651 # Do not disable fdt / initrd relocation
2652 if ($rawline =~ /^\+.*(fdt|initrd)_high=0xffffffff/) {
2653 ERROR("DISABLE_FDT_OR_INITRD_RELOC",
2654 "fdt or initrd relocation disabled at boot time\n" . $herecurr);
2655 }
2656
2657 # make sure 'skip_board_fixup' is not
2658 if ($rawline =~ /.*skip_board_fixup.*/) {
2659 ERROR("SKIP_BOARD_FIXUP",
2660 "Avoid setting skip_board_fixup env variable\n" . $herecurr);
2661 }
2662
2663 # Do not use CONFIG_ prefix in CONFIG_IS_ENABLED() calls
2664 if ($line =~ /^\+.*CONFIG_IS_ENABLED\(CONFIG_\w*\).*/) {
2665 ERROR("CONFIG_IS_ENABLED_CONFIG",
2666 "CONFIG_IS_ENABLED() takes values without the CONFIG_ prefix\n" . $herecurr);
2667 }
2668
2669 # Use _priv as a suffix for the device-private data struct
2670 if ($line =~ /^\+\s*\.priv_auto\s*=\s*sizeof\(struct\((\w+)\).*/) {
2671 my $struct_name = $1;
2672 if ($struct_name !~ /^\w+_priv/) {
2673 WARN("PRIV_AUTO", "struct \'$struct_name\' should have a _priv suffix");
2674 }
2675 }
2676
2677 # Check struct names for the 'auto' members of struct driver
2678 u_boot_struct_name($line, "priv_auto", "_priv", "PRIV_AUTO", $herecurr);
2679 u_boot_struct_name($line, "plat_auto", "_plat", "PLAT_AUTO", $herecurr);
2680 u_boot_struct_name($line, "per_child_auto", "_priv", "CHILD_PRIV_AUTO", $herecurr);
2681 u_boot_struct_name($line, "per_child_plat_auto", "_plat",
2682 "CHILD_PLAT_AUTO", $herecurr);
2683
2684 # Now the ones for struct uclass, skipping those in common with above
2685 u_boot_struct_name($line, "per_device_auto", "_priv",
2686 "DEVICE_PRIV_AUTO", $herecurr);
2687 u_boot_struct_name($line, "per_device_plat_auto", "_plat",
2688 "DEVICE_PLAT_AUTO", $herecurr);
2689
2690 # Avoid using the pre-schema driver model tags
2691 if ($line =~ /^\+.*u-boot,dm-.*/) {
2692 ERROR("PRE_SCHEMA",
2693 "Driver model schema uses 'bootph-...' tags now\n" . $herecurr);
2694 }
2695}
2696
2697sub exclude_global_initialisers {
2698 my ($realfile) = @_;
2699
2700 # Do not check for BPF programs (tools/testing/selftests/bpf/progs/*.c, samples/bpf/*_kern.c, *.bpf.c).
2701 return $realfile =~ m@^tools/testing/selftests/bpf/progs/.*\.c$@ ||
2702 $realfile =~ m@^samples/bpf/.*_kern\.c$@ ||
2703 $realfile =~ m@/bpf/.*\.bpf\.c$@;
2704}
2705
2706sub process {
2707 my $filename = shift;
2708
2709 my $linenr=0;
2710 my $prevline="";
2711 my $prevrawline="";
2712 my $stashline="";
2713 my $stashrawline="";
2714
2715 my $length;
2716 my $indent;
2717 my $previndent=0;
2718 my $stashindent=0;
2719
2720 our $clean = 1;
2721 my $signoff = 0;
2722 my $author = '';
2723 my $authorsignoff = 0;
2724 my $author_sob = '';
2725 my $is_patch = 0;
2726 my $is_binding_patch = -1;
2727 my $in_header_lines = $file ? 0 : 1;
2728 my $in_commit_log = 0; #Scanning lines before patch
2729 my $has_patch_separator = 0; #Found a --- line
2730 my $has_commit_log = 0; #Encountered lines before patch
2731 my $commit_log_lines = 0; #Number of commit log lines
2732 my $commit_log_possible_stack_dump = 0;
2733 my $commit_log_long_line = 0;
2734 my $commit_log_has_diff = 0;
2735 my $reported_maintainer_file = 0;
2736 my $non_utf8_charset = 0;
2737
2738 my $last_git_commit_id_linenr = -1;
2739
2740 my $last_blank_line = 0;
2741 my $last_coalesced_string_linenr = -1;
2742
2743 our @report = ();
2744 our $cnt_lines = 0;
2745 our $cnt_error = 0;
2746 our $cnt_warn = 0;
2747 our $cnt_chk = 0;
2748
2749 # Trace the real file/line as we go.
2750 my $realfile = '';
2751 my $realline = 0;
2752 my $realcnt = 0;
2753 my $here = '';
2754 my $context_function; #undef'd unless there's a known function
2755 my $in_comment = 0;
2756 my $comment_edge = 0;
2757 my $first_line = 0;
2758 my $p1_prefix = '';
2759
2760 my $prev_values = 'E';
2761
2762 # suppression flags
2763 my %suppress_ifbraces;
2764 my %suppress_whiletrailers;
2765 my %suppress_export;
2766 my $suppress_statement = 0;
2767
2768 my %signatures = ();
2769
2770 # Pre-scan the patch sanitizing the lines.
2771 # Pre-scan the patch looking for any __setup documentation.
2772 #
2773 my @setup_docs = ();
2774 my $setup_docs = 0;
2775
2776 my $camelcase_file_seeded = 0;
2777
2778 my $checklicenseline = 1;
2779
2780 sanitise_line_reset();
2781 my $line;
2782 foreach my $rawline (@rawlines) {
2783 $linenr++;
2784 $line = $rawline;
2785
2786 push(@fixed, $rawline) if ($fix);
2787
2788 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2789 $setup_docs = 0;
2790 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.txt$@) {
2791 $setup_docs = 1;
2792 }
2793 #next;
2794 }
2795 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2796 $realline=$1-1;
2797 if (defined $2) {
2798 $realcnt=$3+1;
2799 } else {
2800 $realcnt=1+1;
2801 }
2802 $in_comment = 0;
2803
2804 # Guestimate if this is a continuing comment. Run
2805 # the context looking for a comment "edge". If this
2806 # edge is a close comment then we must be in a comment
2807 # at context start.
2808 my $edge;
2809 my $cnt = $realcnt;
2810 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2811 next if (defined $rawlines[$ln - 1] &&
2812 $rawlines[$ln - 1] =~ /^-/);
2813 $cnt--;
2814 #print "RAW<$rawlines[$ln - 1]>\n";
2815 last if (!defined $rawlines[$ln - 1]);
2816 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2817 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2818 ($edge) = $1;
2819 last;
2820 }
2821 }
2822 if (defined $edge && $edge eq '*/') {
2823 $in_comment = 1;
2824 }
2825
2826 # Guestimate if this is a continuing comment. If this
2827 # is the start of a diff block and this line starts
2828 # ' *' then it is very likely a comment.
2829 if (!defined $edge &&
2830 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2831 {
2832 $in_comment = 1;
2833 }
2834
2835 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2836 sanitise_line_reset($in_comment);
2837
2838 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2839 # Standardise the strings and chars within the input to
2840 # simplify matching -- only bother with positive lines.
2841 $line = sanitise_line($rawline);
2842 }
2843 push(@lines, $line);
2844
2845 if ($realcnt > 1) {
2846 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2847 } else {
2848 $realcnt = 0;
2849 }
2850
2851 #print "==>$rawline\n";
2852 #print "-->$line\n";
2853
2854 if ($setup_docs && $line =~ /^\+/) {
2855 push(@setup_docs, $line);
2856 }
2857 }
2858
2859 $prefix = '';
2860
2861 $realcnt = 0;
2862 $linenr = 0;
2863 $fixlinenr = -1;
2864 foreach my $line (@lines) {
2865 $linenr++;
2866 $fixlinenr++;
2867 my $sline = $line; #copy of $line
2868 $sline =~ s/$;/ /g; #with comments as spaces
2869
2870 my $rawline = $rawlines[$linenr - 1];
2871 my $raw_comment = get_raw_comment($line, $rawline);
2872
2873# check if it's a mode change, rename or start of a patch
2874 if (!$in_commit_log &&
2875 ($line =~ /^ mode change [0-7]+ => [0-7]+ \S+\s*$/ ||
2876 ($line =~ /^rename (?:from|to) \S+\s*$/ ||
2877 $line =~ /^diff --git a\/[\w\/\.\_\-]+ b\/\S+\s*$/))) {
2878 $is_patch = 1;
2879 }
2880
2881#extract the line range in the file after the patch is applied
2882 if (!$in_commit_log &&
2883 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2884 my $context = $4;
2885 $is_patch = 1;
2886 $first_line = $linenr + 1;
2887 $realline=$1-1;
2888 if (defined $2) {
2889 $realcnt=$3+1;
2890 } else {
2891 $realcnt=1+1;
2892 }
2893 annotate_reset();
2894 $prev_values = 'E';
2895
2896 %suppress_ifbraces = ();
2897 %suppress_whiletrailers = ();
2898 %suppress_export = ();
2899 $suppress_statement = 0;
2900 if ($context =~ /\b(\w+)\s*\(/) {
2901 $context_function = $1;
2902 } else {
2903 undef $context_function;
2904 }
2905 next;
2906
2907# track the line number as we move through the hunk, note that
2908# new versions of GNU diff omit the leading space on completely
2909# blank context lines so we need to count that too.
2910 } elsif ($line =~ /^( |\+|$)/) {
2911 $realline++;
2912 $realcnt-- if ($realcnt != 0);
2913
2914 # Measure the line length and indent.
2915 ($length, $indent) = line_stats($rawline);
2916
2917 # Track the previous line.
2918 ($prevline, $stashline) = ($stashline, $line);
2919 ($previndent, $stashindent) = ($stashindent, $indent);
2920 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2921
2922 #warn "line<$line>\n";
2923
2924 } elsif ($realcnt == 1) {
2925 $realcnt--;
2926 }
2927
2928 my $hunk_line = ($realcnt != 0);
2929
2930 $here = "#$linenr: " if (!$file);
2931 $here = "#$realline: " if ($file);
2932
2933 my $found_file = 0;
2934 # extract the filename as it passes
2935 if ($line =~ /^diff --git.*?(\S+)$/) {
2936 $realfile = $1;
2937 $realfile =~ s@^([^/]*)/@@ if (!$file);
2938 $in_commit_log = 0;
2939 $found_file = 1;
2940 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2941 $realfile = $1;
2942 $realfile =~ s@^([^/]*)/@@ if (!$file);
2943 $in_commit_log = 0;
2944
2945 $p1_prefix = $1;
2946 if (!$file && $tree && $p1_prefix ne '' &&
2947 -e "$root/$p1_prefix") {
2948 WARN("PATCH_PREFIX",
2949 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2950 }
2951
2952 if ($realfile =~ m@^include/asm/@) {
2953 ERROR("MODIFIED_INCLUDE_ASM",
2954 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2955 }
2956 $found_file = 1;
2957 }
2958
2959#make up the handle for any error we report on this line
2960 if ($showfile) {
2961 $prefix = "$realfile:$realline: "
2962 } elsif ($emacs) {
2963 if ($file) {
2964 $prefix = "$filename:$realline: ";
2965 } else {
2966 $prefix = "$filename:$linenr: ";
2967 }
2968 }
2969
2970 if ($found_file) {
2971 if (is_maintained_obsolete($realfile)) {
2972 WARN("OBSOLETE",
2973 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2974 }
2975 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2976 $check = 1;
2977 } else {
2978 $check = $check_orig;
2979 }
2980 $checklicenseline = 1;
2981
2982 if ($realfile !~ /^MAINTAINERS/) {
2983 my $last_binding_patch = $is_binding_patch;
2984
2985 $is_binding_patch = () = $realfile =~ m@^(?:Documentation/devicetree/|include/dt-bindings/)@;
2986
2987 if (($last_binding_patch != -1) &&
2988 ($last_binding_patch ^ $is_binding_patch)) {
2989 WARN("DT_SPLIT_BINDING_PATCH",
2990 "DT binding docs and includes should be a separate patch. See: Documentation/devicetree/bindings/submitting-patches.rst\n");
2991 }
2992 }
2993
2994 next;
2995 }
2996
2997 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2998
2999 my $hereline = "$here\n$rawline\n";
3000 my $herecurr = "$here\n$rawline\n";
3001 my $hereprev = "$here\n$prevrawline\n$rawline\n";
3002
3003 $cnt_lines++ if ($realcnt != 0);
3004
3005# Verify the existence of a commit log if appropriate
3006# 2 is used because a $signature is counted in $commit_log_lines
3007 if ($in_commit_log) {
3008 if ($line !~ /^\s*$/) {
3009 $commit_log_lines++; #could be a $signature
3010 }
3011 } elsif ($has_commit_log && $commit_log_lines < 2) {
3012 WARN("COMMIT_MESSAGE",
3013 "Missing commit description - Add an appropriate one\n");
3014 $commit_log_lines = 2; #warn only once
3015 }
3016
3017# Check if the commit log has what seems like a diff which can confuse patch
3018 if ($in_commit_log && !$commit_log_has_diff &&
3019 (($line =~ m@^\s+diff\b.*a/([\w/]+)@ &&
3020 $line =~ m@^\s+diff\b.*a/[\w/]+\s+b/$1\b@) ||
3021 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
3022 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
3023 ERROR("DIFF_IN_COMMIT_MSG",
3024 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
3025 $commit_log_has_diff = 1;
3026 }
3027
3028# Check for incorrect file permissions
3029 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
3030 my $permhere = $here . "FILE: $realfile\n";
3031 if ($realfile !~ m@scripts/@ &&
3032 $realfile !~ /\.(py|pl|awk|sh)$/) {
3033 ERROR("EXECUTE_PERMISSIONS",
3034 "do not set execute permissions for source files\n" . $permhere);
3035 }
3036 }
3037
3038# Check the patch for a From:
3039 if (decode("MIME-Header", $line) =~ /^From:\s*(.*)/) {
3040 $author = $1;
3041 my $curline = $linenr;
3042 while(defined($rawlines[$curline]) && ($rawlines[$curline++] =~ /^[ \t]\s*(.*)/)) {
3043 $author .= $1;
3044 }
3045 $author = encode("utf8", $author) if ($line =~ /=\?utf-8\?/i);
3046 $author =~ s/"//g;
3047 $author = reformat_email($author);
3048 }
3049
3050# Check the patch for a signoff:
3051 if ($line =~ /^\s*signed-off-by:\s*(.*)/i) {
3052 $signoff++;
3053 $in_commit_log = 0;
3054 if ($author ne '' && $authorsignoff != 1) {
3055 if (same_email_addresses($1, $author)) {
3056 $authorsignoff = 1;
3057 } else {
3058 my $ctx = $1;
3059 my ($email_name, $email_comment, $email_address, $comment1) = parse_email($ctx);
3060 my ($author_name, $author_comment, $author_address, $comment2) = parse_email($author);
3061
3062 if (lc $email_address eq lc $author_address && $email_name eq $author_name) {
3063 $author_sob = $ctx;
3064 $authorsignoff = 2;
3065 } elsif (lc $email_address eq lc $author_address) {
3066 $author_sob = $ctx;
3067 $authorsignoff = 3;
3068 } elsif ($email_name eq $author_name) {
3069 $author_sob = $ctx;
3070 $authorsignoff = 4;
3071
3072 my $address1 = $email_address;
3073 my $address2 = $author_address;
3074
3075 if ($address1 =~ /(\S+)\+\S+(\@.*)/) {
3076 $address1 = "$1$2";
3077 }
3078 if ($address2 =~ /(\S+)\+\S+(\@.*)/) {
3079 $address2 = "$1$2";
3080 }
3081 if ($address1 eq $address2) {
3082 $authorsignoff = 5;
3083 }
3084 }
3085 }
3086 }
3087 }
3088
3089# Check for patch separator
3090 if ($line =~ /^---$/) {
3091 $has_patch_separator = 1;
3092 $in_commit_log = 0;
3093 }
3094
3095# Check if MAINTAINERS is being updated. If so, there's probably no need to
3096# emit the "does MAINTAINERS need updating?" message on file add/move/delete
3097 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
3098 $reported_maintainer_file = 1;
3099 }
3100
3101# Check signature styles
3102 if (!$in_header_lines &&
3103 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
3104 my $space_before = $1;
3105 my $sign_off = $2;
3106 my $space_after = $3;
3107 my $email = $4;
3108 my $ucfirst_sign_off = ucfirst(lc($sign_off));
3109
3110 if ($sign_off !~ /$signature_tags/) {
3111 my $suggested_signature = find_standard_signature($sign_off);
3112 if ($suggested_signature eq "") {
3113 WARN("BAD_SIGN_OFF",
3114 "Non-standard signature: $sign_off\n" . $herecurr);
3115 } else {
3116 if (WARN("BAD_SIGN_OFF",
3117 "Non-standard signature: '$sign_off' - perhaps '$suggested_signature'?\n" . $herecurr) &&
3118 $fix) {
3119 $fixed[$fixlinenr] =~ s/$sign_off/$suggested_signature/;
3120 }
3121 }
3122 }
3123 if (defined $space_before && $space_before ne "") {
3124 if (WARN("BAD_SIGN_OFF",
3125 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
3126 $fix) {
3127 $fixed[$fixlinenr] =
3128 "$ucfirst_sign_off $email";
3129 }
3130 }
3131 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
3132 if (WARN("BAD_SIGN_OFF",
3133 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
3134 $fix) {
3135 $fixed[$fixlinenr] =
3136 "$ucfirst_sign_off $email";
3137 }
3138
3139 }
3140 if (!defined $space_after || $space_after ne " ") {
3141 if (WARN("BAD_SIGN_OFF",
3142 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
3143 $fix) {
3144 $fixed[$fixlinenr] =
3145 "$ucfirst_sign_off $email";
3146 }
3147 }
3148
3149 my ($email_name, $name_comment, $email_address, $comment) = parse_email($email);
3150 my $suggested_email = format_email(($email_name, $name_comment, $email_address, $comment));
3151 if ($suggested_email eq "") {
3152 ERROR("BAD_SIGN_OFF",
3153 "Unrecognized email address: '$email'\n" . $herecurr);
3154 } else {
3155 my $dequoted = $suggested_email;
3156 $dequoted =~ s/^"//;
3157 $dequoted =~ s/" </ </;
3158 # Don't force email to have quotes
3159 # Allow just an angle bracketed address
3160 if (!same_email_addresses($email, $suggested_email)) {
3161 if (WARN("BAD_SIGN_OFF",
3162 "email address '$email' might be better as '$suggested_email'\n" . $herecurr) &&
3163 $fix) {
3164 $fixed[$fixlinenr] =~ s/\Q$email\E/$suggested_email/;
3165 }
3166 }
3167
3168 # Address part shouldn't have comments
3169 my $stripped_address = $email_address;
3170 $stripped_address =~ s/\([^\(\)]*\)//g;
3171 if ($email_address ne $stripped_address) {
3172 if (WARN("BAD_SIGN_OFF",
3173 "address part of email should not have comments: '$email_address'\n" . $herecurr) &&
3174 $fix) {
3175 $fixed[$fixlinenr] =~ s/\Q$email_address\E/$stripped_address/;
3176 }
3177 }
3178
3179 # Only one name comment should be allowed
3180 my $comment_count = () = $name_comment =~ /\([^\)]+\)/g;
3181 if ($comment_count > 1) {
3182 WARN("BAD_SIGN_OFF",
3183 "Use a single name comment in email: '$email'\n" . $herecurr);
3184 }
3185
3186
3187 # stable@vger.kernel.org or stable@kernel.org shouldn't
3188 # have an email name. In addition comments should strictly
3189 # begin with a #
3190 if ($email =~ /^.*stable\@(?:vger\.)?kernel\.org/i) {
3191 if (($comment ne "" && $comment !~ /^#.+/) ||
3192 ($email_name ne "")) {
3193 my $cur_name = $email_name;
3194 my $new_comment = $comment;
3195 $cur_name =~ s/[a-zA-Z\s\-\"]+//g;
3196
3197 # Remove brackets enclosing comment text
3198 # and # from start of comments to get comment text
3199 $new_comment =~ s/^\((.*)\)$/$1/;
3200 $new_comment =~ s/^\[(.*)\]$/$1/;
3201 $new_comment =~ s/^[\s\#]+|\s+$//g;
3202
3203 $new_comment = trim("$new_comment $cur_name") if ($cur_name ne $new_comment);
3204 $new_comment = " # $new_comment" if ($new_comment ne "");
3205 my $new_email = "$email_address$new_comment";
3206
3207 if (WARN("BAD_STABLE_ADDRESS_STYLE",
3208 "Invalid email format for stable: '$email', prefer '$new_email'\n" . $herecurr) &&
3209 $fix) {
3210 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3211 }
3212 }
3213 } elsif ($comment ne "" && $comment !~ /^(?:#.+|\(.+\))$/) {
3214 my $new_comment = $comment;
3215
3216 # Extract comment text from within brackets or
3217 # c89 style /*...*/ comments
3218 $new_comment =~ s/^\[(.*)\]$/$1/;
3219 $new_comment =~ s/^\/\*(.*)\*\/$/$1/;
3220
3221 $new_comment = trim($new_comment);
3222 $new_comment =~ s/^[^\w]$//; # Single lettered comment with non word character is usually a typo
3223 $new_comment = "($new_comment)" if ($new_comment ne "");
3224 my $new_email = format_email($email_name, $name_comment, $email_address, $new_comment);
3225
3226 if (WARN("BAD_SIGN_OFF",
3227 "Unexpected content after email: '$email', should be: '$new_email'\n" . $herecurr) &&
3228 $fix) {
3229 $fixed[$fixlinenr] =~ s/\Q$email\E/$new_email/;
3230 }
3231 }
3232 }
3233
3234# Check for duplicate signatures
3235 my $sig_nospace = $line;
3236 $sig_nospace =~ s/\s//g;
3237 $sig_nospace = lc($sig_nospace);
3238 if (defined $signatures{$sig_nospace}) {
3239 WARN("BAD_SIGN_OFF",
3240 "Duplicate signature\n" . $herecurr);
3241 } else {
3242 $signatures{$sig_nospace} = 1;
3243 }
3244
3245# Check Co-developed-by: immediately followed by Signed-off-by: with same name and email
3246 if ($sign_off =~ /^co-developed-by:$/i) {
3247 if ($email eq $author) {
3248 WARN("BAD_SIGN_OFF",
3249 "Co-developed-by: should not be used to attribute nominal patch author '$author'\n" . "$here\n" . $rawline);
3250 }
3251 if (!defined $lines[$linenr]) {
3252 WARN("BAD_SIGN_OFF",
3253 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline);
3254 } elsif ($rawlines[$linenr] !~ /^\s*signed-off-by:\s*(.*)/i) {
3255 WARN("BAD_SIGN_OFF",
3256 "Co-developed-by: must be immediately followed by Signed-off-by:\n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3257 } elsif ($1 ne $email) {
3258 WARN("BAD_SIGN_OFF",
3259 "Co-developed-by and Signed-off-by: name/email do not match \n" . "$here\n" . $rawline . "\n" .$rawlines[$linenr]);
3260 }
3261 }
3262 }
3263
3264# Check email subject for common tools that don't need to be mentioned
3265 if ($in_header_lines &&
3266 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
3267 WARN("EMAIL_SUBJECT",
3268 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
3269 }
3270
3271# Check for Gerrit Change-Ids not in any patch context
3272 if ($realfile eq '' && !$has_patch_separator && $line =~ /^\s*change-id:/i) {
3273 if (ERROR("GERRIT_CHANGE_ID",
3274 "Remove Gerrit Change-Id's before submitting upstream\n" . $herecurr) &&
3275 $fix) {
3276 fix_delete_line($fixlinenr, $rawline);
3277 }
3278 }
3279
3280# Check if the commit log is in a possible stack dump
3281 if ($in_commit_log && !$commit_log_possible_stack_dump &&
3282 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
3283 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
3284 # timestamp
3285 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/) ||
3286 $line =~ /^(?:\s+\w+:\s+[0-9a-fA-F]+){3,3}/ ||
3287 $line =~ /^\s*\#\d+\s*\[[0-9a-fA-F]+\]\s*\w+ at [0-9a-fA-F]+/) {
3288 # stack dump address styles
3289 $commit_log_possible_stack_dump = 1;
3290 }
3291
3292# Check for line lengths > 75 in commit log, warn once
3293 if ($in_commit_log && !$commit_log_long_line &&
3294 length($line) > 75 &&
3295 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
3296 # file delta changes
3297 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
3298 # filename then :
3299 $line =~ /^\s*(?:Fixes:|Link:|$signature_tags)/i ||
3300 # A Fixes: or Link: line or signature tag line
3301 $commit_log_possible_stack_dump)) {
3302 WARN("COMMIT_LOG_LONG_LINE",
3303 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
3304 $commit_log_long_line = 1;
3305 }
3306
3307# Reset possible stack dump if a blank line is found
3308 if ($in_commit_log && $commit_log_possible_stack_dump &&
3309 $line =~ /^\s*$/) {
3310 $commit_log_possible_stack_dump = 0;
3311 }
3312
3313# Check for lines starting with a #
3314 if ($in_commit_log && $line =~ /^#/) {
3315 if (WARN("COMMIT_COMMENT_SYMBOL",
3316 "Commit log lines starting with '#' are dropped by git as comments\n" . $herecurr) &&
3317 $fix) {
3318 $fixed[$fixlinenr] =~ s/^/ /;
3319 }
3320 }
3321
3322# Check for git id commit length and improperly formed commit descriptions
3323# A correctly formed commit description is:
3324# commit <SHA-1 hash length 12+ chars> ("Complete commit subject")
3325# with the commit subject '("' prefix and '")' suffix
3326# This is a fairly compilicated block as it tests for what appears to be
3327# bare SHA-1 hash with minimum length of 5. It also avoids several types of
3328# possible SHA-1 matches.
3329# A commit match can span multiple lines so this block attempts to find a
3330# complete typical commit on a maximum of 3 lines
3331 if ($perl_version_ok &&
3332 $in_commit_log && !$commit_log_possible_stack_dump &&
3333 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink|base-commit):/i &&
3334 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
3335 (($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
3336 ($line =~ /\bcommit\s*$/i && defined($rawlines[$linenr]) && $rawlines[$linenr] =~ /^\s*[0-9a-f]{5,}\b/i)) ||
3337 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
3338 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
3339 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
3340 my $init_char = "c";
3341 my $orig_commit = "";
3342 my $short = 1;
3343 my $long = 0;
3344 my $case = 1;
3345 my $space = 1;
3346 my $id = '0123456789ab';
3347 my $orig_desc = "commit description";
3348 my $description = "";
3349 my $herectx = $herecurr;
3350 my $has_parens = 0;
3351 my $has_quotes = 0;
3352
3353 my $input = $line;
3354 if ($line =~ /(?:\bcommit\s+[0-9a-f]{5,}|\bcommit\s*$)/i) {
3355 for (my $n = 0; $n < 2; $n++) {
3356 if ($input =~ /\bcommit\s+[0-9a-f]{5,}\s*($balanced_parens)/i) {
3357 $orig_desc = $1;
3358 $has_parens = 1;
3359 # Always strip leading/trailing parens then double quotes if existing
3360 $orig_desc = substr($orig_desc, 1, -1);
3361 if ($orig_desc =~ /^".*"$/) {
3362 $orig_desc = substr($orig_desc, 1, -1);
3363 $has_quotes = 1;
3364 }
3365 last;
3366 }
3367 last if ($#lines < $linenr + $n);
3368 $input .= " " . trim($rawlines[$linenr + $n]);
3369 $herectx .= "$rawlines[$linenr + $n]\n";
3370 }
3371 $herectx = $herecurr if (!$has_parens);
3372 }
3373
3374 if ($input =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
3375 $init_char = $1;
3376 $orig_commit = lc($2);
3377 $short = 0 if ($input =~ /\bcommit\s+[0-9a-f]{12,40}/i);
3378 $long = 1 if ($input =~ /\bcommit\s+[0-9a-f]{41,}/i);
3379 $space = 0 if ($input =~ /\bcommit [0-9a-f]/i);
3380 $case = 0 if ($input =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
3381 } elsif ($input =~ /\b([0-9a-f]{12,40})\b/i) {
3382 $orig_commit = lc($1);
3383 }
3384
3385 ($id, $description) = git_commit_info($orig_commit,
3386 $id, $orig_desc);
3387
3388 if (defined($id) &&
3389 ($short || $long || $space || $case || ($orig_desc ne $description) || !$has_quotes) &&
3390 $last_git_commit_id_linenr != $linenr - 1) {
3391 ERROR("GIT_COMMIT_ID",
3392 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herectx);
3393 }
3394 #don't report the next line if this line ends in commit and the sha1 hash is the next line
3395 $last_git_commit_id_linenr = $linenr if ($line =~ /\bcommit\s*$/i);
3396 }
3397
3398# Check for added, moved or deleted files
3399 if (!$reported_maintainer_file && !$in_commit_log &&
3400 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
3401 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
3402 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
3403 (defined($1) || defined($2))))) {
3404 $is_patch = 1;
3405 $reported_maintainer_file = 1;
3406 WARN("FILE_PATH_CHANGES",
3407 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
3408 }
3409
3410# Check for adding new DT bindings not in schema format
3411 if (!$in_commit_log &&
3412 ($line =~ /^new file mode\s*\d+\s*$/) &&
3413 ($realfile =~ m@^Documentation/devicetree/bindings/.*\.txt$@)) {
3414 WARN("DT_SCHEMA_BINDING_PATCH",
3415 "DT bindings should be in DT schema format. See: Documentation/devicetree/bindings/writing-schema.rst\n");
3416 }
3417
3418# Check for wrappage within a valid hunk of the file
3419 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
3420 ERROR("CORRUPTED_PATCH",
3421 "patch seems to be corrupt (line wrapped?)\n" .
3422 $herecurr) if (!$emitted_corrupt++);
3423 }
3424
3425# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
3426 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
3427 $rawline !~ m/^$UTF8*$/) {
3428 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
3429
3430 my $blank = copy_spacing($rawline);
3431 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
3432 my $hereptr = "$hereline$ptr\n";
3433
3434 CHK("INVALID_UTF8",
3435 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
3436 }
3437
3438# Check if it's the start of a commit log
3439# (not a header line and we haven't seen the patch filename)
3440 if ($in_header_lines && $realfile =~ /^$/ &&
3441 !($rawline =~ /^\s+(?:\S|$)/ ||
3442 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
3443 $in_header_lines = 0;
3444 $in_commit_log = 1;
3445 $has_commit_log = 1;
3446 }
3447
3448# Check if there is UTF-8 in a commit log when a mail header has explicitly
3449# declined it, i.e defined some charset where it is missing.
3450 if ($in_header_lines &&
3451 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
3452 $1 !~ /utf-8/i) {
3453 $non_utf8_charset = 1;
3454 }
3455
3456 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
3457 $rawline =~ /$NON_ASCII_UTF8/) {
3458 WARN("UTF8_BEFORE_PATCH",
3459 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
3460 }
3461
3462# Check for absolute kernel paths in commit message
3463 if ($tree && $in_commit_log) {
3464 while ($line =~ m{(?:^|\s)(/\S*)}g) {
3465 my $file = $1;
3466
3467 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
3468 check_absolute_file($1, $herecurr)) {
3469 #
3470 } else {
3471 check_absolute_file($file, $herecurr);
3472 }
3473 }
3474 }
3475
3476# Check for various typo / spelling mistakes
3477 if (defined($misspellings) &&
3478 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
3479 while ($rawline =~ /(?:^|[^\w\-'`])($misspellings)(?:[^\w\-'`]|$)/gi) {
3480 my $typo = $1;
3481 my $blank = copy_spacing($rawline);
3482 my $ptr = substr($blank, 0, $-[1]) . "^" x length($typo);
3483 my $hereptr = "$hereline$ptr\n";
3484 my $typo_fix = $spelling_fix{lc($typo)};
3485 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
3486 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
3487 my $msg_level = \&WARN;
3488 $msg_level = \&CHK if ($file);
3489 if (&{$msg_level}("TYPO_SPELLING",
3490 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $hereptr) &&
3491 $fix) {
3492 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
3493 }
3494 }
3495 }
3496
3497# check for invalid commit id
3498 if ($in_commit_log && $line =~ /(^fixes:|\bcommit)\s+([0-9a-f]{6,40})\b/i) {
3499 my $id;
3500 my $description;
3501 ($id, $description) = git_commit_info($2, undef, undef);
3502 if (!defined($id)) {
3503 WARN("UNKNOWN_COMMIT_ID",
3504 "Unknown commit id '$2', maybe rebased or not pulled?\n" . $herecurr);
3505 }
3506 }
3507
3508# check for repeated words separated by a single space
3509# avoid false positive from list command eg, '-rw-r--r-- 1 root root'
3510 if (($rawline =~ /^\+/ || $in_commit_log) &&
3511 $rawline !~ /[bcCdDlMnpPs\?-][rwxsStT-]{9}/) {
3512 pos($rawline) = 1 if (!$in_commit_log);
3513 while ($rawline =~ /\b($word_pattern) (?=($word_pattern))/g) {
3514
3515 my $first = $1;
3516 my $second = $2;
3517 my $start_pos = $-[1];
3518 my $end_pos = $+[2];
3519 if ($first =~ /(?:struct|union|enum)/) {
3520 pos($rawline) += length($first) + length($second) + 1;
3521 next;
3522 }
3523
3524 next if (lc($first) ne lc($second));
3525 next if ($first eq 'long');
3526
3527 # check for character before and after the word matches
3528 my $start_char = '';
3529 my $end_char = '';
3530 $start_char = substr($rawline, $start_pos - 1, 1) if ($start_pos > ($in_commit_log ? 0 : 1));
3531 $end_char = substr($rawline, $end_pos, 1) if ($end_pos < length($rawline));
3532
3533 next if ($start_char =~ /^\S$/);
3534 next if (index(" \t.,;?!", $end_char) == -1);
3535
3536 # avoid repeating hex occurrences like 'ff ff fe 09 ...'
3537 if ($first =~ /\b[0-9a-f]{2,}\b/i) {
3538 next if (!exists($allow_repeated_words{lc($first)}));
3539 }
3540
3541 if (WARN("REPEATED_WORD",
3542 "Possible repeated word: '$first'\n" . $herecurr) &&
3543 $fix) {
3544 $fixed[$fixlinenr] =~ s/\b$first $second\b/$first/;
3545 }
3546 }
3547
3548 # if it's a repeated word on consecutive lines in a comment block
3549 if ($prevline =~ /$;+\s*$/ &&
3550 $prevrawline =~ /($word_pattern)\s*$/) {
3551 my $last_word = $1;
3552 if ($rawline =~ /^\+\s*\*\s*$last_word /) {
3553 if (WARN("REPEATED_WORD",
3554 "Possible repeated word: '$last_word'\n" . $hereprev) &&
3555 $fix) {
3556 $fixed[$fixlinenr] =~ s/(\+\s*\*\s*)$last_word /$1/;
3557 }
3558 }
3559 }
3560 }
3561
3562# ignore non-hunk lines and lines being removed
3563 next if (!$hunk_line || $line =~ /^-/);
3564
3565#trailing whitespace
3566 if ($line =~ /^\+.*\015/) {
3567 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3568 if (ERROR("DOS_LINE_ENDINGS",
3569 "DOS line endings\n" . $herevet) &&
3570 $fix) {
3571 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
3572 }
3573 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
3574 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3575 if (ERROR("TRAILING_WHITESPACE",
3576 "trailing whitespace\n" . $herevet) &&
3577 $fix) {
3578 $fixed[$fixlinenr] =~ s/\s+$//;
3579 }
3580
3581 $rpt_cleaners = 1;
3582 }
3583
3584# Check for FSF mailing addresses.
3585 if ($rawline =~ /\bwrite to the Free/i ||
3586 $rawline =~ /\b675\s+Mass\s+Ave/i ||
3587 $rawline =~ /\b59\s+Temple\s+Pl/i ||
3588 $rawline =~ /\b51\s+Franklin\s+St/i) {
3589 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3590 my $msg_level = \&ERROR;
3591 $msg_level = \&CHK if ($file);
3592 &{$msg_level}("FSF_MAILING_ADDRESS",
3593 "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)
3594 }
3595
3596# check for Kconfig help text having a real description
3597# Only applies when adding the entry originally, after that we do not have
3598# sufficient context to determine whether it is indeed long enough.
3599 if ($realfile =~ /Kconfig/ &&
3600 # 'choice' is usually the last thing on the line (though
3601 # Kconfig supports named choices), so use a word boundary
3602 # (\b) rather than a whitespace character (\s)
3603 $line =~ /^\+\s*(?:config|menuconfig|choice)\b/) {
3604 my $length = 0;
3605 my $cnt = $realcnt;
3606 my $ln = $linenr + 1;
3607 my $f;
3608 my $is_start = 0;
3609 my $is_end = 0;
3610 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
3611 $f = $lines[$ln - 1];
3612 $cnt-- if ($lines[$ln - 1] !~ /^-/);
3613 $is_end = $lines[$ln - 1] =~ /^\+/;
3614
3615 next if ($f =~ /^-/);
3616 last if (!$file && $f =~ /^\@\@/);
3617
3618 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate|prompt)\s*["']/) {
3619 $is_start = 1;
3620 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
3621 $length = -1;
3622 }
3623
3624 $f =~ s/^.//;
3625 $f =~ s/#.*//;
3626 $f =~ s/^\s+//;
3627 next if ($f =~ /^$/);
3628
3629 # This only checks context lines in the patch
3630 # and so hopefully shouldn't trigger false
3631 # positives, even though some of these are
3632 # common words in help texts
3633 if ($f =~ /^\s*(?:config|menuconfig|choice|endchoice|
3634 if|endif|menu|endmenu|source)\b/x) {
3635 $is_end = 1;
3636 last;
3637 }
3638 $length++;
3639 }
3640 if ($is_start && $is_end && $length < $min_conf_desc_length) {
3641 WARN("CONFIG_DESCRIPTION",
3642 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
3643 }
3644 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
3645 }
3646
3647# check MAINTAINERS entries
3648 if ($realfile =~ /^MAINTAINERS$/) {
3649# check MAINTAINERS entries for the right form
3650 if ($rawline =~ /^\+[A-Z]:/ &&
3651 $rawline !~ /^\+[A-Z]:\t\S/) {
3652 if (WARN("MAINTAINERS_STYLE",
3653 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
3654 $fix) {
3655 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
3656 }
3657 }
3658# check MAINTAINERS entries for the right ordering too
3659 my $preferred_order = 'MRLSWQBCPTFXNK';
3660 if ($rawline =~ /^\+[A-Z]:/ &&
3661 $prevrawline =~ /^[\+ ][A-Z]:/) {
3662 $rawline =~ /^\+([A-Z]):\s*(.*)/;
3663 my $cur = $1;
3664 my $curval = $2;
3665 $prevrawline =~ /^[\+ ]([A-Z]):\s*(.*)/;
3666 my $prev = $1;
3667 my $prevval = $2;
3668 my $curindex = index($preferred_order, $cur);
3669 my $previndex = index($preferred_order, $prev);
3670 if ($curindex < 0) {
3671 WARN("MAINTAINERS_STYLE",
3672 "Unknown MAINTAINERS entry type: '$cur'\n" . $herecurr);
3673 } else {
3674 if ($previndex >= 0 && $curindex < $previndex) {
3675 WARN("MAINTAINERS_STYLE",
3676 "Misordered MAINTAINERS entry - list '$cur:' before '$prev:'\n" . $hereprev);
3677 } elsif ((($prev eq 'F' && $cur eq 'F') ||
3678 ($prev eq 'X' && $cur eq 'X')) &&
3679 ($prevval cmp $curval) > 0) {
3680 WARN("MAINTAINERS_STYLE",
3681 "Misordered MAINTAINERS entry - list file patterns in alphabetic order\n" . $hereprev);
3682 }
3683 }
3684 }
3685 }
3686
3687 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
3688 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
3689 my $flag = $1;
3690 my $replacement = {
3691 'EXTRA_AFLAGS' => 'asflags-y',
3692 'EXTRA_CFLAGS' => 'ccflags-y',
3693 'EXTRA_CPPFLAGS' => 'cppflags-y',
3694 'EXTRA_LDFLAGS' => 'ldflags-y',
3695 };
3696
3697 WARN("DEPRECATED_VARIABLE",
3698 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
3699 }
3700
3701# check for DT compatible documentation
3702 if (defined $root &&
3703 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
3704 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
3705
3706 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
3707
3708 my $dt_path = $root . "/Documentation/devicetree/bindings/";
3709 my $vp_file = $dt_path . "vendor-prefixes.yaml";
3710
3711 foreach my $compat (@compats) {
3712 my $compat2 = $compat;
3713 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
3714 my $compat3 = $compat;
3715 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
3716 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
3717 if ( $? >> 8 ) {
3718 WARN("UNDOCUMENTED_DT_STRING",
3719 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
3720 }
3721
3722 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
3723 my $vendor = $1;
3724 `grep -Eq "\\"\\^\Q$vendor\E,\\.\\*\\":" $vp_file`;
3725 if ( $? >> 8 ) {
3726 WARN("UNDOCUMENTED_DT_STRING",
3727 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
3728 }
3729 }
3730 }
3731
3732# check for using SPDX license tag at beginning of files
3733 if ($realline == $checklicenseline) {
3734 if ($rawline =~ /^[ \+]\s*\#\!\s*\//) {
3735 $checklicenseline = 2;
3736 } elsif ($rawline =~ /^\+/) {
3737 my $comment = "";
3738 if ($realfile =~ /\.(h|s|S)$/) {
3739 $comment = '/*';
3740 } elsif ($realfile =~ /\.(c|dts|dtsi)$/) {
3741 $comment = '//';
3742 } elsif (($checklicenseline == 2) || $realfile =~ /\.(sh|pl|py|awk|tc|yaml)$/) {
3743 $comment = '#';
3744 } elsif ($realfile =~ /\.rst$/) {
3745 $comment = '..';
3746 }
3747
3748# check SPDX comment style for .[chsS] files
3749 if ($realfile =~ /\.[chsS]$/ &&
3750 $rawline =~ /SPDX-License-Identifier:/ &&
3751 $rawline !~ m@^\+\s*\Q$comment\E\s*@) {
3752 WARN("SPDX_LICENSE_TAG",
3753 "Improper SPDX comment style for '$realfile', please use '$comment' instead\n" . $herecurr);
3754 }
3755
3756 if ($comment !~ /^$/ &&
3757 $rawline !~ m@^\+\Q$comment\E SPDX-License-Identifier: @) {
3758 WARN("SPDX_LICENSE_TAG",
3759 "Missing or malformed SPDX-License-Identifier tag in line $checklicenseline\n" . $herecurr);
3760 } elsif ($rawline =~ /(SPDX-License-Identifier: .*)/) {
3761 my $spdx_license = $1;
3762 if (!is_SPDX_License_valid($spdx_license)) {
3763 WARN("SPDX_LICENSE_TAG",
3764 "'$spdx_license' is not supported in LICENSES/...\n" . $herecurr);
3765 }
3766 if ($realfile =~ m@^Documentation/devicetree/bindings/@ &&
3767 not $spdx_license =~ /GPL-2\.0.*BSD-2-Clause/) {
3768 my $msg_level = \&WARN;
3769 $msg_level = \&CHK if ($file);
3770 if (&{$msg_level}("SPDX_LICENSE_TAG",
3771
3772 "DT binding documents should be licensed (GPL-2.0-only OR BSD-2-Clause)\n" . $herecurr) &&
3773 $fix) {
3774 $fixed[$fixlinenr] =~ s/SPDX-License-Identifier: .*/SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)/;
3775 }
3776 }
3777 }
3778 }
3779 }
3780
3781# check for embedded filenames
3782 if ($rawline =~ /^\+.*\Q$realfile\E/) {
3783 WARN("EMBEDDED_FILENAME",
3784 "It's generally not useful to have the filename in the file\n" . $herecurr);
3785 }
3786
3787# check we are in a valid source file if not then ignore this hunk
3788 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
3789
3790# check for using SPDX-License-Identifier on the wrong line number
3791 if ($realline != $checklicenseline &&
3792 $rawline =~ /\bSPDX-License-Identifier:/ &&
3793 substr($line, @-, @+ - @-) eq "$;" x (@+ - @-)) {
3794 WARN("SPDX_LICENSE_TAG",
3795 "Misplaced SPDX-License-Identifier tag - use line $checklicenseline instead\n" . $herecurr);
3796 }
3797
3798# line length limit (with some exclusions)
3799#
3800# There are a few types of lines that may extend beyond $max_line_length:
3801# logging functions like pr_info that end in a string
3802# lines with a single string
3803# #defines that are a single string
3804# lines with an RFC3986 like URL
3805#
3806# There are 3 different line length message types:
3807# LONG_LINE_COMMENT a comment starts before but extends beyond $max_line_length
3808# LONG_LINE_STRING a string starts before but extends beyond $max_line_length
3809# LONG_LINE all other lines longer than $max_line_length
3810#
3811# if LONG_LINE is ignored, the other 2 types are also ignored
3812#
3813
3814 if ($line =~ /^\+/ && $length > $max_line_length) {
3815 my $msg_type = "LONG_LINE";
3816
3817 # Check the allowed long line types first
3818
3819 # logging functions that end in a string that starts
3820 # before $max_line_length
3821 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
3822 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3823 $msg_type = "";
3824
3825 # lines with only strings (w/ possible termination)
3826 # #defines with only strings
3827 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
3828 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
3829 $msg_type = "";
3830
3831 # More special cases
3832 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/ ||
3833 $line =~ /^\+\s*(?:\w+)?\s*DEFINE_PER_CPU/) {
3834 $msg_type = "";
3835
3836 # URL ($rawline is used in case the URL is in a comment)
3837 } elsif ($rawline =~ /^\+.*\b[a-z][\w\.\+\-]*:\/\/\S+/i) {
3838 $msg_type = "";
3839
3840 # Otherwise set the alternate message types
3841
3842 # a comment starts before $max_line_length
3843 } elsif ($line =~ /($;[\s$;]*)$/ &&
3844 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3845 $msg_type = "LONG_LINE_COMMENT"
3846
3847 # a quoted string starts before $max_line_length
3848 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
3849 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
3850 $msg_type = "LONG_LINE_STRING"
3851 }
3852
3853 if ($msg_type ne "" &&
3854 (show_type("LONG_LINE") || show_type($msg_type))) {
3855 my $msg_level = \&WARN;
3856 $msg_level = \&CHK if ($file);
3857 &{$msg_level}($msg_type,
3858 "line length of $length exceeds $max_line_length columns\n" . $herecurr);
3859 }
3860 }
3861
3862# check for adding lines without a newline.
3863 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
3864 if (WARN("MISSING_EOF_NEWLINE",
3865 "adding a line without newline at end of file\n" . $herecurr) &&
3866 $fix) {
3867 fix_delete_line($fixlinenr+1, "No newline at end of file");
3868 }
3869 }
3870
3871# check for .L prefix local symbols in .S files
3872 if ($realfile =~ /\.S$/ &&
3873 $line =~ /^\+\s*(?:[A-Z]+_)?SYM_[A-Z]+_(?:START|END)(?:_[A-Z_]+)?\s*\(\s*\.L/) {
3874 WARN("AVOID_L_PREFIX",
3875 "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);
3876 }
3877
3878 if ($u_boot) {
3879 u_boot_line($realfile, $line, $rawline, $herecurr);
3880 }
3881
3882# check we are in a valid source file C or perl if not then ignore this hunk
3883 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
3884
3885# at the beginning of a line any tabs must come first and anything
3886# more than $tabsize must use tabs.
3887 if ($rawline =~ /^\+\s* \t\s*\S/ ||
3888 $rawline =~ /^\+\s* \s*/) {
3889 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3890 $rpt_cleaners = 1;
3891 if (ERROR("CODE_INDENT",
3892 "code indent should use tabs where possible\n" . $herevet) &&
3893 $fix) {
3894 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
3895 }
3896 }
3897
3898# check for space before tabs.
3899 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
3900 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
3901 if (WARN("SPACE_BEFORE_TAB",
3902 "please, no space before tabs\n" . $herevet) &&
3903 $fix) {
3904 while ($fixed[$fixlinenr] =~
3905 s/(^\+.*) {$tabsize,$tabsize}\t/$1\t\t/) {}
3906 while ($fixed[$fixlinenr] =~
3907 s/(^\+.*) +\t/$1\t/) {}
3908 }
3909 }
3910
3911# check for assignments on the start of a line
3912 if ($sline =~ /^\+\s+($Assignment)[^=]/) {
3913 my $operator = $1;
3914 if (CHK("ASSIGNMENT_CONTINUATIONS",
3915 "Assignment operator '$1' should be on the previous line\n" . $hereprev) &&
3916 $fix && $prevrawline =~ /^\+/) {
3917 # add assignment operator to the previous line, remove from current line
3918 $fixed[$fixlinenr - 1] .= " $operator";
3919 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3920 }
3921 }
3922
3923# check for && or || at the start of a line
3924 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
3925 my $operator = $1;
3926 if (CHK("LOGICAL_CONTINUATIONS",
3927 "Logical continuations should be on the previous line\n" . $hereprev) &&
3928 $fix && $prevrawline =~ /^\+/) {
3929 # insert logical operator at last non-comment, non-whitepsace char on previous line
3930 $prevline =~ /[\s$;]*$/;
3931 my $line_end = substr($prevrawline, $-[0]);
3932 $fixed[$fixlinenr - 1] =~ s/\Q$line_end\E$/ $operator$line_end/;
3933 $fixed[$fixlinenr] =~ s/\Q$operator\E\s*//;
3934 }
3935 }
3936
3937# check indentation starts on a tab stop
3938 if ($perl_version_ok &&
3939 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$)|$Declare\s*$Ident\s*[;=])/) {
3940 my $indent = length($1);
3941 if ($indent % $tabsize) {
3942 if (WARN("TABSTOP",
3943 "Statements should start on a tabstop\n" . $herecurr) &&
3944 $fix) {
3945 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/$tabsize)@e;
3946 }
3947 }
3948 }
3949
3950# check multi-line statement indentation matches previous line
3951 if ($perl_version_ok &&
3952 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3953 $prevline =~ /^\+(\t*)(.*)$/;
3954 my $oldindent = $1;
3955 my $rest = $2;
3956
3957 my $pos = pos_last_openparen($rest);
3958 if ($pos >= 0) {
3959 $line =~ /^(\+| )([ \t]*)/;
3960 my $newindent = $2;
3961
3962 my $goodtabindent = $oldindent .
3963 "\t" x ($pos / $tabsize) .
3964 " " x ($pos % $tabsize);
3965 my $goodspaceindent = $oldindent . " " x $pos;
3966
3967 if ($newindent ne $goodtabindent &&
3968 $newindent ne $goodspaceindent) {
3969
3970 if (CHK("PARENTHESIS_ALIGNMENT",
3971 "Alignment should match open parenthesis\n" . $hereprev) &&
3972 $fix && $line =~ /^\+/) {
3973 $fixed[$fixlinenr] =~
3974 s/^\+[ \t]*/\+$goodtabindent/;
3975 }
3976 }
3977 }
3978 }
3979
3980# check for space after cast like "(int) foo" or "(struct foo) bar"
3981# avoid checking a few false positives:
3982# "sizeof(<type>)" or "__alignof__(<type>)"
3983# function pointer declarations like "(*foo)(int) = bar;"
3984# structure definitions like "(struct foo) { 0 };"
3985# multiline macros that define functions
3986# known attributes or the __attribute__ keyword
3987 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3988 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3989 if (CHK("SPACING",
3990 "No space is necessary after a cast\n" . $herecurr) &&
3991 $fix) {
3992 $fixed[$fixlinenr] =~
3993 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3994 }
3995 }
3996
3997# Block comment styles
3998# Networking with an initial /*
3999 if ($realfile =~ m@^(drivers/net/|net/)@ &&
4000 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
4001 $rawline =~ /^\+[ \t]*\*/ &&
4002 $realline > 3) { # Do not warn about the initial copyright comment block after SPDX-License-Identifier
4003 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
4004 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
4005 }
4006
4007# Block comments use * on subsequent lines
4008 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
4009 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
4010 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
4011 $rawline =~ /^\+/ && #line is new
4012 $rawline !~ /^\+[ \t]*\*/) { #no leading *
4013 WARN("BLOCK_COMMENT_STYLE",
4014 "Block comments use * on subsequent lines\n" . $hereprev);
4015 }
4016
4017# Block comments use */ on trailing lines
4018 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
4019 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
4020 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
4021 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
4022 WARN("BLOCK_COMMENT_STYLE",
4023 "Block comments use a trailing */ on a separate line\n" . $herecurr);
4024 }
4025
4026# Block comment * alignment
4027 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
4028 $line =~ /^\+[ \t]*$;/ && #leading comment
4029 $rawline =~ /^\+[ \t]*\*/ && #leading *
4030 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
4031 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
4032 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
4033 my $oldindent;
4034 $prevrawline =~ m@^\+([ \t]*/?)\*@;
4035 if (defined($1)) {
4036 $oldindent = expand_tabs($1);
4037 } else {
4038 $prevrawline =~ m@^\+(.*/?)\*@;
4039 $oldindent = expand_tabs($1);
4040 }
4041 $rawline =~ m@^\+([ \t]*)\*@;
4042 my $newindent = $1;
4043 $newindent = expand_tabs($newindent);
4044 if (length($oldindent) ne length($newindent)) {
4045 WARN("BLOCK_COMMENT_STYLE",
4046 "Block comments should align the * on each line\n" . $hereprev);
4047 }
4048 }
4049
4050# check for missing blank lines after struct/union declarations
4051# with exceptions for various attributes and macros
4052 if ($prevline =~ /^[\+ ]};?\s*$/ &&
4053 $line =~ /^\+/ &&
4054 !($line =~ /^\+\s*$/ ||
4055 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
4056 $line =~ /^\+\s*MODULE_/i ||
4057 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
4058 $line =~ /^\+[a-z_]*init/ ||
4059 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
4060 $line =~ /^\+\s*DECLARE/ ||
4061 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
4062 $line =~ /^\+\s*__setup/)) {
4063 if (CHK("LINE_SPACING",
4064 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
4065 $fix) {
4066 fix_insert_line($fixlinenr, "\+");
4067 }
4068 }
4069
4070# check for multiple consecutive blank lines
4071 if ($prevline =~ /^[\+ ]\s*$/ &&
4072 $line =~ /^\+\s*$/ &&
4073 $last_blank_line != ($linenr - 1)) {
4074 if (CHK("LINE_SPACING",
4075 "Please don't use multiple blank lines\n" . $hereprev) &&
4076 $fix) {
4077 fix_delete_line($fixlinenr, $rawline);
4078 }
4079
4080 $last_blank_line = $linenr;
4081 }
4082
4083# check for missing blank lines after declarations
4084# (declarations must have the same indentation and not be at the start of line)
4085 if (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/) {
4086 # use temporaries
4087 my $sl = $sline;
4088 my $pl = $prevline;
4089 # remove $Attribute/$Sparse uses to simplify comparisons
4090 $sl =~ s/\b(?:$Attribute|$Sparse)\b//g;
4091 $pl =~ s/\b(?:$Attribute|$Sparse)\b//g;
4092 if (($pl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
4093 # function pointer declarations
4094 $pl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
4095 # foo bar; where foo is some local typedef or #define
4096 $pl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
4097 # known declaration macros
4098 $pl =~ /^\+\s+$declaration_macros/) &&
4099 # for "else if" which can look like "$Ident $Ident"
4100 !($pl =~ /^\+\s+$c90_Keywords\b/ ||
4101 # other possible extensions of declaration lines
4102 $pl =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
4103 # not starting a section or a macro "\" extended line
4104 $pl =~ /(?:\{\s*|\\)$/) &&
4105 # looks like a declaration
4106 !($sl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
4107 # function pointer declarations
4108 $sl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
4109 # foo bar; where foo is some local typedef or #define
4110 $sl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
4111 # known declaration macros
4112 $sl =~ /^\+\s+$declaration_macros/ ||
4113 # start of struct or union or enum
4114 $sl =~ /^\+\s+(?:static\s+)?(?:const\s+)?(?:union|struct|enum|typedef)\b/ ||
4115 # start or end of block or continuation of declaration
4116 $sl =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
4117 # bitfield continuation
4118 $sl =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
4119 # other possible extensions of declaration lines
4120 $sl =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/)) {
4121 if (WARN("LINE_SPACING",
4122 "Missing a blank line after declarations\n" . $hereprev) &&
4123 $fix) {
4124 fix_insert_line($fixlinenr, "\+");
4125 }
4126 }
4127 }
4128
4129# check for spaces at the beginning of a line.
4130# Exceptions:
4131# 1) within comments
4132# 2) indented preprocessor commands
4133# 3) hanging labels
4134 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
4135 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
4136 if (WARN("LEADING_SPACE",
4137 "please, no spaces at the start of a line\n" . $herevet) &&
4138 $fix) {
4139 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
4140 }
4141 }
4142
4143# check we are in a valid C source file if not then ignore this hunk
4144 next if ($realfile !~ /\.(h|c)$/);
4145
4146# check for unusual line ending [ or (
4147 if ($line =~ /^\+.*([\[\(])\s*$/) {
4148 CHK("OPEN_ENDED_LINE",
4149 "Lines should not end with a '$1'\n" . $herecurr);
4150 }
4151
4152# check if this appears to be the start function declaration, save the name
4153 if ($sline =~ /^\+\{\s*$/ &&
4154 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
4155 $context_function = $1;
4156 }
4157
4158# check if this appears to be the end of function declaration
4159 if ($sline =~ /^\+\}\s*$/) {
4160 undef $context_function;
4161 }
4162
4163# check indentation of any line with a bare else
4164# (but not if it is a multiple line "if (foo) return bar; else return baz;")
4165# if the previous line is a break or return and is indented 1 tab more...
4166 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
4167 my $tabs = length($1) + 1;
4168 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
4169 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
4170 defined $lines[$linenr] &&
4171 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
4172 WARN("UNNECESSARY_ELSE",
4173 "else is not generally useful after a break or return\n" . $hereprev);
4174 }
4175 }
4176
4177# check indentation of a line with a break;
4178# if the previous line is a goto, return or break
4179# and is indented the same # of tabs
4180 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
4181 my $tabs = $1;
4182 if ($prevline =~ /^\+$tabs(goto|return|break)\b/) {
4183 if (WARN("UNNECESSARY_BREAK",
4184 "break is not useful after a $1\n" . $hereprev) &&
4185 $fix) {
4186 fix_delete_line($fixlinenr, $rawline);
4187 }
4188 }
4189 }
4190
4191# check for RCS/CVS revision markers
4192 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
4193 WARN("CVS_KEYWORD",
4194 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
4195 }
4196
4197# check for old HOTPLUG __dev<foo> section markings
4198 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
4199 WARN("HOTPLUG_SECTION",
4200 "Using $1 is unnecessary\n" . $herecurr);
4201 }
4202
4203# Check for potential 'bare' types
4204 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
4205 $realline_next);
4206#print "LINE<$line>\n";
4207 if ($linenr > $suppress_statement &&
4208 $realcnt && $sline =~ /.\s*\S/) {
4209 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4210 ctx_statement_block($linenr, $realcnt, 0);
4211 $stat =~ s/\n./\n /g;
4212 $cond =~ s/\n./\n /g;
4213
4214#print "linenr<$linenr> <$stat>\n";
4215 # If this statement has no statement boundaries within
4216 # it there is no point in retrying a statement scan
4217 # until we hit end of it.
4218 my $frag = $stat; $frag =~ s/;+\s*$//;
4219 if ($frag !~ /(?:{|;)/) {
4220#print "skip<$line_nr_next>\n";
4221 $suppress_statement = $line_nr_next;
4222 }
4223
4224 # Find the real next line.
4225 $realline_next = $line_nr_next;
4226 if (defined $realline_next &&
4227 (!defined $lines[$realline_next - 1] ||
4228 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
4229 $realline_next++;
4230 }
4231
4232 my $s = $stat;
4233 $s =~ s/{.*$//s;
4234
4235 # Ignore goto labels.
4236 if ($s =~ /$Ident:\*$/s) {
4237
4238 # Ignore functions being called
4239 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
4240
4241 } elsif ($s =~ /^.\s*else\b/s) {
4242
4243 # declarations always start with types
4244 } 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) {
4245 my $type = $1;
4246 $type =~ s/\s+/ /g;
4247 possible($type, "A:" . $s);
4248
4249 # definitions in global scope can only start with types
4250 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
4251 possible($1, "B:" . $s);
4252 }
4253
4254 # any (foo ... *) is a pointer cast, and foo is a type
4255 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
4256 possible($1, "C:" . $s);
4257 }
4258
4259 # Check for any sort of function declaration.
4260 # int foo(something bar, other baz);
4261 # void (*store_gdt)(x86_descr_ptr *);
4262 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
4263 my ($name_len) = length($1);
4264
4265 my $ctx = $s;
4266 substr($ctx, 0, $name_len + 1, '');
4267 $ctx =~ s/\)[^\)]*$//;
4268
4269 for my $arg (split(/\s*,\s*/, $ctx)) {
4270 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
4271
4272 possible($1, "D:" . $s);
4273 }
4274 }
4275 }
4276
4277 }
4278
4279#
4280# Checks which may be anchored in the context.
4281#
4282
4283# Check for switch () and associated case and default
4284# statements should be at the same indent.
4285 if ($line=~/\bswitch\s*\(.*\)/) {
4286 my $err = '';
4287 my $sep = '';
4288 my @ctx = ctx_block_outer($linenr, $realcnt);
4289 shift(@ctx);
4290 for my $ctx (@ctx) {
4291 my ($clen, $cindent) = line_stats($ctx);
4292 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
4293 $indent != $cindent) {
4294 $err .= "$sep$ctx\n";
4295 $sep = '';
4296 } else {
4297 $sep = "[...]\n";
4298 }
4299 }
4300 if ($err ne '') {
4301 ERROR("SWITCH_CASE_INDENT_LEVEL",
4302 "switch and case should be at the same indent\n$hereline$err");
4303 }
4304 }
4305
4306# if/while/etc brace do not go on next line, unless defining a do while loop,
4307# or if that brace on the next line is for something else
4308 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
4309 my $pre_ctx = "$1$2";
4310
4311 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
4312
4313 if ($line =~ /^\+\t{6,}/) {
4314 WARN("DEEP_INDENTATION",
4315 "Too many leading tabs - consider code refactoring\n" . $herecurr);
4316 }
4317
4318 my $ctx_cnt = $realcnt - $#ctx - 1;
4319 my $ctx = join("\n", @ctx);
4320
4321 my $ctx_ln = $linenr;
4322 my $ctx_skip = $realcnt;
4323
4324 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
4325 defined $lines[$ctx_ln - 1] &&
4326 $lines[$ctx_ln - 1] =~ /^-/)) {
4327 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
4328 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
4329 $ctx_ln++;
4330 }
4331
4332 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
4333 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
4334
4335 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
4336 ERROR("OPEN_BRACE",
4337 "that open brace { should be on the previous line\n" .
4338 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4339 }
4340 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
4341 $ctx =~ /\)\s*\;\s*$/ &&
4342 defined $lines[$ctx_ln - 1])
4343 {
4344 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
4345 if ($nindent > $indent) {
4346 WARN("TRAILING_SEMICOLON",
4347 "trailing semicolon indicates no statements, indent implies otherwise\n" .
4348 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4349 }
4350 }
4351 }
4352
4353# Check relative indent for conditionals and blocks.
4354 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
4355 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4356 ctx_statement_block($linenr, $realcnt, 0)
4357 if (!defined $stat);
4358 my ($s, $c) = ($stat, $cond);
4359
4360 substr($s, 0, length($c), '');
4361
4362 # remove inline comments
4363 $s =~ s/$;/ /g;
4364 $c =~ s/$;/ /g;
4365
4366 # Find out how long the conditional actually is.
4367 my @newlines = ($c =~ /\n/gs);
4368 my $cond_lines = 1 + $#newlines;
4369
4370 # Make sure we remove the line prefixes as we have
4371 # none on the first line, and are going to readd them
4372 # where necessary.
4373 $s =~ s/\n./\n/gs;
4374 while ($s =~ /\n\s+\\\n/) {
4375 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
4376 }
4377
4378 # We want to check the first line inside the block
4379 # starting at the end of the conditional, so remove:
4380 # 1) any blank line termination
4381 # 2) any opening brace { on end of the line
4382 # 3) any do (...) {
4383 my $continuation = 0;
4384 my $check = 0;
4385 $s =~ s/^.*\bdo\b//;
4386 $s =~ s/^\s*{//;
4387 if ($s =~ s/^\s*\\//) {
4388 $continuation = 1;
4389 }
4390 if ($s =~ s/^\s*?\n//) {
4391 $check = 1;
4392 $cond_lines++;
4393 }
4394
4395 # Also ignore a loop construct at the end of a
4396 # preprocessor statement.
4397 if (($prevline =~ /^.\s*#\s*define\s/ ||
4398 $prevline =~ /\\\s*$/) && $continuation == 0) {
4399 $check = 0;
4400 }
4401
4402 my $cond_ptr = -1;
4403 $continuation = 0;
4404 while ($cond_ptr != $cond_lines) {
4405 $cond_ptr = $cond_lines;
4406
4407 # If we see an #else/#elif then the code
4408 # is not linear.
4409 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
4410 $check = 0;
4411 }
4412
4413 # Ignore:
4414 # 1) blank lines, they should be at 0,
4415 # 2) preprocessor lines, and
4416 # 3) labels.
4417 if ($continuation ||
4418 $s =~ /^\s*?\n/ ||
4419 $s =~ /^\s*#\s*?/ ||
4420 $s =~ /^\s*$Ident\s*:/) {
4421 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
4422 if ($s =~ s/^.*?\n//) {
4423 $cond_lines++;
4424 }
4425 }
4426 }
4427
4428 my (undef, $sindent) = line_stats("+" . $s);
4429 my $stat_real = raw_line($linenr, $cond_lines);
4430
4431 # Check if either of these lines are modified, else
4432 # this is not this patch's fault.
4433 if (!defined($stat_real) ||
4434 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
4435 $check = 0;
4436 }
4437 if (defined($stat_real) && $cond_lines > 1) {
4438 $stat_real = "[...]\n$stat_real";
4439 }
4440
4441 #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";
4442
4443 if ($check && $s ne '' &&
4444 (($sindent % $tabsize) != 0 ||
4445 ($sindent < $indent) ||
4446 ($sindent == $indent &&
4447 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
4448 ($sindent > $indent + $tabsize))) {
4449 WARN("SUSPECT_CODE_INDENT",
4450 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
4451 }
4452 }
4453
4454 # Track the 'values' across context and added lines.
4455 my $opline = $line; $opline =~ s/^./ /;
4456 my ($curr_values, $curr_vars) =
4457 annotate_values($opline . "\n", $prev_values);
4458 $curr_values = $prev_values . $curr_values;
4459 if ($dbg_values) {
4460 my $outline = $opline; $outline =~ s/\t/ /g;
4461 print "$linenr > .$outline\n";
4462 print "$linenr > $curr_values\n";
4463 print "$linenr > $curr_vars\n";
4464 }
4465 $prev_values = substr($curr_values, -1);
4466
4467#ignore lines not being added
4468 next if ($line =~ /^[^\+]/);
4469
4470# check for self assignments used to avoid compiler warnings
4471# e.g.: int foo = foo, *bar = NULL;
4472# struct foo bar = *(&(bar));
4473 if ($line =~ /^\+\s*(?:$Declare)?([A-Za-z_][A-Za-z\d_]*)\s*=/) {
4474 my $var = $1;
4475 if ($line =~ /^\+\s*(?:$Declare)?$var\s*=\s*(?:$var|\*\s*\(?\s*&\s*\(?\s*$var\s*\)?\s*\)?)\s*[;,]/) {
4476 WARN("SELF_ASSIGNMENT",
4477 "Do not use self-assignments to avoid compiler warnings\n" . $herecurr);
4478 }
4479 }
4480
4481# check for dereferences that span multiple lines
4482 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
4483 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
4484 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
4485 my $ref = $1;
4486 $line =~ /^.\s*($Lval)/;
4487 $ref .= $1;
4488 $ref =~ s/\s//g;
4489 WARN("MULTILINE_DEREFERENCE",
4490 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
4491 }
4492
4493# check for declarations of signed or unsigned without int
4494 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
4495 my $type = $1;
4496 my $var = $2;
4497 $var = "" if (!defined $var);
4498 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
4499 my $sign = $1;
4500 my $pointer = $2;
4501
4502 $pointer = "" if (!defined $pointer);
4503
4504 if (WARN("UNSPECIFIED_INT",
4505 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
4506 $fix) {
4507 my $decl = trim($sign) . " int ";
4508 my $comp_pointer = $pointer;
4509 $comp_pointer =~ s/\s//g;
4510 $decl .= $comp_pointer;
4511 $decl = rtrim($decl) if ($var eq "");
4512 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
4513 }
4514 }
4515 }
4516
4517# TEST: allow direct testing of the type matcher.
4518 if ($dbg_type) {
4519 if ($line =~ /^.\s*$Declare\s*$/) {
4520 ERROR("TEST_TYPE",
4521 "TEST: is type\n" . $herecurr);
4522 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
4523 ERROR("TEST_NOT_TYPE",
4524 "TEST: is not type ($1 is)\n". $herecurr);
4525 }
4526 next;
4527 }
4528# TEST: allow direct testing of the attribute matcher.
4529 if ($dbg_attr) {
4530 if ($line =~ /^.\s*$Modifier\s*$/) {
4531 ERROR("TEST_ATTR",
4532 "TEST: is attr\n" . $herecurr);
4533 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
4534 ERROR("TEST_NOT_ATTR",
4535 "TEST: is not attr ($1 is)\n". $herecurr);
4536 }
4537 next;
4538 }
4539
4540# check for initialisation to aggregates open brace on the next line
4541 if ($line =~ /^.\s*{/ &&
4542 $prevline =~ /(?:^|[^=])=\s*$/) {
4543 if (ERROR("OPEN_BRACE",
4544 "that open brace { should be on the previous line\n" . $hereprev) &&
4545 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4546 fix_delete_line($fixlinenr - 1, $prevrawline);
4547 fix_delete_line($fixlinenr, $rawline);
4548 my $fixedline = $prevrawline;
4549 $fixedline =~ s/\s*=\s*$/ = {/;
4550 fix_insert_line($fixlinenr, $fixedline);
4551 $fixedline = $line;
4552 $fixedline =~ s/^(.\s*)\{\s*/$1/;
4553 fix_insert_line($fixlinenr, $fixedline);
4554 }
4555 }
4556
4557#
4558# Checks which are anchored on the added line.
4559#
4560
4561# check for malformed paths in #include statements (uses RAW line)
4562 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
4563 my $path = $1;
4564 if ($path =~ m{//}) {
4565 ERROR("MALFORMED_INCLUDE",
4566 "malformed #include filename\n" . $herecurr);
4567 }
4568 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
4569 ERROR("UAPI_INCLUDE",
4570 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
4571 }
4572 }
4573
4574# no C99 // comments
4575 if ($line =~ m{//}) {
4576 if (ERROR("C99_COMMENTS",
4577 "do not use C99 // comments\n" . $herecurr) &&
4578 $fix) {
4579 my $line = $fixed[$fixlinenr];
4580 if ($line =~ /\/\/(.*)$/) {
4581 my $comment = trim($1);
4582 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
4583 }
4584 }
4585 }
4586 # Remove C99 comments.
4587 $line =~ s@//.*@@;
4588 $opline =~ s@//.*@@;
4589
4590# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
4591# the whole statement.
4592#print "APW <$lines[$realline_next - 1]>\n";
4593 if (defined $realline_next &&
4594 exists $lines[$realline_next - 1] &&
4595 !defined $suppress_export{$realline_next} &&
4596 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4597 # Handle definitions which produce identifiers with
4598 # a prefix:
4599 # XXX(foo);
4600 # EXPORT_SYMBOL(something_foo);
4601 my $name = $1;
4602 $name =~ s/^\s*($Ident).*/$1/;
4603 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
4604 $name =~ /^${Ident}_$2/) {
4605#print "FOO C name<$name>\n";
4606 $suppress_export{$realline_next} = 1;
4607
4608 } elsif ($stat !~ /(?:
4609 \n.}\s*$|
4610 ^.DEFINE_$Ident\(\Q$name\E\)|
4611 ^.DECLARE_$Ident\(\Q$name\E\)|
4612 ^.LIST_HEAD\(\Q$name\E\)|
4613 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
4614 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
4615 )/x) {
4616#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
4617 $suppress_export{$realline_next} = 2;
4618 } else {
4619 $suppress_export{$realline_next} = 1;
4620 }
4621 }
4622 if (!defined $suppress_export{$linenr} &&
4623 $prevline =~ /^.\s*$/ &&
4624 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4625#print "FOO B <$lines[$linenr - 1]>\n";
4626 $suppress_export{$linenr} = 2;
4627 }
4628 if (defined $suppress_export{$linenr} &&
4629 $suppress_export{$linenr} == 2) {
4630 WARN("EXPORT_SYMBOL",
4631 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
4632 }
4633
4634# check for global initialisers.
4635 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/ &&
4636 !exclude_global_initialisers($realfile)) {
4637 if (ERROR("GLOBAL_INITIALISERS",
4638 "do not initialise globals to $1\n" . $herecurr) &&
4639 $fix) {
4640 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
4641 }
4642 }
4643# check for static initialisers.
4644 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
4645 if (ERROR("INITIALISED_STATIC",
4646 "do not initialise statics to $1\n" .
4647 $herecurr) &&
4648 $fix) {
4649 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
4650 }
4651 }
4652
4653# check for misordered declarations of char/short/int/long with signed/unsigned
4654 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
4655 my $tmp = trim($1);
4656 WARN("MISORDERED_TYPE",
4657 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
4658 }
4659
4660# check for unnecessary <signed> int declarations of short/long/long long
4661 while ($sline =~ m{\b($TypeMisordered(\s*\*)*|$C90_int_types)\b}g) {
4662 my $type = trim($1);
4663 next if ($type !~ /\bint\b/);
4664 next if ($type !~ /\b(?:short|long\s+long|long)\b/);
4665 my $new_type = $type;
4666 $new_type =~ s/\b\s*int\s*\b/ /;
4667 $new_type =~ s/\b\s*(?:un)?signed\b\s*/ /;
4668 $new_type =~ s/^const\s+//;
4669 $new_type = "unsigned $new_type" if ($type =~ /\bunsigned\b/);
4670 $new_type = "const $new_type" if ($type =~ /^const\b/);
4671 $new_type =~ s/\s+/ /g;
4672 $new_type = trim($new_type);
4673 if (WARN("UNNECESSARY_INT",
4674 "Prefer '$new_type' over '$type' as the int is unnecessary\n" . $herecurr) &&
4675 $fix) {
4676 $fixed[$fixlinenr] =~ s/\b\Q$type\E\b/$new_type/;
4677 }
4678 }
4679
4680# check for static const char * arrays.
4681 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
4682 WARN("STATIC_CONST_CHAR_ARRAY",
4683 "static const char * array should probably be static const char * const\n" .
4684 $herecurr);
4685 }
4686
4687# check for initialized const char arrays that should be static const
4688 if ($line =~ /^\+\s*const\s+(char|unsigned\s+char|_*u8|(?:[us]_)?int8_t)\s+\w+\s*\[\s*(?:\w+\s*)?\]\s*=\s*"/) {
4689 if (WARN("STATIC_CONST_CHAR_ARRAY",
4690 "const array should probably be static const\n" . $herecurr) &&
4691 $fix) {
4692 $fixed[$fixlinenr] =~ s/(^.\s*)const\b/${1}static const/;
4693 }
4694 }
4695
4696# check for static char foo[] = "bar" declarations.
4697 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
4698 WARN("STATIC_CONST_CHAR_ARRAY",
4699 "static char array declaration should probably be static const char\n" .
4700 $herecurr);
4701 }
4702
4703# check for const <foo> const where <foo> is not a pointer or array type
4704 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
4705 my $found = $1;
4706 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
4707 WARN("CONST_CONST",
4708 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
4709 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
4710 WARN("CONST_CONST",
4711 "'const $found const' should probably be 'const $found'\n" . $herecurr);
4712 }
4713 }
4714
4715# check for const static or static <non ptr type> const declarations
4716# prefer 'static const <foo>' over 'const static <foo>' and 'static <foo> const'
4717 if ($sline =~ /^\+\s*const\s+static\s+($Type)\b/ ||
4718 $sline =~ /^\+\s*static\s+($BasicType)\s+const\b/) {
4719 if (WARN("STATIC_CONST",
4720 "Move const after static - use 'static const $1'\n" . $herecurr) &&
4721 $fix) {
4722 $fixed[$fixlinenr] =~ s/\bconst\s+static\b/static const/;
4723 $fixed[$fixlinenr] =~ s/\bstatic\s+($BasicType)\s+const\b/static const $1/;
4724 }
4725 }
4726
4727# check for non-global char *foo[] = {"bar", ...} declarations.
4728 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
4729 WARN("STATIC_CONST_CHAR_ARRAY",
4730 "char * array declaration might be better as static const\n" .
4731 $herecurr);
4732 }
4733
4734# check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
4735 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
4736 my $array = $1;
4737 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
4738 my $array_div = $1;
4739 if (WARN("ARRAY_SIZE",
4740 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
4741 $fix) {
4742 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
4743 }
4744 }
4745 }
4746
4747# check for function declarations without arguments like "int foo()"
4748 if ($line =~ /(\b$Type\s*$Ident)\s*\(\s*\)/) {
4749 if (ERROR("FUNCTION_WITHOUT_ARGS",
4750 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
4751 $fix) {
4752 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
4753 }
4754 }
4755
4756# check for new typedefs, only function parameters and sparse annotations
4757# make sense.
4758 if ($line =~ /\btypedef\s/ &&
4759 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
4760 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
4761 $line !~ /\b$typeTypedefs\b/ &&
4762 $line !~ /\b__bitwise\b/) {
4763 WARN("NEW_TYPEDEFS",
4764 "do not add new typedefs\n" . $herecurr);
4765 }
4766
4767# * goes on variable not on type
4768 # (char*[ const])
4769 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
4770 #print "AA<$1>\n";
4771 my ($ident, $from, $to) = ($1, $2, $2);
4772
4773 # Should start with a space.
4774 $to =~ s/^(\S)/ $1/;
4775 # Should not end with a space.
4776 $to =~ s/\s+$//;
4777 # '*'s should not have spaces between.
4778 while ($to =~ s/\*\s+\*/\*\*/) {
4779 }
4780
4781## print "1: from<$from> to<$to> ident<$ident>\n";
4782 if ($from ne $to) {
4783 if (ERROR("POINTER_LOCATION",
4784 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
4785 $fix) {
4786 my $sub_from = $ident;
4787 my $sub_to = $ident;
4788 $sub_to =~ s/\Q$from\E/$to/;
4789 $fixed[$fixlinenr] =~
4790 s@\Q$sub_from\E@$sub_to@;
4791 }
4792 }
4793 }
4794 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
4795 #print "BB<$1>\n";
4796 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
4797
4798 # Should start with a space.
4799 $to =~ s/^(\S)/ $1/;
4800 # Should not end with a space.
4801 $to =~ s/\s+$//;
4802 # '*'s should not have spaces between.
4803 while ($to =~ s/\*\s+\*/\*\*/) {
4804 }
4805 # Modifiers should have spaces.
4806 $to =~ s/(\b$Modifier$)/$1 /;
4807
4808## print "2: from<$from> to<$to> ident<$ident>\n";
4809 if ($from ne $to && $ident !~ /^$Modifier$/) {
4810 if (ERROR("POINTER_LOCATION",
4811 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
4812 $fix) {
4813
4814 my $sub_from = $match;
4815 my $sub_to = $match;
4816 $sub_to =~ s/\Q$from\E/$to/;
4817 $fixed[$fixlinenr] =~
4818 s@\Q$sub_from\E@$sub_to@;
4819 }
4820 }
4821 }
4822
4823# avoid BUG() or BUG_ON()
4824 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
4825 my $msg_level = \&WARN;
4826 $msg_level = \&CHK if ($file);
4827 &{$msg_level}("AVOID_BUG",
4828 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
4829 }
4830
4831# avoid LINUX_VERSION_CODE
4832 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
4833 WARN("LINUX_VERSION_CODE",
4834 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
4835 }
4836
4837# check for uses of printk_ratelimit
4838 if ($line =~ /\bprintk_ratelimit\s*\(/) {
4839 WARN("PRINTK_RATELIMITED",
4840 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
4841 }
4842
4843# printk should use KERN_* levels
4844 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
4845 WARN("PRINTK_WITHOUT_KERN_LEVEL",
4846 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
4847 }
4848
4849# prefer variants of (subsystem|netdev|dev|pr)_<level> to printk(KERN_<LEVEL>
4850 if ($line =~ /\b(printk(_once|_ratelimited)?)\s*\(\s*KERN_([A-Z]+)/) {
4851 my $printk = $1;
4852 my $modifier = $2;
4853 my $orig = $3;
4854 $modifier = "" if (!defined($modifier));
4855 my $level = lc($orig);
4856 $level = "warn" if ($level eq "warning");
4857 my $level2 = $level;
4858 $level2 = "dbg" if ($level eq "debug");
4859 $level .= $modifier;
4860 $level2 .= $modifier;
4861 WARN("PREFER_PR_LEVEL",
4862 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to $printk(KERN_$orig ...\n" . $herecurr);
4863 }
4864
4865# prefer dev_<level> to dev_printk(KERN_<LEVEL>
4866 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
4867 my $orig = $1;
4868 my $level = lc($orig);
4869 $level = "warn" if ($level eq "warning");
4870 $level = "dbg" if ($level eq "debug");
4871 WARN("PREFER_DEV_LEVEL",
4872 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
4873 }
4874
4875# trace_printk should not be used in production code.
4876 if ($line =~ /\b(trace_printk|trace_puts|ftrace_vprintk)\s*\(/) {
4877 WARN("TRACE_PRINTK",
4878 "Do not use $1() in production code (this can be ignored if built only with a debug config option)\n" . $herecurr);
4879 }
4880
4881# ENOSYS means "bad syscall nr" and nothing else. This will have a small
4882# number of false positives, but assembly files are not checked, so at
4883# least the arch entry code will not trigger this warning.
4884 if ($line =~ /\bENOSYS\b/) {
4885 WARN("ENOSYS",
4886 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
4887 }
4888
4889# ENOTSUPP is not a standard error code and should be avoided in new patches.
4890# Folks usually mean EOPNOTSUPP (also called ENOTSUP), when they type ENOTSUPP.
4891# Similarly to ENOSYS warning a small number of false positives is expected.
4892 if (!$file && $line =~ /\bENOTSUPP\b/) {
4893 if (WARN("ENOTSUPP",
4894 "ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP\n" . $herecurr) &&
4895 $fix) {
4896 $fixed[$fixlinenr] =~ s/\bENOTSUPP\b/EOPNOTSUPP/;
4897 }
4898 }
4899
4900# function brace can't be on same line, except for #defines of do while,
4901# or if closed on same line
4902 if ($perl_version_ok &&
4903 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
4904 $sline !~ /\#\s*define\b.*do\s*\{/ &&
4905 $sline !~ /}/) {
4906 if (ERROR("OPEN_BRACE",
4907 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
4908 $fix) {
4909 fix_delete_line($fixlinenr, $rawline);
4910 my $fixed_line = $rawline;
4911 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*)\{(.*)$/;
4912 my $line1 = $1;
4913 my $line2 = $2;
4914 fix_insert_line($fixlinenr, ltrim($line1));
4915 fix_insert_line($fixlinenr, "\+{");
4916 if ($line2 !~ /^\s*$/) {
4917 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
4918 }
4919 }
4920 }
4921
4922# open braces for enum, union and struct go on the same line.
4923 if ($line =~ /^.\s*{/ &&
4924 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
4925 if (ERROR("OPEN_BRACE",
4926 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
4927 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4928 fix_delete_line($fixlinenr - 1, $prevrawline);
4929 fix_delete_line($fixlinenr, $rawline);
4930 my $fixedline = rtrim($prevrawline) . " {";
4931 fix_insert_line($fixlinenr, $fixedline);
4932 $fixedline = $rawline;
4933 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
4934 if ($fixedline !~ /^\+\s*$/) {
4935 fix_insert_line($fixlinenr, $fixedline);
4936 }
4937 }
4938 }
4939
4940# missing space after union, struct or enum definition
4941 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4942 if (WARN("SPACING",
4943 "missing space after $1 definition\n" . $herecurr) &&
4944 $fix) {
4945 $fixed[$fixlinenr] =~
4946 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4947 }
4948 }
4949
4950# Function pointer declarations
4951# check spacing between type, funcptr, and args
4952# canonical declaration is "type (*funcptr)(args...)"
4953 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4954 my $declare = $1;
4955 my $pre_pointer_space = $2;
4956 my $post_pointer_space = $3;
4957 my $funcname = $4;
4958 my $post_funcname_space = $5;
4959 my $pre_args_space = $6;
4960
4961# the $Declare variable will capture all spaces after the type
4962# so check it for a missing trailing missing space but pointer return types
4963# don't need a space so don't warn for those.
4964 my $post_declare_space = "";
4965 if ($declare =~ /(\s+)$/) {
4966 $post_declare_space = $1;
4967 $declare = rtrim($declare);
4968 }
4969 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4970 WARN("SPACING",
4971 "missing space after return type\n" . $herecurr);
4972 $post_declare_space = " ";
4973 }
4974
4975# unnecessary space "type (*funcptr)(args...)"
4976# This test is not currently implemented because these declarations are
4977# equivalent to
4978# int foo(int bar, ...)
4979# and this is form shouldn't/doesn't generate a checkpatch warning.
4980#
4981# elsif ($declare =~ /\s{2,}$/) {
4982# WARN("SPACING",
4983# "Multiple spaces after return type\n" . $herecurr);
4984# }
4985
4986# unnecessary space "type ( *funcptr)(args...)"
4987 if (defined $pre_pointer_space &&
4988 $pre_pointer_space =~ /^\s/) {
4989 WARN("SPACING",
4990 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
4991 }
4992
4993# unnecessary space "type (* funcptr)(args...)"
4994 if (defined $post_pointer_space &&
4995 $post_pointer_space =~ /^\s/) {
4996 WARN("SPACING",
4997 "Unnecessary space before function pointer name\n" . $herecurr);
4998 }
4999
5000# unnecessary space "type (*funcptr )(args...)"
5001 if (defined $post_funcname_space &&
5002 $post_funcname_space =~ /^\s/) {
5003 WARN("SPACING",
5004 "Unnecessary space after function pointer name\n" . $herecurr);
5005 }
5006
5007# unnecessary space "type (*funcptr) (args...)"
5008 if (defined $pre_args_space &&
5009 $pre_args_space =~ /^\s/) {
5010 WARN("SPACING",
5011 "Unnecessary space before function pointer arguments\n" . $herecurr);
5012 }
5013
5014 if (show_type("SPACING") && $fix) {
5015 $fixed[$fixlinenr] =~
5016 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
5017 }
5018 }
5019
5020# check for spacing round square brackets; allowed:
5021# 1. with a type on the left -- int [] a;
5022# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
5023# 3. inside a curly brace -- = { [0...10] = 5 }
5024 while ($line =~ /(.*?\s)\[/g) {
5025 my ($where, $prefix) = ($-[1], $1);
5026 if ($prefix !~ /$Type\s+$/ &&
5027 ($where != 0 || $prefix !~ /^.\s+$/) &&
5028 $prefix !~ /[{,:]\s+$/) {
5029 if (ERROR("BRACKET_SPACE",
5030 "space prohibited before open square bracket '['\n" . $herecurr) &&
5031 $fix) {
5032 $fixed[$fixlinenr] =~
5033 s/^(\+.*?)\s+\[/$1\[/;
5034 }
5035 }
5036 }
5037
5038# check for spaces between functions and their parentheses.
5039 while ($line =~ /($Ident)\s+\(/g) {
5040 my $name = $1;
5041 my $ctx_before = substr($line, 0, $-[1]);
5042 my $ctx = "$ctx_before$name";
5043
5044 # Ignore those directives where spaces _are_ permitted.
5045 if ($name =~ /^(?:
5046 if|for|while|switch|return|case|
5047 volatile|__volatile__|
5048 __attribute__|format|__extension__|
5049 asm|__asm__)$/x)
5050 {
5051 # cpp #define statements have non-optional spaces, ie
5052 # if there is a space between the name and the open
5053 # parenthesis it is simply not a parameter group.
5054 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
5055
5056 # cpp #elif statement condition may start with a (
5057 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
5058
5059 # If this whole things ends with a type its most
5060 # likely a typedef for a function.
5061 } elsif ($ctx =~ /$Type$/) {
5062
5063 } else {
5064 if (WARN("SPACING",
5065 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
5066 $fix) {
5067 $fixed[$fixlinenr] =~
5068 s/\b$name\s+\(/$name\(/;
5069 }
5070 }
5071 }
5072
5073# Check operator spacing.
5074 if (!($line=~/\#\s*include/)) {
5075 my $fixed_line = "";
5076 my $line_fixed = 0;
5077
5078 my $ops = qr{
5079 <<=|>>=|<=|>=|==|!=|
5080 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
5081 =>|->|<<|>>|<|>|=|!|~|
5082 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
5083 \?:|\?|:
5084 }x;
5085 my @elements = split(/($ops|;)/, $opline);
5086
5087## print("element count: <" . $#elements . ">\n");
5088## foreach my $el (@elements) {
5089## print("el: <$el>\n");
5090## }
5091
5092 my @fix_elements = ();
5093 my $off = 0;
5094
5095 foreach my $el (@elements) {
5096 push(@fix_elements, substr($rawline, $off, length($el)));
5097 $off += length($el);
5098 }
5099
5100 $off = 0;
5101
5102 my $blank = copy_spacing($opline);
5103 my $last_after = -1;
5104
5105 for (my $n = 0; $n < $#elements; $n += 2) {
5106
5107 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
5108
5109## print("n: <$n> good: <$good>\n");
5110
5111 $off += length($elements[$n]);
5112
5113 # Pick up the preceding and succeeding characters.
5114 my $ca = substr($opline, 0, $off);
5115 my $cc = '';
5116 if (length($opline) >= ($off + length($elements[$n + 1]))) {
5117 $cc = substr($opline, $off + length($elements[$n + 1]));
5118 }
5119 my $cb = "$ca$;$cc";
5120
5121 my $a = '';
5122 $a = 'V' if ($elements[$n] ne '');
5123 $a = 'W' if ($elements[$n] =~ /\s$/);
5124 $a = 'C' if ($elements[$n] =~ /$;$/);
5125 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
5126 $a = 'O' if ($elements[$n] eq '');
5127 $a = 'E' if ($ca =~ /^\s*$/);
5128
5129 my $op = $elements[$n + 1];
5130
5131 my $c = '';
5132 if (defined $elements[$n + 2]) {
5133 $c = 'V' if ($elements[$n + 2] ne '');
5134 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
5135 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
5136 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
5137 $c = 'O' if ($elements[$n + 2] eq '');
5138 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
5139 } else {
5140 $c = 'E';
5141 }
5142
5143 my $ctx = "${a}x${c}";
5144
5145 my $at = "(ctx:$ctx)";
5146
5147 my $ptr = substr($blank, 0, $off) . "^";
5148 my $hereptr = "$hereline$ptr\n";
5149
5150 # Pull out the value of this operator.
5151 my $op_type = substr($curr_values, $off + 1, 1);
5152
5153 # Get the full operator variant.
5154 my $opv = $op . substr($curr_vars, $off, 1);
5155
5156 # Ignore operators passed as parameters.
5157 if ($op_type ne 'V' &&
5158 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
5159
5160# # Ignore comments
5161# } elsif ($op =~ /^$;+$/) {
5162
5163 # ; should have either the end of line or a space or \ after it
5164 } elsif ($op eq ';') {
5165 if ($ctx !~ /.x[WEBC]/ &&
5166 $cc !~ /^\\/ && $cc !~ /^;/) {
5167 if (ERROR("SPACING",
5168 "space required after that '$op' $at\n" . $hereptr)) {
5169 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5170 $line_fixed = 1;
5171 }
5172 }
5173
5174 # // is a comment
5175 } elsif ($op eq '//') {
5176
5177 # : when part of a bitfield
5178 } elsif ($opv eq ':B') {
5179 # skip the bitfield test for now
5180
5181 # No spaces for:
5182 # ->
5183 } elsif ($op eq '->') {
5184 if ($ctx =~ /Wx.|.xW/) {
5185 if (ERROR("SPACING",
5186 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
5187 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5188 if (defined $fix_elements[$n + 2]) {
5189 $fix_elements[$n + 2] =~ s/^\s+//;
5190 }
5191 $line_fixed = 1;
5192 }
5193 }
5194
5195 # , must not have a space before and must have a space on the right.
5196 } elsif ($op eq ',') {
5197 my $rtrim_before = 0;
5198 my $space_after = 0;
5199 if ($ctx =~ /Wx./) {
5200 if (ERROR("SPACING",
5201 "space prohibited before that '$op' $at\n" . $hereptr)) {
5202 $line_fixed = 1;
5203 $rtrim_before = 1;
5204 }
5205 }
5206 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
5207 if (ERROR("SPACING",
5208 "space required after that '$op' $at\n" . $hereptr)) {
5209 $line_fixed = 1;
5210 $last_after = $n;
5211 $space_after = 1;
5212 }
5213 }
5214 if ($rtrim_before || $space_after) {
5215 if ($rtrim_before) {
5216 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5217 } else {
5218 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5219 }
5220 if ($space_after) {
5221 $good .= " ";
5222 }
5223 }
5224
5225 # '*' as part of a type definition -- reported already.
5226 } elsif ($opv eq '*_') {
5227 #warn "'*' is part of type\n";
5228
5229 # unary operators should have a space before and
5230 # none after. May be left adjacent to another
5231 # unary operator, or a cast
5232 } elsif ($op eq '!' || $op eq '~' ||
5233 $opv eq '*U' || $opv eq '-U' ||
5234 $opv eq '&U' || $opv eq '&&U') {
5235 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
5236 if (ERROR("SPACING",
5237 "space required before that '$op' $at\n" . $hereptr)) {
5238 if ($n != $last_after + 2) {
5239 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
5240 $line_fixed = 1;
5241 }
5242 }
5243 }
5244 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
5245 # A unary '*' may be const
5246
5247 } elsif ($ctx =~ /.xW/) {
5248 if (ERROR("SPACING",
5249 "space prohibited after that '$op' $at\n" . $hereptr)) {
5250 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
5251 if (defined $fix_elements[$n + 2]) {
5252 $fix_elements[$n + 2] =~ s/^\s+//;
5253 }
5254 $line_fixed = 1;
5255 }
5256 }
5257
5258 # unary ++ and unary -- are allowed no space on one side.
5259 } elsif ($op eq '++' or $op eq '--') {
5260 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
5261 if (ERROR("SPACING",
5262 "space required one side of that '$op' $at\n" . $hereptr)) {
5263 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5264 $line_fixed = 1;
5265 }
5266 }
5267 if ($ctx =~ /Wx[BE]/ ||
5268 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
5269 if (ERROR("SPACING",
5270 "space prohibited before that '$op' $at\n" . $hereptr)) {
5271 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5272 $line_fixed = 1;
5273 }
5274 }
5275 if ($ctx =~ /ExW/) {
5276 if (ERROR("SPACING",
5277 "space prohibited after that '$op' $at\n" . $hereptr)) {
5278 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5279 if (defined $fix_elements[$n + 2]) {
5280 $fix_elements[$n + 2] =~ s/^\s+//;
5281 }
5282 $line_fixed = 1;
5283 }
5284 }
5285
5286 # << and >> may either have or not have spaces both sides
5287 } elsif ($op eq '<<' or $op eq '>>' or
5288 $op eq '&' or $op eq '^' or $op eq '|' or
5289 $op eq '+' or $op eq '-' or
5290 $op eq '*' or $op eq '/' or
5291 $op eq '%')
5292 {
5293 if ($check) {
5294 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
5295 if (CHK("SPACING",
5296 "spaces preferred around that '$op' $at\n" . $hereptr)) {
5297 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5298 $fix_elements[$n + 2] =~ s/^\s+//;
5299 $line_fixed = 1;
5300 }
5301 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
5302 if (CHK("SPACING",
5303 "space preferred before that '$op' $at\n" . $hereptr)) {
5304 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
5305 $line_fixed = 1;
5306 }
5307 }
5308 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
5309 if (ERROR("SPACING",
5310 "need consistent spacing around '$op' $at\n" . $hereptr)) {
5311 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5312 if (defined $fix_elements[$n + 2]) {
5313 $fix_elements[$n + 2] =~ s/^\s+//;
5314 }
5315 $line_fixed = 1;
5316 }
5317 }
5318
5319 # A colon needs no spaces before when it is
5320 # terminating a case value or a label.
5321 } elsif ($opv eq ':C' || $opv eq ':L') {
5322 if ($ctx =~ /Wx./ and $realfile !~ m@.*\.lds\.h$@) {
5323 if (ERROR("SPACING",
5324 "space prohibited before that '$op' $at\n" . $hereptr)) {
5325 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5326 $line_fixed = 1;
5327 }
5328 }
5329
5330 # All the others need spaces both sides.
5331 } elsif ($ctx !~ /[EWC]x[CWE]/) {
5332 my $ok = 0;
5333
5334 # Ignore email addresses <foo@bar>
5335 if (($op eq '<' &&
5336 $cc =~ /^\S+\@\S+>/) ||
5337 ($op eq '>' &&
5338 $ca =~ /<\S+\@\S+$/))
5339 {
5340 $ok = 1;
5341 }
5342
5343 # for asm volatile statements
5344 # ignore a colon with another
5345 # colon immediately before or after
5346 if (($op eq ':') &&
5347 ($ca =~ /:$/ || $cc =~ /^:/)) {
5348 $ok = 1;
5349 }
5350
5351 # messages are ERROR, but ?: are CHK
5352 if ($ok == 0) {
5353 my $msg_level = \&ERROR;
5354 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
5355
5356 if (&{$msg_level}("SPACING",
5357 "spaces required around that '$op' $at\n" . $hereptr)) {
5358 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5359 if (defined $fix_elements[$n + 2]) {
5360 $fix_elements[$n + 2] =~ s/^\s+//;
5361 }
5362 $line_fixed = 1;
5363 }
5364 }
5365 }
5366 $off += length($elements[$n + 1]);
5367
5368## print("n: <$n> GOOD: <$good>\n");
5369
5370 $fixed_line = $fixed_line . $good;
5371 }
5372
5373 if (($#elements % 2) == 0) {
5374 $fixed_line = $fixed_line . $fix_elements[$#elements];
5375 }
5376
5377 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
5378 $fixed[$fixlinenr] = $fixed_line;
5379 }
5380
5381
5382 }
5383
5384# check for whitespace before a non-naked semicolon
5385 if ($line =~ /^\+.*\S\s+;\s*$/) {
5386 if (WARN("SPACING",
5387 "space prohibited before semicolon\n" . $herecurr) &&
5388 $fix) {
5389 1 while $fixed[$fixlinenr] =~
5390 s/^(\+.*\S)\s+;/$1;/;
5391 }
5392 }
5393
5394# check for multiple assignments
5395 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
5396 CHK("MULTIPLE_ASSIGNMENTS",
5397 "multiple assignments should be avoided\n" . $herecurr);
5398 }
5399
5400## # check for multiple declarations, allowing for a function declaration
5401## # continuation.
5402## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
5403## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
5404##
5405## # Remove any bracketed sections to ensure we do not
5406## # falsely report the parameters of functions.
5407## my $ln = $line;
5408## while ($ln =~ s/\([^\(\)]*\)//g) {
5409## }
5410## if ($ln =~ /,/) {
5411## WARN("MULTIPLE_DECLARATION",
5412## "declaring multiple variables together should be avoided\n" . $herecurr);
5413## }
5414## }
5415
5416#need space before brace following if, while, etc
5417 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
5418 $line =~ /\b(?:else|do)\{/) {
5419 if (ERROR("SPACING",
5420 "space required before the open brace '{'\n" . $herecurr) &&
5421 $fix) {
5422 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|else|\)))\{/$1 {/;
5423 }
5424 }
5425
5426## # check for blank lines before declarations
5427## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
5428## $prevrawline =~ /^.\s*$/) {
5429## WARN("SPACING",
5430## "No blank lines before declarations\n" . $hereprev);
5431## }
5432##
5433
5434# closing brace should have a space following it when it has anything
5435# on the line
5436 if ($line =~ /}(?!(?:,|;|\)|\}))\S/) {
5437 if (ERROR("SPACING",
5438 "space required after that close brace '}'\n" . $herecurr) &&
5439 $fix) {
5440 $fixed[$fixlinenr] =~
5441 s/}((?!(?:,|;|\)))\S)/} $1/;
5442 }
5443 }
5444
5445# check spacing on square brackets
5446 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
5447 if (ERROR("SPACING",
5448 "space prohibited after that open square bracket '['\n" . $herecurr) &&
5449 $fix) {
5450 $fixed[$fixlinenr] =~
5451 s/\[\s+/\[/;
5452 }
5453 }
5454 if ($line =~ /\s\]/) {
5455 if (ERROR("SPACING",
5456 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
5457 $fix) {
5458 $fixed[$fixlinenr] =~
5459 s/\s+\]/\]/;
5460 }
5461 }
5462
5463# check spacing on parentheses
5464 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
5465 $line !~ /for\s*\(\s+;/) {
5466 if (ERROR("SPACING",
5467 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
5468 $fix) {
5469 $fixed[$fixlinenr] =~
5470 s/\(\s+/\(/;
5471 }
5472 }
5473 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
5474 $line !~ /for\s*\(.*;\s+\)/ &&
5475 $line !~ /:\s+\)/) {
5476 if (ERROR("SPACING",
5477 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
5478 $fix) {
5479 $fixed[$fixlinenr] =~
5480 s/\s+\)/\)/;
5481 }
5482 }
5483
5484# check unnecessary parentheses around addressof/dereference single $Lvals
5485# ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
5486
5487 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
5488 my $var = $1;
5489 if (CHK("UNNECESSARY_PARENTHESES",
5490 "Unnecessary parentheses around $var\n" . $herecurr) &&
5491 $fix) {
5492 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
5493 }
5494 }
5495
5496# check for unnecessary parentheses around function pointer uses
5497# ie: (foo->bar)(); should be foo->bar();
5498# but not "if (foo->bar) (" to avoid some false positives
5499 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
5500 my $var = $2;
5501 if (CHK("UNNECESSARY_PARENTHESES",
5502 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
5503 $fix) {
5504 my $var2 = deparenthesize($var);
5505 $var2 =~ s/\s//g;
5506 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
5507 }
5508 }
5509
5510# check for unnecessary parentheses around comparisons in if uses
5511# when !drivers/staging or command-line uses --strict
5512 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
5513 $perl_version_ok && defined($stat) &&
5514 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
5515 my $if_stat = $1;
5516 my $test = substr($2, 1, -1);
5517 my $herectx;
5518 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
5519 my $match = $1;
5520 # avoid parentheses around potential macro args
5521 next if ($match =~ /^\s*\w+\s*$/);
5522 if (!defined($herectx)) {
5523 $herectx = $here . "\n";
5524 my $cnt = statement_rawlines($if_stat);
5525 for (my $n = 0; $n < $cnt; $n++) {
5526 my $rl = raw_line($linenr, $n);
5527 $herectx .= $rl . "\n";
5528 last if $rl =~ /^[ \+].*\{/;
5529 }
5530 }
5531 CHK("UNNECESSARY_PARENTHESES",
5532 "Unnecessary parentheses around '$match'\n" . $herectx);
5533 }
5534 }
5535
5536# check that goto labels aren't indented (allow a single space indentation)
5537# and ignore bitfield definitions like foo:1
5538# Strictly, labels can have whitespace after the identifier and before the :
5539# but this is not allowed here as many ?: uses would appear to be labels
5540 if ($sline =~ /^.\s+[A-Za-z_][A-Za-z\d_]*:(?!\s*\d+)/ &&
5541 $sline !~ /^. [A-Za-z\d_][A-Za-z\d_]*:/ &&
5542 $sline !~ /^.\s+default:/) {
5543 if (WARN("INDENTED_LABEL",
5544 "labels should not be indented\n" . $herecurr) &&
5545 $fix) {
5546 $fixed[$fixlinenr] =~
5547 s/^(.)\s+/$1/;
5548 }
5549 }
5550
5551# check if a statement with a comma should be two statements like:
5552# foo = bar(), /* comma should be semicolon */
5553# bar = baz();
5554 if (defined($stat) &&
5555 $stat =~ /^\+\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*,\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*;\s*$/) {
5556 my $cnt = statement_rawlines($stat);
5557 my $herectx = get_stat_here($linenr, $cnt, $here);
5558 WARN("SUSPECT_COMMA_SEMICOLON",
5559 "Possible comma where semicolon could be used\n" . $herectx);
5560 }
5561
5562# return is not a function
5563 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
5564 my $spacing = $1;
5565 if ($perl_version_ok &&
5566 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
5567 my $value = $1;
5568 $value = deparenthesize($value);
5569 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
5570 ERROR("RETURN_PARENTHESES",
5571 "return is not a function, parentheses are not required\n" . $herecurr);
5572 }
5573 } elsif ($spacing !~ /\s+/) {
5574 ERROR("SPACING",
5575 "space required before the open parenthesis '('\n" . $herecurr);
5576 }
5577 }
5578
5579# unnecessary return in a void function
5580# at end-of-function, with the previous line a single leading tab, then return;
5581# and the line before that not a goto label target like "out:"
5582 if ($sline =~ /^[ \+]}\s*$/ &&
5583 $prevline =~ /^\+\treturn\s*;\s*$/ &&
5584 $linenr >= 3 &&
5585 $lines[$linenr - 3] =~ /^[ +]/ &&
5586 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
5587 WARN("RETURN_VOID",
5588 "void function return statements are not generally useful\n" . $hereprev);
5589 }
5590
5591# if statements using unnecessary parentheses - ie: if ((foo == bar))
5592 if ($perl_version_ok &&
5593 $line =~ /\bif\s*((?:\(\s*){2,})/) {
5594 my $openparens = $1;
5595 my $count = $openparens =~ tr@\(@\(@;
5596 my $msg = "";
5597 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
5598 my $comp = $4; #Not $1 because of $LvalOrFunc
5599 $msg = " - maybe == should be = ?" if ($comp eq "==");
5600 WARN("UNNECESSARY_PARENTHESES",
5601 "Unnecessary parentheses$msg\n" . $herecurr);
5602 }
5603 }
5604
5605# comparisons with a constant or upper case identifier on the left
5606# avoid cases like "foo + BAR < baz"
5607# only fix matches surrounded by parentheses to avoid incorrect
5608# conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
5609 if ($perl_version_ok &&
5610 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
5611 my $lead = $1;
5612 my $const = $2;
5613 my $comp = $3;
5614 my $to = $4;
5615 my $newcomp = $comp;
5616 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
5617 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
5618 WARN("CONSTANT_COMPARISON",
5619 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
5620 $fix) {
5621 if ($comp eq "<") {
5622 $newcomp = ">";
5623 } elsif ($comp eq "<=") {
5624 $newcomp = ">=";
5625 } elsif ($comp eq ">") {
5626 $newcomp = "<";
5627 } elsif ($comp eq ">=") {
5628 $newcomp = "<=";
5629 }
5630 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
5631 }
5632 }
5633
5634# Return of what appears to be an errno should normally be negative
5635 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
5636 my $name = $1;
5637 if ($name ne 'EOF' && $name ne 'ERROR' && $name !~ /^EPOLL/) {
5638 WARN("USE_NEGATIVE_ERRNO",
5639 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
5640 }
5641 }
5642
5643# Need a space before open parenthesis after if, while etc
5644 if ($line =~ /\b(if|while|for|switch)\(/) {
5645 if (ERROR("SPACING",
5646 "space required before the open parenthesis '('\n" . $herecurr) &&
5647 $fix) {
5648 $fixed[$fixlinenr] =~
5649 s/\b(if|while|for|switch)\(/$1 \(/;
5650 }
5651 }
5652
5653# Check for illegal assignment in if conditional -- and check for trailing
5654# statements after the conditional.
5655 if ($line =~ /do\s*(?!{)/) {
5656 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
5657 ctx_statement_block($linenr, $realcnt, 0)
5658 if (!defined $stat);
5659 my ($stat_next) = ctx_statement_block($line_nr_next,
5660 $remain_next, $off_next);
5661 $stat_next =~ s/\n./\n /g;
5662 ##print "stat<$stat> stat_next<$stat_next>\n";
5663
5664 if ($stat_next =~ /^\s*while\b/) {
5665 # If the statement carries leading newlines,
5666 # then count those as offsets.
5667 my ($whitespace) =
5668 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
5669 my $offset =
5670 statement_rawlines($whitespace) - 1;
5671
5672 $suppress_whiletrailers{$line_nr_next +
5673 $offset} = 1;
5674 }
5675 }
5676 if (!defined $suppress_whiletrailers{$linenr} &&
5677 defined($stat) && defined($cond) &&
5678 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
5679 my ($s, $c) = ($stat, $cond);
5680
5681 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
5682 if (ERROR("ASSIGN_IN_IF",
5683 "do not use assignment in if condition\n" . $herecurr) &&
5684 $fix && $perl_version_ok) {
5685 if ($rawline =~ /^\+(\s+)if\s*\(\s*(\!)?\s*\(\s*(($Lval)\s*=\s*$LvalOrFunc)\s*\)\s*(?:($Compare)\s*($FuncArg))?\s*\)\s*(\{)?\s*$/) {
5686 my $space = $1;
5687 my $not = $2;
5688 my $statement = $3;
5689 my $assigned = $4;
5690 my $test = $8;
5691 my $against = $9;
5692 my $brace = $15;
5693 fix_delete_line($fixlinenr, $rawline);
5694 fix_insert_line($fixlinenr, "$space$statement;");
5695 my $newline = "${space}if (";
5696 $newline .= '!' if defined($not);
5697 $newline .= '(' if (defined $not && defined($test) && defined($against));
5698 $newline .= "$assigned";
5699 $newline .= " $test $against" if (defined($test) && defined($against));
5700 $newline .= ')' if (defined $not && defined($test) && defined($against));
5701 $newline .= ')';
5702 $newline .= " {" if (defined($brace));
5703 fix_insert_line($fixlinenr + 1, $newline);
5704 }
5705 }
5706 }
5707
5708 # Find out what is on the end of the line after the
5709 # conditional.
5710 substr($s, 0, length($c), '');
5711 $s =~ s/\n.*//g;
5712 $s =~ s/$;//g; # Remove any comments
5713 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
5714 $c !~ /}\s*while\s*/)
5715 {
5716 # Find out how long the conditional actually is.
5717 my @newlines = ($c =~ /\n/gs);
5718 my $cond_lines = 1 + $#newlines;
5719 my $stat_real = '';
5720
5721 $stat_real = raw_line($linenr, $cond_lines)
5722 . "\n" if ($cond_lines);
5723 if (defined($stat_real) && $cond_lines > 1) {
5724 $stat_real = "[...]\n$stat_real";
5725 }
5726
5727 ERROR("TRAILING_STATEMENTS",
5728 "trailing statements should be on next line\n" . $herecurr . $stat_real);
5729 }
5730 }
5731
5732# Check for bitwise tests written as boolean
5733 if ($line =~ /
5734 (?:
5735 (?:\[|\(|\&\&|\|\|)
5736 \s*0[xX][0-9]+\s*
5737 (?:\&\&|\|\|)
5738 |
5739 (?:\&\&|\|\|)
5740 \s*0[xX][0-9]+\s*
5741 (?:\&\&|\|\||\)|\])
5742 )/x)
5743 {
5744 WARN("HEXADECIMAL_BOOLEAN_TEST",
5745 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
5746 }
5747
5748# if and else should not have general statements after it
5749 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
5750 my $s = $1;
5751 $s =~ s/$;//g; # Remove any comments
5752 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
5753 ERROR("TRAILING_STATEMENTS",
5754 "trailing statements should be on next line\n" . $herecurr);
5755 }
5756 }
5757# if should not continue a brace
5758 if ($line =~ /}\s*if\b/) {
5759 ERROR("TRAILING_STATEMENTS",
5760 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
5761 $herecurr);
5762 }
5763# case and default should not have general statements after them
5764 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
5765 $line !~ /\G(?:
5766 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
5767 \s*return\s+
5768 )/xg)
5769 {
5770 ERROR("TRAILING_STATEMENTS",
5771 "trailing statements should be on next line\n" . $herecurr);
5772 }
5773
5774 # Check for }<nl>else {, these must be at the same
5775 # indent level to be relevant to each other.
5776 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
5777 $previndent == $indent) {
5778 if (ERROR("ELSE_AFTER_BRACE",
5779 "else should follow close brace '}'\n" . $hereprev) &&
5780 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5781 fix_delete_line($fixlinenr - 1, $prevrawline);
5782 fix_delete_line($fixlinenr, $rawline);
5783 my $fixedline = $prevrawline;
5784 $fixedline =~ s/}\s*$//;
5785 if ($fixedline !~ /^\+\s*$/) {
5786 fix_insert_line($fixlinenr, $fixedline);
5787 }
5788 $fixedline = $rawline;
5789 $fixedline =~ s/^(.\s*)else/$1} else/;
5790 fix_insert_line($fixlinenr, $fixedline);
5791 }
5792 }
5793
5794 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
5795 $previndent == $indent) {
5796 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
5797
5798 # Find out what is on the end of the line after the
5799 # conditional.
5800 substr($s, 0, length($c), '');
5801 $s =~ s/\n.*//g;
5802
5803 if ($s =~ /^\s*;/) {
5804 if (ERROR("WHILE_AFTER_BRACE",
5805 "while should follow close brace '}'\n" . $hereprev) &&
5806 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5807 fix_delete_line($fixlinenr - 1, $prevrawline);
5808 fix_delete_line($fixlinenr, $rawline);
5809 my $fixedline = $prevrawline;
5810 my $trailing = $rawline;
5811 $trailing =~ s/^\+//;
5812 $trailing = trim($trailing);
5813 $fixedline =~ s/}\s*$/} $trailing/;
5814 fix_insert_line($fixlinenr, $fixedline);
5815 }
5816 }
5817 }
5818
5819#Specific variable tests
5820 while ($line =~ m{($Constant|$Lval)}g) {
5821 my $var = $1;
5822
5823#CamelCase
5824 if ($var !~ /^$Constant$/ &&
5825 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
5826#Ignore some autogenerated defines and enum values
5827 $var !~ /^(?:[A-Z]+_){1,5}[A-Z]{1,3}[a-z]/ &&
5828#Ignore Page<foo> variants
5829 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
5830#Ignore SI style variants like nS, mV and dB
5831#(ie: max_uV, regulator_min_uA_show, RANGE_mA_VALUE)
5832 $var !~ /^(?:[a-z0-9_]*|[A-Z0-9_]*)?_?[a-z][A-Z](?:_[a-z0-9_]+|_[A-Z0-9_]+)?$/ &&
5833#Ignore some three character SI units explicitly, like MiB and KHz
5834 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
5835 while ($var =~ m{($Ident)}g) {
5836 my $word = $1;
5837 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
5838 if ($check) {
5839 seed_camelcase_includes();
5840 if (!$file && !$camelcase_file_seeded) {
5841 seed_camelcase_file($realfile);
5842 $camelcase_file_seeded = 1;
5843 }
5844 }
5845 if (!defined $camelcase{$word}) {
5846 $camelcase{$word} = 1;
5847 CHK("CAMELCASE",
5848 "Avoid CamelCase: <$word>\n" . $herecurr);
5849 }
5850 }
5851 }
5852 }
5853
5854#no spaces allowed after \ in define
5855 if ($line =~ /\#\s*define.*\\\s+$/) {
5856 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
5857 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
5858 $fix) {
5859 $fixed[$fixlinenr] =~ s/\s+$//;
5860 }
5861 }
5862
5863# warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
5864# itself <asm/foo.h> (uses RAW line)
5865 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
5866 my $file = "$1.h";
5867 my $checkfile = "include/linux/$file";
5868 if (-f "$root/$checkfile" &&
5869 $realfile ne $checkfile &&
5870 $1 !~ /$allowed_asm_includes/)
5871 {
5872 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
5873 if ($asminclude > 0) {
5874 if ($realfile =~ m{^arch/}) {
5875 CHK("ARCH_INCLUDE_LINUX",
5876 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5877 } else {
5878 WARN("INCLUDE_LINUX",
5879 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5880 }
5881 }
5882 }
5883 }
5884
5885# multi-statement macros should be enclosed in a do while loop, grab the
5886# first statement and ensure its the whole macro if its not enclosed
5887# in a known good container
5888 if ($realfile !~ m@/vmlinux.lds.h$@ &&
5889 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
5890 my $ln = $linenr;
5891 my $cnt = $realcnt;
5892 my ($off, $dstat, $dcond, $rest);
5893 my $ctx = '';
5894 my $has_flow_statement = 0;
5895 my $has_arg_concat = 0;
5896 ($dstat, $dcond, $ln, $cnt, $off) =
5897 ctx_statement_block($linenr, $realcnt, 0);
5898 $ctx = $dstat;
5899 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
5900 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
5901
5902 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
5903 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
5904
5905 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
5906 my $define_args = $1;
5907 my $define_stmt = $dstat;
5908 my @def_args = ();
5909
5910 if (defined $define_args && $define_args ne "") {
5911 $define_args = substr($define_args, 1, length($define_args) - 2);
5912 $define_args =~ s/\s*//g;
5913 $define_args =~ s/\\\+?//g;
5914 @def_args = split(",", $define_args);
5915 }
5916
5917 $dstat =~ s/$;//g;
5918 $dstat =~ s/\\\n.//g;
5919 $dstat =~ s/^\s*//s;
5920 $dstat =~ s/\s*$//s;
5921
5922 # Flatten any parentheses and braces
5923 while ($dstat =~ s/\([^\(\)]*\)/1u/ ||
5924 $dstat =~ s/\{[^\{\}]*\}/1u/ ||
5925 $dstat =~ s/.\[[^\[\]]*\]/1u/)
5926 {
5927 }
5928
5929 # Flatten any obvious string concatenation.
5930 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
5931 $dstat =~ s/$Ident\s*($String)/$1/)
5932 {
5933 }
5934
5935 # Make asm volatile uses seem like a generic function
5936 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
5937
5938 my $exceptions = qr{
5939 $Declare|
5940 module_param_named|
5941 MODULE_PARM_DESC|
5942 DECLARE_PER_CPU|
5943 DEFINE_PER_CPU|
5944 __typeof__\(|
5945 union|
5946 struct|
5947 \.$Ident\s*=\s*|
5948 ^\"|\"$|
5949 ^\[
5950 }x;
5951 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
5952
5953 $ctx =~ s/\n*$//;
5954 my $stmt_cnt = statement_rawlines($ctx);
5955 my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
5956
5957 if ($dstat ne '' &&
5958 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
5959 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
5960 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
5961 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
5962 $dstat !~ /$exceptions/ &&
5963 $dstat !~ /^\.$Ident\s*=/ && # .foo =
5964 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
5965 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
5966 $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ && # while (...) {...}
5967 $dstat !~ /^for\s*$Constant$/ && # for (...)
5968 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
5969 $dstat !~ /^do\s*{/ && # do {...
5970 $dstat !~ /^\(\{/ && # ({...
5971 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
5972 {
5973 if ($dstat =~ /^\s*if\b/) {
5974 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5975 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
5976 } elsif ($dstat =~ /;/) {
5977 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
5978 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
5979 } else {
5980 ERROR("COMPLEX_MACRO",
5981 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
5982 }
5983
5984 }
5985
5986 # Make $define_stmt single line, comment-free, etc
5987 my @stmt_array = split('\n', $define_stmt);
5988 my $first = 1;
5989 $define_stmt = "";
5990 foreach my $l (@stmt_array) {
5991 $l =~ s/\\$//;
5992 if ($first) {
5993 $define_stmt = $l;
5994 $first = 0;
5995 } elsif ($l =~ /^[\+ ]/) {
5996 $define_stmt .= substr($l, 1);
5997 }
5998 }
5999 $define_stmt =~ s/$;//g;
6000 $define_stmt =~ s/\s+/ /g;
6001 $define_stmt = trim($define_stmt);
6002
6003# check if any macro arguments are reused (ignore '...' and 'type')
6004 foreach my $arg (@def_args) {
6005 next if ($arg =~ /\.\.\./);
6006 next if ($arg =~ /^type$/i);
6007 my $tmp_stmt = $define_stmt;
6008 $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;
6009 $tmp_stmt =~ s/\#+\s*$arg\b//g;
6010 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
6011 my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
6012 if ($use_cnt > 1) {
6013 CHK("MACRO_ARG_REUSE",
6014 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
6015 }
6016# check if any macro arguments may have other precedence issues
6017 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
6018 ((defined($1) && $1 ne ',') ||
6019 (defined($2) && $2 ne ','))) {
6020 CHK("MACRO_ARG_PRECEDENCE",
6021 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
6022 }
6023 }
6024
6025# check for macros with flow control, but without ## concatenation
6026# ## concatenation is commonly a macro that defines a function so ignore those
6027 if ($has_flow_statement && !$has_arg_concat) {
6028 my $cnt = statement_rawlines($ctx);
6029 my $herectx = get_stat_here($linenr, $cnt, $here);
6030
6031 WARN("MACRO_WITH_FLOW_CONTROL",
6032 "Macros with flow control statements should be avoided\n" . "$herectx");
6033 }
6034
6035# check for line continuations outside of #defines, preprocessor #, and asm
6036
6037 } else {
6038 if ($prevline !~ /^..*\\$/ &&
6039 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
6040 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
6041 $line =~ /^\+.*\\$/) {
6042 WARN("LINE_CONTINUATIONS",
6043 "Avoid unnecessary line continuations\n" . $herecurr);
6044 }
6045 }
6046
6047# do {} while (0) macro tests:
6048# single-statement macros do not need to be enclosed in do while (0) loop,
6049# macro should not end with a semicolon
6050 if ($perl_version_ok &&
6051 $realfile !~ m@/vmlinux.lds.h$@ &&
6052 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
6053 my $ln = $linenr;
6054 my $cnt = $realcnt;
6055 my ($off, $dstat, $dcond, $rest);
6056 my $ctx = '';
6057 ($dstat, $dcond, $ln, $cnt, $off) =
6058 ctx_statement_block($linenr, $realcnt, 0);
6059 $ctx = $dstat;
6060
6061 $dstat =~ s/\\\n.//g;
6062 $dstat =~ s/$;/ /g;
6063
6064 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
6065 my $stmts = $2;
6066 my $semis = $3;
6067
6068 $ctx =~ s/\n*$//;
6069 my $cnt = statement_rawlines($ctx);
6070 my $herectx = get_stat_here($linenr, $cnt, $here);
6071
6072 if (($stmts =~ tr/;/;/) == 1 &&
6073 $stmts !~ /^\s*(if|while|for|switch)\b/) {
6074 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
6075 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
6076 }
6077 if (defined $semis && $semis ne "") {
6078 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
6079 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
6080 }
6081 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
6082 $ctx =~ s/\n*$//;
6083 my $cnt = statement_rawlines($ctx);
6084 my $herectx = get_stat_here($linenr, $cnt, $here);
6085
6086 WARN("TRAILING_SEMICOLON",
6087 "macros should not use a trailing semicolon\n" . "$herectx");
6088 }
6089 }
6090
6091# check for redundant bracing round if etc
6092 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
6093 my ($level, $endln, @chunks) =
6094 ctx_statement_full($linenr, $realcnt, 1);
6095 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
6096 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
6097 if ($#chunks > 0 && $level == 0) {
6098 my @allowed = ();
6099 my $allow = 0;
6100 my $seen = 0;
6101 my $herectx = $here . "\n";
6102 my $ln = $linenr - 1;
6103 for my $chunk (@chunks) {
6104 my ($cond, $block) = @{$chunk};
6105
6106 # If the condition carries leading newlines, then count those as offsets.
6107 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
6108 my $offset = statement_rawlines($whitespace) - 1;
6109
6110 $allowed[$allow] = 0;
6111 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
6112
6113 # We have looked at and allowed this specific line.
6114 $suppress_ifbraces{$ln + $offset} = 1;
6115
6116 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
6117 $ln += statement_rawlines($block) - 1;
6118
6119 substr($block, 0, length($cond), '');
6120
6121 $seen++ if ($block =~ /^\s*{/);
6122
6123 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
6124 if (statement_lines($cond) > 1) {
6125 #print "APW: ALLOWED: cond<$cond>\n";
6126 $allowed[$allow] = 1;
6127 }
6128 if ($block =~/\b(?:if|for|while)\b/) {
6129 #print "APW: ALLOWED: block<$block>\n";
6130 $allowed[$allow] = 1;
6131 }
6132 if (statement_block_size($block) > 1) {
6133 #print "APW: ALLOWED: lines block<$block>\n";
6134 $allowed[$allow] = 1;
6135 }
6136 $allow++;
6137 }
6138 if ($seen) {
6139 my $sum_allowed = 0;
6140 foreach (@allowed) {
6141 $sum_allowed += $_;
6142 }
6143 if ($sum_allowed == 0) {
6144 WARN("BRACES",
6145 "braces {} are not necessary for any arm of this statement\n" . $herectx);
6146 } elsif ($sum_allowed != $allow &&
6147 $seen != $allow) {
6148 CHK("BRACES",
6149 "braces {} should be used on all arms of this statement\n" . $herectx);
6150 }
6151 }
6152 }
6153 }
6154 if (!defined $suppress_ifbraces{$linenr - 1} &&
6155 $line =~ /\b(if|while|for|else)\b/) {
6156 my $allowed = 0;
6157
6158 # Check the pre-context.
6159 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
6160 #print "APW: ALLOWED: pre<$1>\n";
6161 $allowed = 1;
6162 }
6163
6164 my ($level, $endln, @chunks) =
6165 ctx_statement_full($linenr, $realcnt, $-[0]);
6166
6167 # Check the condition.
6168 my ($cond, $block) = @{$chunks[0]};
6169 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
6170 if (defined $cond) {
6171 substr($block, 0, length($cond), '');
6172 }
6173 if (statement_lines($cond) > 1) {
6174 #print "APW: ALLOWED: cond<$cond>\n";
6175 $allowed = 1;
6176 }
6177 if ($block =~/\b(?:if|for|while)\b/) {
6178 #print "APW: ALLOWED: block<$block>\n";
6179 $allowed = 1;
6180 }
6181 if (statement_block_size($block) > 1) {
6182 #print "APW: ALLOWED: lines block<$block>\n";
6183 $allowed = 1;
6184 }
6185 # Check the post-context.
6186 if (defined $chunks[1]) {
6187 my ($cond, $block) = @{$chunks[1]};
6188 if (defined $cond) {
6189 substr($block, 0, length($cond), '');
6190 }
6191 if ($block =~ /^\s*\{/) {
6192 #print "APW: ALLOWED: chunk-1 block<$block>\n";
6193 $allowed = 1;
6194 }
6195 }
6196 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
6197 my $cnt = statement_rawlines($block);
6198 my $herectx = get_stat_here($linenr, $cnt, $here);
6199
6200 WARN("BRACES",
6201 "braces {} are not necessary for single statement blocks\n" . $herectx);
6202 }
6203 }
6204
6205# check for single line unbalanced braces
6206 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
6207 $sline =~ /^.\s*else\s*\{\s*$/) {
6208 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
6209 }
6210
6211# check for unnecessary blank lines around braces
6212 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
6213 if (CHK("BRACES",
6214 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
6215 $fix && $prevrawline =~ /^\+/) {
6216 fix_delete_line($fixlinenr - 1, $prevrawline);
6217 }
6218 }
6219 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
6220 if (CHK("BRACES",
6221 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
6222 $fix) {
6223 fix_delete_line($fixlinenr, $rawline);
6224 }
6225 }
6226
6227# no volatiles please
6228 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
6229 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
6230 WARN("VOLATILE",
6231 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
6232 }
6233
6234# Check for user-visible strings broken across lines, which breaks the ability
6235# to grep for the string. Make exceptions when the previous string ends in a
6236# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
6237# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
6238 if ($line =~ /^\+\s*$String/ &&
6239 $prevline =~ /"\s*$/ &&
6240 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
6241 if (WARN("SPLIT_STRING",
6242 "quoted string split across lines\n" . $hereprev) &&
6243 $fix &&
6244 $prevrawline =~ /^\+.*"\s*$/ &&
6245 $last_coalesced_string_linenr != $linenr - 1) {
6246 my $extracted_string = get_quoted_string($line, $rawline);
6247 my $comma_close = "";
6248 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
6249 $comma_close = $1;
6250 }
6251
6252 fix_delete_line($fixlinenr - 1, $prevrawline);
6253 fix_delete_line($fixlinenr, $rawline);
6254 my $fixedline = $prevrawline;
6255 $fixedline =~ s/"\s*$//;
6256 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
6257 fix_insert_line($fixlinenr - 1, $fixedline);
6258 $fixedline = $rawline;
6259 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
6260 if ($fixedline !~ /\+\s*$/) {
6261 fix_insert_line($fixlinenr, $fixedline);
6262 }
6263 $last_coalesced_string_linenr = $linenr;
6264 }
6265 }
6266
6267# check for missing a space in a string concatenation
6268 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
6269 WARN('MISSING_SPACE',
6270 "break quoted strings at a space character\n" . $hereprev);
6271 }
6272
6273# check for an embedded function name in a string when the function is known
6274# This does not work very well for -f --file checking as it depends on patch
6275# context providing the function name or a single line form for in-file
6276# function declarations
6277 if ($line =~ /^\+.*$String/ &&
6278 defined($context_function) &&
6279 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
6280 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
6281 WARN("EMBEDDED_FUNCTION_NAME",
6282 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
6283 }
6284
6285# check for unnecessary function tracing like uses
6286# This does not use $logFunctions because there are many instances like
6287# 'dprintk(FOO, "%s()\n", __func__);' which do not match $logFunctions
6288 if ($rawline =~ /^\+.*\([^"]*"$tracing_logging_tags{0,3}%s(?:\s*\(\s*\)\s*)?$tracing_logging_tags{0,3}(?:\\n)?"\s*,\s*__func__\s*\)\s*;/) {
6289 if (WARN("TRACING_LOGGING",
6290 "Unnecessary ftrace-like logging - prefer using ftrace\n" . $herecurr) &&
6291 $fix) {
6292 fix_delete_line($fixlinenr, $rawline);
6293 }
6294 }
6295
6296# check for spaces before a quoted newline
6297 if ($rawline =~ /^.*\".*\s\\n/) {
6298 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
6299 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
6300 $fix) {
6301 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
6302 }
6303
6304 }
6305
6306# concatenated string without spaces between elements
6307 if ($line =~ /$String[A-Z_]/ ||
6308 ($line =~ /([A-Za-z0-9_]+)$String/ && $1 !~ /^[Lu]$/)) {
6309 if (CHK("CONCATENATED_STRING",
6310 "Concatenated strings should use spaces between elements\n" . $herecurr) &&
6311 $fix) {
6312 while ($line =~ /($String)/g) {
6313 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6314 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
6315 $fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
6316 }
6317 }
6318 }
6319
6320# uncoalesced string fragments
6321 if ($line =~ /$String\s*[Lu]?"/) {
6322 if (WARN("STRING_FRAGMENTS",
6323 "Consecutive strings are generally better as a single string\n" . $herecurr) &&
6324 $fix) {
6325 while ($line =~ /($String)(?=\s*")/g) {
6326 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6327 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
6328 }
6329 }
6330 }
6331
6332# check for non-standard and hex prefixed decimal printf formats
6333 my $show_L = 1; #don't show the same defect twice
6334 my $show_Z = 1;
6335 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
6336 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
6337 $string =~ s/%%/__/g;
6338 # check for %L
6339 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
6340 WARN("PRINTF_L",
6341 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
6342 $show_L = 0;
6343 }
6344 # check for %Z
6345 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
6346 WARN("PRINTF_Z",
6347 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
6348 $show_Z = 0;
6349 }
6350 # check for 0x<decimal>
6351 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
6352 ERROR("PRINTF_0XDECIMAL",
6353 "Prefixing 0x with decimal output is defective\n" . $herecurr);
6354 }
6355 }
6356
6357# check for line continuations in quoted strings with odd counts of "
6358 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
6359 WARN("LINE_CONTINUATIONS",
6360 "Avoid line continuations in quoted strings\n" . $herecurr);
6361 }
6362
6363# warn about #if 0
6364 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
6365 WARN("IF_0",
6366 "Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
6367 }
6368
6369# warn about #if 1
6370 if ($line =~ /^.\s*\#\s*if\s+1\b/) {
6371 WARN("IF_1",
6372 "Consider removing the #if 1 and its #endif\n" . $herecurr);
6373 }
6374
6375# check for needless "if (<foo>) fn(<foo>)" uses
6376 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
6377 my $tested = quotemeta($1);
6378 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
6379 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
6380 my $func = $1;
6381 if (WARN('NEEDLESS_IF',
6382 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
6383 $fix) {
6384 my $do_fix = 1;
6385 my $leading_tabs = "";
6386 my $new_leading_tabs = "";
6387 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
6388 $leading_tabs = $1;
6389 } else {
6390 $do_fix = 0;
6391 }
6392 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
6393 $new_leading_tabs = $1;
6394 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
6395 $do_fix = 0;
6396 }
6397 } else {
6398 $do_fix = 0;
6399 }
6400 if ($do_fix) {
6401 fix_delete_line($fixlinenr - 1, $prevrawline);
6402 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
6403 }
6404 }
6405 }
6406 }
6407
6408# check for unnecessary "Out of Memory" messages
6409 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
6410 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
6411 (defined $1 || defined $3) &&
6412 $linenr > 3) {
6413 my $testval = $2;
6414 my $testline = $lines[$linenr - 3];
6415
6416 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
6417# print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
6418
6419 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
6420 $s !~ /\b__GFP_NOWARN\b/ ) {
6421 WARN("OOM_MESSAGE",
6422 "Possible unnecessary 'out of memory' message\n" . $hereprev);
6423 }
6424 }
6425
6426# check for logging functions with KERN_<LEVEL>
6427 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
6428 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
6429 my $level = $1;
6430 if (WARN("UNNECESSARY_KERN_LEVEL",
6431 "Possible unnecessary $level\n" . $herecurr) &&
6432 $fix) {
6433 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
6434 }
6435 }
6436
6437# check for logging continuations
6438 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
6439 WARN("LOGGING_CONTINUATION",
6440 "Avoid logging continuation uses where feasible\n" . $herecurr);
6441 }
6442
6443# check for unnecessary use of %h[xudi] and %hh[xudi] in logging functions
6444 if (defined $stat &&
6445 $line =~ /\b$logFunctions\s*\(/ &&
6446 index($stat, '"') >= 0) {
6447 my $lc = $stat =~ tr@\n@@;
6448 $lc = $lc + $linenr;
6449 my $stat_real = get_stat_real($linenr, $lc);
6450 pos($stat_real) = index($stat_real, '"');
6451 while ($stat_real =~ /[^\"%]*(%[\#\d\.\*\-]*(h+)[idux])/g) {
6452 my $pspec = $1;
6453 my $h = $2;
6454 my $lineoff = substr($stat_real, 0, $-[1]) =~ tr@\n@@;
6455 if (WARN("UNNECESSARY_MODIFIER",
6456 "Integer promotion: Using '$h' in '$pspec' is unnecessary\n" . "$here\n$stat_real\n") &&
6457 $fix && $fixed[$fixlinenr + $lineoff] =~ /^\+/) {
6458 my $nspec = $pspec;
6459 $nspec =~ s/h//g;
6460 $fixed[$fixlinenr + $lineoff] =~ s/\Q$pspec\E/$nspec/;
6461 }
6462 }
6463 }
6464
6465# check for mask then right shift without a parentheses
6466 if ($perl_version_ok &&
6467 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
6468 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
6469 WARN("MASK_THEN_SHIFT",
6470 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
6471 }
6472
6473# check for pointer comparisons to NULL
6474 if ($perl_version_ok) {
6475 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
6476 my $val = $1;
6477 my $equal = "!";
6478 $equal = "" if ($4 eq "!=");
6479 if (CHK("COMPARISON_TO_NULL",
6480 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
6481 $fix) {
6482 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
6483 }
6484 }
6485 }
6486
6487# check for bad placement of section $InitAttribute (e.g.: __initdata)
6488 if ($line =~ /(\b$InitAttribute\b)/) {
6489 my $attr = $1;
6490 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
6491 my $ptr = $1;
6492 my $var = $2;
6493 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
6494 ERROR("MISPLACED_INIT",
6495 "$attr should be placed after $var\n" . $herecurr)) ||
6496 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
6497 WARN("MISPLACED_INIT",
6498 "$attr should be placed after $var\n" . $herecurr))) &&
6499 $fix) {
6500 $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;
6501 }
6502 }
6503 }
6504
6505# check for $InitAttributeData (ie: __initdata) with const
6506 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
6507 my $attr = $1;
6508 $attr =~ /($InitAttributePrefix)(.*)/;
6509 my $attr_prefix = $1;
6510 my $attr_type = $2;
6511 if (ERROR("INIT_ATTRIBUTE",
6512 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
6513 $fix) {
6514 $fixed[$fixlinenr] =~
6515 s/$InitAttributeData/${attr_prefix}initconst/;
6516 }
6517 }
6518
6519# check for $InitAttributeConst (ie: __initconst) without const
6520 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
6521 my $attr = $1;
6522 if (ERROR("INIT_ATTRIBUTE",
6523 "Use of $attr requires a separate use of const\n" . $herecurr) &&
6524 $fix) {
6525 my $lead = $fixed[$fixlinenr] =~
6526 /(^\+\s*(?:static\s+))/;
6527 $lead = rtrim($1);
6528 $lead = "$lead " if ($lead !~ /^\+$/);
6529 $lead = "${lead}const ";
6530 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
6531 }
6532 }
6533
6534# check for __read_mostly with const non-pointer (should just be const)
6535 if ($line =~ /\b__read_mostly\b/ &&
6536 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
6537 if (ERROR("CONST_READ_MOSTLY",
6538 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
6539 $fix) {
6540 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
6541 }
6542 }
6543
6544# don't use __constant_<foo> functions outside of include/uapi/
6545 if ($realfile !~ m@^include/uapi/@ &&
6546 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
6547 my $constant_func = $1;
6548 my $func = $constant_func;
6549 $func =~ s/^__constant_//;
6550 if (WARN("CONSTANT_CONVERSION",
6551 "$constant_func should be $func\n" . $herecurr) &&
6552 $fix) {
6553 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
6554 }
6555 }
6556
6557# prefer usleep_range over udelay
6558 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
6559 my $delay = $1;
6560 # ignore udelay's < 10, however
6561 if (! ($delay < 10) ) {
6562 CHK("USLEEP_RANGE",
6563 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6564 }
6565 if ($delay > 2000) {
6566 WARN("LONG_UDELAY",
6567 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
6568 }
6569 }
6570
6571# warn about unexpectedly long msleep's
6572 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
6573 if ($1 < 20) {
6574 WARN("MSLEEP",
6575 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6576 }
6577 }
6578
6579# check for comparisons of jiffies
6580 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
6581 WARN("JIFFIES_COMPARISON",
6582 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
6583 }
6584
6585# check for comparisons of get_jiffies_64()
6586 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
6587 WARN("JIFFIES_COMPARISON",
6588 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
6589 }
6590
6591# warn about #ifdefs in C files
6592# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
6593# print "#ifdef in C files should be avoided\n";
6594# print "$herecurr";
6595# $clean = 0;
6596# }
6597
6598# warn about spacing in #ifdefs
6599 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
6600 if (ERROR("SPACING",
6601 "exactly one space required after that #$1\n" . $herecurr) &&
6602 $fix) {
6603 $fixed[$fixlinenr] =~
6604 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
6605 }
6606
6607 }
6608
6609# check for spinlock_t definitions without a comment.
6610 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
6611 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
6612 my $which = $1;
6613 if (!ctx_has_comment($first_line, $linenr)) {
6614 CHK("UNCOMMENTED_DEFINITION",
6615 "$1 definition without comment\n" . $herecurr);
6616 }
6617 }
6618# check for memory barriers without a comment.
6619
6620 my $barriers = qr{
6621 mb|
6622 rmb|
6623 wmb
6624 }x;
6625 my $barrier_stems = qr{
6626 mb__before_atomic|
6627 mb__after_atomic|
6628 store_release|
6629 load_acquire|
6630 store_mb|
6631 (?:$barriers)
6632 }x;
6633 my $all_barriers = qr{
6634 (?:$barriers)|
6635 smp_(?:$barrier_stems)|
6636 virt_(?:$barrier_stems)
6637 }x;
6638
6639 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
6640 if (!ctx_has_comment($first_line, $linenr)) {
6641 WARN("MEMORY_BARRIER",
6642 "memory barrier without comment\n" . $herecurr);
6643 }
6644 }
6645
6646 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
6647
6648 if ($realfile !~ m@^include/asm-generic/@ &&
6649 $realfile !~ m@/barrier\.h$@ &&
6650 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
6651 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
6652 WARN("MEMORY_BARRIER",
6653 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6654 }
6655
6656# check for waitqueue_active without a comment.
6657 if ($line =~ /\bwaitqueue_active\s*\(/) {
6658 if (!ctx_has_comment($first_line, $linenr)) {
6659 WARN("WAITQUEUE_ACTIVE",
6660 "waitqueue_active without comment\n" . $herecurr);
6661 }
6662 }
6663
6664# check for data_race without a comment.
6665 if ($line =~ /\bdata_race\s*\(/) {
6666 if (!ctx_has_comment($first_line, $linenr)) {
6667 WARN("DATA_RACE",
6668 "data_race without comment\n" . $herecurr);
6669 }
6670 }
6671
6672# check of hardware specific defines
6673 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
6674 CHK("ARCH_DEFINES",
6675 "architecture specific defines should be avoided\n" . $herecurr);
6676 }
6677
6678# check that the storage class is not after a type
6679 if ($line =~ /\b($Type)\s+($Storage)\b/) {
6680 WARN("STORAGE_CLASS",
6681 "storage class '$2' should be located before type '$1'\n" . $herecurr);
6682 }
6683# Check that the storage class is at the beginning of a declaration
6684 if ($line =~ /\b$Storage\b/ &&
6685 $line !~ /^.\s*$Storage/ &&
6686 $line =~ /^.\s*(.+?)\$Storage\s/ &&
6687 $1 !~ /[\,\)]\s*$/) {
6688 WARN("STORAGE_CLASS",
6689 "storage class should be at the beginning of the declaration\n" . $herecurr);
6690 }
6691
6692# check the location of the inline attribute, that it is between
6693# storage class and type.
6694 if ($line =~ /\b$Type\s+$Inline\b/ ||
6695 $line =~ /\b$Inline\s+$Storage\b/) {
6696 ERROR("INLINE_LOCATION",
6697 "inline keyword should sit between storage class and type\n" . $herecurr);
6698 }
6699
6700# Check for __inline__ and __inline, prefer inline
6701 if ($realfile !~ m@\binclude/uapi/@ &&
6702 $line =~ /\b(__inline__|__inline)\b/) {
6703 if (WARN("INLINE",
6704 "plain inline is preferred over $1\n" . $herecurr) &&
6705 $fix) {
6706 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
6707
6708 }
6709 }
6710
6711# Check for compiler attributes
6712 if ($realfile !~ m@\binclude/uapi/@ &&
6713 $rawline =~ /\b__attribute__\s*\(\s*($balanced_parens)\s*\)/) {
6714 my $attr = $1;
6715 $attr =~ s/\s*\(\s*(.*)\)\s*/$1/;
6716
6717 my %attr_list = (
6718 "alias" => "__alias",
6719 "aligned" => "__aligned",
6720 "always_inline" => "__always_inline",
6721 "assume_aligned" => "__assume_aligned",
6722 "cold" => "__cold",
6723 "const" => "__attribute_const__",
6724 "copy" => "__copy",
6725 "designated_init" => "__designated_init",
6726 "externally_visible" => "__visible",
6727 "format" => "printf|scanf",
6728 "gnu_inline" => "__gnu_inline",
6729 "malloc" => "__malloc",
6730 "mode" => "__mode",
6731 "no_caller_saved_registers" => "__no_caller_saved_registers",
6732 "noclone" => "__noclone",
6733 "noinline" => "noinline",
6734 "nonstring" => "__nonstring",
6735 "noreturn" => "__noreturn",
6736 "packed" => "__packed",
6737 "pure" => "__pure",
6738 "section" => "__section",
6739 "used" => "__used",
6740 "weak" => "__weak"
6741 );
6742
6743 while ($attr =~ /\s*(\w+)\s*(${balanced_parens})?/g) {
6744 my $orig_attr = $1;
6745 my $params = '';
6746 $params = $2 if defined($2);
6747 my $curr_attr = $orig_attr;
6748 $curr_attr =~ s/^[\s_]+|[\s_]+$//g;
6749 if (exists($attr_list{$curr_attr})) {
6750 my $new = $attr_list{$curr_attr};
6751 if ($curr_attr eq "format" && $params) {
6752 $params =~ /^\s*\(\s*(\w+)\s*,\s*(.*)/;
6753 $new = "__$1\($2";
6754 } else {
6755 $new = "$new$params";
6756 }
6757 if (WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6758 "Prefer $new over __attribute__(($orig_attr$params))\n" . $herecurr) &&
6759 $fix) {
6760 my $remove = "\Q$orig_attr\E" . '\s*' . "\Q$params\E" . '(?:\s*,\s*)?';
6761 $fixed[$fixlinenr] =~ s/$remove//;
6762 $fixed[$fixlinenr] =~ s/\b__attribute__/$new __attribute__/;
6763 $fixed[$fixlinenr] =~ s/\}\Q$new\E/} $new/;
6764 $fixed[$fixlinenr] =~ s/ __attribute__\s*\(\s*\(\s*\)\s*\)//;
6765 }
6766 }
6767 }
6768
6769 # Check for __attribute__ unused, prefer __always_unused or __maybe_unused
6770 if ($attr =~ /^_*unused/) {
6771 WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6772 "__always_unused or __maybe_unused is preferred over __attribute__((__unused__))\n" . $herecurr);
6773 }
6774 }
6775
6776# Check for __attribute__ weak, or __weak declarations (may have link issues)
6777 if ($perl_version_ok &&
6778 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
6779 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
6780 $line =~ /\b__weak\b/)) {
6781 ERROR("WEAK_DECLARATION",
6782 "Using weak declarations can have unintended link defects\n" . $herecurr);
6783 }
6784
6785# check for c99 types like uint8_t used outside of uapi/ and tools/
6786 if ($realfile !~ m@\binclude/uapi/@ &&
6787 $realfile !~ m@\btools/@ &&
6788 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
6789 my $type = $1;
6790 if ($type =~ /\b($typeC99Typedefs)\b/) {
6791 $type = $1;
6792 my $kernel_type = 'u';
6793 $kernel_type = 's' if ($type =~ /^_*[si]/);
6794 $type =~ /(\d+)/;
6795 $kernel_type .= $1;
6796 if (CHK("PREFER_KERNEL_TYPES",
6797 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6798 $fix) {
6799 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6800 }
6801 }
6802 }
6803
6804# check for cast of C90 native int or longer types constants
6805 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
6806 my $cast = $1;
6807 my $const = $2;
6808 my $suffix = "";
6809 my $newconst = $const;
6810 $newconst =~ s/${Int_type}$//;
6811 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6812 if ($cast =~ /\blong\s+long\b/) {
6813 $suffix .= 'LL';
6814 } elsif ($cast =~ /\blong\b/) {
6815 $suffix .= 'L';
6816 }
6817 if (WARN("TYPECAST_INT_CONSTANT",
6818 "Unnecessary typecast of c90 int constant - '$cast$const' could be '$const$suffix'\n" . $herecurr) &&
6819 $fix) {
6820 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6821 }
6822 }
6823
6824# check for sizeof(&)
6825 if ($line =~ /\bsizeof\s*\(\s*\&/) {
6826 WARN("SIZEOF_ADDRESS",
6827 "sizeof(& should be avoided\n" . $herecurr);
6828 }
6829
6830# check for sizeof without parenthesis
6831 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
6832 if (WARN("SIZEOF_PARENTHESIS",
6833 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6834 $fix) {
6835 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
6836 }
6837 }
6838
6839# check for struct spinlock declarations
6840 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
6841 WARN("USE_SPINLOCK_T",
6842 "struct spinlock should be spinlock_t\n" . $herecurr);
6843 }
6844
6845# check for seq_printf uses that could be seq_puts
6846 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
6847 my $fmt = get_quoted_string($line, $rawline);
6848 $fmt =~ s/%%//g;
6849 if ($fmt !~ /%/) {
6850 if (WARN("PREFER_SEQ_PUTS",
6851 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
6852 $fix) {
6853 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6854 }
6855 }
6856 }
6857
6858# check for vsprintf extension %p<foo> misuses
6859 if ($perl_version_ok &&
6860 defined $stat &&
6861 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
6862 $1 !~ /^_*volatile_*$/) {
6863 my $stat_real;
6864
6865 my $lc = $stat =~ tr@\n@@;
6866 $lc = $lc + $linenr;
6867 for (my $count = $linenr; $count <= $lc; $count++) {
6868 my $specifier;
6869 my $extension;
6870 my $qualifier;
6871 my $bad_specifier = "";
6872 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
6873 $fmt =~ s/%%//g;
6874
6875 while ($fmt =~ /(\%[\*\d\.]*p(\w)(\w*))/g) {
6876 $specifier = $1;
6877 $extension = $2;
6878 $qualifier = $3;
6879 if ($extension !~ /[4SsBKRraEehMmIiUDdgVCbGNOxtf]/ ||
6880 ($extension eq "f" &&
6881 defined $qualifier && $qualifier !~ /^w/) ||
6882 ($extension eq "4" &&
6883 defined $qualifier && $qualifier !~ /^cc/)) {
6884 $bad_specifier = $specifier;
6885 last;
6886 }
6887 if ($extension eq "x" && !defined($stat_real)) {
6888 if (!defined($stat_real)) {
6889 $stat_real = get_stat_real($linenr, $lc);
6890 }
6891 WARN("VSPRINTF_SPECIFIER_PX",
6892 "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");
6893 }
6894 }
6895 if ($bad_specifier ne "") {
6896 my $stat_real = get_stat_real($linenr, $lc);
6897 my $ext_type = "Invalid";
6898 my $use = "";
6899 if ($bad_specifier =~ /p[Ff]/) {
6900 $use = " - use %pS instead";
6901 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6902 }
6903
6904 WARN("VSPRINTF_POINTER_EXTENSION",
6905 "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6906 }
6907 }
6908 }
6909
6910# Check for misused memsets
6911 if ($perl_version_ok &&
6912 defined $stat &&
6913 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
6914
6915 my $ms_addr = $2;
6916 my $ms_val = $7;
6917 my $ms_size = $12;
6918
6919 if ($ms_size =~ /^(0x|)0$/i) {
6920 ERROR("MEMSET",
6921 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6922 } elsif ($ms_size =~ /^(0x|)1$/i) {
6923 WARN("MEMSET",
6924 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6925 }
6926 }
6927
6928# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6929# if ($perl_version_ok &&
6930# defined $stat &&
6931# $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6932# if (WARN("PREFER_ETHER_ADDR_COPY",
6933# "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6934# $fix) {
6935# $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
6936# }
6937# }
6938
6939# Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6940# if ($perl_version_ok &&
6941# defined $stat &&
6942# $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6943# WARN("PREFER_ETHER_ADDR_EQUAL",
6944# "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6945# }
6946
6947# check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6948# check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
6949# if ($perl_version_ok &&
6950# defined $stat &&
6951# $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6952#
6953# my $ms_val = $7;
6954#
6955# if ($ms_val =~ /^(?:0x|)0+$/i) {
6956# if (WARN("PREFER_ETH_ZERO_ADDR",
6957# "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
6958# $fix) {
6959# $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
6960# }
6961# } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
6962# if (WARN("PREFER_ETH_BROADCAST_ADDR",
6963# "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
6964# $fix) {
6965# $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
6966# }
6967# }
6968# }
6969
6970# typecasts on min/max could be min_t/max_t
6971 if ($perl_version_ok &&
6972 defined $stat &&
6973 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
6974 if (defined $2 || defined $7) {
6975 my $call = $1;
6976 my $cast1 = deparenthesize($2);
6977 my $arg1 = $3;
6978 my $cast2 = deparenthesize($7);
6979 my $arg2 = $8;
6980 my $cast;
6981
6982 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
6983 $cast = "$cast1 or $cast2";
6984 } elsif ($cast1 ne "") {
6985 $cast = $cast1;
6986 } else {
6987 $cast = $cast2;
6988 }
6989 WARN("MINMAX",
6990 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
6991 }
6992 }
6993
6994# check usleep_range arguments
6995 if ($perl_version_ok &&
6996 defined $stat &&
6997 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
6998 my $min = $1;
6999 my $max = $7;
7000 if ($min eq $max) {
7001 WARN("USLEEP_RANGE",
7002 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
7003 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
7004 $min > $max) {
7005 WARN("USLEEP_RANGE",
7006 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
7007 }
7008 }
7009
7010# check for naked sscanf
7011 if ($perl_version_ok &&
7012 defined $stat &&
7013 $line =~ /\bsscanf\b/ &&
7014 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
7015 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
7016 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
7017 my $lc = $stat =~ tr@\n@@;
7018 $lc = $lc + $linenr;
7019 my $stat_real = get_stat_real($linenr, $lc);
7020 WARN("NAKED_SSCANF",
7021 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
7022 }
7023
7024# check for simple sscanf that should be kstrto<foo>
7025 if ($perl_version_ok &&
7026 defined $stat &&
7027 $line =~ /\bsscanf\b/) {
7028 my $lc = $stat =~ tr@\n@@;
7029 $lc = $lc + $linenr;
7030 my $stat_real = get_stat_real($linenr, $lc);
7031 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
7032 my $format = $6;
7033 my $count = $format =~ tr@%@%@;
7034 if ($count == 1 &&
7035 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
7036 WARN("SSCANF_TO_KSTRTO",
7037 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
7038 }
7039 }
7040 }
7041
7042# check for new externs in .h files.
7043 if ($realfile =~ /\.h$/ &&
7044 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
7045 if (CHK("AVOID_EXTERNS",
7046 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
7047 $fix) {
7048 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
7049 }
7050 }
7051
7052# check for new externs in .c files.
7053 if ($realfile =~ /\.c$/ && defined $stat &&
7054 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
7055 {
7056 my $function_name = $1;
7057 my $paren_space = $2;
7058
7059 my $s = $stat;
7060 if (defined $cond) {
7061 substr($s, 0, length($cond), '');
7062 }
7063 if ($s =~ /^\s*;/)
7064 {
7065 WARN("AVOID_EXTERNS",
7066 "externs should be avoided in .c files\n" . $herecurr);
7067 }
7068
7069 if ($paren_space =~ /\n/) {
7070 WARN("FUNCTION_ARGUMENTS",
7071 "arguments for function declarations should follow identifier\n" . $herecurr);
7072 }
7073
7074 } elsif ($realfile =~ /\.c$/ && defined $stat &&
7075 $stat =~ /^.\s*extern\s+/)
7076 {
7077 WARN("AVOID_EXTERNS",
7078 "externs should be avoided in .c files\n" . $herecurr);
7079 }
7080
7081# check for function declarations that have arguments without identifier names
7082 if (defined $stat &&
7083 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
7084 $1 ne "void") {
7085 my $args = trim($1);
7086 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
7087 my $arg = trim($1);
7088 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
7089 WARN("FUNCTION_ARGUMENTS",
7090 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
7091 }
7092 }
7093 }
7094
7095# check for function definitions
7096 if ($perl_version_ok &&
7097 defined $stat &&
7098 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
7099 $context_function = $1;
7100
7101# check for multiline function definition with misplaced open brace
7102 my $ok = 0;
7103 my $cnt = statement_rawlines($stat);
7104 my $herectx = $here . "\n";
7105 for (my $n = 0; $n < $cnt; $n++) {
7106 my $rl = raw_line($linenr, $n);
7107 $herectx .= $rl . "\n";
7108 $ok = 1 if ($rl =~ /^[ \+]\{/);
7109 $ok = 1 if ($rl =~ /\{/ && $n == 0);
7110 last if $rl =~ /^[ \+].*\{/;
7111 }
7112 if (!$ok) {
7113 ERROR("OPEN_BRACE",
7114 "open brace '{' following function definitions go on the next line\n" . $herectx);
7115 }
7116 }
7117
7118# checks for new __setup's
7119 if ($rawline =~ /\b__setup\("([^"]*)"/) {
7120 my $name = $1;
7121
7122 if (!grep(/$name/, @setup_docs)) {
7123 CHK("UNDOCUMENTED_SETUP",
7124 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
7125 }
7126 }
7127
7128# check for pointless casting of alloc functions
7129 if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
7130 WARN("UNNECESSARY_CASTS",
7131 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
7132 }
7133
7134# alloc style
7135# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
7136 if ($perl_version_ok &&
7137 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
7138 CHK("ALLOC_SIZEOF_STRUCT",
7139 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
7140 }
7141
7142# check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
7143 if ($perl_version_ok &&
7144 defined $stat &&
7145 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
7146 my $oldfunc = $3;
7147 my $a1 = $4;
7148 my $a2 = $10;
7149 my $newfunc = "kmalloc_array";
7150 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
7151 my $r1 = $a1;
7152 my $r2 = $a2;
7153 if ($a1 =~ /^sizeof\s*\S/) {
7154 $r1 = $a2;
7155 $r2 = $a1;
7156 }
7157 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
7158 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
7159 my $cnt = statement_rawlines($stat);
7160 my $herectx = get_stat_here($linenr, $cnt, $here);
7161
7162 if (WARN("ALLOC_WITH_MULTIPLY",
7163 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
7164 $cnt == 1 &&
7165 $fix) {
7166 $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
7167 }
7168 }
7169 }
7170
7171# check for krealloc arg reuse
7172 if ($perl_version_ok &&
7173 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*($Lval)\s*,/ &&
7174 $1 eq $3) {
7175 WARN("KREALLOC_ARG_REUSE",
7176 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
7177 }
7178
7179# check for alloc argument mismatch
7180 if ($line =~ /\b((?:devm_)?(?:kcalloc|kmalloc_array))\s*\(\s*sizeof\b/) {
7181 WARN("ALLOC_ARRAY_ARGS",
7182 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
7183 }
7184
7185# check for multiple semicolons
7186 if ($line =~ /;\s*;\s*$/) {
7187 if (WARN("ONE_SEMICOLON",
7188 "Statements terminations use 1 semicolon\n" . $herecurr) &&
7189 $fix) {
7190 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
7191 }
7192 }
7193
7194# check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
7195 if ($realfile !~ m@^include/uapi/@ &&
7196 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
7197 my $ull = "";
7198 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
7199 if (CHK("BIT_MACRO",
7200 "Prefer using the BIT$ull macro\n" . $herecurr) &&
7201 $fix) {
7202 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
7203 }
7204 }
7205
7206# check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
7207 if ($rawline =~ /\bIS_ENABLED\s*\(\s*(\w+)\s*\)/ && $1 !~ /^${CONFIG_}/) {
7208 WARN("IS_ENABLED_CONFIG",
7209 "IS_ENABLED($1) is normally used as IS_ENABLED(${CONFIG_}$1)\n" . $herecurr);
7210 }
7211
7212# check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
7213 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(${CONFIG_}[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
7214 my $config = $1;
7215 if (WARN("PREFER_IS_ENABLED",
7216 "Prefer IS_ENABLED(<FOO>) to ${CONFIG_}<FOO> || ${CONFIG_}<FOO>_MODULE\n" . $herecurr) &&
7217 $fix) {
7218 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
7219 }
7220 }
7221
7222# check for /* fallthrough */ like comment, prefer fallthrough;
7223 my @fallthroughs = (
7224 'fallthrough',
7225 '@fallthrough@',
7226 'lint -fallthrough[ \t]*',
7227 'intentional(?:ly)?[ \t]*fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)',
7228 '(?:else,?\s*)?FALL(?:S | |-)?THR(?:OUGH|U|EW)[ \t.!]*(?:-[^\n\r]*)?',
7229 'Fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7230 'fall(?:s | |-)?thr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7231 );
7232 if ($raw_comment ne '') {
7233 foreach my $ft (@fallthroughs) {
7234 if ($raw_comment =~ /$ft/) {
7235 my $msg_level = \&WARN;
7236 $msg_level = \&CHK if ($file);
7237 &{$msg_level}("PREFER_FALLTHROUGH",
7238 "Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
7239 last;
7240 }
7241 }
7242 }
7243
7244# check for switch/default statements without a break;
7245 if ($perl_version_ok &&
7246 defined $stat &&
7247 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
7248 my $cnt = statement_rawlines($stat);
7249 my $herectx = get_stat_here($linenr, $cnt, $here);
7250
7251 WARN("DEFAULT_NO_BREAK",
7252 "switch default: should use break\n" . $herectx);
7253 }
7254
7255# check for gcc specific __FUNCTION__
7256 if ($line =~ /\b__FUNCTION__\b/) {
7257 if (WARN("USE_FUNC",
7258 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
7259 $fix) {
7260 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
7261 }
7262 }
7263
7264# check for uses of __DATE__, __TIME__, __TIMESTAMP__
7265 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
7266 ERROR("DATE_TIME",
7267 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
7268 }
7269
7270# check for use of yield()
7271 if ($line =~ /\byield\s*\(\s*\)/) {
7272 WARN("YIELD",
7273 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
7274 }
7275
7276# check for comparisons against true and false
7277 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
7278 my $lead = $1;
7279 my $arg = $2;
7280 my $test = $3;
7281 my $otype = $4;
7282 my $trail = $5;
7283 my $op = "!";
7284
7285 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
7286
7287 my $type = lc($otype);
7288 if ($type =~ /^(?:true|false)$/) {
7289 if (("$test" eq "==" && "$type" eq "true") ||
7290 ("$test" eq "!=" && "$type" eq "false")) {
7291 $op = "";
7292 }
7293
7294 CHK("BOOL_COMPARISON",
7295 "Using comparison to $otype is error prone\n" . $herecurr);
7296
7297## maybe suggesting a correct construct would better
7298## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
7299
7300 }
7301 }
7302
7303# check for semaphores initialized locked
7304 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
7305 WARN("CONSIDER_COMPLETION",
7306 "consider using a completion\n" . $herecurr);
7307 }
7308
7309# recommend kstrto* over simple_strto* and strict_strto*
7310 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
7311 WARN("CONSIDER_KSTRTO",
7312 "$1 is obsolete, use k$3 instead\n" . $herecurr);
7313 }
7314
7315# check for __initcall(), use device_initcall() explicitly or more appropriate function please
7316 if ($line =~ /^.\s*__initcall\s*\(/) {
7317 WARN("USE_DEVICE_INITCALL",
7318 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
7319 }
7320
7321# check for spin_is_locked(), suggest lockdep instead
7322 if ($line =~ /\bspin_is_locked\(/) {
7323 WARN("USE_LOCKDEP",
7324 "Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
7325 }
7326
7327# check for deprecated apis
7328 if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
7329 my $deprecated_api = $1;
7330 my $new_api = $deprecated_apis{$deprecated_api};
7331 WARN("DEPRECATED_API",
7332 "Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
7333 }
7334
7335# check for various structs that are normally const (ops, kgdb, device_tree)
7336# and avoid what seem like struct definitions 'struct foo {'
7337 if (defined($const_structs) &&
7338 $line !~ /\bconst\b/ &&
7339 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
7340 WARN("CONST_STRUCT",
7341 "struct $1 should normally be const\n" . $herecurr);
7342 }
7343
7344# use of NR_CPUS is usually wrong
7345# ignore definitions of NR_CPUS and usage to define arrays as likely right
7346# ignore designated initializers using NR_CPUS
7347 if ($line =~ /\bNR_CPUS\b/ &&
7348 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
7349 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
7350 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
7351 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
7352 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/ &&
7353 $line !~ /^.\s*\.\w+\s*=\s*.*\bNR_CPUS\b/)
7354 {
7355 WARN("NR_CPUS",
7356 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
7357 }
7358
7359# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
7360 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
7361 ERROR("DEFINE_ARCH_HAS",
7362 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
7363 }
7364
7365# likely/unlikely comparisons similar to "(likely(foo) > 0)"
7366 if ($perl_version_ok &&
7367 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
7368 WARN("LIKELY_MISUSE",
7369 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
7370 }
7371
7372# return sysfs_emit(foo, fmt, ...) fmt without newline
7373 if ($line =~ /\breturn\s+sysfs_emit\s*\(\s*$FuncArg\s*,\s*($String)/ &&
7374 substr($rawline, $-[6], $+[6] - $-[6]) !~ /\\n"$/) {
7375 my $offset = $+[6] - 1;
7376 if (WARN("SYSFS_EMIT",
7377 "return sysfs_emit(...) formats should include a terminating newline\n" . $herecurr) &&
7378 $fix) {
7379 substr($fixed[$fixlinenr], $offset, 0) = '\\n';
7380 }
7381 }
7382
7383# nested likely/unlikely calls
7384 if ($line =~ /\b(?:(?:un)?likely)\s*\(\s*!?\s*(IS_ERR(?:_OR_NULL|_VALUE)?|WARN)/) {
7385 WARN("LIKELY_MISUSE",
7386 "nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
7387 }
7388
7389# whine mightly about in_atomic
7390 if ($line =~ /\bin_atomic\s*\(/) {
7391 if ($realfile =~ m@^drivers/@) {
7392 ERROR("IN_ATOMIC",
7393 "do not use in_atomic in drivers\n" . $herecurr);
7394 } elsif ($realfile !~ m@^kernel/@) {
7395 WARN("IN_ATOMIC",
7396 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
7397 }
7398 }
7399
7400# check for lockdep_set_novalidate_class
7401 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
7402 $line =~ /__lockdep_no_validate__\s*\)/ ) {
7403 if ($realfile !~ m@^kernel/lockdep@ &&
7404 $realfile !~ m@^include/linux/lockdep@ &&
7405 $realfile !~ m@^drivers/base/core@) {
7406 ERROR("LOCKDEP",
7407 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
7408 }
7409 }
7410
7411 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
7412 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
7413 WARN("EXPORTED_WORLD_WRITABLE",
7414 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
7415 }
7416
7417# check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
7418# and whether or not function naming is typical and if
7419# DEVICE_ATTR permissions uses are unusual too
7420 if ($perl_version_ok &&
7421 defined $stat &&
7422 $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*\)/) {
7423 my $var = $1;
7424 my $perms = $2;
7425 my $show = $3;
7426 my $store = $4;
7427 my $octal_perms = perms_to_octal($perms);
7428 if ($show =~ /^${var}_show$/ &&
7429 $store =~ /^${var}_store$/ &&
7430 $octal_perms eq "0644") {
7431 if (WARN("DEVICE_ATTR_RW",
7432 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
7433 $fix) {
7434 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
7435 }
7436 } elsif ($show =~ /^${var}_show$/ &&
7437 $store =~ /^NULL$/ &&
7438 $octal_perms eq "0444") {
7439 if (WARN("DEVICE_ATTR_RO",
7440 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
7441 $fix) {
7442 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
7443 }
7444 } elsif ($show =~ /^NULL$/ &&
7445 $store =~ /^${var}_store$/ &&
7446 $octal_perms eq "0200") {
7447 if (WARN("DEVICE_ATTR_WO",
7448 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
7449 $fix) {
7450 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
7451 }
7452 } elsif ($octal_perms eq "0644" ||
7453 $octal_perms eq "0444" ||
7454 $octal_perms eq "0200") {
7455 my $newshow = "$show";
7456 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
7457 my $newstore = $store;
7458 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
7459 my $rename = "";
7460 if ($show ne $newshow) {
7461 $rename .= " '$show' to '$newshow'";
7462 }
7463 if ($store ne $newstore) {
7464 $rename .= " '$store' to '$newstore'";
7465 }
7466 WARN("DEVICE_ATTR_FUNCTIONS",
7467 "Consider renaming function(s)$rename\n" . $herecurr);
7468 } else {
7469 WARN("DEVICE_ATTR_PERMS",
7470 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
7471 }
7472 }
7473
7474# Mode permission misuses where it seems decimal should be octal
7475# This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
7476# o Ignore module_param*(...) uses with a decimal 0 permission as that has a
7477# specific definition of not visible in sysfs.
7478# o Ignore proc_create*(...) uses with a decimal 0 permission as that means
7479# use the default permissions
7480 if ($perl_version_ok &&
7481 defined $stat &&
7482 $line =~ /$mode_perms_search/) {
7483 foreach my $entry (@mode_permission_funcs) {
7484 my $func = $entry->[0];
7485 my $arg_pos = $entry->[1];
7486
7487 my $lc = $stat =~ tr@\n@@;
7488 $lc = $lc + $linenr;
7489 my $stat_real = get_stat_real($linenr, $lc);
7490
7491 my $skip_args = "";
7492 if ($arg_pos > 1) {
7493 $arg_pos--;
7494 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
7495 }
7496 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
7497 if ($stat =~ /$test/) {
7498 my $val = $1;
7499 $val = $6 if ($skip_args ne "");
7500 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
7501 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
7502 ($val =~ /^$Octal$/ && length($val) ne 4))) {
7503 ERROR("NON_OCTAL_PERMISSIONS",
7504 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
7505 }
7506 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
7507 ERROR("EXPORTED_WORLD_WRITABLE",
7508 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
7509 }
7510 }
7511 }
7512 }
7513
7514# check for uses of S_<PERMS> that could be octal for readability
7515 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
7516 my $oval = $1;
7517 my $octal = perms_to_octal($oval);
7518 if (WARN("SYMBOLIC_PERMS",
7519 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
7520 $fix) {
7521 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
7522 }
7523 }
7524
7525# validate content of MODULE_LICENSE against list from include/linux/module.h
7526 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
7527 my $extracted_string = get_quoted_string($line, $rawline);
7528 my $valid_licenses = qr{
7529 GPL|
7530 GPL\ v2|
7531 GPL\ and\ additional\ rights|
7532 Dual\ BSD/GPL|
7533 Dual\ MIT/GPL|
7534 Dual\ MPL/GPL|
7535 Proprietary
7536 }x;
7537 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
7538 WARN("MODULE_LICENSE",
7539 "unknown module license " . $extracted_string . "\n" . $herecurr);
7540 }
7541 }
7542
7543# check for sysctl duplicate constants
7544 if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
7545 WARN("DUPLICATED_SYSCTL_CONST",
7546 "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
7547 }
7548 }
7549
7550 # If we have no input at all, then there is nothing to report on
7551 # so just keep quiet.
7552 if ($#rawlines == -1) {
7553 exit(0);
7554 }
7555
7556 # In mailback mode only produce a report in the negative, for
7557 # things that appear to be patches.
7558 if ($mailback && ($clean == 1 || !$is_patch)) {
7559 exit(0);
7560 }
7561
7562 # This is not a patch, and we are in 'no-patch' mode so
7563 # just keep quiet.
7564 if (!$chk_patch && !$is_patch) {
7565 exit(0);
7566 }
7567
7568 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
7569 ERROR("NOT_UNIFIED_DIFF",
7570 "Does not appear to be a unified-diff format patch\n");
7571 }
7572 if ($is_patch && $has_commit_log && $chk_signoff) {
7573 if ($signoff == 0) {
7574 ERROR("MISSING_SIGN_OFF",
7575 "Missing Signed-off-by: line(s)\n");
7576 } elsif ($authorsignoff != 1) {
7577 # authorsignoff values:
7578 # 0 -> missing sign off
7579 # 1 -> sign off identical
7580 # 2 -> names and addresses match, comments mismatch
7581 # 3 -> addresses match, names different
7582 # 4 -> names match, addresses different
7583 # 5 -> names match, addresses excluding subaddress details (refer RFC 5233) match
7584
7585 my $sob_msg = "'From: $author' != 'Signed-off-by: $author_sob'";
7586
7587 if ($authorsignoff == 0) {
7588 ERROR("NO_AUTHOR_SIGN_OFF",
7589 "Missing Signed-off-by: line by nominal patch author '$author'\n");
7590 } elsif ($authorsignoff == 2) {
7591 CHK("FROM_SIGN_OFF_MISMATCH",
7592 "From:/Signed-off-by: email comments mismatch: $sob_msg\n");
7593 } elsif ($authorsignoff == 3) {
7594 WARN("FROM_SIGN_OFF_MISMATCH",
7595 "From:/Signed-off-by: email name mismatch: $sob_msg\n");
7596 } elsif ($authorsignoff == 4) {
7597 WARN("FROM_SIGN_OFF_MISMATCH",
7598 "From:/Signed-off-by: email address mismatch: $sob_msg\n");
7599 } elsif ($authorsignoff == 5) {
7600 WARN("FROM_SIGN_OFF_MISMATCH",
7601 "From:/Signed-off-by: email subaddress mismatch: $sob_msg\n");
7602 }
7603 }
7604 }
7605
7606 print report_dump();
7607 if ($summary && !($clean == 1 && $quiet == 1)) {
7608 print "$filename " if ($summary_file);
7609 print "total: $cnt_error errors, $cnt_warn warnings, " .
7610 (($check)? "$cnt_chk checks, " : "") .
7611 "$cnt_lines lines checked\n";
7612 }
7613
7614 if ($quiet == 0) {
7615 # If there were any defects found and not already fixing them
7616 if (!$clean and !$fix) {
7617 print << "EOM"
7618
7619NOTE: For some of the reported defects, checkpatch may be able to
7620 mechanically convert to the typical style using --fix or --fix-inplace.
7621EOM
7622 }
7623 # If there were whitespace errors which cleanpatch can fix
7624 # then suggest that.
7625 if ($rpt_cleaners) {
7626 $rpt_cleaners = 0;
7627 print << "EOM"
7628
7629NOTE: Whitespace errors detected.
7630 You may wish to use scripts/cleanpatch or scripts/cleanfile
7631EOM
7632 }
7633 }
7634
7635 if ($clean == 0 && $fix &&
7636 ("@rawlines" ne "@fixed" ||
7637 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
7638 my $newfile = $filename;
7639 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
7640 my $linecount = 0;
7641 my $f;
7642
7643 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
7644
7645 open($f, '>', $newfile)
7646 or die "$P: Can't open $newfile for write\n";
7647 foreach my $fixed_line (@fixed) {
7648 $linecount++;
7649 if ($file) {
7650 if ($linecount > 3) {
7651 $fixed_line =~ s/^\+//;
7652 print $f $fixed_line . "\n";
7653 }
7654 } else {
7655 print $f $fixed_line . "\n";
7656 }
7657 }
7658 close($f);
7659
7660 if (!$quiet) {
7661 print << "EOM";
7662
7663Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
7664
7665Do _NOT_ trust the results written to this file.
7666Do _NOT_ submit these changes without inspecting them for correctness.
7667
7668This EXPERIMENTAL file is simply a convenience to help rewrite patches.
7669No warranties, expressed or implied...
7670EOM
7671 }
7672 }
7673
7674 if ($quiet == 0) {
7675 print "\n";
7676 if ($clean == 1) {
7677 print "$vname has no obvious style problems and is ready for submission.\n";
7678 } else {
7679 print "$vname has style problems, please review.\n";
7680 }
7681 }
7682 return $clean;
7683}