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