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 comment styles
4019 # Networking with an initial /*
4020 if ($realfile =~ m@^(drivers/net/|net/)@ &&
4021 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
4022 $rawline =~ /^\+[ \t]*\*/ &&
4023 $realline > 3) { # Do not warn about the initial copyright comment block after SPDX-License-Identifier
4024 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
4025 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
4026 }
4027
4028 # Block comments use * on subsequent lines
4029 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
4030 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
4031 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
4032 $rawline =~ /^\+/ && #line is new
4033 $rawline !~ /^\+[ \t]*\*/) { #no leading *
4034 WARN("BLOCK_COMMENT_STYLE",
4035 "Block comments use * on subsequent lines\n" . $hereprev);
4036 }
4037
4038 # Block comments use */ on trailing lines
4039 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
4040 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
4041 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
4042 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
4043 WARN("BLOCK_COMMENT_STYLE",
4044 "Block comments use a trailing */ on a separate line\n" . $herecurr);
4045 }
4046
4047 # Block comment * alignment
4048 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
4049 $line =~ /^\+[ \t]*$;/ && #leading comment
4050 $rawline =~ /^\+[ \t]*\*/ && #leading *
4051 (($prevrawline =~ /^\+.*?\/\*/ && #leading /*
4052 $prevrawline !~ /\*\/[ \t]*$/) || #no trailing */
4053 $prevrawline =~ /^\+[ \t]*\*/)) { #leading *
4054 my $oldindent;
4055 $prevrawline =~ m@^\+([ \t]*/?)\*@;
4056 if (defined($1)) {
4057 $oldindent = expand_tabs($1);
4058 } else {
4059 $prevrawline =~ m@^\+(.*/?)\*@;
4060 $oldindent = expand_tabs($1);
4061 }
4062 $rawline =~ m@^\+([ \t]*)\*@;
4063 my $newindent = $1;
4064 $newindent = expand_tabs($newindent);
4065 if (length($oldindent) ne length($newindent)) {
4066 WARN("BLOCK_COMMENT_STYLE",
4067 "Block comments should align the * on each line\n" . $hereprev);
4068 }
4069 }
4070
4071 # check for missing blank lines after struct/union declarations
4072 # with exceptions for various attributes and macros
4073 if ($prevline =~ /^[\+ ]};?\s*$/ &&
4074 $line =~ /^\+/ &&
4075 !($line =~ /^\+\s*$/ ||
4076 $line =~ /^\+\s*(?:EXPORT_SYMBOL|early_param|ALLOW_ERROR_INJECTION)/ ||
4077 $line =~ /^\+\s*MODULE_/i ||
4078 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
4079 $line =~ /^\+[a-z_]*init/ ||
4080 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
4081 $line =~ /^\+\s*DECLARE/ ||
4082 $line =~ /^\+\s*builtin_[\w_]*driver/ ||
4083 $line =~ /^\+\s*__setup/)) {
4084 if (CHK("LINE_SPACING",
4085 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
4086 $fix) {
4087 fix_insert_line($fixlinenr, "\+");
4088 }
4089 }
4090
4091 # check for multiple consecutive blank lines
4092 if ($prevline =~ /^[\+ ]\s*$/ &&
4093 $line =~ /^\+\s*$/ &&
4094 $last_blank_line != ($linenr - 1)) {
4095 if (CHK("LINE_SPACING",
4096 "Please don't use multiple blank lines\n" . $hereprev) &&
4097 $fix) {
4098 fix_delete_line($fixlinenr, $rawline);
4099 }
4100
4101 $last_blank_line = $linenr;
4102 }
4103
4104 # check for missing blank lines after declarations
4105 # (declarations must have the same indentation and not be at the start of line)
4106 if (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/) {
4107 # use temporaries
4108 my $sl = $sline;
4109 my $pl = $prevline;
4110 # remove $Attribute/$Sparse uses to simplify comparisons
4111 $sl =~ s/\b(?:$Attribute|$Sparse)\b//g;
4112 $pl =~ s/\b(?:$Attribute|$Sparse)\b//g;
4113 if (($pl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
4114 # function pointer declarations
4115 $pl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
4116 # foo bar; where foo is some local typedef or #define
4117 $pl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
4118 # known declaration macros
4119 $pl =~ /^\+\s+$declaration_macros/) &&
4120 # for "else if" which can look like "$Ident $Ident"
4121 !($pl =~ /^\+\s+$c90_Keywords\b/ ||
4122 # other possible extensions of declaration lines
4123 $pl =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
4124 # not starting a section or a macro "\" extended line
4125 $pl =~ /(?:\{\s*|\\)$/) &&
4126 # looks like a declaration
4127 !($sl =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
4128 # function pointer declarations
4129 $sl =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
4130 # foo bar; where foo is some local typedef or #define
4131 $sl =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
4132 # known declaration macros
4133 $sl =~ /^\+\s+$declaration_macros/ ||
4134 # start of struct or union or enum
4135 $sl =~ /^\+\s+(?:static\s+)?(?:const\s+)?(?:union|struct|enum|typedef)\b/ ||
4136 # start or end of block or continuation of declaration
4137 $sl =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
4138 # bitfield continuation
4139 $sl =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
4140 # other possible extensions of declaration lines
4141 $sl =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/)) {
4142 if (WARN("LINE_SPACING",
4143 "Missing a blank line after declarations\n" . $hereprev) &&
4144 $fix) {
4145 fix_insert_line($fixlinenr, "\+");
4146 }
4147 }
4148 }
4149
4150 # check for spaces at the beginning of a line.
4151 # Exceptions:
4152 # 1) within comments
4153 # 2) indented preprocessor commands
4154 # 3) hanging labels
4155 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
4156 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
4157 if (WARN("LEADING_SPACE",
4158 "please, no spaces at the start of a line\n" . $herevet) &&
4159 $fix) {
4160 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
4161 }
4162 }
4163
4164 # check we are in a valid C source file if not then ignore this hunk
4165 next if ($realfile !~ /\.(h|c)$/);
4166
4167 # check for unusual line ending [ or (
4168 if ($line =~ /^\+.*([\[\(])\s*$/) {
4169 CHK("OPEN_ENDED_LINE",
4170 "Lines should not end with a '$1'\n" . $herecurr);
4171 }
4172
4173 # check if this appears to be the start function declaration, save the name
4174 if ($sline =~ /^\+\{\s*$/ &&
4175 $prevline =~ /^\+(?:(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*)?($Ident)\(/) {
4176 $context_function = $1;
4177 }
4178
4179 # check if this appears to be the end of function declaration
4180 if ($sline =~ /^\+\}\s*$/) {
4181 undef $context_function;
4182 }
4183
4184 # check indentation of any line with a bare else
4185 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
4186 # if the previous line is a break or return and is indented 1 tab more...
4187 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
4188 my $tabs = length($1) + 1;
4189 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
4190 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
4191 defined $lines[$linenr] &&
4192 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
4193 WARN("UNNECESSARY_ELSE",
4194 "else is not generally useful after a break or return\n" . $hereprev);
4195 }
4196 }
4197
4198 # check indentation of a line with a break;
4199 # if the previous line is a goto, return or break
4200 # and is indented the same # of tabs
4201 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
4202 my $tabs = $1;
4203 if ($prevline =~ /^\+$tabs(goto|return|break)\b/) {
4204 if (WARN("UNNECESSARY_BREAK",
4205 "break is not useful after a $1\n" . $hereprev) &&
4206 $fix) {
4207 fix_delete_line($fixlinenr, $rawline);
4208 }
4209 }
4210 }
4211
4212 # check for RCS/CVS revision markers
4213 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
4214 WARN("CVS_KEYWORD",
4215 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
4216 }
4217
4218 # check for old HOTPLUG __dev<foo> section markings
4219 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
4220 WARN("HOTPLUG_SECTION",
4221 "Using $1 is unnecessary\n" . $herecurr);
4222 }
4223
4224 # Check for potential 'bare' types
4225 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
4226 $realline_next);
4227 #print "LINE<$line>\n";
4228 if ($linenr > $suppress_statement &&
4229 $realcnt && $sline =~ /.\s*\S/) {
4230 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4231 ctx_statement_block($linenr, $realcnt, 0);
4232 $stat =~ s/\n./\n /g;
4233 $cond =~ s/\n./\n /g;
4234
4235 #print "linenr<$linenr> <$stat>\n";
4236 # If this statement has no statement boundaries within
4237 # it there is no point in retrying a statement scan
4238 # until we hit end of it.
4239 my $frag = $stat; $frag =~ s/;+\s*$//;
4240 if ($frag !~ /(?:{|;)/) {
4241 #print "skip<$line_nr_next>\n";
4242 $suppress_statement = $line_nr_next;
4243 }
4244
4245 # Find the real next line.
4246 $realline_next = $line_nr_next;
4247 if (defined $realline_next &&
4248 (!defined $lines[$realline_next - 1] ||
4249 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
4250 $realline_next++;
4251 }
4252
4253 my $s = $stat;
4254 $s =~ s/{.*$//s;
4255
4256 # Ignore goto labels.
4257 if ($s =~ /$Ident:\*$/s) {
4258
4259 # Ignore functions being called
4260 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
4261
4262 } elsif ($s =~ /^.\s*else\b/s) {
4263
4264 # declarations always start with types
4265 } 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) {
4266 my $type = $1;
4267 $type =~ s/\s+/ /g;
4268 possible($type, "A:" . $s);
4269
4270 # definitions in global scope can only start with types
4271 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
4272 possible($1, "B:" . $s);
4273 }
4274
4275 # any (foo ... *) is a pointer cast, and foo is a type
4276 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
4277 possible($1, "C:" . $s);
4278 }
4279
4280 # Check for any sort of function declaration.
4281 # int foo(something bar, other baz);
4282 # void (*store_gdt)(x86_descr_ptr *);
4283 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
4284 my ($name_len) = length($1);
4285
4286 my $ctx = $s;
4287 substr($ctx, 0, $name_len + 1, '');
4288 $ctx =~ s/\)[^\)]*$//;
4289
4290 for my $arg (split(/\s*,\s*/, $ctx)) {
4291 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
4292
4293 possible($1, "D:" . $s);
4294 }
4295 }
4296 }
4297
4298 }
4299
4300 #
4301 # Checks which may be anchored in the context.
4302 #
4303
4304 # Check for switch () and associated case and default
4305 # statements should be at the same indent.
4306 if ($line=~/\bswitch\s*\(.*\)/) {
4307 my $err = '';
4308 my $sep = '';
4309 my @ctx = ctx_block_outer($linenr, $realcnt);
4310 shift(@ctx);
4311 for my $ctx (@ctx) {
4312 my ($clen, $cindent) = line_stats($ctx);
4313 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
4314 $indent != $cindent) {
4315 $err .= "$sep$ctx\n";
4316 $sep = '';
4317 } else {
4318 $sep = "[...]\n";
4319 }
4320 }
4321 if ($err ne '') {
4322 ERROR("SWITCH_CASE_INDENT_LEVEL",
4323 "switch and case should be at the same indent\n$hereline$err");
4324 }
4325 }
4326
4327 # if/while/etc brace do not go on next line, unless defining a do while loop,
4328 # or if that brace on the next line is for something else
4329 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
4330 my $pre_ctx = "$1$2";
4331
4332 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
4333
4334 if ($line =~ /^\+\t{6,}/) {
4335 WARN("DEEP_INDENTATION",
4336 "Too many leading tabs - consider code refactoring\n" . $herecurr);
4337 }
4338
4339 my $ctx_cnt = $realcnt - $#ctx - 1;
4340 my $ctx = join("\n", @ctx);
4341
4342 my $ctx_ln = $linenr;
4343 my $ctx_skip = $realcnt;
4344
4345 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
4346 defined $lines[$ctx_ln - 1] &&
4347 $lines[$ctx_ln - 1] =~ /^-/)) {
4348 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
4349 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
4350 $ctx_ln++;
4351 }
4352
4353 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
4354 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
4355
4356 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
4357 ERROR("OPEN_BRACE",
4358 "that open brace { should be on the previous line\n" .
4359 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4360 }
4361 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
4362 $ctx =~ /\)\s*\;\s*$/ &&
4363 defined $lines[$ctx_ln - 1])
4364 {
4365 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
4366 if ($nindent > $indent) {
4367 WARN("TRAILING_SEMICOLON",
4368 "trailing semicolon indicates no statements, indent implies otherwise\n" .
4369 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
4370 }
4371 }
4372 }
4373
4374 # Check relative indent for conditionals and blocks.
4375 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|(?:do|else)\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
4376 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4377 ctx_statement_block($linenr, $realcnt, 0)
4378 if (!defined $stat);
4379 my ($s, $c) = ($stat, $cond);
4380
4381 substr($s, 0, length($c), '');
4382
4383 # remove inline comments
4384 $s =~ s/$;/ /g;
4385 $c =~ s/$;/ /g;
4386
4387 # Find out how long the conditional actually is.
4388 my @newlines = ($c =~ /\n/gs);
4389 my $cond_lines = 1 + $#newlines;
4390
4391 # Make sure we remove the line prefixes as we have
4392 # none on the first line, and are going to readd them
4393 # where necessary.
4394 $s =~ s/\n./\n/gs;
4395 while ($s =~ /\n\s+\\\n/) {
4396 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
4397 }
4398
4399 # We want to check the first line inside the block
4400 # starting at the end of the conditional, so remove:
4401 # 1) any blank line termination
4402 # 2) any opening brace { on end of the line
4403 # 3) any do (...) {
4404 my $continuation = 0;
4405 my $check = 0;
4406 $s =~ s/^.*\bdo\b//;
4407 $s =~ s/^\s*{//;
4408 if ($s =~ s/^\s*\\//) {
4409 $continuation = 1;
4410 }
4411 if ($s =~ s/^\s*?\n//) {
4412 $check = 1;
4413 $cond_lines++;
4414 }
4415
4416 # Also ignore a loop construct at the end of a
4417 # preprocessor statement.
4418 if (($prevline =~ /^.\s*#\s*define\s/ ||
4419 $prevline =~ /\\\s*$/) && $continuation == 0) {
4420 $check = 0;
4421 }
4422
4423 my $cond_ptr = -1;
4424 $continuation = 0;
4425 while ($cond_ptr != $cond_lines) {
4426 $cond_ptr = $cond_lines;
4427
4428 # If we see an #else/#elif then the code
4429 # is not linear.
4430 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
4431 $check = 0;
4432 }
4433
4434 # Ignore:
4435 # 1) blank lines, they should be at 0,
4436 # 2) preprocessor lines, and
4437 # 3) labels.
4438 if ($continuation ||
4439 $s =~ /^\s*?\n/ ||
4440 $s =~ /^\s*#\s*?/ ||
4441 $s =~ /^\s*$Ident\s*:/) {
4442 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
4443 if ($s =~ s/^.*?\n//) {
4444 $cond_lines++;
4445 }
4446 }
4447 }
4448
4449 my (undef, $sindent) = line_stats("+" . $s);
4450 my $stat_real = raw_line($linenr, $cond_lines);
4451
4452 # Check if either of these lines are modified, else
4453 # this is not this patch's fault.
4454 if (!defined($stat_real) ||
4455 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
4456 $check = 0;
4457 }
4458 if (defined($stat_real) && $cond_lines > 1) {
4459 $stat_real = "[...]\n$stat_real";
4460 }
4461
4462 #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";
4463
4464 if ($check && $s ne '' &&
4465 (($sindent % $tabsize) != 0 ||
4466 ($sindent < $indent) ||
4467 ($sindent == $indent &&
4468 ($s !~ /^\s*(?:\}|\{|else\b)/)) ||
4469 ($sindent > $indent + $tabsize))) {
4470 WARN("SUSPECT_CODE_INDENT",
4471 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
4472 }
4473 }
4474
4475 # Track the 'values' across context and added lines.
4476 my $opline = $line; $opline =~ s/^./ /;
4477 my ($curr_values, $curr_vars) =
4478 annotate_values($opline . "\n", $prev_values);
4479 $curr_values = $prev_values . $curr_values;
4480 if ($dbg_values) {
4481 my $outline = $opline; $outline =~ s/\t/ /g;
4482 print "$linenr > .$outline\n";
4483 print "$linenr > $curr_values\n";
4484 print "$linenr > $curr_vars\n";
4485 }
4486 $prev_values = substr($curr_values, -1);
4487
4488 #ignore lines not being added
4489 next if ($line =~ /^[^\+]/);
4490
4491 # check for self assignments used to avoid compiler warnings
4492 # e.g.: int foo = foo, *bar = NULL;
4493 # struct foo bar = *(&(bar));
4494 if ($line =~ /^\+\s*(?:$Declare)?([A-Za-z_][A-Za-z\d_]*)\s*=/) {
4495 my $var = $1;
4496 if ($line =~ /^\+\s*(?:$Declare)?$var\s*=\s*(?:$var|\*\s*\(?\s*&\s*\(?\s*$var\s*\)?\s*\)?)\s*[;,]/) {
4497 WARN("SELF_ASSIGNMENT",
4498 "Do not use self-assignments to avoid compiler warnings\n" . $herecurr);
4499 }
4500 }
4501
4502 # check for dereferences that span multiple lines
4503 if ($prevline =~ /^\+.*$Lval\s*(?:\.|->)\s*$/ &&
4504 $line =~ /^\+\s*(?!\#\s*(?!define\s+|if))\s*$Lval/) {
4505 $prevline =~ /($Lval\s*(?:\.|->))\s*$/;
4506 my $ref = $1;
4507 $line =~ /^.\s*($Lval)/;
4508 $ref .= $1;
4509 $ref =~ s/\s//g;
4510 WARN("MULTILINE_DEREFERENCE",
4511 "Avoid multiple line dereference - prefer '$ref'\n" . $hereprev);
4512 }
4513
4514 # check for declarations of signed or unsigned without int
4515 while ($line =~ m{\b($Declare)\s*(?!char\b|short\b|int\b|long\b)\s*($Ident)?\s*[=,;\[\)\(]}g) {
4516 my $type = $1;
4517 my $var = $2;
4518 $var = "" if (!defined $var);
4519 if ($type =~ /^(?:(?:$Storage|$Inline|$Attribute)\s+)*((?:un)?signed)((?:\s*\*)*)\s*$/) {
4520 my $sign = $1;
4521 my $pointer = $2;
4522
4523 $pointer = "" if (!defined $pointer);
4524
4525 if (WARN("UNSPECIFIED_INT",
4526 "Prefer '" . trim($sign) . " int" . rtrim($pointer) . "' to bare use of '$sign" . rtrim($pointer) . "'\n" . $herecurr) &&
4527 $fix) {
4528 my $decl = trim($sign) . " int ";
4529 my $comp_pointer = $pointer;
4530 $comp_pointer =~ s/\s//g;
4531 $decl .= $comp_pointer;
4532 $decl = rtrim($decl) if ($var eq "");
4533 $fixed[$fixlinenr] =~ s@\b$sign\s*\Q$pointer\E\s*$var\b@$decl$var@;
4534 }
4535 }
4536 }
4537
4538 # TEST: allow direct testing of the type matcher.
4539 if ($dbg_type) {
4540 if ($line =~ /^.\s*$Declare\s*$/) {
4541 ERROR("TEST_TYPE",
4542 "TEST: is type\n" . $herecurr);
4543 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
4544 ERROR("TEST_NOT_TYPE",
4545 "TEST: is not type ($1 is)\n". $herecurr);
4546 }
4547 next;
4548 }
4549 # TEST: allow direct testing of the attribute matcher.
4550 if ($dbg_attr) {
4551 if ($line =~ /^.\s*$Modifier\s*$/) {
4552 ERROR("TEST_ATTR",
4553 "TEST: is attr\n" . $herecurr);
4554 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
4555 ERROR("TEST_NOT_ATTR",
4556 "TEST: is not attr ($1 is)\n". $herecurr);
4557 }
4558 next;
4559 }
4560
4561 # check for initialisation to aggregates open brace on the next line
4562 if ($line =~ /^.\s*{/ &&
4563 $prevline =~ /(?:^|[^=])=\s*$/) {
4564 if (ERROR("OPEN_BRACE",
4565 "that open brace { should be on the previous line\n" . $hereprev) &&
4566 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4567 fix_delete_line($fixlinenr - 1, $prevrawline);
4568 fix_delete_line($fixlinenr, $rawline);
4569 my $fixedline = $prevrawline;
4570 $fixedline =~ s/\s*=\s*$/ = {/;
4571 fix_insert_line($fixlinenr, $fixedline);
4572 $fixedline = $line;
4573 $fixedline =~ s/^(.\s*)\{\s*/$1/;
4574 fix_insert_line($fixlinenr, $fixedline);
4575 }
4576 }
4577
4578 #
4579 # Checks which are anchored on the added line.
4580 #
4581
4582 # check for malformed paths in #include statements (uses RAW line)
4583 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
4584 my $path = $1;
4585 if ($path =~ m{//}) {
4586 ERROR("MALFORMED_INCLUDE",
4587 "malformed #include filename\n" . $herecurr);
4588 }
4589 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
4590 ERROR("UAPI_INCLUDE",
4591 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
4592 }
4593 }
4594
4595 # no C99 // comments
4596 if ($line =~ m{//}) {
4597 if (ERROR("C99_COMMENTS",
4598 "do not use C99 // comments\n" . $herecurr) &&
4599 $fix) {
4600 my $line = $fixed[$fixlinenr];
4601 if ($line =~ /\/\/(.*)$/) {
4602 my $comment = trim($1);
4603 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
4604 }
4605 }
4606 }
4607 # Remove C99 comments.
4608 $line =~ s@//.*@@;
4609 $opline =~ s@//.*@@;
4610
4611 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
4612 # the whole statement.
4613 #print "APW <$lines[$realline_next - 1]>\n";
4614 if (defined $realline_next &&
4615 exists $lines[$realline_next - 1] &&
4616 !defined $suppress_export{$realline_next} &&
4617 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4618 # Handle definitions which produce identifiers with
4619 # a prefix:
4620 # XXX(foo);
4621 # EXPORT_SYMBOL(something_foo);
4622 my $name = $1;
4623 $name =~ s/^\s*($Ident).*/$1/;
4624 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
4625 $name =~ /^${Ident}_$2/) {
4626 #print "FOO C name<$name>\n";
4627 $suppress_export{$realline_next} = 1;
4628
4629 } elsif ($stat !~ /(?:
4630 \n.}\s*$|
4631 ^.DEFINE_$Ident\(\Q$name\E\)|
4632 ^.DECLARE_$Ident\(\Q$name\E\)|
4633 ^.LIST_HEAD\(\Q$name\E\)|
4634 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
4635 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
4636 )/x) {
4637 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
4638 $suppress_export{$realline_next} = 2;
4639 } else {
4640 $suppress_export{$realline_next} = 1;
4641 }
4642 }
4643 if (!defined $suppress_export{$linenr} &&
4644 $prevline =~ /^.\s*$/ &&
4645 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/)) {
4646 #print "FOO B <$lines[$linenr - 1]>\n";
4647 $suppress_export{$linenr} = 2;
4648 }
4649 if (defined $suppress_export{$linenr} &&
4650 $suppress_export{$linenr} == 2) {
4651 WARN("EXPORT_SYMBOL",
4652 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
4653 }
4654
4655 # check for global initialisers.
4656 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/ &&
4657 !exclude_global_initialisers($realfile)) {
4658 if (ERROR("GLOBAL_INITIALISERS",
4659 "do not initialise globals to $1\n" . $herecurr) &&
4660 $fix) {
4661 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
4662 }
4663 }
4664 # check for static initialisers.
4665 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
4666 if (ERROR("INITIALISED_STATIC",
4667 "do not initialise statics to $1\n" .
4668 $herecurr) &&
4669 $fix) {
4670 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
4671 }
4672 }
4673
4674 # check for misordered declarations of char/short/int/long with signed/unsigned
4675 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
4676 my $tmp = trim($1);
4677 WARN("MISORDERED_TYPE",
4678 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
4679 }
4680
4681 # check for unnecessary <signed> int declarations of short/long/long long
4682 while ($sline =~ m{\b($TypeMisordered(\s*\*)*|$C90_int_types)\b}g) {
4683 my $type = trim($1);
4684 next if ($type !~ /\bint\b/);
4685 next if ($type !~ /\b(?:short|long\s+long|long)\b/);
4686 my $new_type = $type;
4687 $new_type =~ s/\b\s*int\s*\b/ /;
4688 $new_type =~ s/\b\s*(?:un)?signed\b\s*/ /;
4689 $new_type =~ s/^const\s+//;
4690 $new_type = "unsigned $new_type" if ($type =~ /\bunsigned\b/);
4691 $new_type = "const $new_type" if ($type =~ /^const\b/);
4692 $new_type =~ s/\s+/ /g;
4693 $new_type = trim($new_type);
4694 if (WARN("UNNECESSARY_INT",
4695 "Prefer '$new_type' over '$type' as the int is unnecessary\n" . $herecurr) &&
4696 $fix) {
4697 $fixed[$fixlinenr] =~ s/\b\Q$type\E\b/$new_type/;
4698 }
4699 }
4700
4701 # check for static const char * arrays.
4702 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
4703 WARN("STATIC_CONST_CHAR_ARRAY",
4704 "static const char * array should probably be static const char * const\n" .
4705 $herecurr);
4706 }
4707
4708 # check for initialized const char arrays that should be static const
4709 if ($line =~ /^\+\s*const\s+(char|unsigned\s+char|_*u8|(?:[us]_)?int8_t)\s+\w+\s*\[\s*(?:\w+\s*)?\]\s*=\s*"/) {
4710 if (WARN("STATIC_CONST_CHAR_ARRAY",
4711 "const array should probably be static const\n" . $herecurr) &&
4712 $fix) {
4713 $fixed[$fixlinenr] =~ s/(^.\s*)const\b/${1}static const/;
4714 }
4715 }
4716
4717 # check for static char foo[] = "bar" declarations.
4718 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
4719 WARN("STATIC_CONST_CHAR_ARRAY",
4720 "static char array declaration should probably be static const char\n" .
4721 $herecurr);
4722 }
4723
4724 # check for const <foo> const where <foo> is not a pointer or array type
4725 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
4726 my $found = $1;
4727 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
4728 WARN("CONST_CONST",
4729 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
4730 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
4731 WARN("CONST_CONST",
4732 "'const $found const' should probably be 'const $found'\n" . $herecurr);
4733 }
4734 }
4735
4736 # check for const static or static <non ptr type> const declarations
4737 # prefer 'static const <foo>' over 'const static <foo>' and 'static <foo> const'
4738 if ($sline =~ /^\+\s*const\s+static\s+($Type)\b/ ||
4739 $sline =~ /^\+\s*static\s+($BasicType)\s+const\b/) {
4740 if (WARN("STATIC_CONST",
4741 "Move const after static - use 'static const $1'\n" . $herecurr) &&
4742 $fix) {
4743 $fixed[$fixlinenr] =~ s/\bconst\s+static\b/static const/;
4744 $fixed[$fixlinenr] =~ s/\bstatic\s+($BasicType)\s+const\b/static const $1/;
4745 }
4746 }
4747
4748 # check for non-global char *foo[] = {"bar", ...} declarations.
4749 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
4750 WARN("STATIC_CONST_CHAR_ARRAY",
4751 "char * array declaration might be better as static const\n" .
4752 $herecurr);
4753 }
4754
4755 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
4756 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
4757 my $array = $1;
4758 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
4759 my $array_div = $1;
4760 if (WARN("ARRAY_SIZE",
4761 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
4762 $fix) {
4763 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
4764 }
4765 }
4766 }
4767
4768 # check for function declarations without arguments like "int foo()"
4769 if ($line =~ /(\b$Type\s*$Ident)\s*\(\s*\)/) {
4770 if (ERROR("FUNCTION_WITHOUT_ARGS",
4771 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
4772 $fix) {
4773 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
4774 }
4775 }
4776
4777 # check for new typedefs, only function parameters and sparse annotations
4778 # make sense.
4779 if ($line =~ /\btypedef\s/ &&
4780 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
4781 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
4782 $line !~ /\b$typeTypedefs\b/ &&
4783 $line !~ /\b__bitwise\b/) {
4784 WARN("NEW_TYPEDEFS",
4785 "do not add new typedefs\n" . $herecurr);
4786 }
4787
4788 # * goes on variable not on type
4789 # (char*[ const])
4790 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
4791 #print "AA<$1>\n";
4792 my ($ident, $from, $to) = ($1, $2, $2);
4793
4794 # Should start with a space.
4795 $to =~ s/^(\S)/ $1/;
4796 # Should not end with a space.
4797 $to =~ s/\s+$//;
4798 # '*'s should not have spaces between.
4799 while ($to =~ s/\*\s+\*/\*\*/) {
4800 }
4801
4802 ## print "1: from<$from> to<$to> ident<$ident>\n";
4803 if ($from ne $to) {
4804 if (ERROR("POINTER_LOCATION",
4805 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
4806 $fix) {
4807 my $sub_from = $ident;
4808 my $sub_to = $ident;
4809 $sub_to =~ s/\Q$from\E/$to/;
4810 $fixed[$fixlinenr] =~
4811 s@\Q$sub_from\E@$sub_to@;
4812 }
4813 }
4814 }
4815 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
4816 #print "BB<$1>\n";
4817 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
4818
4819 # Should start with a space.
4820 $to =~ s/^(\S)/ $1/;
4821 # Should not end with a space.
4822 $to =~ s/\s+$//;
4823 # '*'s should not have spaces between.
4824 while ($to =~ s/\*\s+\*/\*\*/) {
4825 }
4826 # Modifiers should have spaces.
4827 $to =~ s/(\b$Modifier$)/$1 /;
4828
4829 ## print "2: from<$from> to<$to> ident<$ident>\n";
4830 if ($from ne $to && $ident !~ /^$Modifier$/) {
4831 if (ERROR("POINTER_LOCATION",
4832 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
4833 $fix) {
4834
4835 my $sub_from = $match;
4836 my $sub_to = $match;
4837 $sub_to =~ s/\Q$from\E/$to/;
4838 $fixed[$fixlinenr] =~
4839 s@\Q$sub_from\E@$sub_to@;
4840 }
4841 }
4842 }
4843
4844 # do not use BUG() or variants
4845 if ($line =~ /\b(?!AA_|BUILD_|DCCP_|IDA_|KVM_|RWLOCK_|snd_|SPIN_)(?:[a-zA-Z_]*_)?BUG(?:_ON)?(?:_[A-Z_]+)?\s*\(/) {
4846 my $msg_level = \&WARN;
4847 $msg_level = \&CHK if ($file);
4848 &{$msg_level}("AVOID_BUG",
4849 "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);
4850 }
4851
4852 # avoid LINUX_VERSION_CODE
4853 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
4854 WARN("LINUX_VERSION_CODE",
4855 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
4856 }
4857
4858 # check for uses of printk_ratelimit
4859 if ($line =~ /\bprintk_ratelimit\s*\(/) {
4860 WARN("PRINTK_RATELIMITED",
4861 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
4862 }
4863
4864 # printk should use KERN_* levels
4865 if ($line =~ /\bprintk\s*\(\s*(?!KERN_[A-Z]+\b)/) {
4866 WARN("PRINTK_WITHOUT_KERN_LEVEL",
4867 "printk() should include KERN_<LEVEL> facility level\n" . $herecurr);
4868 }
4869
4870 # prefer variants of (subsystem|netdev|dev|pr)_<level> to printk(KERN_<LEVEL>
4871 if ($line =~ /\b(printk(_once|_ratelimited)?)\s*\(\s*KERN_([A-Z]+)/) {
4872 my $printk = $1;
4873 my $modifier = $2;
4874 my $orig = $3;
4875 $modifier = "" if (!defined($modifier));
4876 my $level = lc($orig);
4877 $level = "warn" if ($level eq "warning");
4878 my $level2 = $level;
4879 $level2 = "dbg" if ($level eq "debug");
4880 $level .= $modifier;
4881 $level2 .= $modifier;
4882 WARN("PREFER_PR_LEVEL",
4883 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to $printk(KERN_$orig ...\n" . $herecurr);
4884 }
4885
4886 # prefer dev_<level> to dev_printk(KERN_<LEVEL>
4887 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
4888 my $orig = $1;
4889 my $level = lc($orig);
4890 $level = "warn" if ($level eq "warning");
4891 $level = "dbg" if ($level eq "debug");
4892 WARN("PREFER_DEV_LEVEL",
4893 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
4894 }
4895
4896 # trace_printk should not be used in production code.
4897 if ($line =~ /\b(trace_printk|trace_puts|ftrace_vprintk)\s*\(/) {
4898 WARN("TRACE_PRINTK",
4899 "Do not use $1() in production code (this can be ignored if built only with a debug config option)\n" . $herecurr);
4900 }
4901
4902 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
4903 # number of false positives, but assembly files are not checked, so at
4904 # least the arch entry code will not trigger this warning.
4905 if ($line =~ /\bENOSYS\b/) {
4906 WARN("ENOSYS",
4907 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
4908 }
4909
4910 # ENOTSUPP is not a standard error code and should be avoided in new patches.
4911 # Folks usually mean EOPNOTSUPP (also called ENOTSUP), when they type ENOTSUPP.
4912 # Similarly to ENOSYS warning a small number of false positives is expected.
4913 if (!$file && $line =~ /\bENOTSUPP\b/) {
4914 if (WARN("ENOTSUPP",
4915 "ENOTSUPP is not a SUSV4 error code, prefer EOPNOTSUPP\n" . $herecurr) &&
4916 $fix) {
4917 $fixed[$fixlinenr] =~ s/\bENOTSUPP\b/EOPNOTSUPP/;
4918 }
4919 }
4920
4921 # function brace can't be on same line, except for #defines of do while,
4922 # or if closed on same line
4923 if ($perl_version_ok &&
4924 $sline =~ /$Type\s*$Ident\s*$balanced_parens\s*\{/ &&
4925 $sline !~ /\#\s*define\b.*do\s*\{/ &&
4926 $sline !~ /}/) {
4927 if (ERROR("OPEN_BRACE",
4928 "open brace '{' following function definitions go on the next line\n" . $herecurr) &&
4929 $fix) {
4930 fix_delete_line($fixlinenr, $rawline);
4931 my $fixed_line = $rawline;
4932 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*)\{(.*)$/;
4933 my $line1 = $1;
4934 my $line2 = $2;
4935 fix_insert_line($fixlinenr, ltrim($line1));
4936 fix_insert_line($fixlinenr, "\+{");
4937 if ($line2 !~ /^\s*$/) {
4938 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
4939 }
4940 }
4941 }
4942
4943 # open braces for enum, union and struct go on the same line.
4944 if ($line =~ /^.\s*{/ &&
4945 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
4946 if (ERROR("OPEN_BRACE",
4947 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
4948 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4949 fix_delete_line($fixlinenr - 1, $prevrawline);
4950 fix_delete_line($fixlinenr, $rawline);
4951 my $fixedline = rtrim($prevrawline) . " {";
4952 fix_insert_line($fixlinenr, $fixedline);
4953 $fixedline = $rawline;
4954 $fixedline =~ s/^(.\s*)\{\s*/$1\t/;
4955 if ($fixedline !~ /^\+\s*$/) {
4956 fix_insert_line($fixlinenr, $fixedline);
4957 }
4958 }
4959 }
4960
4961 # missing space after union, struct or enum definition
4962 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
4963 if (WARN("SPACING",
4964 "missing space after $1 definition\n" . $herecurr) &&
4965 $fix) {
4966 $fixed[$fixlinenr] =~
4967 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
4968 }
4969 }
4970
4971 # Function pointer declarations
4972 # check spacing between type, funcptr, and args
4973 # canonical declaration is "type (*funcptr)(args...)"
4974 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
4975 my $declare = $1;
4976 my $pre_pointer_space = $2;
4977 my $post_pointer_space = $3;
4978 my $funcname = $4;
4979 my $post_funcname_space = $5;
4980 my $pre_args_space = $6;
4981
4982 # the $Declare variable will capture all spaces after the type
4983 # so check it for a missing trailing missing space but pointer return types
4984 # don't need a space so don't warn for those.
4985 my $post_declare_space = "";
4986 if ($declare =~ /(\s+)$/) {
4987 $post_declare_space = $1;
4988 $declare = rtrim($declare);
4989 }
4990 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
4991 WARN("SPACING",
4992 "missing space after return type\n" . $herecurr);
4993 $post_declare_space = " ";
4994 }
4995
4996 # unnecessary space "type (*funcptr)(args...)"
4997 # This test is not currently implemented because these declarations are
4998 # equivalent to
4999 # int foo(int bar, ...)
5000 # and this is form shouldn't/doesn't generate a checkpatch warning.
5001 #
5002 # elsif ($declare =~ /\s{2,}$/) {
5003 # WARN("SPACING",
5004 # "Multiple spaces after return type\n" . $herecurr);
5005 # }
5006
5007 # unnecessary space "type ( *funcptr)(args...)"
5008 if (defined $pre_pointer_space &&
5009 $pre_pointer_space =~ /^\s/) {
5010 WARN("SPACING",
5011 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
5012 }
5013
5014 # unnecessary space "type (* funcptr)(args...)"
5015 if (defined $post_pointer_space &&
5016 $post_pointer_space =~ /^\s/) {
5017 WARN("SPACING",
5018 "Unnecessary space before function pointer name\n" . $herecurr);
5019 }
5020
5021 # unnecessary space "type (*funcptr )(args...)"
5022 if (defined $post_funcname_space &&
5023 $post_funcname_space =~ /^\s/) {
5024 WARN("SPACING",
5025 "Unnecessary space after function pointer name\n" . $herecurr);
5026 }
5027
5028 # unnecessary space "type (*funcptr) (args...)"
5029 if (defined $pre_args_space &&
5030 $pre_args_space =~ /^\s/) {
5031 WARN("SPACING",
5032 "Unnecessary space before function pointer arguments\n" . $herecurr);
5033 }
5034
5035 if (show_type("SPACING") && $fix) {
5036 $fixed[$fixlinenr] =~
5037 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
5038 }
5039 }
5040
5041 # check for spacing round square brackets; allowed:
5042 # 1. with a type on the left -- int [] a;
5043 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
5044 # 3. inside a curly brace -- = { [0...10] = 5 }
5045 while ($line =~ /(.*?\s)\[/g) {
5046 my ($where, $prefix) = ($-[1], $1);
5047 if ($prefix !~ /$Type\s+$/ &&
5048 ($where != 0 || $prefix !~ /^.\s+$/) &&
5049 $prefix !~ /[{,:]\s+$/) {
5050 if (ERROR("BRACKET_SPACE",
5051 "space prohibited before open square bracket '['\n" . $herecurr) &&
5052 $fix) {
5053 $fixed[$fixlinenr] =~
5054 s/^(\+.*?)\s+\[/$1\[/;
5055 }
5056 }
5057 }
5058
5059 # check for spaces between functions and their parentheses.
5060 while ($line =~ /($Ident)\s+\(/g) {
5061 my $name = $1;
5062 my $ctx_before = substr($line, 0, $-[1]);
5063 my $ctx = "$ctx_before$name";
5064
5065 # Ignore those directives where spaces _are_ permitted.
5066 if ($name =~ /^(?:
5067 if|for|while|switch|return|case|
5068 volatile|__volatile__|
5069 __attribute__|format|__extension__|
5070 asm|__asm__|scoped_guard)$/x)
5071 {
5072 # cpp #define statements have non-optional spaces, ie
5073 # if there is a space between the name and the open
5074 # parenthesis it is simply not a parameter group.
5075 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
5076
5077 # cpp #elif statement condition may start with a (
5078 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
5079
5080 # If this whole things ends with a type its most
5081 # likely a typedef for a function.
5082 } elsif ($ctx =~ /$Type$/) {
5083
5084 } else {
5085 if (WARN("SPACING",
5086 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
5087 $fix) {
5088 $fixed[$fixlinenr] =~
5089 s/\b$name\s+\(/$name\(/;
5090 }
5091 }
5092 }
5093
5094 # Check operator spacing.
5095 if (!($line=~/\#\s*include/)) {
5096 my $fixed_line = "";
5097 my $line_fixed = 0;
5098
5099 my $ops = qr{
5100 <<=|>>=|<=|>=|==|!=|
5101 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
5102 =>|->|<<|>>|<|>|=|!|~|
5103 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
5104 \?:|\?|:
5105 }x;
5106 my @elements = split(/($ops|;)/, $opline);
5107
5108 ## print("element count: <" . $#elements . ">\n");
5109 ## foreach my $el (@elements) {
5110 ## print("el: <$el>\n");
5111 ## }
5112
5113 my @fix_elements = ();
5114 my $off = 0;
5115
5116 foreach my $el (@elements) {
5117 push(@fix_elements, substr($rawline, $off, length($el)));
5118 $off += length($el);
5119 }
5120
5121 $off = 0;
5122
5123 my $blank = copy_spacing($opline);
5124 my $last_after = -1;
5125
5126 for (my $n = 0; $n < $#elements; $n += 2) {
5127
5128 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
5129
5130 ## print("n: <$n> good: <$good>\n");
5131
5132 $off += length($elements[$n]);
5133
5134 # Pick up the preceding and succeeding characters.
5135 my $ca = substr($opline, 0, $off);
5136 my $cc = '';
5137 if (length($opline) >= ($off + length($elements[$n + 1]))) {
5138 $cc = substr($opline, $off + length($elements[$n + 1]));
5139 }
5140 my $cb = "$ca$;$cc";
5141
5142 my $a = '';
5143 $a = 'V' if ($elements[$n] ne '');
5144 $a = 'W' if ($elements[$n] =~ /\s$/);
5145 $a = 'C' if ($elements[$n] =~ /$;$/);
5146 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
5147 $a = 'O' if ($elements[$n] eq '');
5148 $a = 'E' if ($ca =~ /^\s*$/);
5149
5150 my $op = $elements[$n + 1];
5151
5152 my $c = '';
5153 if (defined $elements[$n + 2]) {
5154 $c = 'V' if ($elements[$n + 2] ne '');
5155 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
5156 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
5157 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
5158 $c = 'O' if ($elements[$n + 2] eq '');
5159 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
5160 } else {
5161 $c = 'E';
5162 }
5163
5164 my $ctx = "${a}x${c}";
5165
5166 my $at = "(ctx:$ctx)";
5167
5168 my $ptr = substr($blank, 0, $off) . "^";
5169 my $hereptr = "$hereline$ptr\n";
5170
5171 # Pull out the value of this operator.
5172 my $op_type = substr($curr_values, $off + 1, 1);
5173
5174 # Get the full operator variant.
5175 my $opv = $op . substr($curr_vars, $off, 1);
5176
5177 # Ignore operators passed as parameters.
5178 if ($op_type ne 'V' &&
5179 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
5180
5181 # # Ignore comments
5182 # } elsif ($op =~ /^$;+$/) {
5183
5184 # ; should have either the end of line or a space or \ after it
5185 } elsif ($op eq ';') {
5186 if ($ctx !~ /.x[WEBC]/ &&
5187 $cc !~ /^\\/ && $cc !~ /^;/) {
5188 if (ERROR("SPACING",
5189 "space required after that '$op' $at\n" . $hereptr)) {
5190 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5191 $line_fixed = 1;
5192 }
5193 }
5194
5195 # // is a comment
5196 } elsif ($op eq '//') {
5197
5198 # : when part of a bitfield
5199 } elsif ($opv eq ':B') {
5200 # skip the bitfield test for now
5201
5202 # No spaces for:
5203 # ->
5204 } elsif ($op eq '->') {
5205 if ($ctx =~ /Wx.|.xW/) {
5206 if (ERROR("SPACING",
5207 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
5208 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5209 if (defined $fix_elements[$n + 2]) {
5210 $fix_elements[$n + 2] =~ s/^\s+//;
5211 }
5212 $line_fixed = 1;
5213 }
5214 }
5215
5216 # , must not have a space before and must have a space on the right.
5217 } elsif ($op eq ',') {
5218 my $rtrim_before = 0;
5219 my $space_after = 0;
5220 if ($ctx =~ /Wx./) {
5221 if (ERROR("SPACING",
5222 "space prohibited before that '$op' $at\n" . $hereptr)) {
5223 $line_fixed = 1;
5224 $rtrim_before = 1;
5225 }
5226 }
5227 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
5228 if (ERROR("SPACING",
5229 "space required after that '$op' $at\n" . $hereptr)) {
5230 $line_fixed = 1;
5231 $last_after = $n;
5232 $space_after = 1;
5233 }
5234 }
5235 if ($rtrim_before || $space_after) {
5236 if ($rtrim_before) {
5237 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5238 } else {
5239 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5240 }
5241 if ($space_after) {
5242 $good .= " ";
5243 }
5244 }
5245
5246 # '*' as part of a type definition -- reported already.
5247 } elsif ($opv eq '*_') {
5248 #warn "'*' is part of type\n";
5249
5250 # unary operators should have a space before and
5251 # none after. May be left adjacent to another
5252 # unary operator, or a cast
5253 } elsif ($op eq '!' || $op eq '~' ||
5254 $opv eq '*U' || $opv eq '-U' ||
5255 $opv eq '&U' || $opv eq '&&U') {
5256 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
5257 if (ERROR("SPACING",
5258 "space required before that '$op' $at\n" . $hereptr)) {
5259 if ($n != $last_after + 2) {
5260 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
5261 $line_fixed = 1;
5262 }
5263 }
5264 }
5265 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
5266 # A unary '*' may be const
5267
5268 } elsif ($ctx =~ /.xW/) {
5269 if (ERROR("SPACING",
5270 "space prohibited after that '$op' $at\n" . $hereptr)) {
5271 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
5272 if (defined $fix_elements[$n + 2]) {
5273 $fix_elements[$n + 2] =~ s/^\s+//;
5274 }
5275 $line_fixed = 1;
5276 }
5277 }
5278
5279 # unary ++ and unary -- are allowed no space on one side.
5280 } elsif ($op eq '++' or $op eq '--') {
5281 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
5282 if (ERROR("SPACING",
5283 "space required one side of that '$op' $at\n" . $hereptr)) {
5284 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
5285 $line_fixed = 1;
5286 }
5287 }
5288 if ($ctx =~ /Wx[BE]/ ||
5289 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
5290 if (ERROR("SPACING",
5291 "space prohibited before that '$op' $at\n" . $hereptr)) {
5292 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5293 $line_fixed = 1;
5294 }
5295 }
5296 if ($ctx =~ /ExW/) {
5297 if (ERROR("SPACING",
5298 "space prohibited after that '$op' $at\n" . $hereptr)) {
5299 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
5300 if (defined $fix_elements[$n + 2]) {
5301 $fix_elements[$n + 2] =~ s/^\s+//;
5302 }
5303 $line_fixed = 1;
5304 }
5305 }
5306
5307 # << and >> may either have or not have spaces both sides
5308 } elsif ($op eq '<<' or $op eq '>>' or
5309 $op eq '&' or $op eq '^' or $op eq '|' or
5310 $op eq '+' or $op eq '-' or
5311 $op eq '*' or $op eq '/' or
5312 $op eq '%')
5313 {
5314 if ($check) {
5315 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
5316 if (CHK("SPACING",
5317 "spaces preferred around that '$op' $at\n" . $hereptr)) {
5318 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5319 $fix_elements[$n + 2] =~ s/^\s+//;
5320 $line_fixed = 1;
5321 }
5322 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
5323 if (CHK("SPACING",
5324 "space preferred before that '$op' $at\n" . $hereptr)) {
5325 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
5326 $line_fixed = 1;
5327 }
5328 }
5329 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
5330 if (ERROR("SPACING",
5331 "need consistent spacing around '$op' $at\n" . $hereptr)) {
5332 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5333 if (defined $fix_elements[$n + 2]) {
5334 $fix_elements[$n + 2] =~ s/^\s+//;
5335 }
5336 $line_fixed = 1;
5337 }
5338 }
5339
5340 # A colon needs no spaces before when it is
5341 # terminating a case value or a label.
5342 } elsif ($opv eq ':C' || $opv eq ':L') {
5343 if ($ctx =~ /Wx./ and $realfile !~ m@.*\.lds\.h$@) {
5344 if (ERROR("SPACING",
5345 "space prohibited before that '$op' $at\n" . $hereptr)) {
5346 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
5347 $line_fixed = 1;
5348 }
5349 }
5350
5351 # All the others need spaces both sides.
5352 } elsif ($ctx !~ /[EWC]x[CWE]/) {
5353 my $ok = 0;
5354
5355 # Ignore email addresses <foo@bar>
5356 if (($op eq '<' &&
5357 $cc =~ /^\S+\@\S+>/) ||
5358 ($op eq '>' &&
5359 $ca =~ /<\S+\@\S+$/))
5360 {
5361 $ok = 1;
5362 }
5363
5364 # for asm volatile statements
5365 # ignore a colon with another
5366 # colon immediately before or after
5367 if (($op eq ':') &&
5368 ($ca =~ /:$/ || $cc =~ /^:/)) {
5369 $ok = 1;
5370 }
5371
5372 # messages are ERROR, but ?: are CHK
5373 if ($ok == 0) {
5374 my $msg_level = \&ERROR;
5375 $msg_level = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
5376
5377 if (&{$msg_level}("SPACING",
5378 "spaces required around that '$op' $at\n" . $hereptr)) {
5379 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
5380 if (defined $fix_elements[$n + 2]) {
5381 $fix_elements[$n + 2] =~ s/^\s+//;
5382 }
5383 $line_fixed = 1;
5384 }
5385 }
5386 }
5387 $off += length($elements[$n + 1]);
5388
5389 ## print("n: <$n> GOOD: <$good>\n");
5390
5391 $fixed_line = $fixed_line . $good;
5392 }
5393
5394 if (($#elements % 2) == 0) {
5395 $fixed_line = $fixed_line . $fix_elements[$#elements];
5396 }
5397
5398 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
5399 $fixed[$fixlinenr] = $fixed_line;
5400 }
5401
5402
5403 }
5404
5405 # check for whitespace before a non-naked semicolon
5406 if ($line =~ /^\+.*\S\s+;\s*$/) {
5407 if (WARN("SPACING",
5408 "space prohibited before semicolon\n" . $herecurr) &&
5409 $fix) {
5410 1 while $fixed[$fixlinenr] =~
5411 s/^(\+.*\S)\s+;/$1;/;
5412 }
5413 }
5414
5415 # check for multiple assignments
5416 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
5417 CHK("MULTIPLE_ASSIGNMENTS",
5418 "multiple assignments should be avoided\n" . $herecurr);
5419 }
5420
5421 ## # check for multiple declarations, allowing for a function declaration
5422 ## # continuation.
5423 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
5424 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
5425 ##
5426 ## # Remove any bracketed sections to ensure we do not
5427 ## # falsely report the parameters of functions.
5428 ## my $ln = $line;
5429 ## while ($ln =~ s/\([^\(\)]*\)//g) {
5430 ## }
5431 ## if ($ln =~ /,/) {
5432 ## WARN("MULTIPLE_DECLARATION",
5433 ## "declaring multiple variables together should be avoided\n" . $herecurr);
5434 ## }
5435 ## }
5436
5437 #need space before brace following if, while, etc
5438 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\)\{/) ||
5439 $line =~ /\b(?:else|do)\{/) {
5440 if (ERROR("SPACING",
5441 "space required before the open brace '{'\n" . $herecurr) &&
5442 $fix) {
5443 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|else|\)))\{/$1 {/;
5444 }
5445 }
5446
5447 ## # check for blank lines before declarations
5448 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
5449 ## $prevrawline =~ /^.\s*$/) {
5450 ## WARN("SPACING",
5451 ## "No blank lines before declarations\n" . $hereprev);
5452 ## }
5453 ##
5454
5455 # closing brace should have a space following it when it has anything
5456 # on the line
5457 if ($line =~ /}(?!(?:,|;|\)|\}))\S/) {
5458 if (ERROR("SPACING",
5459 "space required after that close brace '}'\n" . $herecurr) &&
5460 $fix) {
5461 $fixed[$fixlinenr] =~
5462 s/}((?!(?:,|;|\)))\S)/} $1/;
5463 }
5464 }
5465
5466 # check spacing on square brackets
5467 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
5468 if (ERROR("SPACING",
5469 "space prohibited after that open square bracket '['\n" . $herecurr) &&
5470 $fix) {
5471 $fixed[$fixlinenr] =~
5472 s/\[\s+/\[/;
5473 }
5474 }
5475 if ($line =~ /\s\]/) {
5476 if (ERROR("SPACING",
5477 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
5478 $fix) {
5479 $fixed[$fixlinenr] =~
5480 s/\s+\]/\]/;
5481 }
5482 }
5483
5484 # check spacing on parentheses
5485 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
5486 $line !~ /for\s*\(\s+;/) {
5487 if (ERROR("SPACING",
5488 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
5489 $fix) {
5490 $fixed[$fixlinenr] =~
5491 s/\(\s+/\(/;
5492 }
5493 }
5494 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
5495 $line !~ /for\s*\(.*;\s+\)/ &&
5496 $line !~ /:\s+\)/) {
5497 if (ERROR("SPACING",
5498 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
5499 $fix) {
5500 $fixed[$fixlinenr] =~
5501 s/\s+\)/\)/;
5502 }
5503 }
5504
5505 # check unnecessary parentheses around addressof/dereference single $Lvals
5506 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
5507
5508 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
5509 my $var = $1;
5510 if (CHK("UNNECESSARY_PARENTHESES",
5511 "Unnecessary parentheses around $var\n" . $herecurr) &&
5512 $fix) {
5513 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
5514 }
5515 }
5516
5517 # check for unnecessary parentheses around function pointer uses
5518 # ie: (foo->bar)(); should be foo->bar();
5519 # but not "if (foo->bar) (" to avoid some false positives
5520 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
5521 my $var = $2;
5522 if (CHK("UNNECESSARY_PARENTHESES",
5523 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
5524 $fix) {
5525 my $var2 = deparenthesize($var);
5526 $var2 =~ s/\s//g;
5527 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
5528 }
5529 }
5530
5531 # check for unnecessary parentheses around comparisons in if uses
5532 # when !drivers/staging or command-line uses --strict
5533 if (($realfile !~ m@^(?:drivers/staging/)@ || $check_orig) &&
5534 $perl_version_ok && defined($stat) &&
5535 $stat =~ /(^.\s*if\s*($balanced_parens))/) {
5536 my $if_stat = $1;
5537 my $test = substr($2, 1, -1);
5538 my $herectx;
5539 while ($test =~ /(?:^|[^\w\&\!\~])+\s*\(\s*([\&\!\~]?\s*$Lval\s*(?:$Compare\s*$FuncArg)?)\s*\)/g) {
5540 my $match = $1;
5541 # avoid parentheses around potential macro args
5542 next if ($match =~ /^\s*\w+\s*$/);
5543 if (!defined($herectx)) {
5544 $herectx = $here . "\n";
5545 my $cnt = statement_rawlines($if_stat);
5546 for (my $n = 0; $n < $cnt; $n++) {
5547 my $rl = raw_line($linenr, $n);
5548 $herectx .= $rl . "\n";
5549 last if $rl =~ /^[ \+].*\{/;
5550 }
5551 }
5552 CHK("UNNECESSARY_PARENTHESES",
5553 "Unnecessary parentheses around '$match'\n" . $herectx);
5554 }
5555 }
5556
5557 # check that goto labels aren't indented (allow a single space indentation)
5558 # and ignore bitfield definitions like foo:1
5559 # Strictly, labels can have whitespace after the identifier and before the :
5560 # but this is not allowed here as many ?: uses would appear to be labels
5561 if ($sline =~ /^.\s+[A-Za-z_][A-Za-z\d_]*:(?!\s*\d+)/ &&
5562 $sline !~ /^. [A-Za-z\d_][A-Za-z\d_]*:/ &&
5563 $sline !~ /^.\s+default:/) {
5564 if (WARN("INDENTED_LABEL",
5565 "labels should not be indented\n" . $herecurr) &&
5566 $fix) {
5567 $fixed[$fixlinenr] =~
5568 s/^(.)\s+/$1/;
5569 }
5570 }
5571
5572 # check if a statement with a comma should be two statements like:
5573 # foo = bar(), /* comma should be semicolon */
5574 # bar = baz();
5575 if (defined($stat) &&
5576 $stat =~ /^\+\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*,\s*(?:$Lval\s*$Assignment\s*)?$FuncArg\s*;\s*$/) {
5577 my $cnt = statement_rawlines($stat);
5578 my $herectx = get_stat_here($linenr, $cnt, $here);
5579 WARN("SUSPECT_COMMA_SEMICOLON",
5580 "Possible comma where semicolon could be used\n" . $herectx);
5581 }
5582
5583 # return is not a function
5584 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
5585 my $spacing = $1;
5586 if ($perl_version_ok &&
5587 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
5588 my $value = $1;
5589 $value = deparenthesize($value);
5590 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
5591 ERROR("RETURN_PARENTHESES",
5592 "return is not a function, parentheses are not required\n" . $herecurr);
5593 }
5594 } elsif ($spacing !~ /\s+/) {
5595 ERROR("SPACING",
5596 "space required before the open parenthesis '('\n" . $herecurr);
5597 }
5598 }
5599
5600 # unnecessary return in a void function
5601 # at end-of-function, with the previous line a single leading tab, then return;
5602 # and the line before that not a goto label target like "out:"
5603 if ($sline =~ /^[ \+]}\s*$/ &&
5604 $prevline =~ /^\+\treturn\s*;\s*$/ &&
5605 $linenr >= 3 &&
5606 $lines[$linenr - 3] =~ /^[ +]/ &&
5607 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
5608 WARN("RETURN_VOID",
5609 "void function return statements are not generally useful\n" . $hereprev);
5610 }
5611
5612 # if statements using unnecessary parentheses - ie: if ((foo == bar))
5613 if ($perl_version_ok &&
5614 $line =~ /\bif\s*((?:\(\s*){2,})/) {
5615 my $openparens = $1;
5616 my $count = $openparens =~ tr@\(@\(@;
5617 my $msg = "";
5618 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
5619 my $comp = $4; #Not $1 because of $LvalOrFunc
5620 $msg = " - maybe == should be = ?" if ($comp eq "==");
5621 WARN("UNNECESSARY_PARENTHESES",
5622 "Unnecessary parentheses$msg\n" . $herecurr);
5623 }
5624 }
5625
5626 # comparisons with a constant or upper case identifier on the left
5627 # avoid cases like "foo + BAR < baz"
5628 # only fix matches surrounded by parentheses to avoid incorrect
5629 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
5630 if ($perl_version_ok &&
5631 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
5632 my $lead = $1;
5633 my $const = $2;
5634 my $comp = $3;
5635 my $to = $4;
5636 my $newcomp = $comp;
5637 if ($lead !~ /(?:$Operators|\.)\s*$/ &&
5638 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
5639 WARN("CONSTANT_COMPARISON",
5640 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
5641 $fix) {
5642 if ($comp eq "<") {
5643 $newcomp = ">";
5644 } elsif ($comp eq "<=") {
5645 $newcomp = ">=";
5646 } elsif ($comp eq ">") {
5647 $newcomp = "<";
5648 } elsif ($comp eq ">=") {
5649 $newcomp = "<=";
5650 }
5651 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
5652 }
5653 }
5654
5655 # Return of what appears to be an errno should normally be negative
5656 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
5657 my $name = $1;
5658 if ($name ne 'EOF' && $name ne 'ERROR' && $name !~ /^EPOLL/) {
5659 WARN("USE_NEGATIVE_ERRNO",
5660 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
5661 }
5662 }
5663
5664 # Need a space before open parenthesis after if, while etc
5665 if ($line =~ /\b(if|while|for|switch)\(/) {
5666 if (ERROR("SPACING",
5667 "space required before the open parenthesis '('\n" . $herecurr) &&
5668 $fix) {
5669 $fixed[$fixlinenr] =~
5670 s/\b(if|while|for|switch)\(/$1 \(/;
5671 }
5672 }
5673
5674 # Check for illegal assignment in if conditional -- and check for trailing
5675 # statements after the conditional.
5676 if ($line =~ /do\s*(?!{)/) {
5677 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
5678 ctx_statement_block($linenr, $realcnt, 0)
5679 if (!defined $stat);
5680 my ($stat_next) = ctx_statement_block($line_nr_next,
5681 $remain_next, $off_next);
5682 $stat_next =~ s/\n./\n /g;
5683 ##print "stat<$stat> stat_next<$stat_next>\n";
5684
5685 if ($stat_next =~ /^\s*while\b/) {
5686 # If the statement carries leading newlines,
5687 # then count those as offsets.
5688 my ($whitespace) =
5689 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
5690 my $offset =
5691 statement_rawlines($whitespace) - 1;
5692
5693 $suppress_whiletrailers{$line_nr_next +
5694 $offset} = 1;
5695 }
5696 }
5697 if (!defined $suppress_whiletrailers{$linenr} &&
5698 defined($stat) && defined($cond) &&
5699 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
5700 my ($s, $c) = ($stat, $cond);
5701 my $fixed_assign_in_if = 0;
5702
5703 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
5704 if (ERROR("ASSIGN_IN_IF",
5705 "do not use assignment in if condition\n" . $herecurr) &&
5706 $fix && $perl_version_ok) {
5707 if ($rawline =~ /^\+(\s+)if\s*\(\s*(\!)?\s*\(\s*(($Lval)\s*=\s*$LvalOrFunc)\s*\)\s*(?:($Compare)\s*($FuncArg))?\s*\)\s*(\{)?\s*$/) {
5708 my $space = $1;
5709 my $not = $2;
5710 my $statement = $3;
5711 my $assigned = $4;
5712 my $test = $8;
5713 my $against = $9;
5714 my $brace = $15;
5715 fix_delete_line($fixlinenr, $rawline);
5716 fix_insert_line($fixlinenr, "$space$statement;");
5717 my $newline = "${space}if (";
5718 $newline .= '!' if defined($not);
5719 $newline .= '(' if (defined $not && defined($test) && defined($against));
5720 $newline .= "$assigned";
5721 $newline .= " $test $against" if (defined($test) && defined($against));
5722 $newline .= ')' if (defined $not && defined($test) && defined($against));
5723 $newline .= ')';
5724 $newline .= " {" if (defined($brace));
5725 fix_insert_line($fixlinenr + 1, $newline);
5726 $fixed_assign_in_if = 1;
5727 }
5728 }
5729 }
5730
5731 # Find out what is on the end of the line after the
5732 # conditional.
5733 substr($s, 0, length($c), '');
5734 $s =~ s/\n.*//g;
5735 $s =~ s/$;//g; # Remove any comments
5736 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
5737 $c !~ /}\s*while\s*/)
5738 {
5739 # Find out how long the conditional actually is.
5740 my @newlines = ($c =~ /\n/gs);
5741 my $cond_lines = 1 + $#newlines;
5742 my $stat_real = '';
5743
5744 $stat_real = raw_line($linenr, $cond_lines)
5745 . "\n" if ($cond_lines);
5746 if (defined($stat_real) && $cond_lines > 1) {
5747 $stat_real = "[...]\n$stat_real";
5748 }
5749
5750 if (ERROR("TRAILING_STATEMENTS",
5751 "trailing statements should be on next line\n" . $herecurr . $stat_real) &&
5752 !$fixed_assign_in_if &&
5753 $cond_lines == 0 &&
5754 $fix && $perl_version_ok &&
5755 $fixed[$fixlinenr] =~ /^\+(\s*)((?:if|while|for)\s*$balanced_parens)\s*(.*)$/) {
5756 my $indent = $1;
5757 my $test = $2;
5758 my $rest = rtrim($4);
5759 if ($rest =~ /;$/) {
5760 $fixed[$fixlinenr] = "\+$indent$test";
5761 fix_insert_line($fixlinenr + 1, "$indent\t$rest");
5762 }
5763 }
5764 }
5765 }
5766
5767 # Check for bitwise tests written as boolean
5768 if ($line =~ /
5769 (?:
5770 (?:\[|\(|\&\&|\|\|)
5771 \s*0[xX][0-9]+\s*
5772 (?:\&\&|\|\|)
5773 |
5774 (?:\&\&|\|\|)
5775 \s*0[xX][0-9]+\s*
5776 (?:\&\&|\|\||\)|\])
5777 )/x)
5778 {
5779 WARN("HEXADECIMAL_BOOLEAN_TEST",
5780 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
5781 }
5782
5783 # if and else should not have general statements after it
5784 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
5785 my $s = $1;
5786 $s =~ s/$;//g; # Remove any comments
5787 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
5788 ERROR("TRAILING_STATEMENTS",
5789 "trailing statements should be on next line\n" . $herecurr);
5790 }
5791 }
5792 # if should not continue a brace
5793 if ($line =~ /}\s*if\b/) {
5794 ERROR("TRAILING_STATEMENTS",
5795 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
5796 $herecurr);
5797 }
5798 # case and default should not have general statements after them
5799 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
5800 $line !~ /\G(?:
5801 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
5802 \s*return\s+
5803 )/xg)
5804 {
5805 ERROR("TRAILING_STATEMENTS",
5806 "trailing statements should be on next line\n" . $herecurr);
5807 }
5808
5809 # Check for }<nl>else {, these must be at the same
5810 # indent level to be relevant to each other.
5811 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
5812 $previndent == $indent) {
5813 if (ERROR("ELSE_AFTER_BRACE",
5814 "else should follow close brace '}'\n" . $hereprev) &&
5815 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5816 fix_delete_line($fixlinenr - 1, $prevrawline);
5817 fix_delete_line($fixlinenr, $rawline);
5818 my $fixedline = $prevrawline;
5819 $fixedline =~ s/}\s*$//;
5820 if ($fixedline !~ /^\+\s*$/) {
5821 fix_insert_line($fixlinenr, $fixedline);
5822 }
5823 $fixedline = $rawline;
5824 $fixedline =~ s/^(.\s*)else/$1} else/;
5825 fix_insert_line($fixlinenr, $fixedline);
5826 }
5827 }
5828
5829 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
5830 $previndent == $indent) {
5831 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
5832
5833 # Find out what is on the end of the line after the
5834 # conditional.
5835 substr($s, 0, length($c), '');
5836 $s =~ s/\n.*//g;
5837
5838 if ($s =~ /^\s*;/) {
5839 if (ERROR("WHILE_AFTER_BRACE",
5840 "while should follow close brace '}'\n" . $hereprev) &&
5841 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
5842 fix_delete_line($fixlinenr - 1, $prevrawline);
5843 fix_delete_line($fixlinenr, $rawline);
5844 my $fixedline = $prevrawline;
5845 my $trailing = $rawline;
5846 $trailing =~ s/^\+//;
5847 $trailing = trim($trailing);
5848 $fixedline =~ s/}\s*$/} $trailing/;
5849 fix_insert_line($fixlinenr, $fixedline);
5850 }
5851 }
5852 }
5853
5854 #Specific variable tests
5855 while ($line =~ m{($Constant|$Lval)}g) {
5856 my $var = $1;
5857
5858 #CamelCase
5859 if ($var !~ /^$Constant$/ &&
5860 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
5861 #Ignore some autogenerated defines and enum values
5862 $var !~ /^(?:[A-Z]+_){1,5}[A-Z]{1,3}[a-z]/ &&
5863 #Ignore Page<foo> variants
5864 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
5865 #Ignore ETHTOOL_LINK_MODE_<foo> variants
5866 $var !~ /^ETHTOOL_LINK_MODE_/ &&
5867 #Ignore SI style variants like nS, mV and dB
5868 #(ie: max_uV, regulator_min_uA_show, RANGE_mA_VALUE)
5869 $var !~ /^(?:[a-z0-9_]*|[A-Z0-9_]*)?_?[a-z][A-Z](?:_[a-z0-9_]+|_[A-Z0-9_]+)?$/ &&
5870 #Ignore some three character SI units explicitly, like MiB and KHz
5871 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
5872 while ($var =~ m{\b($Ident)}g) {
5873 my $word = $1;
5874 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
5875 if ($check) {
5876 seed_camelcase_includes();
5877 if (!$file && !$camelcase_file_seeded) {
5878 seed_camelcase_file($realfile);
5879 $camelcase_file_seeded = 1;
5880 }
5881 }
5882 if (!defined $camelcase{$word}) {
5883 $camelcase{$word} = 1;
5884 CHK("CAMELCASE",
5885 "Avoid CamelCase: <$word>\n" . $herecurr);
5886 }
5887 }
5888 }
5889 }
5890
5891 #no spaces allowed after \ in define
5892 if ($line =~ /\#\s*define.*\\\s+$/) {
5893 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
5894 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
5895 $fix) {
5896 $fixed[$fixlinenr] =~ s/\s+$//;
5897 }
5898 }
5899
5900 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
5901 # itself <asm/foo.h> (uses RAW line)
5902 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
5903 my $file = "$1.h";
5904 my $checkfile = "include/linux/$file";
5905 if (-f "$root/$checkfile" &&
5906 $realfile ne $checkfile &&
5907 $1 !~ /$allowed_asm_includes/)
5908 {
5909 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
5910 if ($asminclude > 0) {
5911 if ($realfile =~ m{^arch/}) {
5912 CHK("ARCH_INCLUDE_LINUX",
5913 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5914 } else {
5915 WARN("INCLUDE_LINUX",
5916 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
5917 }
5918 }
5919 }
5920 }
5921
5922 # multi-statement macros should be enclosed in a do while loop, grab the
5923 # first statement and ensure its the whole macro if its not enclosed
5924 # in a known good container
5925 if ($realfile !~ m@/vmlinux.lds.h$@ &&
5926 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
5927 my $ln = $linenr;
5928 my $cnt = $realcnt;
5929 my ($off, $dstat, $dcond, $rest);
5930 my $ctx = '';
5931 my $has_flow_statement = 0;
5932 my $has_arg_concat = 0;
5933 ($dstat, $dcond, $ln, $cnt, $off) =
5934 ctx_statement_block($linenr, $realcnt, 0);
5935 $ctx = $dstat;
5936 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
5937 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
5938
5939 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
5940 $has_arg_concat = 1 if ($ctx =~ /\#\#/ && $ctx !~ /\#\#\s*(?:__VA_ARGS__|args)\b/);
5941
5942 $dstat =~ s/^.\s*\#\s*define\s+$Ident(\([^\)]*\))?\s*//;
5943 my $define_args = $1;
5944 my $define_stmt = $dstat;
5945 my @def_args = ();
5946
5947 if (defined $define_args && $define_args ne "") {
5948 $define_args = substr($define_args, 1, length($define_args) - 2);
5949 $define_args =~ s/\s*//g;
5950 $define_args =~ s/\\\+?//g;
5951 @def_args = split(",", $define_args);
5952 }
5953
5954 $dstat =~ s/$;//g;
5955 $dstat =~ s/\\\n.//g;
5956 $dstat =~ s/^\s*//s;
5957 $dstat =~ s/\s*$//s;
5958
5959 # Flatten any parentheses and braces
5960 while ($dstat =~ s/\([^\(\)]*\)/1u/ ||
5961 $dstat =~ s/\{[^\{\}]*\}/1u/ ||
5962 $dstat =~ s/.\[[^\[\]]*\]/1u/)
5963 {
5964 }
5965
5966 # Flatten any obvious string concatenation.
5967 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
5968 $dstat =~ s/$Ident\s*($String)/$1/)
5969 {
5970 }
5971
5972 # Make asm volatile uses seem like a generic function
5973 $dstat =~ s/\b_*asm_*\s+_*volatile_*\b/asm_volatile/g;
5974
5975 my $exceptions = qr{
5976 $Declare|
5977 module_param_named|
5978 MODULE_PARM_DESC|
5979 DECLARE_PER_CPU|
5980 DEFINE_PER_CPU|
5981 __typeof__\(|
5982 union|
5983 struct|
5984 \.$Ident\s*=\s*|
5985 ^\"|\"$|
5986 ^\[
5987 }x;
5988 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
5989
5990 $ctx =~ s/\n*$//;
5991 my $stmt_cnt = statement_rawlines($ctx);
5992 my $herectx = get_stat_here($linenr, $stmt_cnt, $here);
5993
5994 if ($dstat ne '' &&
5995 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
5996 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
5997 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
5998 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
5999 $dstat !~ /$exceptions/ &&
6000 $dstat !~ /^\.$Ident\s*=/ && # .foo =
6001 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
6002 $dstat !~ /^case\b/ && # case ...
6003 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
6004 $dstat !~ /^while\s*$Constant\s*$Constant\s*$/ && # while (...) {...}
6005 $dstat !~ /^for\s*$Constant$/ && # for (...)
6006 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
6007 $dstat !~ /^do\s*{/ && # do {...
6008 $dstat !~ /^\(\{/ && # ({...
6009 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
6010 {
6011 if ($dstat =~ /^\s*if\b/) {
6012 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
6013 "Macros starting with if should be enclosed by a do - while loop to avoid possible if/else logic defects\n" . "$herectx");
6014 } elsif ($dstat =~ /;/) {
6015 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
6016 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
6017 } else {
6018 ERROR("COMPLEX_MACRO",
6019 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
6020 }
6021
6022 }
6023
6024 # Make $define_stmt single line, comment-free, etc
6025 my @stmt_array = split('\n', $define_stmt);
6026 my $first = 1;
6027 $define_stmt = "";
6028 foreach my $l (@stmt_array) {
6029 $l =~ s/\\$//;
6030 if ($first) {
6031 $define_stmt = $l;
6032 $first = 0;
6033 } elsif ($l =~ /^[\+ ]/) {
6034 $define_stmt .= substr($l, 1);
6035 }
6036 }
6037 $define_stmt =~ s/$;//g;
6038 $define_stmt =~ s/\s+/ /g;
6039 $define_stmt = trim($define_stmt);
6040
6041 # check if any macro arguments are reused (ignore '...' and 'type')
6042 foreach my $arg (@def_args) {
6043 next if ($arg =~ /\.\.\./);
6044 next if ($arg =~ /^type$/i);
6045 my $tmp_stmt = $define_stmt;
6046 $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;
6047 $tmp_stmt =~ s/\#+\s*$arg\b//g;
6048 $tmp_stmt =~ s/\b$arg\s*\#\#//g;
6049 my $use_cnt = () = $tmp_stmt =~ /\b$arg\b/g;
6050 if ($use_cnt > 1) {
6051 CHK("MACRO_ARG_REUSE",
6052 "Macro argument reuse '$arg' - possible side-effects?\n" . "$herectx");
6053 }
6054 # check if any macro arguments may have other precedence issues
6055 if ($tmp_stmt =~ m/($Operators)?\s*\b$arg\b\s*($Operators)?/m &&
6056 ((defined($1) && $1 ne ',') ||
6057 (defined($2) && $2 ne ','))) {
6058 CHK("MACRO_ARG_PRECEDENCE",
6059 "Macro argument '$arg' may be better as '($arg)' to avoid precedence issues\n" . "$herectx");
6060 }
6061
6062 # check if this is an unused argument
6063 if ($define_stmt !~ /\b$arg\b/) {
6064 WARN("MACRO_ARG_UNUSED",
6065 "Argument '$arg' is not used in function-like macro\n" . "$herectx");
6066 }
6067 }
6068
6069 # check for macros with flow control, but without ## concatenation
6070 # ## concatenation is commonly a macro that defines a function so ignore those
6071 if ($has_flow_statement && !$has_arg_concat) {
6072 my $cnt = statement_rawlines($ctx);
6073 my $herectx = get_stat_here($linenr, $cnt, $here);
6074
6075 WARN("MACRO_WITH_FLOW_CONTROL",
6076 "Macros with flow control statements should be avoided\n" . "$herectx");
6077 }
6078
6079 # check for line continuations outside of #defines, preprocessor #, and asm
6080
6081 } elsif ($realfile =~ m@/vmlinux.lds.h$@) {
6082 $line =~ s/(\w+)/$maybe_linker_symbol{$1}++/ge;
6083 #print "REAL: $realfile\nln: $line\nkeys:", sort keys %maybe_linker_symbol;
6084 } else {
6085 if ($prevline !~ /^..*\\$/ &&
6086 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
6087 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
6088 $line =~ /^\+.*\\$/) {
6089 WARN("LINE_CONTINUATIONS",
6090 "Avoid unnecessary line continuations\n" . $herecurr);
6091 }
6092 }
6093
6094 # do {} while (0) macro tests:
6095 # single-statement macros do not need to be enclosed in do while (0) loop,
6096 # macro should not end with a semicolon
6097 if ($perl_version_ok &&
6098 $realfile !~ m@/vmlinux.lds.h$@ &&
6099 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
6100 my $ln = $linenr;
6101 my $cnt = $realcnt;
6102 my ($off, $dstat, $dcond, $rest);
6103 my $ctx = '';
6104 ($dstat, $dcond, $ln, $cnt, $off) =
6105 ctx_statement_block($linenr, $realcnt, 0);
6106 $ctx = $dstat;
6107
6108 $dstat =~ s/\\\n.//g;
6109 $dstat =~ s/$;/ /g;
6110
6111 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
6112 my $stmts = $2;
6113 my $semis = $3;
6114
6115 $ctx =~ s/\n*$//;
6116 my $cnt = statement_rawlines($ctx);
6117 my $herectx = get_stat_here($linenr, $cnt, $here);
6118
6119 if (($stmts =~ tr/;/;/) == 1 &&
6120 $stmts !~ /^\s*(if|while|for|switch)\b/) {
6121 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
6122 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
6123 }
6124 if (defined $semis && $semis ne "") {
6125 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
6126 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
6127 }
6128 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
6129 $ctx =~ s/\n*$//;
6130 my $cnt = statement_rawlines($ctx);
6131 my $herectx = get_stat_here($linenr, $cnt, $here);
6132
6133 WARN("TRAILING_SEMICOLON",
6134 "macros should not use a trailing semicolon\n" . "$herectx");
6135 }
6136 }
6137
6138 # check for redundant bracing round if etc
6139 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
6140 my ($level, $endln, @chunks) =
6141 ctx_statement_full($linenr, $realcnt, 1);
6142 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
6143 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
6144 if ($#chunks > 0 && $level == 0) {
6145 my @allowed = ();
6146 my $allow = 0;
6147 my $seen = 0;
6148 my $herectx = $here . "\n";
6149 my $ln = $linenr - 1;
6150 for my $chunk (@chunks) {
6151 my ($cond, $block) = @{$chunk};
6152
6153 # If the condition carries leading newlines, then count those as offsets.
6154 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
6155 my $offset = statement_rawlines($whitespace) - 1;
6156
6157 $allowed[$allow] = 0;
6158 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
6159
6160 # We have looked at and allowed this specific line.
6161 $suppress_ifbraces{$ln + $offset} = 1;
6162
6163 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
6164 $ln += statement_rawlines($block) - 1;
6165
6166 substr($block, 0, length($cond), '');
6167
6168 $seen++ if ($block =~ /^\s*{/);
6169
6170 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
6171 if (statement_lines($cond) > 1) {
6172 #print "APW: ALLOWED: cond<$cond>\n";
6173 $allowed[$allow] = 1;
6174 }
6175 if ($block =~/\b(?:if|for|while)\b/) {
6176 #print "APW: ALLOWED: block<$block>\n";
6177 $allowed[$allow] = 1;
6178 }
6179 if (statement_block_size($block) > 1) {
6180 #print "APW: ALLOWED: lines block<$block>\n";
6181 $allowed[$allow] = 1;
6182 }
6183 $allow++;
6184 }
6185 if ($seen) {
6186 my $sum_allowed = 0;
6187 foreach (@allowed) {
6188 $sum_allowed += $_;
6189 }
6190 if ($sum_allowed == 0) {
6191 WARN("BRACES",
6192 "braces {} are not necessary for any arm of this statement\n" . $herectx);
6193 } elsif ($sum_allowed != $allow &&
6194 $seen != $allow) {
6195 CHK("BRACES",
6196 "braces {} should be used on all arms of this statement\n" . $herectx);
6197 }
6198 }
6199 }
6200 }
6201 if (!defined $suppress_ifbraces{$linenr - 1} &&
6202 $line =~ /\b(if|while|for|else)\b/) {
6203 my $allowed = 0;
6204
6205 # Check the pre-context.
6206 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
6207 #print "APW: ALLOWED: pre<$1>\n";
6208 $allowed = 1;
6209 }
6210
6211 my ($level, $endln, @chunks) =
6212 ctx_statement_full($linenr, $realcnt, $-[0]);
6213
6214 # Check the condition.
6215 my ($cond, $block) = @{$chunks[0]};
6216 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
6217 if (defined $cond) {
6218 substr($block, 0, length($cond), '');
6219 }
6220 if (statement_lines($cond) > 1) {
6221 #print "APW: ALLOWED: cond<$cond>\n";
6222 $allowed = 1;
6223 }
6224 if ($block =~/\b(?:if|for|while)\b/) {
6225 #print "APW: ALLOWED: block<$block>\n";
6226 $allowed = 1;
6227 }
6228 if (statement_block_size($block) > 1) {
6229 #print "APW: ALLOWED: lines block<$block>\n";
6230 $allowed = 1;
6231 }
6232 # Check the post-context.
6233 if (defined $chunks[1]) {
6234 my ($cond, $block) = @{$chunks[1]};
6235 if (defined $cond) {
6236 substr($block, 0, length($cond), '');
6237 }
6238 if ($block =~ /^\s*\{/) {
6239 #print "APW: ALLOWED: chunk-1 block<$block>\n";
6240 $allowed = 1;
6241 }
6242 }
6243 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
6244 my $cnt = statement_rawlines($block);
6245 my $herectx = get_stat_here($linenr, $cnt, $here);
6246
6247 WARN("BRACES",
6248 "braces {} are not necessary for single statement blocks\n" . $herectx);
6249 }
6250 }
6251
6252 # check for single line unbalanced braces
6253 if ($sline =~ /^.\s*\}\s*else\s*$/ ||
6254 $sline =~ /^.\s*else\s*\{\s*$/) {
6255 CHK("BRACES", "Unbalanced braces around else statement\n" . $herecurr);
6256 }
6257
6258 # check for unnecessary blank lines around braces
6259 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
6260 if (CHK("BRACES",
6261 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
6262 $fix && $prevrawline =~ /^\+/) {
6263 fix_delete_line($fixlinenr - 1, $prevrawline);
6264 }
6265 }
6266 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
6267 if (CHK("BRACES",
6268 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
6269 $fix) {
6270 fix_delete_line($fixlinenr, $rawline);
6271 }
6272 }
6273
6274 # no volatiles please
6275 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
6276 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
6277 WARN("VOLATILE",
6278 "Use of volatile is usually wrong: see Documentation/process/volatile-considered-harmful.rst\n" . $herecurr);
6279 }
6280
6281 # Check for user-visible strings broken across lines, which breaks the ability
6282 # to grep for the string. Make exceptions when the previous string ends in a
6283 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
6284 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
6285 if ($line =~ /^\+\s*$String/ &&
6286 $prevline =~ /"\s*$/ &&
6287 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
6288 if (WARN("SPLIT_STRING",
6289 "quoted string split across lines\n" . $hereprev) &&
6290 $fix &&
6291 $prevrawline =~ /^\+.*"\s*$/ &&
6292 $last_coalesced_string_linenr != $linenr - 1) {
6293 my $extracted_string = get_quoted_string($line, $rawline);
6294 my $comma_close = "";
6295 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
6296 $comma_close = $1;
6297 }
6298
6299 fix_delete_line($fixlinenr - 1, $prevrawline);
6300 fix_delete_line($fixlinenr, $rawline);
6301 my $fixedline = $prevrawline;
6302 $fixedline =~ s/"\s*$//;
6303 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
6304 fix_insert_line($fixlinenr - 1, $fixedline);
6305 $fixedline = $rawline;
6306 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
6307 if ($fixedline !~ /\+\s*$/) {
6308 fix_insert_line($fixlinenr, $fixedline);
6309 }
6310 $last_coalesced_string_linenr = $linenr;
6311 }
6312 }
6313
6314 # check for missing a space in a string concatenation
6315 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
6316 WARN('MISSING_SPACE',
6317 "break quoted strings at a space character\n" . $hereprev);
6318 }
6319
6320 # check for an embedded function name in a string when the function is known
6321 # This does not work very well for -f --file checking as it depends on patch
6322 # context providing the function name or a single line form for in-file
6323 # function declarations
6324 if ($line =~ /^\+.*$String/ &&
6325 defined($context_function) &&
6326 get_quoted_string($line, $rawline) =~ /\b$context_function\b/ &&
6327 length(get_quoted_string($line, $rawline)) != (length($context_function) + 2)) {
6328 WARN("EMBEDDED_FUNCTION_NAME",
6329 "Prefer using '\"%s...\", __func__' to using '$context_function', this function's name, in a string\n" . $herecurr);
6330 }
6331
6332 # check for unnecessary function tracing like uses
6333 # This does not use $logFunctions because there are many instances like
6334 # 'dprintk(FOO, "%s()\n", __func__);' which do not match $logFunctions
6335 if ($rawline =~ /^\+.*\([^"]*"$tracing_logging_tags{0,3}%s(?:\s*\(\s*\)\s*)?$tracing_logging_tags{0,3}(?:\\n)?"\s*,\s*__func__\s*\)\s*;/) {
6336 if (WARN("TRACING_LOGGING",
6337 "Unnecessary ftrace-like logging - prefer using ftrace\n" . $herecurr) &&
6338 $fix) {
6339 fix_delete_line($fixlinenr, $rawline);
6340 }
6341 }
6342
6343 # check for spaces before a quoted newline
6344 if ($rawline =~ /^.*\".*\s\\n/) {
6345 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
6346 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
6347 $fix) {
6348 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
6349 }
6350
6351 }
6352
6353 # concatenated string without spaces between elements
6354 if ($line =~ /$String[A-Z_]/ ||
6355 ($line =~ /([A-Za-z0-9_]+)$String/ && $1 !~ /^[Lu]$/)) {
6356 if (CHK("CONCATENATED_STRING",
6357 "Concatenated strings should use spaces between elements\n" . $herecurr) &&
6358 $fix) {
6359 while ($line =~ /($String)/g) {
6360 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6361 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E([A-Za-z0-9_])/$extracted_string $1/;
6362 $fixed[$fixlinenr] =~ s/([A-Za-z0-9_])\Q$extracted_string\E/$1 $extracted_string/;
6363 }
6364 }
6365 }
6366
6367 # uncoalesced string fragments
6368 if ($line =~ /$String\s*[Lu]?"/) {
6369 if (WARN("STRING_FRAGMENTS",
6370 "Consecutive strings are generally better as a single string\n" . $herecurr) &&
6371 $fix) {
6372 while ($line =~ /($String)(?=\s*")/g) {
6373 my $extracted_string = substr($rawline, $-[0], $+[0] - $-[0]);
6374 $fixed[$fixlinenr] =~ s/\Q$extracted_string\E\s*"/substr($extracted_string, 0, -1)/e;
6375 }
6376 }
6377 }
6378
6379 # check for non-standard and hex prefixed decimal printf formats
6380 my $show_L = 1; #don't show the same defect twice
6381 my $show_Z = 1;
6382 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
6383 my $string = substr($rawline, $-[1], $+[1] - $-[1]);
6384 $string =~ s/%%/__/g;
6385 # check for %L
6386 if ($show_L && $string =~ /%[\*\d\.\$]*L([diouxX])/) {
6387 WARN("PRINTF_L",
6388 "\%L$1 is non-standard C, use %ll$1\n" . $herecurr);
6389 $show_L = 0;
6390 }
6391 # check for %Z
6392 if ($show_Z && $string =~ /%[\*\d\.\$]*Z([diouxX])/) {
6393 WARN("PRINTF_Z",
6394 "%Z$1 is non-standard C, use %z$1\n" . $herecurr);
6395 $show_Z = 0;
6396 }
6397 # check for 0x<decimal>
6398 if ($string =~ /0x%[\*\d\.\$\Llzth]*[diou]/) {
6399 ERROR("PRINTF_0XDECIMAL",
6400 "Prefixing 0x with decimal output is defective\n" . $herecurr);
6401 }
6402 }
6403
6404 # check for line continuations in quoted strings with odd counts of "
6405 if ($rawline =~ /\\$/ && $sline =~ tr/"/"/ % 2) {
6406 WARN("LINE_CONTINUATIONS",
6407 "Avoid line continuations in quoted strings\n" . $herecurr);
6408 }
6409
6410 # warn about #if 0
6411 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
6412 WARN("IF_0",
6413 "Consider removing the code enclosed by this #if 0 and its #endif\n" . $herecurr);
6414 }
6415
6416 # warn about #if 1
6417 if ($line =~ /^.\s*\#\s*if\s+1\b/) {
6418 WARN("IF_1",
6419 "Consider removing the #if 1 and its #endif\n" . $herecurr);
6420 }
6421
6422 # check for needless "if (<foo>) fn(<foo>)" uses
6423 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
6424 my $tested = quotemeta($1);
6425 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
6426 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
6427 my $func = $1;
6428 if (WARN('NEEDLESS_IF',
6429 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
6430 $fix) {
6431 my $do_fix = 1;
6432 my $leading_tabs = "";
6433 my $new_leading_tabs = "";
6434 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
6435 $leading_tabs = $1;
6436 } else {
6437 $do_fix = 0;
6438 }
6439 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
6440 $new_leading_tabs = $1;
6441 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
6442 $do_fix = 0;
6443 }
6444 } else {
6445 $do_fix = 0;
6446 }
6447 if ($do_fix) {
6448 fix_delete_line($fixlinenr - 1, $prevrawline);
6449 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
6450 }
6451 }
6452 }
6453 }
6454
6455 # check for unnecessary "Out of Memory" messages
6456 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
6457 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
6458 (defined $1 || defined $3) &&
6459 $linenr > 3) {
6460 my $testval = $2;
6461 my $testline = $lines[$linenr - 3];
6462
6463 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
6464 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
6465
6466 if ($s =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*$allocFunctions\s*\(/ &&
6467 $s !~ /\b__GFP_NOWARN\b/ ) {
6468 WARN("OOM_MESSAGE",
6469 "Possible unnecessary 'out of memory' message\n" . $hereprev);
6470 }
6471 }
6472
6473 # check for logging functions with KERN_<LEVEL>
6474 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
6475 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
6476 my $level = $1;
6477 if (WARN("UNNECESSARY_KERN_LEVEL",
6478 "Possible unnecessary $level\n" . $herecurr) &&
6479 $fix) {
6480 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
6481 }
6482 }
6483
6484 # check for logging continuations
6485 if ($line =~ /\bprintk\s*\(\s*KERN_CONT\b|\bpr_cont\s*\(/) {
6486 WARN("LOGGING_CONTINUATION",
6487 "Avoid logging continuation uses where feasible\n" . $herecurr);
6488 }
6489
6490 # check for unnecessary use of %h[xudi] and %hh[xudi] in logging functions
6491 if (defined $stat &&
6492 $line =~ /\b$logFunctions\s*\(/ &&
6493 index($stat, '"') >= 0) {
6494 my $lc = $stat =~ tr@\n@@;
6495 $lc = $lc + $linenr;
6496 my $stat_real = get_stat_real($linenr, $lc);
6497 pos($stat_real) = index($stat_real, '"');
6498 while ($stat_real =~ /[^\"%]*(%[\#\d\.\*\-]*(h+)[idux])/g) {
6499 my $pspec = $1;
6500 my $h = $2;
6501 my $lineoff = substr($stat_real, 0, $-[1]) =~ tr@\n@@;
6502 if (WARN("UNNECESSARY_MODIFIER",
6503 "Integer promotion: Using '$h' in '$pspec' is unnecessary\n" . "$here\n$stat_real\n") &&
6504 $fix && $fixed[$fixlinenr + $lineoff] =~ /^\+/) {
6505 my $nspec = $pspec;
6506 $nspec =~ s/h//g;
6507 $fixed[$fixlinenr + $lineoff] =~ s/\Q$pspec\E/$nspec/;
6508 }
6509 }
6510 }
6511
6512 # check for mask then right shift without a parentheses
6513 if ($perl_version_ok &&
6514 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
6515 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
6516 WARN("MASK_THEN_SHIFT",
6517 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
6518 }
6519
6520 # check for pointer comparisons to NULL
6521 if ($perl_version_ok) {
6522 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
6523 my $val = $1;
6524 my $equal = "!";
6525 $equal = "" if ($4 eq "!=");
6526 if (CHK("COMPARISON_TO_NULL",
6527 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
6528 $fix) {
6529 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
6530 }
6531 }
6532 }
6533
6534 # check for bad placement of section $InitAttribute (e.g.: __initdata)
6535 if ($line =~ /(\b$InitAttribute\b)/) {
6536 my $attr = $1;
6537 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
6538 my $ptr = $1;
6539 my $var = $2;
6540 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
6541 ERROR("MISPLACED_INIT",
6542 "$attr should be placed after $var\n" . $herecurr)) ||
6543 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
6544 WARN("MISPLACED_INIT",
6545 "$attr should be placed after $var\n" . $herecurr))) &&
6546 $fix) {
6547 $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;
6548 }
6549 }
6550 }
6551
6552 # check for $InitAttributeData (ie: __initdata) with const
6553 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
6554 my $attr = $1;
6555 $attr =~ /($InitAttributePrefix)(.*)/;
6556 my $attr_prefix = $1;
6557 my $attr_type = $2;
6558 if (ERROR("INIT_ATTRIBUTE",
6559 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
6560 $fix) {
6561 $fixed[$fixlinenr] =~
6562 s/$InitAttributeData/${attr_prefix}initconst/;
6563 }
6564 }
6565
6566 # check for $InitAttributeConst (ie: __initconst) without const
6567 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
6568 my $attr = $1;
6569 if (ERROR("INIT_ATTRIBUTE",
6570 "Use of $attr requires a separate use of const\n" . $herecurr) &&
6571 $fix) {
6572 my $lead = $fixed[$fixlinenr] =~
6573 /(^\+\s*(?:static\s+))/;
6574 $lead = rtrim($1);
6575 $lead = "$lead " if ($lead !~ /^\+$/);
6576 $lead = "${lead}const ";
6577 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
6578 }
6579 }
6580
6581 # check for __read_mostly with const non-pointer (should just be const)
6582 if ($line =~ /\b__read_mostly\b/ &&
6583 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
6584 if (ERROR("CONST_READ_MOSTLY",
6585 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
6586 $fix) {
6587 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
6588 }
6589 }
6590
6591 # don't use __constant_<foo> functions outside of include/uapi/
6592 if ($realfile !~ m@^include/uapi/@ &&
6593 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
6594 my $constant_func = $1;
6595 my $func = $constant_func;
6596 $func =~ s/^__constant_//;
6597 if (WARN("CONSTANT_CONVERSION",
6598 "$constant_func should be $func\n" . $herecurr) &&
6599 $fix) {
6600 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
6601 }
6602 }
6603
6604 # prefer usleep_range over udelay
6605 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
6606 my $delay = $1;
6607 # ignore udelay's < 10, however
6608 if (! ($delay < 10) ) {
6609 CHK("USLEEP_RANGE",
6610 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6611 }
6612 if ($delay > 2000) {
6613 WARN("LONG_UDELAY",
6614 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
6615 }
6616 }
6617
6618 # warn about unexpectedly long msleep's
6619 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
6620 if ($1 < 20) {
6621 WARN("MSLEEP",
6622 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.rst\n" . $herecurr);
6623 }
6624 }
6625
6626 # check for comparisons of jiffies
6627 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
6628 WARN("JIFFIES_COMPARISON",
6629 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
6630 }
6631
6632 # check for comparisons of get_jiffies_64()
6633 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
6634 WARN("JIFFIES_COMPARISON",
6635 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
6636 }
6637
6638 # warn about #ifdefs in C files
6639 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
6640 # print "#ifdef in C files should be avoided\n";
6641 # print "$herecurr";
6642 # $clean = 0;
6643 # }
6644
6645 # warn about spacing in #ifdefs
6646 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
6647 if (ERROR("SPACING",
6648 "exactly one space required after that #$1\n" . $herecurr) &&
6649 $fix) {
6650 $fixed[$fixlinenr] =~
6651 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
6652 }
6653
6654 }
6655
6656 # check for spinlock_t definitions without a comment.
6657 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
6658 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
6659 my $which = $1;
6660 if (!ctx_has_comment($first_line, $linenr)) {
6661 CHK("UNCOMMENTED_DEFINITION",
6662 "$1 definition without comment\n" . $herecurr);
6663 }
6664 }
6665 # check for memory barriers without a comment.
6666
6667 my $barriers = qr{
6668 mb|
6669 rmb|
6670 wmb
6671 }x;
6672 my $barrier_stems = qr{
6673 mb__before_atomic|
6674 mb__after_atomic|
6675 store_release|
6676 load_acquire|
6677 store_mb|
6678 (?:$barriers)
6679 }x;
6680 my $all_barriers = qr{
6681 (?:$barriers)|
6682 smp_(?:$barrier_stems)|
6683 virt_(?:$barrier_stems)
6684 }x;
6685
6686 if ($line =~ /\b(?:$all_barriers)\s*\(/) {
6687 if (!ctx_has_comment($first_line, $linenr)) {
6688 WARN("MEMORY_BARRIER",
6689 "memory barrier without comment\n" . $herecurr);
6690 }
6691 }
6692
6693 my $underscore_smp_barriers = qr{__smp_(?:$barrier_stems)}x;
6694
6695 if ($realfile !~ m@^include/asm-generic/@ &&
6696 $realfile !~ m@/barrier\.h$@ &&
6697 $line =~ m/\b(?:$underscore_smp_barriers)\s*\(/ &&
6698 $line !~ m/^.\s*\#\s*define\s+(?:$underscore_smp_barriers)\s*\(/) {
6699 WARN("MEMORY_BARRIER",
6700 "__smp memory barriers shouldn't be used outside barrier.h and asm-generic\n" . $herecurr);
6701 }
6702
6703 # check for waitqueue_active without a comment.
6704 if ($line =~ /\bwaitqueue_active\s*\(/) {
6705 if (!ctx_has_comment($first_line, $linenr)) {
6706 WARN("WAITQUEUE_ACTIVE",
6707 "waitqueue_active without comment\n" . $herecurr);
6708 }
6709 }
6710
6711 # check for data_race without a comment.
6712 if ($line =~ /\bdata_race\s*\(/) {
6713 if (!ctx_has_comment($first_line, $linenr)) {
6714 WARN("DATA_RACE",
6715 "data_race without comment\n" . $herecurr);
6716 }
6717 }
6718
6719 # check of hardware specific defines
6720 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
6721 CHK("ARCH_DEFINES",
6722 "architecture specific defines should be avoided\n" . $herecurr);
6723 }
6724
6725 # check that the storage class is not after a type
6726 if ($line =~ /\b($Type)\s+($Storage)\b/) {
6727 WARN("STORAGE_CLASS",
6728 "storage class '$2' should be located before type '$1'\n" . $herecurr);
6729 }
6730 # Check that the storage class is at the beginning of a declaration
6731 if ($line =~ /\b$Storage\b/ &&
6732 $line !~ /^.\s*$Storage/ &&
6733 $line =~ /^.\s*(.+?)\$Storage\s/ &&
6734 $1 !~ /[\,\)]\s*$/) {
6735 WARN("STORAGE_CLASS",
6736 "storage class should be at the beginning of the declaration\n" . $herecurr);
6737 }
6738
6739 # check the location of the inline attribute, that it is between
6740 # storage class and type.
6741 if ($line =~ /\b$Type\s+$Inline\b/ ||
6742 $line =~ /\b$Inline\s+$Storage\b/) {
6743 ERROR("INLINE_LOCATION",
6744 "inline keyword should sit between storage class and type\n" . $herecurr);
6745 }
6746
6747 # Check for __inline__ and __inline, prefer inline
6748 if ($realfile !~ m@\binclude/uapi/@ &&
6749 $line =~ /\b(__inline__|__inline)\b/) {
6750 if (WARN("INLINE",
6751 "plain inline is preferred over $1\n" . $herecurr) &&
6752 $fix) {
6753 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
6754
6755 }
6756 }
6757
6758 # Check for compiler attributes
6759 if ($realfile !~ m@\binclude/uapi/@ &&
6760 $rawline =~ /\b__attribute__\s*\(\s*($balanced_parens)\s*\)/) {
6761 my $attr = $1;
6762 $attr =~ s/\s*\(\s*(.*)\)\s*/$1/;
6763
6764 my %attr_list = (
6765 "alias" => "__alias",
6766 "aligned" => "__aligned",
6767 "always_inline" => "__always_inline",
6768 "assume_aligned" => "__assume_aligned",
6769 "cold" => "__cold",
6770 "const" => "__attribute_const__",
6771 "copy" => "__copy",
6772 "designated_init" => "__designated_init",
6773 "externally_visible" => "__visible",
6774 "format" => "printf|scanf",
6775 "gnu_inline" => "__gnu_inline",
6776 "malloc" => "__malloc",
6777 "mode" => "__mode",
6778 "no_caller_saved_registers" => "__no_caller_saved_registers",
6779 "noclone" => "__noclone",
6780 "noinline" => "noinline",
6781 "nonstring" => "__nonstring",
6782 "noreturn" => "__noreturn",
6783 "packed" => "__packed",
6784 "pure" => "__pure",
6785 "section" => "__section",
6786 "used" => "__used",
6787 "weak" => "__weak"
6788 );
6789
6790 while ($attr =~ /\s*(\w+)\s*(${balanced_parens})?/g) {
6791 my $orig_attr = $1;
6792 my $params = '';
6793 $params = $2 if defined($2);
6794 my $curr_attr = $orig_attr;
6795 $curr_attr =~ s/^[\s_]+|[\s_]+$//g;
6796 if (exists($attr_list{$curr_attr})) {
6797 my $new = $attr_list{$curr_attr};
6798 if ($curr_attr eq "format" && $params) {
6799 $params =~ /^\s*\(\s*(\w+)\s*,\s*(.*)/;
6800 $new = "__$1\($2";
6801 } else {
6802 $new = "$new$params";
6803 }
6804 if (WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6805 "Prefer $new over __attribute__(($orig_attr$params))\n" . $herecurr) &&
6806 $fix) {
6807 my $remove = "\Q$orig_attr\E" . '\s*' . "\Q$params\E" . '(?:\s*,\s*)?';
6808 $fixed[$fixlinenr] =~ s/$remove//;
6809 $fixed[$fixlinenr] =~ s/\b__attribute__/$new __attribute__/;
6810 $fixed[$fixlinenr] =~ s/\}\Q$new\E/} $new/;
6811 $fixed[$fixlinenr] =~ s/ __attribute__\s*\(\s*\(\s*\)\s*\)//;
6812 }
6813 }
6814 }
6815
6816 # Check for __attribute__ unused, prefer __always_unused or __maybe_unused
6817 if ($attr =~ /^_*unused/) {
6818 WARN("PREFER_DEFINED_ATTRIBUTE_MACRO",
6819 "__always_unused or __maybe_unused is preferred over __attribute__((__unused__))\n" . $herecurr);
6820 }
6821 }
6822
6823 # Check for __attribute__ weak, or __weak declarations (may have link issues)
6824 if ($perl_version_ok &&
6825 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
6826 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
6827 $line =~ /\b__weak\b/)) {
6828 ERROR("WEAK_DECLARATION",
6829 "Using weak declarations can have unintended link defects\n" . $herecurr);
6830 }
6831
6832 # check for c99 types like uint8_t used outside of uapi/ and tools/
6833 if ($realfile !~ m@\binclude/uapi/@ &&
6834 $realfile !~ m@\btools/@ &&
6835 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
6836 my $type = $1;
6837 if ($type =~ /\b($typeC99Typedefs)\b/) {
6838 $type = $1;
6839 my $kernel_type = 'u';
6840 $kernel_type = 's' if ($type =~ /^_*[si]/);
6841 $type =~ /(\d+)/;
6842 $kernel_type .= $1;
6843 if (CHK("PREFER_KERNEL_TYPES",
6844 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
6845 $fix) {
6846 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
6847 }
6848 }
6849 }
6850
6851 # check for cast of C90 native int or longer types constants
6852 if ($line =~ /(\(\s*$C90_int_types\s*\)\s*)($Constant)\b/) {
6853 my $cast = $1;
6854 my $const = $2;
6855 my $suffix = "";
6856 my $newconst = $const;
6857 $newconst =~ s/${Int_type}$//;
6858 $suffix .= 'U' if ($cast =~ /\bunsigned\b/);
6859 if ($cast =~ /\blong\s+long\b/) {
6860 $suffix .= 'LL';
6861 } elsif ($cast =~ /\blong\b/) {
6862 $suffix .= 'L';
6863 }
6864 if (WARN("TYPECAST_INT_CONSTANT",
6865 "Unnecessary typecast of c90 int constant - '$cast$const' could be '$const$suffix'\n" . $herecurr) &&
6866 $fix) {
6867 $fixed[$fixlinenr] =~ s/\Q$cast\E$const\b/$newconst$suffix/;
6868 }
6869 }
6870
6871 # check for sizeof(&)
6872 if ($line =~ /\bsizeof\s*\(\s*\&/) {
6873 WARN("SIZEOF_ADDRESS",
6874 "sizeof(& should be avoided\n" . $herecurr);
6875 }
6876
6877 # check for sizeof without parenthesis
6878 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
6879 if (WARN("SIZEOF_PARENTHESIS",
6880 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
6881 $fix) {
6882 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
6883 }
6884 }
6885
6886 # check for struct spinlock declarations
6887 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
6888 WARN("USE_SPINLOCK_T",
6889 "struct spinlock should be spinlock_t\n" . $herecurr);
6890 }
6891
6892 # check for seq_printf uses that could be seq_puts
6893 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
6894 my $fmt = get_quoted_string($line, $rawline);
6895 $fmt =~ s/%%//g;
6896 if ($fmt !~ /%/) {
6897 if (WARN("PREFER_SEQ_PUTS",
6898 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
6899 $fix) {
6900 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
6901 }
6902 }
6903 }
6904
6905 # check for vsprintf extension %p<foo> misuses
6906 if ($perl_version_ok &&
6907 defined $stat &&
6908 $stat =~ /^\+(?![^\{]*\{\s*).*\b(\w+)\s*\(.*$String\s*,/s &&
6909 $1 !~ /^_*volatile_*$/) {
6910 my $stat_real;
6911
6912 my $lc = $stat =~ tr@\n@@;
6913 $lc = $lc + $linenr;
6914 for (my $count = $linenr; $count <= $lc; $count++) {
6915 my $specifier;
6916 my $extension;
6917 my $qualifier;
6918 my $bad_specifier = "";
6919 my $fmt = get_quoted_string($lines[$count - 1], raw_line($count, 0));
6920 $fmt =~ s/%%//g;
6921
6922 while ($fmt =~ /(\%[\*\d\.]*p(\w)(\w*))/g) {
6923 $specifier = $1;
6924 $extension = $2;
6925 $qualifier = $3;
6926 if ($extension !~ /[4SsBKRraEehMmIiUDdgVCbGNOxtf]/ ||
6927 ($extension eq "f" &&
6928 defined $qualifier && $qualifier !~ /^w/) ||
6929 ($extension eq "4" &&
6930 defined $qualifier && $qualifier !~ /^cc/)) {
6931 $bad_specifier = $specifier;
6932 last;
6933 }
6934 if ($extension eq "x" && !defined($stat_real)) {
6935 if (!defined($stat_real)) {
6936 $stat_real = get_stat_real($linenr, $lc);
6937 }
6938 WARN("VSPRINTF_SPECIFIER_PX",
6939 "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");
6940 }
6941 }
6942 if ($bad_specifier ne "") {
6943 my $stat_real = get_stat_real($linenr, $lc);
6944 my $msg_level = \&WARN;
6945 my $ext_type = "Invalid";
6946 my $use = "";
6947 if ($bad_specifier =~ /p[Ff]/) {
6948 $use = " - use %pS instead";
6949 $use =~ s/pS/ps/ if ($bad_specifier =~ /pf/);
6950 } elsif ($bad_specifier =~ /pA/) {
6951 $use = " - '%pA' is only intended to be used from Rust code";
6952 $msg_level = \&ERROR;
6953 }
6954
6955 &{$msg_level}("VSPRINTF_POINTER_EXTENSION",
6956 "$ext_type vsprintf pointer extension '$bad_specifier'$use\n" . "$here\n$stat_real\n");
6957 }
6958 }
6959 }
6960
6961 # Check for misused memsets
6962 if ($perl_version_ok &&
6963 defined $stat &&
6964 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
6965
6966 my $ms_addr = $2;
6967 my $ms_val = $7;
6968 my $ms_size = $12;
6969
6970 if ($ms_size =~ /^(0x|)0$/i) {
6971 ERROR("MEMSET",
6972 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
6973 } elsif ($ms_size =~ /^(0x|)1$/i) {
6974 WARN("MEMSET",
6975 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
6976 }
6977 }
6978
6979 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
6980 # if ($perl_version_ok &&
6981 # defined $stat &&
6982 # $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6983 # if (WARN("PREFER_ETHER_ADDR_COPY",
6984 # "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
6985 # $fix) {
6986 # $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
6987 # }
6988 # }
6989
6990 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
6991 # if ($perl_version_ok &&
6992 # defined $stat &&
6993 # $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
6994 # WARN("PREFER_ETHER_ADDR_EQUAL",
6995 # "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
6996 # }
6997
6998 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
6999 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
7000 # if ($perl_version_ok &&
7001 # defined $stat &&
7002 # $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
7003 #
7004 # my $ms_val = $7;
7005 #
7006 # if ($ms_val =~ /^(?:0x|)0+$/i) {
7007 # if (WARN("PREFER_ETH_ZERO_ADDR",
7008 # "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
7009 # $fix) {
7010 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
7011 # }
7012 # } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
7013 # if (WARN("PREFER_ETH_BROADCAST_ADDR",
7014 # "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
7015 # $fix) {
7016 # $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
7017 # }
7018 # }
7019 # }
7020
7021 # strcpy uses that should likely be strscpy
7022 if ($line =~ /\bstrcpy\s*\(/) {
7023 WARN("STRCPY",
7024 "Prefer strscpy over strcpy - see: https://github.com/KSPP/linux/issues/88\n" . $herecurr);
7025 }
7026
7027 # strlcpy uses that should likely be strscpy
7028 if ($line =~ /\bstrlcpy\s*\(/) {
7029 WARN("STRLCPY",
7030 "Prefer strscpy over strlcpy - see: https://github.com/KSPP/linux/issues/89\n" . $herecurr);
7031 }
7032
7033 # strncpy uses that should likely be strscpy or strscpy_pad
7034 if ($line =~ /\bstrncpy\s*\(/) {
7035 WARN("STRNCPY",
7036 "Prefer strscpy, strscpy_pad, or __nonstring over strncpy - see: https://github.com/KSPP/linux/issues/90\n" . $herecurr);
7037 }
7038
7039 # ethtool_sprintf uses that should likely be ethtool_puts
7040 if ($line =~ /\bethtool_sprintf\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
7041 if (WARN("PREFER_ETHTOOL_PUTS",
7042 "Prefer ethtool_puts over ethtool_sprintf with only two arguments\n" . $herecurr) &&
7043 $fix) {
7044 $fixed[$fixlinenr] =~ s/\bethtool_sprintf\s*\(\s*($FuncArg)\s*,\s*($FuncArg)/ethtool_puts($1, $7)/;
7045 }
7046 }
7047
7048 # use $rawline because $line loses %s via sanitization and thus we can't match against it.
7049 if ($rawline =~ /\bethtool_sprintf\s*\(\s*$FuncArg\s*,\s*\"\%s\"\s*,\s*$FuncArg\s*\)/) {
7050 if (WARN("PREFER_ETHTOOL_PUTS",
7051 "Prefer ethtool_puts over ethtool_sprintf with standalone \"%s\" specifier\n" . $herecurr) &&
7052 $fix) {
7053 $fixed[$fixlinenr] =~ s/\bethtool_sprintf\s*\(\s*($FuncArg)\s*,\s*"\%s"\s*,\s*($FuncArg)/ethtool_puts($1, $7)/;
7054 }
7055 }
7056
7057
7058 # typecasts on min/max could be min_t/max_t
7059 if ($perl_version_ok &&
7060 defined $stat &&
7061 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
7062 if (defined $2 || defined $7) {
7063 my $call = $1;
7064 my $cast1 = deparenthesize($2);
7065 my $arg1 = $3;
7066 my $cast2 = deparenthesize($7);
7067 my $arg2 = $8;
7068 my $cast;
7069
7070 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
7071 $cast = "$cast1 or $cast2";
7072 } elsif ($cast1 ne "") {
7073 $cast = $cast1;
7074 } else {
7075 $cast = $cast2;
7076 }
7077 WARN("MINMAX",
7078 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
7079 }
7080 }
7081
7082 # check usleep_range arguments
7083 if ($perl_version_ok &&
7084 defined $stat &&
7085 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
7086 my $min = $1;
7087 my $max = $7;
7088 if ($min eq $max) {
7089 WARN("USLEEP_RANGE",
7090 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
7091 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
7092 $min > $max) {
7093 WARN("USLEEP_RANGE",
7094 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.rst\n" . "$here\n$stat\n");
7095 }
7096 }
7097
7098 # check for naked sscanf
7099 if ($perl_version_ok &&
7100 defined $stat &&
7101 $line =~ /\bsscanf\b/ &&
7102 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
7103 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
7104 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
7105 my $lc = $stat =~ tr@\n@@;
7106 $lc = $lc + $linenr;
7107 my $stat_real = get_stat_real($linenr, $lc);
7108 WARN("NAKED_SSCANF",
7109 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
7110 }
7111
7112 # check for simple sscanf that should be kstrto<foo>
7113 if ($perl_version_ok &&
7114 defined $stat &&
7115 $line =~ /\bsscanf\b/) {
7116 my $lc = $stat =~ tr@\n@@;
7117 $lc = $lc + $linenr;
7118 my $stat_real = get_stat_real($linenr, $lc);
7119 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
7120 my $format = $6;
7121 my $count = $format =~ tr@%@%@;
7122 if ($count == 1 &&
7123 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
7124 WARN("SSCANF_TO_KSTRTO",
7125 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
7126 }
7127 }
7128 }
7129
7130 # check for new externs in .h files.
7131 if ($realfile =~ /\.h$/ &&
7132 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
7133 if (CHK("AVOID_EXTERNS",
7134 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
7135 $fix) {
7136 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
7137 }
7138 }
7139
7140 # check for new externs in .c files.
7141 if ($realfile =~ /\.c$/ && defined $stat &&
7142 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
7143 {
7144 my $function_name = $1;
7145 my $paren_space = $2;
7146
7147 my $s = $stat;
7148 if (defined $cond) {
7149 substr($s, 0, length($cond), '');
7150 }
7151 if ($s =~ /^\s*;/)
7152 {
7153 WARN("AVOID_EXTERNS",
7154 "externs should be avoided in .c files\n" . $herecurr);
7155 }
7156
7157 if ($paren_space =~ /\n/) {
7158 WARN("FUNCTION_ARGUMENTS",
7159 "arguments for function declarations should follow identifier\n" . $herecurr);
7160 }
7161
7162 } elsif ($realfile =~ /\.c$/ && defined $stat &&
7163 $stat =~ /^\+extern struct\s+(\w+)\s+(\w+)\[\];/)
7164 {
7165 my ($st_type, $st_name) = ($1, $2);
7166
7167 for my $s (keys %maybe_linker_symbol) {
7168 #print "Linker symbol? $st_name : $s\n";
7169 goto LIKELY_LINKER_SYMBOL
7170 if $st_name =~ /$s/;
7171 }
7172 WARN("AVOID_EXTERNS",
7173 "found a file-scoped extern type:$st_type name:$st_name in .c file\n"
7174 . "is this a linker symbol ?\n" . $herecurr);
7175 LIKELY_LINKER_SYMBOL:
7176
7177 } elsif ($realfile =~ /\.c$/ && defined $stat &&
7178 $stat =~ /^.\s*extern\s+/)
7179 {
7180 WARN("AVOID_EXTERNS",
7181 "externs should be avoided in .c files\n" . $herecurr);
7182 }
7183
7184 # check for function declarations that have arguments without identifier names
7185 if (defined $stat &&
7186 $stat =~ /^.\s*(?:extern\s+)?$Type\s*(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*\(\s*([^{]+)\s*\)\s*;/s &&
7187 $1 ne "void") {
7188 my $args = trim($1);
7189 while ($args =~ m/\s*($Type\s*(?:$Ident|\(\s*\*\s*$Ident?\s*\)\s*$balanced_parens)?)/g) {
7190 my $arg = trim($1);
7191 if ($arg =~ /^$Type$/ && $arg !~ /enum\s+$Ident$/) {
7192 WARN("FUNCTION_ARGUMENTS",
7193 "function definition argument '$arg' should also have an identifier name\n" . $herecurr);
7194 }
7195 }
7196 }
7197
7198 # check for function definitions
7199 if ($perl_version_ok &&
7200 defined $stat &&
7201 $stat =~ /^.\s*(?:$Storage\s+)?$Type\s*($Ident)\s*$balanced_parens\s*{/s) {
7202 $context_function = $1;
7203
7204 # check for multiline function definition with misplaced open brace
7205 my $ok = 0;
7206 my $cnt = statement_rawlines($stat);
7207 my $herectx = $here . "\n";
7208 for (my $n = 0; $n < $cnt; $n++) {
7209 my $rl = raw_line($linenr, $n);
7210 $herectx .= $rl . "\n";
7211 $ok = 1 if ($rl =~ /^[ \+]\{/);
7212 $ok = 1 if ($rl =~ /\{/ && $n == 0);
7213 last if $rl =~ /^[ \+].*\{/;
7214 }
7215 if (!$ok) {
7216 ERROR("OPEN_BRACE",
7217 "open brace '{' following function definitions go on the next line\n" . $herectx);
7218 }
7219 }
7220
7221 # checks for new __setup's
7222 if ($rawline =~ /\b__setup\("([^"]*)"/) {
7223 my $name = $1;
7224
7225 if (!grep(/$name/, @setup_docs)) {
7226 CHK("UNDOCUMENTED_SETUP",
7227 "__setup appears un-documented -- check Documentation/admin-guide/kernel-parameters.txt\n" . $herecurr);
7228 }
7229 }
7230
7231 # check for pointless casting of alloc functions
7232 if ($line =~ /\*\s*\)\s*$allocFunctions\b/) {
7233 WARN("UNNECESSARY_CASTS",
7234 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
7235 }
7236
7237 # alloc style
7238 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
7239 if ($perl_version_ok &&
7240 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k|v)[mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
7241 CHK("ALLOC_SIZEOF_STRUCT",
7242 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
7243 }
7244
7245 # check for (kv|k)[mz]alloc with multiplies that could be kmalloc_array/kvmalloc_array/kvcalloc/kcalloc
7246 if ($perl_version_ok &&
7247 defined $stat &&
7248 $stat =~ /^\+\s*($Lval)\s*\=\s*(?:$balanced_parens)?\s*((?:kv|k)[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
7249 my $oldfunc = $3;
7250 my $a1 = $4;
7251 my $a2 = $10;
7252 my $newfunc = "kmalloc_array";
7253 $newfunc = "kvmalloc_array" if ($oldfunc eq "kvmalloc");
7254 $newfunc = "kvcalloc" if ($oldfunc eq "kvzalloc");
7255 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
7256 my $r1 = $a1;
7257 my $r2 = $a2;
7258 if ($a1 =~ /^sizeof\s*\S/) {
7259 $r1 = $a2;
7260 $r2 = $a1;
7261 }
7262 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
7263 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
7264 my $cnt = statement_rawlines($stat);
7265 my $herectx = get_stat_here($linenr, $cnt, $here);
7266
7267 if (WARN("ALLOC_WITH_MULTIPLY",
7268 "Prefer $newfunc over $oldfunc with multiply\n" . $herectx) &&
7269 $cnt == 1 &&
7270 $fix) {
7271 $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;
7272 }
7273 }
7274 }
7275
7276 # check for krealloc arg reuse
7277 if ($perl_version_ok &&
7278 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*($Lval)\s*,/ &&
7279 $1 eq $3) {
7280 WARN("KREALLOC_ARG_REUSE",
7281 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
7282 }
7283
7284 # check for alloc argument mismatch
7285 if ($line =~ /\b((?:devm_)?((?:k|kv)?(calloc|malloc_array)(?:_node)?))\s*\(\s*sizeof\b/) {
7286 WARN("ALLOC_ARRAY_ARGS",
7287 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
7288 }
7289
7290 # check for multiple semicolons
7291 if ($line =~ /;\s*;\s*$/) {
7292 if (WARN("ONE_SEMICOLON",
7293 "Statements terminations use 1 semicolon\n" . $herecurr) &&
7294 $fix) {
7295 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
7296 }
7297 }
7298
7299 # check for #defines like: 1 << <digit> that could be BIT(digit), it is not exported to uapi
7300 if ($realfile !~ m@^include/uapi/@ &&
7301 $line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
7302 my $ull = "";
7303 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
7304 if (CHK("BIT_MACRO",
7305 "Prefer using the BIT$ull macro\n" . $herecurr) &&
7306 $fix) {
7307 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
7308 }
7309 }
7310
7311 # check for IS_ENABLED() without CONFIG_<FOO> ($rawline for comments too)
7312 if ($rawline =~ /\bIS_ENABLED\s*\(\s*(\w+)\s*\)/ && $1 !~ /^${CONFIG_}/) {
7313 WARN("IS_ENABLED_CONFIG",
7314 "IS_ENABLED($1) is normally used as IS_ENABLED(${CONFIG_}$1)\n" . $herecurr);
7315 }
7316
7317 # check for #if defined CONFIG_<FOO> || defined CONFIG_<FOO>_MODULE
7318 if ($line =~ /^\+\s*#\s*if\s+defined(?:\s*\(?\s*|\s+)(${CONFIG_}[A-Z_]+)\s*\)?\s*\|\|\s*defined(?:\s*\(?\s*|\s+)\1_MODULE\s*\)?\s*$/) {
7319 my $config = $1;
7320 if (WARN("PREFER_IS_ENABLED",
7321 "Prefer IS_ENABLED(<FOO>) to ${CONFIG_}<FOO> || ${CONFIG_}<FOO>_MODULE\n" . $herecurr) &&
7322 $fix) {
7323 $fixed[$fixlinenr] = "\+#if IS_ENABLED($config)";
7324 }
7325 }
7326
7327 # check for /* fallthrough */ like comment, prefer fallthrough;
7328 my @fallthroughs = (
7329 'fallthrough',
7330 '@fallthrough@',
7331 'lint -fallthrough[ \t]*',
7332 'intentional(?:ly)?[ \t]*fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)',
7333 '(?:else,?\s*)?FALL(?:S | |-)?THR(?:OUGH|U|EW)[ \t.!]*(?:-[^\n\r]*)?',
7334 'Fall(?:(?:s | |-)[Tt]|t)hr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7335 'fall(?:s | |-)?thr(?:ough|u|ew)[ \t.!]*(?:-[^\n\r]*)?',
7336 );
7337 if ($raw_comment ne '') {
7338 foreach my $ft (@fallthroughs) {
7339 if ($raw_comment =~ /$ft/) {
7340 my $msg_level = \&WARN;
7341 $msg_level = \&CHK if ($file);
7342 &{$msg_level}("PREFER_FALLTHROUGH",
7343 "Prefer 'fallthrough;' over fallthrough comment\n" . $herecurr);
7344 last;
7345 }
7346 }
7347 }
7348
7349 # check for switch/default statements without a break;
7350 if ($perl_version_ok &&
7351 defined $stat &&
7352 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
7353 my $cnt = statement_rawlines($stat);
7354 my $herectx = get_stat_here($linenr, $cnt, $here);
7355
7356 WARN("DEFAULT_NO_BREAK",
7357 "switch default: should use break\n" . $herectx);
7358 }
7359
7360 # check for gcc specific __FUNCTION__
7361 if ($line =~ /\b__FUNCTION__\b/) {
7362 if (WARN("USE_FUNC",
7363 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
7364 $fix) {
7365 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
7366 }
7367 }
7368
7369 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
7370 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
7371 ERROR("DATE_TIME",
7372 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
7373 }
7374
7375 # check for use of yield()
7376 if ($line =~ /\byield\s*\(\s*\)/) {
7377 WARN("YIELD",
7378 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
7379 }
7380
7381 # check for comparisons against true and false
7382 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
7383 my $lead = $1;
7384 my $arg = $2;
7385 my $test = $3;
7386 my $otype = $4;
7387 my $trail = $5;
7388 my $op = "!";
7389
7390 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
7391
7392 my $type = lc($otype);
7393 if ($type =~ /^(?:true|false)$/) {
7394 if (("$test" eq "==" && "$type" eq "true") ||
7395 ("$test" eq "!=" && "$type" eq "false")) {
7396 $op = "";
7397 }
7398
7399 CHK("BOOL_COMPARISON",
7400 "Using comparison to $otype is error prone\n" . $herecurr);
7401
7402 ## maybe suggesting a correct construct would better
7403 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
7404
7405 }
7406 }
7407
7408 # check for semaphores initialized locked
7409 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
7410 WARN("CONSIDER_COMPLETION",
7411 "consider using a completion\n" . $herecurr);
7412 }
7413
7414 # recommend kstrto* over simple_strto* and strict_strto*
7415 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
7416 WARN("CONSIDER_KSTRTO",
7417 "$1 is obsolete, use k$3 instead\n" . $herecurr);
7418 }
7419
7420 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
7421 if ($line =~ /^.\s*__initcall\s*\(/) {
7422 WARN("USE_DEVICE_INITCALL",
7423 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
7424 }
7425
7426 # check for spin_is_locked(), suggest lockdep instead
7427 if ($line =~ /\bspin_is_locked\(/) {
7428 WARN("USE_LOCKDEP",
7429 "Where possible, use lockdep_assert_held instead of assertions based on spin_is_locked\n" . $herecurr);
7430 }
7431
7432 # check for deprecated apis
7433 if ($line =~ /\b($deprecated_apis_search)\b\s*\(/) {
7434 my $deprecated_api = $1;
7435 my $new_api = $deprecated_apis{$deprecated_api};
7436 WARN("DEPRECATED_API",
7437 "Deprecated use of '$deprecated_api', prefer '$new_api' instead\n" . $herecurr);
7438 }
7439
7440 # check for various structs that are normally const (ops, kgdb, device_tree)
7441 # and avoid what seem like struct definitions 'struct foo {'
7442 if (defined($const_structs) &&
7443 $line !~ /\bconst\b/ &&
7444 $line =~ /\bstruct\s+($const_structs)\b(?!\s*\{)/) {
7445 WARN("CONST_STRUCT",
7446 "struct $1 should normally be const\n" . $herecurr);
7447 }
7448
7449 # use of NR_CPUS is usually wrong
7450 # ignore definitions of NR_CPUS and usage to define arrays as likely right
7451 # ignore designated initializers using NR_CPUS
7452 if ($line =~ /\bNR_CPUS\b/ &&
7453 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
7454 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
7455 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
7456 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
7457 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/ &&
7458 $line !~ /^.\s*\.\w+\s*=\s*.*\bNR_CPUS\b/)
7459 {
7460 WARN("NR_CPUS",
7461 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
7462 }
7463
7464 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
7465 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
7466 ERROR("DEFINE_ARCH_HAS",
7467 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
7468 }
7469
7470 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
7471 if ($perl_version_ok &&
7472 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
7473 WARN("LIKELY_MISUSE",
7474 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
7475 }
7476
7477 # return sysfs_emit(foo, fmt, ...) fmt without newline
7478 if ($line =~ /\breturn\s+sysfs_emit\s*\(\s*$FuncArg\s*,\s*($String)/ &&
7479 substr($rawline, $-[6], $+[6] - $-[6]) !~ /\\n"$/) {
7480 my $offset = $+[6] - 1;
7481 if (WARN("SYSFS_EMIT",
7482 "return sysfs_emit(...) formats should include a terminating newline\n" . $herecurr) &&
7483 $fix) {
7484 substr($fixed[$fixlinenr], $offset, 0) = '\\n';
7485 }
7486 }
7487
7488 # check for array definition/declarations that should use flexible arrays instead
7489 if ($sline =~ /^[\+ ]\s*\}(?:\s*__packed)?\s*;\s*$/ &&
7490 $prevline =~ /^\+\s*(?:\}(?:\s*__packed\s*)?|$Type)\s*$Ident\s*\[\s*(0|1)\s*\]\s*;\s*$/) {
7491 if (ERROR("FLEXIBLE_ARRAY",
7492 "Use C99 flexible arrays - see https://docs.kernel.org/process/deprecated.html#zero-length-and-one-element-arrays\n" . $hereprev) &&
7493 $1 == '0' && $fix) {
7494 $fixed[$fixlinenr - 1] =~ s/\[\s*0\s*\]/[]/;
7495 }
7496 }
7497
7498 # nested likely/unlikely calls
7499 if ($line =~ /\b(?:(?:un)?likely)\s*\(\s*!?\s*(IS_ERR(?:_OR_NULL|_VALUE)?|WARN)/) {
7500 WARN("LIKELY_MISUSE",
7501 "nested (un)?likely() calls, $1 already uses unlikely() internally\n" . $herecurr);
7502 }
7503
7504 # whine mightly about in_atomic
7505 if ($line =~ /\bin_atomic\s*\(/) {
7506 if ($realfile =~ m@^drivers/@) {
7507 ERROR("IN_ATOMIC",
7508 "do not use in_atomic in drivers\n" . $herecurr);
7509 } elsif ($realfile !~ m@^kernel/@) {
7510 WARN("IN_ATOMIC",
7511 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
7512 }
7513 }
7514
7515 # Complain about RCU Tasks Trace used outside of BPF (and of course, RCU).
7516 our $rcu_trace_funcs = qr{(?x:
7517 rcu_read_lock_trace |
7518 rcu_read_lock_trace_held |
7519 rcu_read_unlock_trace |
7520 call_rcu_tasks_trace |
7521 synchronize_rcu_tasks_trace |
7522 rcu_barrier_tasks_trace |
7523 rcu_request_urgent_qs_task
7524 )};
7525 our $rcu_trace_paths = qr{(?x:
7526 kernel/bpf/ |
7527 include/linux/bpf |
7528 net/bpf/ |
7529 kernel/rcu/ |
7530 include/linux/rcu
7531 )};
7532 if ($line =~ /\b($rcu_trace_funcs)\s*\(/) {
7533 if ($realfile !~ m{^$rcu_trace_paths}) {
7534 WARN("RCU_TASKS_TRACE",
7535 "use of RCU tasks trace is incorrect outside BPF or core RCU code\n" . $herecurr);
7536 }
7537 }
7538
7539 # check for lockdep_set_novalidate_class
7540 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
7541 $line =~ /__lockdep_no_validate__\s*\)/ ) {
7542 if ($realfile !~ m@^kernel/lockdep@ &&
7543 $realfile !~ m@^include/linux/lockdep@ &&
7544 $realfile !~ m@^drivers/base/core@) {
7545 ERROR("LOCKDEP",
7546 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
7547 }
7548 }
7549
7550 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
7551 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
7552 WARN("EXPORTED_WORLD_WRITABLE",
7553 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
7554 }
7555
7556 # check for DEVICE_ATTR uses that could be DEVICE_ATTR_<FOO>
7557 # and whether or not function naming is typical and if
7558 # DEVICE_ATTR permissions uses are unusual too
7559 if ($perl_version_ok &&
7560 defined $stat &&
7561 $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*\)/) {
7562 my $var = $1;
7563 my $perms = $2;
7564 my $show = $3;
7565 my $store = $4;
7566 my $octal_perms = perms_to_octal($perms);
7567 if ($show =~ /^${var}_show$/ &&
7568 $store =~ /^${var}_store$/ &&
7569 $octal_perms eq "0644") {
7570 if (WARN("DEVICE_ATTR_RW",
7571 "Use DEVICE_ATTR_RW\n" . $herecurr) &&
7572 $fix) {
7573 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*$store\s*\)/DEVICE_ATTR_RW(${var})/;
7574 }
7575 } elsif ($show =~ /^${var}_show$/ &&
7576 $store =~ /^NULL$/ &&
7577 $octal_perms eq "0444") {
7578 if (WARN("DEVICE_ATTR_RO",
7579 "Use DEVICE_ATTR_RO\n" . $herecurr) &&
7580 $fix) {
7581 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*$show\s*,\s*NULL\s*\)/DEVICE_ATTR_RO(${var})/;
7582 }
7583 } elsif ($show =~ /^NULL$/ &&
7584 $store =~ /^${var}_store$/ &&
7585 $octal_perms eq "0200") {
7586 if (WARN("DEVICE_ATTR_WO",
7587 "Use DEVICE_ATTR_WO\n" . $herecurr) &&
7588 $fix) {
7589 $fixed[$fixlinenr] =~ s/\bDEVICE_ATTR\s*\(\s*$var\s*,\s*\Q$perms\E\s*,\s*NULL\s*,\s*$store\s*\)/DEVICE_ATTR_WO(${var})/;
7590 }
7591 } elsif ($octal_perms eq "0644" ||
7592 $octal_perms eq "0444" ||
7593 $octal_perms eq "0200") {
7594 my $newshow = "$show";
7595 $newshow = "${var}_show" if ($show ne "NULL" && $show ne "${var}_show");
7596 my $newstore = $store;
7597 $newstore = "${var}_store" if ($store ne "NULL" && $store ne "${var}_store");
7598 my $rename = "";
7599 if ($show ne $newshow) {
7600 $rename .= " '$show' to '$newshow'";
7601 }
7602 if ($store ne $newstore) {
7603 $rename .= " '$store' to '$newstore'";
7604 }
7605 WARN("DEVICE_ATTR_FUNCTIONS",
7606 "Consider renaming function(s)$rename\n" . $herecurr);
7607 } else {
7608 WARN("DEVICE_ATTR_PERMS",
7609 "DEVICE_ATTR unusual permissions '$perms' used\n" . $herecurr);
7610 }
7611 }
7612
7613 # Mode permission misuses where it seems decimal should be octal
7614 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
7615 # o Ignore module_param*(...) uses with a decimal 0 permission as that has a
7616 # specific definition of not visible in sysfs.
7617 # o Ignore proc_create*(...) uses with a decimal 0 permission as that means
7618 # use the default permissions
7619 if ($perl_version_ok &&
7620 defined $stat &&
7621 $line =~ /$mode_perms_search/) {
7622 foreach my $entry (@mode_permission_funcs) {
7623 my $func = $entry->[0];
7624 my $arg_pos = $entry->[1];
7625
7626 my $lc = $stat =~ tr@\n@@;
7627 $lc = $lc + $linenr;
7628 my $stat_real = get_stat_real($linenr, $lc);
7629
7630 my $skip_args = "";
7631 if ($arg_pos > 1) {
7632 $arg_pos--;
7633 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
7634 }
7635 my $test = "\\b$func\\s*\\(${skip_args}($FuncArg(?:\\|\\s*$FuncArg)*)\\s*[,\\)]";
7636 if ($stat =~ /$test/) {
7637 my $val = $1;
7638 $val = $6 if ($skip_args ne "");
7639 if (!($func =~ /^(?:module_param|proc_create)/ && $val eq "0") &&
7640 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
7641 ($val =~ /^$Octal$/ && length($val) ne 4))) {
7642 ERROR("NON_OCTAL_PERMISSIONS",
7643 "Use 4 digit octal (0777) not decimal permissions\n" . "$here\n" . $stat_real);
7644 }
7645 if ($val =~ /^$Octal$/ && (oct($val) & 02)) {
7646 ERROR("EXPORTED_WORLD_WRITABLE",
7647 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . "$here\n" . $stat_real);
7648 }
7649 }
7650 }
7651 }
7652
7653 # check for uses of S_<PERMS> that could be octal for readability
7654 while ($line =~ m{\b($multi_mode_perms_string_search)\b}g) {
7655 my $oval = $1;
7656 my $octal = perms_to_octal($oval);
7657 if (WARN("SYMBOLIC_PERMS",
7658 "Symbolic permissions '$oval' are not preferred. Consider using octal permissions '$octal'.\n" . $herecurr) &&
7659 $fix) {
7660 $fixed[$fixlinenr] =~ s/\Q$oval\E/$octal/;
7661 }
7662 }
7663
7664 # validate content of MODULE_LICENSE against list from include/linux/module.h
7665 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
7666 my $extracted_string = get_quoted_string($line, $rawline);
7667 my $valid_licenses = qr{
7668 GPL|
7669 GPL\ v2|
7670 GPL\ and\ additional\ rights|
7671 Dual\ BSD/GPL|
7672 Dual\ MIT/GPL|
7673 Dual\ MPL/GPL|
7674 Proprietary
7675 }x;
7676 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
7677 WARN("MODULE_LICENSE",
7678 "unknown module license " . $extracted_string . "\n" . $herecurr);
7679 }
7680 if (!$file && $extracted_string eq '"GPL v2"') {
7681 if (WARN("MODULE_LICENSE",
7682 "Prefer \"GPL\" over \"GPL v2\" - see commit bf7fbeeae6db (\"module: Cure the MODULE_LICENSE \"GPL\" vs. \"GPL v2\" bogosity\")\n" . $herecurr) &&
7683 $fix) {
7684 $fixed[$fixlinenr] =~ s/\bMODULE_LICENSE\s*\(\s*"GPL v2"\s*\)/MODULE_LICENSE("GPL")/;
7685 }
7686 }
7687 }
7688
7689 # check for sysctl duplicate constants
7690 if ($line =~ /\.extra[12]\s*=\s*&(zero|one|int_max)\b/) {
7691 WARN("DUPLICATED_SYSCTL_CONST",
7692 "duplicated sysctl range checking value '$1', consider using the shared one in include/linux/sysctl.h\n" . $herecurr);
7693 }
7694 }
7695
7696 # If we have no input at all, then there is nothing to report on
7697 # so just keep quiet.
7698 if ($#rawlines == -1) {
7699 exit(0);
7700 }
7701
7702 # In mailback mode only produce a report in the negative, for
7703 # things that appear to be patches.
7704 if ($mailback && ($clean == 1 || !$is_patch)) {
7705 exit(0);
7706 }
7707
7708 # This is not a patch, and we are in 'no-patch' mode so
7709 # just keep quiet.
7710 if (!$chk_patch && !$is_patch) {
7711 exit(0);
7712 }
7713
7714 if (!$is_patch && $filename !~ /cover-letter\.patch$/) {
7715 ERROR("NOT_UNIFIED_DIFF",
7716 "Does not appear to be a unified-diff format patch\n");
7717 }
7718 if ($is_patch && $has_commit_log && $chk_fixes_tag) {
7719 if ($needs_fixes_tag ne "" && !$is_revert && !$fixes_tag) {
7720 WARN("MISSING_FIXES_TAG",
7721 "The commit message has '$needs_fixes_tag', perhaps it also needs a 'Fixes:' tag?\n");
7722 }
7723 }
7724 if ($is_patch && $has_commit_log && $chk_signoff) {
7725 if ($signoff == 0) {
7726 ERROR("MISSING_SIGN_OFF",
7727 "Missing Signed-off-by: line(s)\n");
7728 } elsif ($authorsignoff != 1) {
7729 # authorsignoff values:
7730 # 0 -> missing sign off
7731 # 1 -> sign off identical
7732 # 2 -> names and addresses match, comments mismatch
7733 # 3 -> addresses match, names different
7734 # 4 -> names match, addresses different
7735 # 5 -> names match, addresses excluding subaddress details (refer RFC 5233) match
7736
7737 my $sob_msg = "'From: $author' != 'Signed-off-by: $author_sob'";
7738
7739 if ($authorsignoff == 0) {
7740 ERROR("NO_AUTHOR_SIGN_OFF",
7741 "Missing Signed-off-by: line by nominal patch author '$author'\n");
7742 } elsif ($authorsignoff == 2) {
7743 CHK("FROM_SIGN_OFF_MISMATCH",
7744 "From:/Signed-off-by: email comments mismatch: $sob_msg\n");
7745 } elsif ($authorsignoff == 3) {
7746 WARN("FROM_SIGN_OFF_MISMATCH",
7747 "From:/Signed-off-by: email name mismatch: $sob_msg\n");
7748 } elsif ($authorsignoff == 4) {
7749 WARN("FROM_SIGN_OFF_MISMATCH",
7750 "From:/Signed-off-by: email address mismatch: $sob_msg\n");
7751 } elsif ($authorsignoff == 5) {
7752 WARN("FROM_SIGN_OFF_MISMATCH",
7753 "From:/Signed-off-by: email subaddress mismatch: $sob_msg\n");
7754 }
7755 }
7756 }
7757
7758 print report_dump();
7759 if ($summary && !($clean == 1 && $quiet == 1)) {
7760 print "$filename " if ($summary_file);
7761 print "total: $cnt_error errors, $cnt_warn warnings, " .
7762 (($check)? "$cnt_chk checks, " : "") .
7763 "$cnt_lines lines checked\n";
7764 }
7765
7766 if ($quiet == 0) {
7767 # If there were any defects found and not already fixing them
7768 if (!$clean and !$fix) {
7769 print << "EOM"
7770
7771 NOTE: For some of the reported defects, checkpatch may be able to
7772 mechanically convert to the typical style using --fix or --fix-inplace.
7773 EOM
7774 }
7775 # If there were whitespace errors which cleanpatch can fix
7776 # then suggest that.
7777 if ($rpt_cleaners) {
7778 $rpt_cleaners = 0;
7779 print << "EOM"
7780
7781 NOTE: Whitespace errors detected.
7782 You may wish to use scripts/cleanpatch or scripts/cleanfile
7783 EOM
7784 }
7785 }
7786
7787 if ($clean == 0 && $fix &&
7788 ("@rawlines" ne "@fixed" ||
7789 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
7790 my $newfile = $filename;
7791 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
7792 my $linecount = 0;
7793 my $f;
7794
7795 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
7796
7797 open($f, '>', $newfile)
7798 or die "$P: Can't open $newfile for write\n";
7799 foreach my $fixed_line (@fixed) {
7800 $linecount++;
7801 if ($file) {
7802 if ($linecount > 3) {
7803 $fixed_line =~ s/^\+//;
7804 print $f $fixed_line . "\n";
7805 }
7806 } else {
7807 print $f $fixed_line . "\n";
7808 }
7809 }
7810 close($f);
7811
7812 if (!$quiet) {
7813 print << "EOM";
7814
7815 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
7816
7817 Do _NOT_ trust the results written to this file.
7818 Do _NOT_ submit these changes without inspecting them for correctness.
7819
7820 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
7821 No warranties, expressed or implied...
7822 EOM
7823 }
7824 }
7825
7826 if ($quiet == 0) {
7827 print "\n";
7828 if ($clean == 1) {
7829 print "$vname has no obvious style problems and is ready for submission.\n";
7830 } else {
7831 print "$vname has style problems, please review.\n";
7832 }
7833 }
7834 return $clean;
7835 }
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.