projects/linux·blob v4.16 · refs

6547 lines · 190.4 KiB

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