blob: 3fed5e4694f8aec4cd9d074f423f331d142332dc [file] [log] [blame]
Joe Hershberger05622192011-10-18 10:06:59 +00001#!/usr/bin/perl -w
2# (c) 2001, Dave Jones. (the file handling bit)
3# (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4# (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
5# (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
6# Licensed under the terms of the GNU GPL License version 2
7
8use strict;
Tom Rini6b9709d2014-02-27 08:27:28 -05009use POSIX;
Joe Hershberger05622192011-10-18 10:06:59 +000010
11my $P = $0;
12$P =~ s@.*/@@g;
13
14my $V = '0.32';
15
16use Getopt::Long qw(:config no_auto_abbrev);
17
18my $quiet = 0;
19my $tree = 1;
20my $chk_signoff = 1;
21my $chk_patch = 1;
22my $tst_only;
23my $emacs = 0;
24my $terse = 0;
25my $file = 0;
26my $check = 0;
27my $summary = 1;
28my $mailback = 0;
29my $summary_file = 0;
30my $show_types = 0;
Tom Rini6b9709d2014-02-27 08:27:28 -050031my $fix = 0;
32my $fix_inplace = 0;
Joe Hershberger05622192011-10-18 10:06:59 +000033my $root;
34my %debug;
Tom Rini6b9709d2014-02-27 08:27:28 -050035my %camelcase = ();
36my %use_type = ();
37my @use = ();
Joe Hershberger05622192011-10-18 10:06:59 +000038my %ignore_type = ();
39my @ignore = ();
40my $help = 0;
41my $configuration_file = ".checkpatch.conf";
Kim Phillipsd45a6ae2013-02-28 12:53:52 +000042my $max_line_length = 80;
Tom Rini6b9709d2014-02-27 08:27:28 -050043my $ignore_perl_version = 0;
44my $minimum_perl_version = 5.10.0;
Joe Hershberger05622192011-10-18 10:06:59 +000045
46sub help {
47 my ($exitcode) = @_;
48
49 print << "EOM";
50Usage: $P [OPTION]... [FILE]...
51Version: $V
52
53Options:
54 -q, --quiet quiet
55 --no-tree run without a kernel tree
56 --no-signoff do not check for 'Signed-off-by' line
57 --patch treat FILE as patchfile (default)
58 --emacs emacs compile window format
59 --terse one line per report
60 -f, --file treat FILE as regular source file
61 --subjective, --strict enable more subjective tests
Tom Rini6b9709d2014-02-27 08:27:28 -050062 --types TYPE(,TYPE2...) show only these comma separated message types
Joe Hershberger05622192011-10-18 10:06:59 +000063 --ignore TYPE(,TYPE2...) ignore various comma separated message types
Kim Phillipsd45a6ae2013-02-28 12:53:52 +000064 --max-line-length=n set the maximum line length, if exceeded, warn
Joe Hershberger05622192011-10-18 10:06:59 +000065 --show-types show the message "types" in the output
66 --root=PATH PATH to the kernel tree root
67 --no-summary suppress the per-file summary
68 --mailback only produce a report in case of warnings/errors
69 --summary-file include the filename in summary
70 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
71 'values', 'possible', 'type', and 'attr' (default
72 is all off)
73 --test-only=WORD report only warnings/errors containing WORD
74 literally
Tom Rini6b9709d2014-02-27 08:27:28 -050075 --fix EXPERIMENTAL - may create horrible results
76 If correctable single-line errors exist, create
77 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
78 with potential errors corrected to the preferred
79 checkpatch style
80 --fix-inplace EXPERIMENTAL - may create horrible results
81 Is the same as --fix, but overwrites the input
82 file. It's your fault if there's no backup or git
83 --ignore-perl-version override checking of perl version. expect
84 runtime errors.
Joe Hershberger05622192011-10-18 10:06:59 +000085 -h, --help, --version display this help and exit
86
87When FILE is - read standard input.
88EOM
89
90 exit($exitcode);
91}
92
93my $conf = which_conf($configuration_file);
94if (-f $conf) {
95 my @conf_args;
96 open(my $conffile, '<', "$conf")
97 or warn "$P: Can't find a readable $configuration_file file $!\n";
98
99 while (<$conffile>) {
100 my $line = $_;
101
102 $line =~ s/\s*\n?$//g;
103 $line =~ s/^\s*//g;
104 $line =~ s/\s+/ /g;
105
106 next if ($line =~ m/^\s*#/);
107 next if ($line =~ m/^\s*$/);
108
109 my @words = split(" ", $line);
110 foreach my $word (@words) {
111 last if ($word =~ m/^#/);
112 push (@conf_args, $word);
113 }
114 }
115 close($conffile);
116 unshift(@ARGV, @conf_args) if @conf_args;
117}
118
119GetOptions(
120 'q|quiet+' => \$quiet,
121 'tree!' => \$tree,
122 'signoff!' => \$chk_signoff,
123 'patch!' => \$chk_patch,
124 'emacs!' => \$emacs,
125 'terse!' => \$terse,
126 'f|file!' => \$file,
127 'subjective!' => \$check,
128 'strict!' => \$check,
129 'ignore=s' => \@ignore,
Tom Rini6b9709d2014-02-27 08:27:28 -0500130 'types=s' => \@use,
Joe Hershberger05622192011-10-18 10:06:59 +0000131 'show-types!' => \$show_types,
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000132 'max-line-length=i' => \$max_line_length,
Joe Hershberger05622192011-10-18 10:06:59 +0000133 'root=s' => \$root,
134 'summary!' => \$summary,
135 'mailback!' => \$mailback,
136 'summary-file!' => \$summary_file,
Tom Rini6b9709d2014-02-27 08:27:28 -0500137 'fix!' => \$fix,
138 'fix-inplace!' => \$fix_inplace,
139 'ignore-perl-version!' => \$ignore_perl_version,
Joe Hershberger05622192011-10-18 10:06:59 +0000140 'debug=s' => \%debug,
141 'test-only=s' => \$tst_only,
142 'h|help' => \$help,
143 'version' => \$help
144) or help(1);
145
146help(0) if ($help);
147
Tom Rini6b9709d2014-02-27 08:27:28 -0500148$fix = 1 if ($fix_inplace);
149
Joe Hershberger05622192011-10-18 10:06:59 +0000150my $exit = 0;
151
Tom Rini6b9709d2014-02-27 08:27:28 -0500152if ($^V && $^V lt $minimum_perl_version) {
153 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
154 if (!$ignore_perl_version) {
155 exit(1);
156 }
157}
158
Joe Hershberger05622192011-10-18 10:06:59 +0000159if ($#ARGV < 0) {
160 print "$P: no input files\n";
161 exit(1);
162}
163
Tom Rini6b9709d2014-02-27 08:27:28 -0500164sub hash_save_array_words {
165 my ($hashRef, $arrayRef) = @_;
Joe Hershberger05622192011-10-18 10:06:59 +0000166
Tom Rini6b9709d2014-02-27 08:27:28 -0500167 my @array = split(/,/, join(',', @$arrayRef));
168 foreach my $word (@array) {
169 $word =~ s/\s*\n?$//g;
170 $word =~ s/^\s*//g;
171 $word =~ s/\s+/ /g;
172 $word =~ tr/[a-z]/[A-Z]/;
Joe Hershberger05622192011-10-18 10:06:59 +0000173
Tom Rini6b9709d2014-02-27 08:27:28 -0500174 next if ($word =~ m/^\s*#/);
175 next if ($word =~ m/^\s*$/);
176
177 $hashRef->{$word}++;
178 }
Joe Hershberger05622192011-10-18 10:06:59 +0000179}
180
Tom Rini6b9709d2014-02-27 08:27:28 -0500181sub hash_show_words {
182 my ($hashRef, $prefix) = @_;
183
184 if ($quiet == 0 && keys %$hashRef) {
185 print "NOTE: $prefix message types:";
186 foreach my $word (sort keys %$hashRef) {
187 print " $word";
188 }
189 print "\n\n";
190 }
191}
192
193hash_save_array_words(\%ignore_type, \@ignore);
194hash_save_array_words(\%use_type, \@use);
195
Joe Hershberger05622192011-10-18 10:06:59 +0000196my $dbg_values = 0;
197my $dbg_possible = 0;
198my $dbg_type = 0;
199my $dbg_attr = 0;
200for my $key (keys %debug) {
201 ## no critic
202 eval "\${dbg_$key} = '$debug{$key}';";
203 die "$@" if ($@);
204}
205
206my $rpt_cleaners = 0;
207
208if ($terse) {
209 $emacs = 1;
210 $quiet++;
211}
212
213if ($tree) {
214 if (defined $root) {
215 if (!top_of_kernel_tree($root)) {
216 die "$P: $root: --root does not point at a valid tree\n";
217 }
218 } else {
219 if (top_of_kernel_tree('.')) {
220 $root = '.';
221 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
222 top_of_kernel_tree($1)) {
223 $root = $1;
224 }
225 }
226
227 if (!defined $root) {
228 print "Must be run from the top-level dir. of a kernel tree\n";
229 exit(2);
230 }
231}
232
233my $emitted_corrupt = 0;
234
235our $Ident = qr{
236 [A-Za-z_][A-Za-z\d_]*
237 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
238 }x;
239our $Storage = qr{extern|static|asmlinkage};
240our $Sparse = qr{
241 __user|
242 __kernel|
243 __force|
244 __iomem|
245 __must_check|
246 __init_refok|
247 __kprobes|
248 __ref|
249 __rcu
250 }x;
Tom Rini6b9709d2014-02-27 08:27:28 -0500251our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
252our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
253our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
254our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
255our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
Joe Hershberger05622192011-10-18 10:06:59 +0000256
257# Notes to $Attribute:
258# We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
259our $Attribute = qr{
260 const|
261 __percpu|
262 __nocast|
263 __safe|
264 __bitwise__|
265 __packed__|
266 __packed2__|
267 __naked|
268 __maybe_unused|
269 __always_unused|
270 __noreturn|
271 __used|
272 __cold|
273 __noclone|
274 __deprecated|
275 __read_mostly|
276 __kprobes|
Tom Rini6b9709d2014-02-27 08:27:28 -0500277 $InitAttribute|
Joe Hershberger05622192011-10-18 10:06:59 +0000278 ____cacheline_aligned|
279 ____cacheline_aligned_in_smp|
280 ____cacheline_internodealigned_in_smp|
281 __weak
282 }x;
283our $Modifier;
284our $Inline = qr{inline|__always_inline|noinline};
285our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
286our $Lval = qr{$Ident(?:$Member)*};
287
Tom Rini6b9709d2014-02-27 08:27:28 -0500288our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
289our $Binary = qr{(?i)0b[01]+$Int_type?};
290our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
291our $Int = qr{[0-9]+$Int_type?};
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000292our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
293our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
294our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
295our $Float = qr{$Float_hex|$Float_dec|$Float_int};
Tom Rini6b9709d2014-02-27 08:27:28 -0500296our $Constant = qr{$Float|$Binary|$Hex|$Int};
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000297our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
Joe Hershberger05622192011-10-18 10:06:59 +0000298our $Compare = qr{<=|>=|==|!=|<|>};
Tom Rini6b9709d2014-02-27 08:27:28 -0500299our $Arithmetic = qr{\+|-|\*|\/|%};
Joe Hershberger05622192011-10-18 10:06:59 +0000300our $Operators = qr{
301 <=|>=|==|!=|
302 =>|->|<<|>>|<|>|!|~|
Tom Rini6b9709d2014-02-27 08:27:28 -0500303 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
Joe Hershberger05622192011-10-18 10:06:59 +0000304 }x;
305
306our $NonptrType;
Tom Rini6b9709d2014-02-27 08:27:28 -0500307our $NonptrTypeWithAttr;
Joe Hershberger05622192011-10-18 10:06:59 +0000308our $Type;
309our $Declare;
310
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000311our $NON_ASCII_UTF8 = qr{
312 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
Joe Hershberger05622192011-10-18 10:06:59 +0000313 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
314 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
315 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
316 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
317 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
318 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
319}x;
320
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000321our $UTF8 = qr{
322 [\x09\x0A\x0D\x20-\x7E] # ASCII
323 | $NON_ASCII_UTF8
324}x;
325
Joe Hershberger05622192011-10-18 10:06:59 +0000326our $typeTypedefs = qr{(?x:
327 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
328 atomic_t
329)};
330
331our $logFunctions = qr{(?x:
332 printk(?:_ratelimited|_once|)|
Tom Rini6b9709d2014-02-27 08:27:28 -0500333 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
Joe Hershberger05622192011-10-18 10:06:59 +0000334 WARN(?:_RATELIMIT|_ONCE|)|
335 panic|
Tom Rini0cab4212013-03-14 05:36:13 +0000336 debug|
Tom Rini397bfd42013-06-06 09:28:19 -0400337 printf|
Tom Rini6b9709d2014-02-27 08:27:28 -0500338 puts|
339 MODULE_[A-Z_]+|
340 seq_vprintf|seq_printf|seq_puts
Joe Hershberger05622192011-10-18 10:06:59 +0000341)};
342
343our $signature_tags = qr{(?xi:
344 Signed-off-by:|
345 Acked-by:|
346 Tested-by:|
347 Reviewed-by:|
348 Reported-by:|
Tom Rini6b9709d2014-02-27 08:27:28 -0500349 Suggested-by:|
Joe Hershberger05622192011-10-18 10:06:59 +0000350 To:|
351 Cc:
352)};
353
354our @typeList = (
355 qr{void},
356 qr{(?:unsigned\s+)?char},
357 qr{(?:unsigned\s+)?short},
358 qr{(?:unsigned\s+)?int},
359 qr{(?:unsigned\s+)?long},
360 qr{(?:unsigned\s+)?long\s+int},
361 qr{(?:unsigned\s+)?long\s+long},
362 qr{(?:unsigned\s+)?long\s+long\s+int},
363 qr{unsigned},
364 qr{float},
365 qr{double},
366 qr{bool},
367 qr{struct\s+$Ident},
368 qr{union\s+$Ident},
369 qr{enum\s+$Ident},
370 qr{${Ident}_t},
371 qr{${Ident}_handler},
372 qr{${Ident}_handler_fn},
373);
Tom Rini6b9709d2014-02-27 08:27:28 -0500374our @typeListWithAttr = (
375 @typeList,
376 qr{struct\s+$InitAttribute\s+$Ident},
377 qr{union\s+$InitAttribute\s+$Ident},
378);
379
Joe Hershberger05622192011-10-18 10:06:59 +0000380our @modifierList = (
381 qr{fastcall},
382);
383
384our $allowed_asm_includes = qr{(?x:
385 irq|
386 memory
387)};
388# memory.h: ARM has a custom one
389
390sub build_types {
391 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
392 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
Tom Rini6b9709d2014-02-27 08:27:28 -0500393 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
Joe Hershberger05622192011-10-18 10:06:59 +0000394 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
395 $NonptrType = qr{
396 (?:$Modifier\s+|const\s+)*
397 (?:
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000398 (?:typeof|__typeof__)\s*\([^\)]*\)|
Joe Hershberger05622192011-10-18 10:06:59 +0000399 (?:$typeTypedefs\b)|
400 (?:${all}\b)
401 )
402 (?:\s+$Modifier|\s+const)*
403 }x;
Tom Rini6b9709d2014-02-27 08:27:28 -0500404 $NonptrTypeWithAttr = qr{
405 (?:$Modifier\s+|const\s+)*
406 (?:
407 (?:typeof|__typeof__)\s*\([^\)]*\)|
408 (?:$typeTypedefs\b)|
409 (?:${allWithAttr}\b)
410 )
411 (?:\s+$Modifier|\s+const)*
412 }x;
Joe Hershberger05622192011-10-18 10:06:59 +0000413 $Type = qr{
414 $NonptrType
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000415 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*|\[\])+|(?:\s*\[\s*\])+)?
Joe Hershberger05622192011-10-18 10:06:59 +0000416 (?:\s+$Inline|\s+$Modifier)*
417 }x;
418 $Declare = qr{(?:$Storage\s+)?$Type};
419}
420build_types();
421
Joe Hershberger05622192011-10-18 10:06:59 +0000422our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000423
424# Using $balanced_parens, $LvalOrFunc, or $FuncArg
425# requires at least perl version v5.10.0
426# Any use must be runtime checked with $^V
427
428our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
429our $LvalOrFunc = qr{($Lval)\s*($balanced_parens{0,1})\s*};
430our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
Joe Hershberger05622192011-10-18 10:06:59 +0000431
432sub deparenthesize {
433 my ($string) = @_;
434 return "" if (!defined($string));
435 $string =~ s@^\s*\(\s*@@g;
436 $string =~ s@\s*\)\s*$@@g;
437 $string =~ s@\s+@ @g;
438 return $string;
439}
440
Tom Rini6b9709d2014-02-27 08:27:28 -0500441sub seed_camelcase_file {
442 my ($file) = @_;
443
444 return if (!(-f $file));
445
446 local $/;
447
448 open(my $include_file, '<', "$file")
449 or warn "$P: Can't read '$file' $!\n";
450 my $text = <$include_file>;
451 close($include_file);
452
453 my @lines = split('\n', $text);
454
455 foreach my $line (@lines) {
456 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
457 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
458 $camelcase{$1} = 1;
459 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
460 $camelcase{$1} = 1;
461 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
462 $camelcase{$1} = 1;
463 }
464 }
465}
466
467my $camelcase_seeded = 0;
468sub seed_camelcase_includes {
469 return if ($camelcase_seeded);
470
471 my $files;
472 my $camelcase_cache = "";
473 my @include_files = ();
474
475 $camelcase_seeded = 1;
476
477 if (-e ".git") {
478 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
479 chomp $git_last_include_commit;
480 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
481 } else {
482 my $last_mod_date = 0;
483 $files = `find $root/include -name "*.h"`;
484 @include_files = split('\n', $files);
485 foreach my $file (@include_files) {
486 my $date = POSIX::strftime("%Y%m%d%H%M",
487 localtime((stat $file)[9]));
488 $last_mod_date = $date if ($last_mod_date < $date);
489 }
490 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
491 }
492
493 if ($camelcase_cache ne "" && -f $camelcase_cache) {
494 open(my $camelcase_file, '<', "$camelcase_cache")
495 or warn "$P: Can't read '$camelcase_cache' $!\n";
496 while (<$camelcase_file>) {
497 chomp;
498 $camelcase{$_} = 1;
499 }
500 close($camelcase_file);
501
502 return;
503 }
504
505 if (-e ".git") {
506 $files = `git ls-files "include/*.h"`;
507 @include_files = split('\n', $files);
508 }
509
510 foreach my $file (@include_files) {
511 seed_camelcase_file($file);
512 }
513
514 if ($camelcase_cache ne "") {
515 unlink glob ".checkpatch-camelcase.*";
516 open(my $camelcase_file, '>', "$camelcase_cache")
517 or warn "$P: Can't write '$camelcase_cache' $!\n";
518 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
519 print $camelcase_file ("$_\n");
520 }
521 close($camelcase_file);
522 }
523}
524
Joe Hershberger05622192011-10-18 10:06:59 +0000525$chk_signoff = 0 if ($file);
526
Joe Hershberger05622192011-10-18 10:06:59 +0000527my @rawlines = ();
528my @lines = ();
Tom Rini6b9709d2014-02-27 08:27:28 -0500529my @fixed = ();
Joe Hershberger05622192011-10-18 10:06:59 +0000530my $vname;
531for my $filename (@ARGV) {
532 my $FILE;
533 if ($file) {
534 open($FILE, '-|', "diff -u /dev/null $filename") ||
535 die "$P: $filename: diff failed - $!\n";
536 } elsif ($filename eq '-') {
537 open($FILE, '<&STDIN');
538 } else {
539 open($FILE, '<', "$filename") ||
540 die "$P: $filename: open failed - $!\n";
541 }
542 if ($filename eq '-') {
543 $vname = 'Your patch';
544 } else {
545 $vname = $filename;
546 }
547 while (<$FILE>) {
548 chomp;
549 push(@rawlines, $_);
550 }
551 close($FILE);
552 if (!process($filename)) {
553 $exit = 1;
554 }
555 @rawlines = ();
556 @lines = ();
Tom Rini6b9709d2014-02-27 08:27:28 -0500557 @fixed = ();
Joe Hershberger05622192011-10-18 10:06:59 +0000558}
559
560exit($exit);
561
562sub top_of_kernel_tree {
563 my ($root) = @_;
564
565 my @tree_check = (
Tom Rini6b9709d2014-02-27 08:27:28 -0500566 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
Joe Hershberger05622192011-10-18 10:06:59 +0000567 "README", "Documentation", "arch", "include", "drivers",
568 "fs", "init", "ipc", "kernel", "lib", "scripts",
569 );
570
571 foreach my $check (@tree_check) {
572 if (! -e $root . '/' . $check) {
573 return 0;
574 }
575 }
576 return 1;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000577}
Joe Hershberger05622192011-10-18 10:06:59 +0000578
579sub parse_email {
580 my ($formatted_email) = @_;
581
582 my $name = "";
583 my $address = "";
584 my $comment = "";
585
586 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
587 $name = $1;
588 $address = $2;
589 $comment = $3 if defined $3;
590 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
591 $address = $1;
592 $comment = $2 if defined $2;
593 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
594 $address = $1;
595 $comment = $2 if defined $2;
596 $formatted_email =~ s/$address.*$//;
597 $name = $formatted_email;
Tom Rini6b9709d2014-02-27 08:27:28 -0500598 $name = trim($name);
Joe Hershberger05622192011-10-18 10:06:59 +0000599 $name =~ s/^\"|\"$//g;
600 # If there's a name left after stripping spaces and
601 # leading quotes, and the address doesn't have both
602 # leading and trailing angle brackets, the address
603 # is invalid. ie:
604 # "joe smith joe@smith.com" bad
605 # "joe smith <joe@smith.com" bad
606 if ($name ne "" && $address !~ /^<[^>]+>$/) {
607 $name = "";
608 $address = "";
609 $comment = "";
610 }
611 }
612
Tom Rini6b9709d2014-02-27 08:27:28 -0500613 $name = trim($name);
Joe Hershberger05622192011-10-18 10:06:59 +0000614 $name =~ s/^\"|\"$//g;
Tom Rini6b9709d2014-02-27 08:27:28 -0500615 $address = trim($address);
Joe Hershberger05622192011-10-18 10:06:59 +0000616 $address =~ s/^\<|\>$//g;
617
618 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
619 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
620 $name = "\"$name\"";
621 }
622
623 return ($name, $address, $comment);
624}
625
626sub format_email {
627 my ($name, $address) = @_;
628
629 my $formatted_email;
630
Tom Rini6b9709d2014-02-27 08:27:28 -0500631 $name = trim($name);
Joe Hershberger05622192011-10-18 10:06:59 +0000632 $name =~ s/^\"|\"$//g;
Tom Rini6b9709d2014-02-27 08:27:28 -0500633 $address = trim($address);
Joe Hershberger05622192011-10-18 10:06:59 +0000634
635 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
636 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
637 $name = "\"$name\"";
638 }
639
640 if ("$name" eq "") {
641 $formatted_email = "$address";
642 } else {
643 $formatted_email = "$name <$address>";
644 }
645
646 return $formatted_email;
647}
648
649sub which_conf {
650 my ($conf) = @_;
651
652 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
653 if (-e "$path/$conf") {
654 return "$path/$conf";
655 }
656 }
657
658 return "";
659}
660
661sub expand_tabs {
662 my ($str) = @_;
663
664 my $res = '';
665 my $n = 0;
666 for my $c (split(//, $str)) {
667 if ($c eq "\t") {
668 $res .= ' ';
669 $n++;
670 for (; ($n % 8) != 0; $n++) {
671 $res .= ' ';
672 }
673 next;
674 }
675 $res .= $c;
676 $n++;
677 }
678
679 return $res;
680}
681sub copy_spacing {
682 (my $res = shift) =~ tr/\t/ /c;
683 return $res;
684}
685
686sub line_stats {
687 my ($line) = @_;
688
689 # Drop the diff line leader and expand tabs
690 $line =~ s/^.//;
691 $line = expand_tabs($line);
692
693 # Pick the indent from the front of the line.
694 my ($white) = ($line =~ /^(\s*)/);
695
696 return (length($line), length($white));
697}
698
699my $sanitise_quote = '';
700
701sub sanitise_line_reset {
702 my ($in_comment) = @_;
703
704 if ($in_comment) {
705 $sanitise_quote = '*/';
706 } else {
707 $sanitise_quote = '';
708 }
709}
710sub sanitise_line {
711 my ($line) = @_;
712
713 my $res = '';
714 my $l = '';
715
716 my $qlen = 0;
717 my $off = 0;
718 my $c;
719
720 # Always copy over the diff marker.
721 $res = substr($line, 0, 1);
722
723 for ($off = 1; $off < length($line); $off++) {
724 $c = substr($line, $off, 1);
725
726 # Comments we are wacking completly including the begin
727 # and end, all to $;.
728 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
729 $sanitise_quote = '*/';
730
731 substr($res, $off, 2, "$;$;");
732 $off++;
733 next;
734 }
735 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
736 $sanitise_quote = '';
737 substr($res, $off, 2, "$;$;");
738 $off++;
739 next;
740 }
741 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
742 $sanitise_quote = '//';
743
744 substr($res, $off, 2, $sanitise_quote);
745 $off++;
746 next;
747 }
748
749 # A \ in a string means ignore the next character.
750 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
751 $c eq "\\") {
752 substr($res, $off, 2, 'XX');
753 $off++;
754 next;
755 }
756 # Regular quotes.
757 if ($c eq "'" || $c eq '"') {
758 if ($sanitise_quote eq '') {
759 $sanitise_quote = $c;
760
761 substr($res, $off, 1, $c);
762 next;
763 } elsif ($sanitise_quote eq $c) {
764 $sanitise_quote = '';
765 }
766 }
767
768 #print "c<$c> SQ<$sanitise_quote>\n";
769 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
770 substr($res, $off, 1, $;);
771 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
772 substr($res, $off, 1, $;);
773 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
774 substr($res, $off, 1, 'X');
775 } else {
776 substr($res, $off, 1, $c);
777 }
778 }
779
780 if ($sanitise_quote eq '//') {
781 $sanitise_quote = '';
782 }
783
784 # The pathname on a #include may be surrounded by '<' and '>'.
785 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
786 my $clean = 'X' x length($1);
787 $res =~ s@\<.*\>@<$clean>@;
788
789 # The whole of a #error is a string.
790 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
791 my $clean = 'X' x length($1);
792 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
793 }
794
795 return $res;
796}
797
Tom Rini6b9709d2014-02-27 08:27:28 -0500798sub get_quoted_string {
799 my ($line, $rawline) = @_;
800
801 return "" if ($line !~ m/(\"[X]+\")/g);
802 return substr($rawline, $-[0], $+[0] - $-[0]);
803}
804
Joe Hershberger05622192011-10-18 10:06:59 +0000805sub ctx_statement_block {
806 my ($linenr, $remain, $off) = @_;
807 my $line = $linenr - 1;
808 my $blk = '';
809 my $soff = $off;
810 my $coff = $off - 1;
811 my $coff_set = 0;
812
813 my $loff = 0;
814
815 my $type = '';
816 my $level = 0;
817 my @stack = ();
818 my $p;
819 my $c;
820 my $len = 0;
821
822 my $remainder;
823 while (1) {
824 @stack = (['', 0]) if ($#stack == -1);
825
826 #warn "CSB: blk<$blk> remain<$remain>\n";
827 # If we are about to drop off the end, pull in more
828 # context.
829 if ($off >= $len) {
830 for (; $remain > 0; $line++) {
831 last if (!defined $lines[$line]);
832 next if ($lines[$line] =~ /^-/);
833 $remain--;
834 $loff = $len;
835 $blk .= $lines[$line] . "\n";
836 $len = length($blk);
837 $line++;
838 last;
839 }
840 # Bail if there is no further context.
841 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
842 if ($off >= $len) {
843 last;
844 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000845 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
846 $level++;
847 $type = '#';
848 }
Joe Hershberger05622192011-10-18 10:06:59 +0000849 }
850 $p = $c;
851 $c = substr($blk, $off, 1);
852 $remainder = substr($blk, $off);
853
854 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
855
856 # Handle nested #if/#else.
857 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
858 push(@stack, [ $type, $level ]);
859 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
860 ($type, $level) = @{$stack[$#stack - 1]};
861 } elsif ($remainder =~ /^#\s*endif\b/) {
862 ($type, $level) = @{pop(@stack)};
863 }
864
865 # Statement ends at the ';' or a close '}' at the
866 # outermost level.
867 if ($level == 0 && $c eq ';') {
868 last;
869 }
870
871 # An else is really a conditional as long as its not else if
872 if ($level == 0 && $coff_set == 0 &&
873 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
874 $remainder =~ /^(else)(?:\s|{)/ &&
875 $remainder !~ /^else\s+if\b/) {
876 $coff = $off + length($1) - 1;
877 $coff_set = 1;
878 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
879 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
880 }
881
882 if (($type eq '' || $type eq '(') && $c eq '(') {
883 $level++;
884 $type = '(';
885 }
886 if ($type eq '(' && $c eq ')') {
887 $level--;
888 $type = ($level != 0)? '(' : '';
889
890 if ($level == 0 && $coff < $soff) {
891 $coff = $off;
892 $coff_set = 1;
893 #warn "CSB: mark coff<$coff>\n";
894 }
895 }
896 if (($type eq '' || $type eq '{') && $c eq '{') {
897 $level++;
898 $type = '{';
899 }
900 if ($type eq '{' && $c eq '}') {
901 $level--;
902 $type = ($level != 0)? '{' : '';
903
904 if ($level == 0) {
905 if (substr($blk, $off + 1, 1) eq ';') {
906 $off++;
907 }
908 last;
909 }
910 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +0000911 # Preprocessor commands end at the newline unless escaped.
912 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
913 $level--;
914 $type = '';
915 $off++;
916 last;
917 }
Joe Hershberger05622192011-10-18 10:06:59 +0000918 $off++;
919 }
920 # We are truly at the end, so shuffle to the next line.
921 if ($off == $len) {
922 $loff = $len + 1;
923 $line++;
924 $remain--;
925 }
926
927 my $statement = substr($blk, $soff, $off - $soff + 1);
928 my $condition = substr($blk, $soff, $coff - $soff + 1);
929
930 #warn "STATEMENT<$statement>\n";
931 #warn "CONDITION<$condition>\n";
932
933 #print "coff<$coff> soff<$off> loff<$loff>\n";
934
935 return ($statement, $condition,
936 $line, $remain + 1, $off - $loff + 1, $level);
937}
938
939sub statement_lines {
940 my ($stmt) = @_;
941
942 # Strip the diff line prefixes and rip blank lines at start and end.
943 $stmt =~ s/(^|\n)./$1/g;
944 $stmt =~ s/^\s*//;
945 $stmt =~ s/\s*$//;
946
947 my @stmt_lines = ($stmt =~ /\n/g);
948
949 return $#stmt_lines + 2;
950}
951
952sub statement_rawlines {
953 my ($stmt) = @_;
954
955 my @stmt_lines = ($stmt =~ /\n/g);
956
957 return $#stmt_lines + 2;
958}
959
960sub statement_block_size {
961 my ($stmt) = @_;
962
963 $stmt =~ s/(^|\n)./$1/g;
964 $stmt =~ s/^\s*{//;
965 $stmt =~ s/}\s*$//;
966 $stmt =~ s/^\s*//;
967 $stmt =~ s/\s*$//;
968
969 my @stmt_lines = ($stmt =~ /\n/g);
970 my @stmt_statements = ($stmt =~ /;/g);
971
972 my $stmt_lines = $#stmt_lines + 2;
973 my $stmt_statements = $#stmt_statements + 1;
974
975 if ($stmt_lines > $stmt_statements) {
976 return $stmt_lines;
977 } else {
978 return $stmt_statements;
979 }
980}
981
982sub ctx_statement_full {
983 my ($linenr, $remain, $off) = @_;
984 my ($statement, $condition, $level);
985
986 my (@chunks);
987
988 # Grab the first conditional/block pair.
989 ($statement, $condition, $linenr, $remain, $off, $level) =
990 ctx_statement_block($linenr, $remain, $off);
991 #print "F: c<$condition> s<$statement> remain<$remain>\n";
992 push(@chunks, [ $condition, $statement ]);
993 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
994 return ($level, $linenr, @chunks);
995 }
996
997 # Pull in the following conditional/block pairs and see if they
998 # could continue the statement.
999 for (;;) {
1000 ($statement, $condition, $linenr, $remain, $off, $level) =
1001 ctx_statement_block($linenr, $remain, $off);
1002 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1003 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1004 #print "C: push\n";
1005 push(@chunks, [ $condition, $statement ]);
1006 }
1007
1008 return ($level, $linenr, @chunks);
1009}
1010
1011sub ctx_block_get {
1012 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1013 my $line;
1014 my $start = $linenr - 1;
1015 my $blk = '';
1016 my @o;
1017 my @c;
1018 my @res = ();
1019
1020 my $level = 0;
1021 my @stack = ($level);
1022 for ($line = $start; $remain > 0; $line++) {
1023 next if ($rawlines[$line] =~ /^-/);
1024 $remain--;
1025
1026 $blk .= $rawlines[$line];
1027
1028 # Handle nested #if/#else.
1029 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1030 push(@stack, $level);
1031 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1032 $level = $stack[$#stack - 1];
1033 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1034 $level = pop(@stack);
1035 }
1036
1037 foreach my $c (split(//, $lines[$line])) {
1038 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1039 if ($off > 0) {
1040 $off--;
1041 next;
1042 }
1043
1044 if ($c eq $close && $level > 0) {
1045 $level--;
1046 last if ($level == 0);
1047 } elsif ($c eq $open) {
1048 $level++;
1049 }
1050 }
1051
1052 if (!$outer || $level <= 1) {
1053 push(@res, $rawlines[$line]);
1054 }
1055
1056 last if ($level == 0);
1057 }
1058
1059 return ($level, @res);
1060}
1061sub ctx_block_outer {
1062 my ($linenr, $remain) = @_;
1063
1064 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1065 return @r;
1066}
1067sub ctx_block {
1068 my ($linenr, $remain) = @_;
1069
1070 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1071 return @r;
1072}
1073sub ctx_statement {
1074 my ($linenr, $remain, $off) = @_;
1075
1076 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1077 return @r;
1078}
1079sub ctx_block_level {
1080 my ($linenr, $remain) = @_;
1081
1082 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1083}
1084sub ctx_statement_level {
1085 my ($linenr, $remain, $off) = @_;
1086
1087 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1088}
1089
1090sub ctx_locate_comment {
1091 my ($first_line, $end_line) = @_;
1092
1093 # Catch a comment on the end of the line itself.
1094 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1095 return $current_comment if (defined $current_comment);
1096
1097 # Look through the context and try and figure out if there is a
1098 # comment.
1099 my $in_comment = 0;
1100 $current_comment = '';
1101 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1102 my $line = $rawlines[$linenr - 1];
1103 #warn " $line\n";
1104 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1105 $in_comment = 1;
1106 }
1107 if ($line =~ m@/\*@) {
1108 $in_comment = 1;
1109 }
1110 if (!$in_comment && $current_comment ne '') {
1111 $current_comment = '';
1112 }
1113 $current_comment .= $line . "\n" if ($in_comment);
1114 if ($line =~ m@\*/@) {
1115 $in_comment = 0;
1116 }
1117 }
1118
1119 chomp($current_comment);
1120 return($current_comment);
1121}
1122sub ctx_has_comment {
1123 my ($first_line, $end_line) = @_;
1124 my $cmt = ctx_locate_comment($first_line, $end_line);
1125
1126 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1127 ##print "CMMT: $cmt\n";
1128
1129 return ($cmt ne '');
1130}
1131
1132sub raw_line {
1133 my ($linenr, $cnt) = @_;
1134
1135 my $offset = $linenr - 1;
1136 $cnt++;
1137
1138 my $line;
1139 while ($cnt) {
1140 $line = $rawlines[$offset++];
1141 next if (defined($line) && $line =~ /^-/);
1142 $cnt--;
1143 }
1144
1145 return $line;
1146}
1147
1148sub cat_vet {
1149 my ($vet) = @_;
1150 my ($res, $coded);
1151
1152 $res = '';
1153 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1154 $res .= $1;
1155 if ($2 ne '') {
1156 $coded = sprintf("^%c", unpack('C', $2) + 64);
1157 $res .= $coded;
1158 }
1159 }
1160 $res =~ s/$/\$/;
1161
1162 return $res;
1163}
1164
1165my $av_preprocessor = 0;
1166my $av_pending;
1167my @av_paren_type;
1168my $av_pend_colon;
1169
1170sub annotate_reset {
1171 $av_preprocessor = 0;
1172 $av_pending = '_';
1173 @av_paren_type = ('E');
1174 $av_pend_colon = 'O';
1175}
1176
1177sub annotate_values {
1178 my ($stream, $type) = @_;
1179
1180 my $res;
1181 my $var = '_' x length($stream);
1182 my $cur = $stream;
1183
1184 print "$stream\n" if ($dbg_values > 1);
1185
1186 while (length($cur)) {
1187 @av_paren_type = ('E') if ($#av_paren_type < 0);
1188 print " <" . join('', @av_paren_type) .
1189 "> <$type> <$av_pending>" if ($dbg_values > 1);
1190 if ($cur =~ /^(\s+)/o) {
1191 print "WS($1)\n" if ($dbg_values > 1);
1192 if ($1 =~ /\n/ && $av_preprocessor) {
1193 $type = pop(@av_paren_type);
1194 $av_preprocessor = 0;
1195 }
1196
1197 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1198 print "CAST($1)\n" if ($dbg_values > 1);
1199 push(@av_paren_type, $type);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001200 $type = 'c';
Joe Hershberger05622192011-10-18 10:06:59 +00001201
1202 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1203 print "DECLARE($1)\n" if ($dbg_values > 1);
1204 $type = 'T';
1205
1206 } elsif ($cur =~ /^($Modifier)\s*/) {
1207 print "MODIFIER($1)\n" if ($dbg_values > 1);
1208 $type = 'T';
1209
1210 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1211 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1212 $av_preprocessor = 1;
1213 push(@av_paren_type, $type);
1214 if ($2 ne '') {
1215 $av_pending = 'N';
1216 }
1217 $type = 'E';
1218
1219 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1220 print "UNDEF($1)\n" if ($dbg_values > 1);
1221 $av_preprocessor = 1;
1222 push(@av_paren_type, $type);
1223
1224 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1225 print "PRE_START($1)\n" if ($dbg_values > 1);
1226 $av_preprocessor = 1;
1227
1228 push(@av_paren_type, $type);
1229 push(@av_paren_type, $type);
1230 $type = 'E';
1231
1232 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1233 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1234 $av_preprocessor = 1;
1235
1236 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1237
1238 $type = 'E';
1239
1240 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1241 print "PRE_END($1)\n" if ($dbg_values > 1);
1242
1243 $av_preprocessor = 1;
1244
1245 # Assume all arms of the conditional end as this
1246 # one does, and continue as if the #endif was not here.
1247 pop(@av_paren_type);
1248 push(@av_paren_type, $type);
1249 $type = 'E';
1250
1251 } elsif ($cur =~ /^(\\\n)/o) {
1252 print "PRECONT($1)\n" if ($dbg_values > 1);
1253
1254 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1255 print "ATTR($1)\n" if ($dbg_values > 1);
1256 $av_pending = $type;
1257 $type = 'N';
1258
1259 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1260 print "SIZEOF($1)\n" if ($dbg_values > 1);
1261 if (defined $2) {
1262 $av_pending = 'V';
1263 }
1264 $type = 'N';
1265
1266 } elsif ($cur =~ /^(if|while|for)\b/o) {
1267 print "COND($1)\n" if ($dbg_values > 1);
1268 $av_pending = 'E';
1269 $type = 'N';
1270
1271 } elsif ($cur =~/^(case)/o) {
1272 print "CASE($1)\n" if ($dbg_values > 1);
1273 $av_pend_colon = 'C';
1274 $type = 'N';
1275
1276 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1277 print "KEYWORD($1)\n" if ($dbg_values > 1);
1278 $type = 'N';
1279
1280 } elsif ($cur =~ /^(\()/o) {
1281 print "PAREN('$1')\n" if ($dbg_values > 1);
1282 push(@av_paren_type, $av_pending);
1283 $av_pending = '_';
1284 $type = 'N';
1285
1286 } elsif ($cur =~ /^(\))/o) {
1287 my $new_type = pop(@av_paren_type);
1288 if ($new_type ne '_') {
1289 $type = $new_type;
1290 print "PAREN('$1') -> $type\n"
1291 if ($dbg_values > 1);
1292 } else {
1293 print "PAREN('$1')\n" if ($dbg_values > 1);
1294 }
1295
1296 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1297 print "FUNC($1)\n" if ($dbg_values > 1);
1298 $type = 'V';
1299 $av_pending = 'V';
1300
1301 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1302 if (defined $2 && $type eq 'C' || $type eq 'T') {
1303 $av_pend_colon = 'B';
1304 } elsif ($type eq 'E') {
1305 $av_pend_colon = 'L';
1306 }
1307 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1308 $type = 'V';
1309
1310 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1311 print "IDENT($1)\n" if ($dbg_values > 1);
1312 $type = 'V';
1313
1314 } elsif ($cur =~ /^($Assignment)/o) {
1315 print "ASSIGN($1)\n" if ($dbg_values > 1);
1316 $type = 'N';
1317
1318 } elsif ($cur =~/^(;|{|})/) {
1319 print "END($1)\n" if ($dbg_values > 1);
1320 $type = 'E';
1321 $av_pend_colon = 'O';
1322
1323 } elsif ($cur =~/^(,)/) {
1324 print "COMMA($1)\n" if ($dbg_values > 1);
1325 $type = 'C';
1326
1327 } elsif ($cur =~ /^(\?)/o) {
1328 print "QUESTION($1)\n" if ($dbg_values > 1);
1329 $type = 'N';
1330
1331 } elsif ($cur =~ /^(:)/o) {
1332 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1333
1334 substr($var, length($res), 1, $av_pend_colon);
1335 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1336 $type = 'E';
1337 } else {
1338 $type = 'N';
1339 }
1340 $av_pend_colon = 'O';
1341
1342 } elsif ($cur =~ /^(\[)/o) {
1343 print "CLOSE($1)\n" if ($dbg_values > 1);
1344 $type = 'N';
1345
1346 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1347 my $variant;
1348
1349 print "OPV($1)\n" if ($dbg_values > 1);
1350 if ($type eq 'V') {
1351 $variant = 'B';
1352 } else {
1353 $variant = 'U';
1354 }
1355
1356 substr($var, length($res), 1, $variant);
1357 $type = 'N';
1358
1359 } elsif ($cur =~ /^($Operators)/o) {
1360 print "OP($1)\n" if ($dbg_values > 1);
1361 if ($1 ne '++' && $1 ne '--') {
1362 $type = 'N';
1363 }
1364
1365 } elsif ($cur =~ /(^.)/o) {
1366 print "C($1)\n" if ($dbg_values > 1);
1367 }
1368 if (defined $1) {
1369 $cur = substr($cur, length($1));
1370 $res .= $type x length($1);
1371 }
1372 }
1373
1374 return ($res, $var);
1375}
1376
1377sub possible {
1378 my ($possible, $line) = @_;
1379 my $notPermitted = qr{(?:
1380 ^(?:
1381 $Modifier|
1382 $Storage|
1383 $Type|
1384 DEFINE_\S+
1385 )$|
1386 ^(?:
1387 goto|
1388 return|
1389 case|
1390 else|
1391 asm|__asm__|
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001392 do|
1393 \#|
1394 \#\#|
Joe Hershberger05622192011-10-18 10:06:59 +00001395 )(?:\s|$)|
1396 ^(?:typedef|struct|enum)\b
1397 )}x;
1398 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1399 if ($possible !~ $notPermitted) {
1400 # Check for modifiers.
1401 $possible =~ s/\s*$Storage\s*//g;
1402 $possible =~ s/\s*$Sparse\s*//g;
1403 if ($possible =~ /^\s*$/) {
1404
1405 } elsif ($possible =~ /\s/) {
1406 $possible =~ s/\s*$Type\s*//g;
1407 for my $modifier (split(' ', $possible)) {
1408 if ($modifier !~ $notPermitted) {
1409 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1410 push(@modifierList, $modifier);
1411 }
1412 }
1413
1414 } else {
1415 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1416 push(@typeList, $possible);
1417 }
1418 build_types();
1419 } else {
1420 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1421 }
1422}
1423
1424my $prefix = '';
1425
1426sub show_type {
Tom Rini6b9709d2014-02-27 08:27:28 -05001427 return defined $use_type{$_[0]} if (scalar keys %use_type > 0);
1428
1429 return !defined $ignore_type{$_[0]};
Joe Hershberger05622192011-10-18 10:06:59 +00001430}
1431
1432sub report {
1433 if (!show_type($_[1]) ||
1434 (defined $tst_only && $_[2] !~ /\Q$tst_only\E/)) {
1435 return 0;
1436 }
1437 my $line;
1438 if ($show_types) {
1439 $line = "$prefix$_[0]:$_[1]: $_[2]\n";
1440 } else {
1441 $line = "$prefix$_[0]: $_[2]\n";
1442 }
1443 $line = (split('\n', $line))[0] . "\n" if ($terse);
1444
1445 push(our @report, $line);
1446
1447 return 1;
1448}
1449sub report_dump {
1450 our @report;
1451}
1452
1453sub ERROR {
1454 if (report("ERROR", $_[0], $_[1])) {
1455 our $clean = 0;
1456 our $cnt_error++;
Tom Rini6b9709d2014-02-27 08:27:28 -05001457 return 1;
Joe Hershberger05622192011-10-18 10:06:59 +00001458 }
Tom Rini6b9709d2014-02-27 08:27:28 -05001459 return 0;
Joe Hershberger05622192011-10-18 10:06:59 +00001460}
1461sub WARN {
1462 if (report("WARNING", $_[0], $_[1])) {
1463 our $clean = 0;
1464 our $cnt_warn++;
Tom Rini6b9709d2014-02-27 08:27:28 -05001465 return 1;
Joe Hershberger05622192011-10-18 10:06:59 +00001466 }
Tom Rini6b9709d2014-02-27 08:27:28 -05001467 return 0;
Joe Hershberger05622192011-10-18 10:06:59 +00001468}
1469sub CHK {
1470 if ($check && report("CHECK", $_[0], $_[1])) {
1471 our $clean = 0;
1472 our $cnt_chk++;
Tom Rini6b9709d2014-02-27 08:27:28 -05001473 return 1;
Joe Hershberger05622192011-10-18 10:06:59 +00001474 }
Tom Rini6b9709d2014-02-27 08:27:28 -05001475 return 0;
Joe Hershberger05622192011-10-18 10:06:59 +00001476}
1477
1478sub check_absolute_file {
1479 my ($absolute, $herecurr) = @_;
1480 my $file = $absolute;
1481
1482 ##print "absolute<$absolute>\n";
1483
1484 # See if any suffix of this path is a path within the tree.
1485 while ($file =~ s@^[^/]*/@@) {
1486 if (-f "$root/$file") {
1487 ##print "file<$file>\n";
1488 last;
1489 }
1490 }
1491 if (! -f _) {
1492 return 0;
1493 }
1494
1495 # It is, so see if the prefix is acceptable.
1496 my $prefix = $absolute;
1497 substr($prefix, -length($file)) = '';
1498
1499 ##print "prefix<$prefix>\n";
1500 if ($prefix ne ".../") {
1501 WARN("USE_RELATIVE_PATH",
1502 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1503 }
1504}
1505
Tom Rini6b9709d2014-02-27 08:27:28 -05001506sub trim {
1507 my ($string) = @_;
1508
1509 $string =~ s/^\s+|\s+$//g;
1510
1511 return $string;
1512}
1513
1514sub ltrim {
1515 my ($string) = @_;
1516
1517 $string =~ s/^\s+//;
1518
1519 return $string;
1520}
1521
1522sub rtrim {
1523 my ($string) = @_;
1524
1525 $string =~ s/\s+$//;
1526
1527 return $string;
1528}
1529
1530sub string_find_replace {
1531 my ($string, $find, $replace) = @_;
1532
1533 $string =~ s/$find/$replace/g;
1534
1535 return $string;
1536}
1537
1538sub tabify {
1539 my ($leading) = @_;
1540
1541 my $source_indent = 8;
1542 my $max_spaces_before_tab = $source_indent - 1;
1543 my $spaces_to_tab = " " x $source_indent;
1544
1545 #convert leading spaces to tabs
1546 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1547 #Remove spaces before a tab
1548 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1549
1550 return "$leading";
1551}
1552
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001553sub pos_last_openparen {
1554 my ($line) = @_;
1555
1556 my $pos = 0;
1557
1558 my $opens = $line =~ tr/\(/\(/;
1559 my $closes = $line =~ tr/\)/\)/;
1560
1561 my $last_openparen = 0;
1562
1563 if (($opens == 0) || ($closes >= $opens)) {
1564 return -1;
1565 }
1566
1567 my $len = length($line);
1568
1569 for ($pos = 0; $pos < $len; $pos++) {
1570 my $string = substr($line, $pos);
1571 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1572 $pos += length($1) - 1;
1573 } elsif (substr($line, $pos, 1) eq '(') {
1574 $last_openparen = $pos;
1575 } elsif (index($string, '(') == -1) {
1576 last;
1577 }
1578 }
1579
1580 return $last_openparen + 1;
1581}
1582
Joe Hershberger05622192011-10-18 10:06:59 +00001583sub process {
1584 my $filename = shift;
1585
1586 my $linenr=0;
1587 my $prevline="";
1588 my $prevrawline="";
1589 my $stashline="";
1590 my $stashrawline="";
1591
1592 my $length;
1593 my $indent;
1594 my $previndent=0;
1595 my $stashindent=0;
1596
1597 our $clean = 1;
1598 my $signoff = 0;
1599 my $is_patch = 0;
1600
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001601 my $in_header_lines = 1;
1602 my $in_commit_log = 0; #Scanning lines before patch
1603
1604 my $non_utf8_charset = 0;
1605
Joe Hershberger05622192011-10-18 10:06:59 +00001606 our @report = ();
1607 our $cnt_lines = 0;
1608 our $cnt_error = 0;
1609 our $cnt_warn = 0;
1610 our $cnt_chk = 0;
1611
1612 # Trace the real file/line as we go.
1613 my $realfile = '';
1614 my $realline = 0;
1615 my $realcnt = 0;
1616 my $here = '';
1617 my $in_comment = 0;
1618 my $comment_edge = 0;
1619 my $first_line = 0;
1620 my $p1_prefix = '';
1621
1622 my $prev_values = 'E';
1623
1624 # suppression flags
1625 my %suppress_ifbraces;
1626 my %suppress_whiletrailers;
1627 my %suppress_export;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001628 my $suppress_statement = 0;
1629
Tom Rini6b9709d2014-02-27 08:27:28 -05001630 my %signatures = ();
Joe Hershberger05622192011-10-18 10:06:59 +00001631
1632 # Pre-scan the patch sanitizing the lines.
1633 # Pre-scan the patch looking for any __setup documentation.
1634 #
1635 my @setup_docs = ();
1636 my $setup_docs = 0;
1637
Tom Rini6b9709d2014-02-27 08:27:28 -05001638 my $camelcase_file_seeded = 0;
1639
Joe Hershberger05622192011-10-18 10:06:59 +00001640 sanitise_line_reset();
1641 my $line;
1642 foreach my $rawline (@rawlines) {
1643 $linenr++;
1644 $line = $rawline;
1645
Tom Rini6b9709d2014-02-27 08:27:28 -05001646 push(@fixed, $rawline) if ($fix);
1647
Joe Hershberger05622192011-10-18 10:06:59 +00001648 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1649 $setup_docs = 0;
1650 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1651 $setup_docs = 1;
1652 }
1653 #next;
1654 }
1655 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1656 $realline=$1-1;
1657 if (defined $2) {
1658 $realcnt=$3+1;
1659 } else {
1660 $realcnt=1+1;
1661 }
1662 $in_comment = 0;
1663
1664 # Guestimate if this is a continuing comment. Run
1665 # the context looking for a comment "edge". If this
1666 # edge is a close comment then we must be in a comment
1667 # at context start.
1668 my $edge;
1669 my $cnt = $realcnt;
1670 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1671 next if (defined $rawlines[$ln - 1] &&
1672 $rawlines[$ln - 1] =~ /^-/);
1673 $cnt--;
1674 #print "RAW<$rawlines[$ln - 1]>\n";
1675 last if (!defined $rawlines[$ln - 1]);
1676 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1677 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1678 ($edge) = $1;
1679 last;
1680 }
1681 }
1682 if (defined $edge && $edge eq '*/') {
1683 $in_comment = 1;
1684 }
1685
1686 # Guestimate if this is a continuing comment. If this
1687 # is the start of a diff block and this line starts
1688 # ' *' then it is very likely a comment.
1689 if (!defined $edge &&
1690 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1691 {
1692 $in_comment = 1;
1693 }
1694
1695 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1696 sanitise_line_reset($in_comment);
1697
1698 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1699 # Standardise the strings and chars within the input to
1700 # simplify matching -- only bother with positive lines.
1701 $line = sanitise_line($rawline);
1702 }
1703 push(@lines, $line);
1704
1705 if ($realcnt > 1) {
1706 $realcnt-- if ($line =~ /^(?:\+| |$)/);
1707 } else {
1708 $realcnt = 0;
1709 }
1710
1711 #print "==>$rawline\n";
1712 #print "-->$line\n";
1713
1714 if ($setup_docs && $line =~ /^\+/) {
1715 push(@setup_docs, $line);
1716 }
1717 }
1718
1719 $prefix = '';
1720
1721 $realcnt = 0;
1722 $linenr = 0;
1723 foreach my $line (@lines) {
1724 $linenr++;
Tom Rini6b9709d2014-02-27 08:27:28 -05001725 my $sline = $line; #copy of $line
1726 $sline =~ s/$;/ /g; #with comments as spaces
Joe Hershberger05622192011-10-18 10:06:59 +00001727
1728 my $rawline = $rawlines[$linenr - 1];
1729
1730#extract the line range in the file after the patch is applied
1731 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1732 $is_patch = 1;
1733 $first_line = $linenr + 1;
1734 $realline=$1-1;
1735 if (defined $2) {
1736 $realcnt=$3+1;
1737 } else {
1738 $realcnt=1+1;
1739 }
1740 annotate_reset();
1741 $prev_values = 'E';
1742
1743 %suppress_ifbraces = ();
1744 %suppress_whiletrailers = ();
1745 %suppress_export = ();
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001746 $suppress_statement = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00001747 next;
1748
1749# track the line number as we move through the hunk, note that
1750# new versions of GNU diff omit the leading space on completely
1751# blank context lines so we need to count that too.
1752 } elsif ($line =~ /^( |\+|$)/) {
1753 $realline++;
1754 $realcnt-- if ($realcnt != 0);
1755
1756 # Measure the line length and indent.
1757 ($length, $indent) = line_stats($rawline);
1758
1759 # Track the previous line.
1760 ($prevline, $stashline) = ($stashline, $line);
1761 ($previndent, $stashindent) = ($stashindent, $indent);
1762 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1763
1764 #warn "line<$line>\n";
1765
1766 } elsif ($realcnt == 1) {
1767 $realcnt--;
1768 }
1769
1770 my $hunk_line = ($realcnt != 0);
1771
1772#make up the handle for any error we report on this line
1773 $prefix = "$filename:$realline: " if ($emacs && $file);
1774 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1775
1776 $here = "#$linenr: " if (!$file);
1777 $here = "#$realline: " if ($file);
1778
1779 # extract the filename as it passes
1780 if ($line =~ /^diff --git.*?(\S+)$/) {
1781 $realfile = $1;
Tom Rini6b9709d2014-02-27 08:27:28 -05001782 $realfile =~ s@^([^/]*)/@@ if (!$file);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001783 $in_commit_log = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00001784 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1785 $realfile = $1;
Tom Rini6b9709d2014-02-27 08:27:28 -05001786 $realfile =~ s@^([^/]*)/@@ if (!$file);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001787 $in_commit_log = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00001788
1789 $p1_prefix = $1;
1790 if (!$file && $tree && $p1_prefix ne '' &&
1791 -e "$root/$p1_prefix") {
1792 WARN("PATCH_PREFIX",
1793 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1794 }
1795
1796 if ($realfile =~ m@^include/asm/@) {
1797 ERROR("MODIFIED_INCLUDE_ASM",
1798 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1799 }
1800 next;
1801 }
1802
1803 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1804
1805 my $hereline = "$here\n$rawline\n";
1806 my $herecurr = "$here\n$rawline\n";
1807 my $hereprev = "$here\n$prevrawline\n$rawline\n";
1808
1809 $cnt_lines++ if ($realcnt != 0);
1810
1811# Check for incorrect file permissions
1812 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1813 my $permhere = $here . "FILE: $realfile\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05001814 if ($realfile !~ m@scripts/@ &&
1815 $realfile !~ /\.(py|pl|awk|sh)$/) {
Joe Hershberger05622192011-10-18 10:06:59 +00001816 ERROR("EXECUTE_PERMISSIONS",
1817 "do not set execute permissions for source files\n" . $permhere);
1818 }
1819 }
1820
1821# Check the patch for a signoff:
1822 if ($line =~ /^\s*signed-off-by:/i) {
1823 $signoff++;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001824 $in_commit_log = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00001825 }
1826
1827# Check signature styles
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001828 if (!$in_header_lines &&
1829 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
Joe Hershberger05622192011-10-18 10:06:59 +00001830 my $space_before = $1;
1831 my $sign_off = $2;
1832 my $space_after = $3;
1833 my $email = $4;
1834 my $ucfirst_sign_off = ucfirst(lc($sign_off));
1835
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001836 if ($sign_off !~ /$signature_tags/) {
1837 WARN("BAD_SIGN_OFF",
1838 "Non-standard signature: $sign_off\n" . $herecurr);
1839 }
Joe Hershberger05622192011-10-18 10:06:59 +00001840 if (defined $space_before && $space_before ne "") {
Tom Rini6b9709d2014-02-27 08:27:28 -05001841 if (WARN("BAD_SIGN_OFF",
1842 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
1843 $fix) {
1844 $fixed[$linenr - 1] =
1845 "$ucfirst_sign_off $email";
1846 }
Joe Hershberger05622192011-10-18 10:06:59 +00001847 }
1848 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
Tom Rini6b9709d2014-02-27 08:27:28 -05001849 if (WARN("BAD_SIGN_OFF",
1850 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
1851 $fix) {
1852 $fixed[$linenr - 1] =
1853 "$ucfirst_sign_off $email";
1854 }
1855
Joe Hershberger05622192011-10-18 10:06:59 +00001856 }
1857 if (!defined $space_after || $space_after ne " ") {
Tom Rini6b9709d2014-02-27 08:27:28 -05001858 if (WARN("BAD_SIGN_OFF",
1859 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
1860 $fix) {
1861 $fixed[$linenr - 1] =
1862 "$ucfirst_sign_off $email";
1863 }
Joe Hershberger05622192011-10-18 10:06:59 +00001864 }
1865
1866 my ($email_name, $email_address, $comment) = parse_email($email);
1867 my $suggested_email = format_email(($email_name, $email_address));
1868 if ($suggested_email eq "") {
1869 ERROR("BAD_SIGN_OFF",
1870 "Unrecognized email address: '$email'\n" . $herecurr);
1871 } else {
1872 my $dequoted = $suggested_email;
1873 $dequoted =~ s/^"//;
1874 $dequoted =~ s/" </ </;
1875 # Don't force email to have quotes
1876 # Allow just an angle bracketed address
1877 if ("$dequoted$comment" ne $email &&
1878 "<$email_address>$comment" ne $email &&
1879 "$suggested_email$comment" ne $email) {
1880 WARN("BAD_SIGN_OFF",
1881 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1882 }
1883 }
Tom Rini6b9709d2014-02-27 08:27:28 -05001884
1885# Check for duplicate signatures
1886 my $sig_nospace = $line;
1887 $sig_nospace =~ s/\s//g;
1888 $sig_nospace = lc($sig_nospace);
1889 if (defined $signatures{$sig_nospace}) {
1890 WARN("BAD_SIGN_OFF",
1891 "Duplicate signature\n" . $herecurr);
1892 } else {
1893 $signatures{$sig_nospace} = 1;
1894 }
Joe Hershberger05622192011-10-18 10:06:59 +00001895 }
1896
1897# Check for wrappage within a valid hunk of the file
1898 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1899 ERROR("CORRUPTED_PATCH",
1900 "patch seems to be corrupt (line wrapped?)\n" .
1901 $herecurr) if (!$emitted_corrupt++);
1902 }
1903
1904# Check for absolute kernel paths.
1905 if ($tree) {
1906 while ($line =~ m{(?:^|\s)(/\S*)}g) {
1907 my $file = $1;
1908
1909 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1910 check_absolute_file($1, $herecurr)) {
1911 #
1912 } else {
1913 check_absolute_file($file, $herecurr);
1914 }
1915 }
1916 }
1917
1918# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1919 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1920 $rawline !~ m/^$UTF8*$/) {
1921 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1922
1923 my $blank = copy_spacing($rawline);
1924 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1925 my $hereptr = "$hereline$ptr\n";
1926
1927 CHK("INVALID_UTF8",
1928 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1929 }
1930
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001931# Check if it's the start of a commit log
1932# (not a header line and we haven't seen the patch filename)
1933 if ($in_header_lines && $realfile =~ /^$/ &&
1934 $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) {
1935 $in_header_lines = 0;
1936 $in_commit_log = 1;
1937 }
1938
1939# Check if there is UTF-8 in a commit log when a mail header has explicitly
1940# declined it, i.e defined some charset where it is missing.
1941 if ($in_header_lines &&
1942 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
1943 $1 !~ /utf-8/i) {
1944 $non_utf8_charset = 1;
1945 }
1946
1947 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
1948 $rawline =~ /$NON_ASCII_UTF8/) {
1949 WARN("UTF8_BEFORE_PATCH",
1950 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
1951 }
1952
Joe Hershberger05622192011-10-18 10:06:59 +00001953# ignore non-hunk lines and lines being removed
1954 next if (!$hunk_line || $line =~ /^-/);
1955
1956#trailing whitespace
1957 if ($line =~ /^\+.*\015/) {
1958 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05001959 if (ERROR("DOS_LINE_ENDINGS",
1960 "DOS line endings\n" . $herevet) &&
1961 $fix) {
1962 $fixed[$linenr - 1] =~ s/[\s\015]+$//;
1963 }
Joe Hershberger05622192011-10-18 10:06:59 +00001964 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
1965 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05001966 if (ERROR("TRAILING_WHITESPACE",
1967 "trailing whitespace\n" . $herevet) &&
1968 $fix) {
1969 $fixed[$linenr - 1] =~ s/\s+$//;
1970 }
1971
Joe Hershberger05622192011-10-18 10:06:59 +00001972 $rpt_cleaners = 1;
1973 }
1974
Tom Rini6b9709d2014-02-27 08:27:28 -05001975# Check for FSF mailing addresses.
1976 if ($rawline =~ /\bwrite to the Free/i ||
1977 $rawline =~ /\b59\s+Temple\s+Pl/i ||
1978 $rawline =~ /\b51\s+Franklin\s+St/i) {
1979 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1980 my $msg_type = \&ERROR;
1981 $msg_type = \&CHK if ($file);
1982 &{$msg_type}("FSF_MAILING_ADDRESS",
1983 "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)
1984 }
1985
Joe Hershberger05622192011-10-18 10:06:59 +00001986# check for Kconfig help text having a real description
1987# Only applies when adding the entry originally, after that we do not have
1988# sufficient context to determine whether it is indeed long enough.
1989 if ($realfile =~ /Kconfig/ &&
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001990 $line =~ /.\s*config\s+/) {
Joe Hershberger05622192011-10-18 10:06:59 +00001991 my $length = 0;
1992 my $cnt = $realcnt;
1993 my $ln = $linenr + 1;
1994 my $f;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001995 my $is_start = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00001996 my $is_end = 0;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00001997 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
Joe Hershberger05622192011-10-18 10:06:59 +00001998 $f = $lines[$ln - 1];
1999 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2000 $is_end = $lines[$ln - 1] =~ /^\+/;
Joe Hershberger05622192011-10-18 10:06:59 +00002001
2002 next if ($f =~ /^-/);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002003
2004 if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) {
2005 $is_start = 1;
2006 } elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {
2007 $length = -1;
2008 }
2009
Joe Hershberger05622192011-10-18 10:06:59 +00002010 $f =~ s/^.//;
2011 $f =~ s/#.*//;
2012 $f =~ s/^\s+//;
2013 next if ($f =~ /^$/);
2014 if ($f =~ /^\s*config\s/) {
2015 $is_end = 1;
2016 last;
2017 }
2018 $length++;
2019 }
2020 WARN("CONFIG_DESCRIPTION",
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002021 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
2022 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2023 }
2024
2025# discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2026 if ($realfile =~ /Kconfig/ &&
2027 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2028 WARN("CONFIG_EXPERIMENTAL",
2029 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2030 }
2031
2032 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2033 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2034 my $flag = $1;
2035 my $replacement = {
2036 'EXTRA_AFLAGS' => 'asflags-y',
2037 'EXTRA_CFLAGS' => 'ccflags-y',
2038 'EXTRA_CPPFLAGS' => 'cppflags-y',
2039 'EXTRA_LDFLAGS' => 'ldflags-y',
2040 };
2041
2042 WARN("DEPRECATED_VARIABLE",
2043 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
Joe Hershberger05622192011-10-18 10:06:59 +00002044 }
2045
Tom Rini6b9709d2014-02-27 08:27:28 -05002046# check for DT compatible documentation
2047 if (defined $root && $realfile =~ /\.dts/ &&
2048 $rawline =~ /^\+\s*compatible\s*=/) {
2049 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2050
2051 foreach my $compat (@compats) {
2052 my $compat2 = $compat;
2053 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2054 $compat2 =~ s/\,[a-z]*\-/\,<\.\*>\-/;
2055 `grep -Erq "$compat|$compat2" $dt_path`;
2056 if ( $? >> 8 ) {
2057 WARN("UNDOCUMENTED_DT_STRING",
2058 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2059 }
2060
2061 my $vendor = $compat;
2062 my $vendor_path = $dt_path . "vendor-prefixes.txt";
2063 next if (! -f $vendor_path);
2064 $vendor =~ s/^([a-zA-Z0-9]+)\,.*/$1/;
2065 `grep -Eq "$vendor" $vendor_path`;
2066 if ( $? >> 8 ) {
2067 WARN("UNDOCUMENTED_DT_STRING",
2068 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vendor_path\n" . $herecurr);
2069 }
2070 }
2071 }
2072
Joe Hershberger05622192011-10-18 10:06:59 +00002073# check we are in a valid source file if not then ignore this hunk
2074 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
2075
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002076#line length limit
Joe Hershberger05622192011-10-18 10:06:59 +00002077 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2078 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2079 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2080 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002081 $length > $max_line_length)
Joe Hershberger05622192011-10-18 10:06:59 +00002082 {
2083 WARN("LONG_LINE",
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002084 "line over $max_line_length characters\n" . $herecurr);
2085 }
2086
2087# Check for user-visible strings broken across lines, which breaks the ability
Tom Rini6b9709d2014-02-27 08:27:28 -05002088# to grep for the string. Make exceptions when the previous string ends in a
2089# newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2090# (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002091 if ($line =~ /^\+\s*"/ &&
2092 $prevline =~ /"\s*$/ &&
Tom Rini6b9709d2014-02-27 08:27:28 -05002093 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002094 WARN("SPLIT_STRING",
2095 "quoted string split across lines\n" . $hereprev);
Joe Hershberger05622192011-10-18 10:06:59 +00002096 }
2097
2098# check for spaces before a quoted newline
2099 if ($rawline =~ /^.*\".*\s\\n/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002100 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2101 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2102 $fix) {
2103 $fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2104 }
2105
Joe Hershberger05622192011-10-18 10:06:59 +00002106 }
2107
2108# check for adding lines without a newline.
2109 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2110 WARN("MISSING_EOF_NEWLINE",
2111 "adding a line without newline at end of file\n" . $herecurr);
2112 }
2113
2114# Blackfin: use hi/lo macros
2115 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2116 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2117 my $herevet = "$here\n" . cat_vet($line) . "\n";
2118 ERROR("LO_MACRO",
2119 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2120 }
2121 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2122 my $herevet = "$here\n" . cat_vet($line) . "\n";
2123 ERROR("HI_MACRO",
2124 "use the HI() macro, not (... >> 16)\n" . $herevet);
2125 }
2126 }
2127
2128# check we are in a valid source file C or perl if not then ignore this hunk
2129 next if ($realfile !~ /\.(h|c|pl)$/);
2130
2131# at the beginning of a line any tabs must come first and anything
2132# more than 8 must use tabs.
2133 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2134 $rawline =~ /^\+\s* \s*/) {
2135 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Joe Hershberger05622192011-10-18 10:06:59 +00002136 $rpt_cleaners = 1;
Tom Rini6b9709d2014-02-27 08:27:28 -05002137 if (ERROR("CODE_INDENT",
2138 "code indent should use tabs where possible\n" . $herevet) &&
2139 $fix) {
2140 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2141 }
Joe Hershberger05622192011-10-18 10:06:59 +00002142 }
2143
2144# check for space before tabs.
2145 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2146 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05002147 if (WARN("SPACE_BEFORE_TAB",
2148 "please, no space before tabs\n" . $herevet) &&
2149 $fix) {
2150 while ($fixed[$linenr - 1] =~
2151 s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2152 while ($fixed[$linenr - 1] =~
2153 s/(^\+.*) +\t/$1\t/) {}
2154 }
Joe Hershberger05622192011-10-18 10:06:59 +00002155 }
2156
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002157# check for && or || at the start of a line
2158 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2159 CHK("LOGICAL_CONTINUATIONS",
2160 "Logical continuations should be on the previous line\n" . $hereprev);
2161 }
2162
2163# check multi-line statement indentation matches previous line
2164 if ($^V && $^V ge 5.10.0 &&
2165 $prevline =~ /^\+(\t*)(if \(|$Ident\().*(\&\&|\|\||,)\s*$/) {
2166 $prevline =~ /^\+(\t*)(.*)$/;
2167 my $oldindent = $1;
2168 my $rest = $2;
2169
2170 my $pos = pos_last_openparen($rest);
2171 if ($pos >= 0) {
2172 $line =~ /^(\+| )([ \t]*)/;
2173 my $newindent = $2;
2174
2175 my $goodtabindent = $oldindent .
2176 "\t" x ($pos / 8) .
2177 " " x ($pos % 8);
2178 my $goodspaceindent = $oldindent . " " x $pos;
2179
2180 if ($newindent ne $goodtabindent &&
2181 $newindent ne $goodspaceindent) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002182
2183 if (CHK("PARENTHESIS_ALIGNMENT",
2184 "Alignment should match open parenthesis\n" . $hereprev) &&
2185 $fix && $line =~ /^\+/) {
2186 $fixed[$linenr - 1] =~
2187 s/^\+[ \t]*/\+$goodtabindent/;
2188 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002189 }
2190 }
2191 }
2192
Tom Rini6b9709d2014-02-27 08:27:28 -05002193 if ($line =~ /^\+.*\*[ \t]*\)[ \t]+(?!$Assignment|$Arithmetic)/) {
2194 if (CHK("SPACING",
2195 "No space is necessary after a cast\n" . $hereprev) &&
2196 $fix) {
2197 $fixed[$linenr - 1] =~
2198 s/^(\+.*\*[ \t]*\))[ \t]+/$1/;
2199 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002200 }
2201
2202 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Tom Rini6b9709d2014-02-27 08:27:28 -05002203 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2204 $rawline =~ /^\+[ \t]*\*/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002205 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2206 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2207 }
2208
2209 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Tom Rini6b9709d2014-02-27 08:27:28 -05002210 $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /*
2211 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
2212 $rawline =~ /^\+/ && #line is new
2213 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2214 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2215 "networking block comments start with * on subsequent lines\n" . $hereprev);
2216 }
2217
2218 if ($realfile =~ m@^(drivers/net/|net/)@ &&
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002219 $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2220 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2221 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2222 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
2223 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2224 "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2225 }
2226
Joe Hershberger05622192011-10-18 10:06:59 +00002227# check for spaces at the beginning of a line.
2228# Exceptions:
2229# 1) within comments
2230# 2) indented preprocessor commands
2231# 3) hanging labels
Tom Rini6b9709d2014-02-27 08:27:28 -05002232 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
Joe Hershberger05622192011-10-18 10:06:59 +00002233 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05002234 if (WARN("LEADING_SPACE",
2235 "please, no spaces at the start of a line\n" . $herevet) &&
2236 $fix) {
2237 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2238 }
Joe Hershberger05622192011-10-18 10:06:59 +00002239 }
2240
2241# check we are in a valid C source file if not then ignore this hunk
2242 next if ($realfile !~ /\.(h|c)$/);
2243
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002244# discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2245 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2246 WARN("CONFIG_EXPERIMENTAL",
2247 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2248 }
2249
Joe Hershberger05622192011-10-18 10:06:59 +00002250# check for RCS/CVS revision markers
2251 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2252 WARN("CVS_KEYWORD",
2253 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2254 }
2255
2256# Blackfin: don't use __builtin_bfin_[cs]sync
2257 if ($line =~ /__builtin_bfin_csync/) {
2258 my $herevet = "$here\n" . cat_vet($line) . "\n";
2259 ERROR("CSYNC",
2260 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2261 }
2262 if ($line =~ /__builtin_bfin_ssync/) {
2263 my $herevet = "$here\n" . cat_vet($line) . "\n";
2264 ERROR("SSYNC",
2265 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2266 }
2267
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002268# check for old HOTPLUG __dev<foo> section markings
2269 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2270 WARN("HOTPLUG_SECTION",
2271 "Using $1 is unnecessary\n" . $herecurr);
2272 }
2273
Joe Hershberger05622192011-10-18 10:06:59 +00002274# Check for potential 'bare' types
2275 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2276 $realline_next);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002277#print "LINE<$line>\n";
2278 if ($linenr >= $suppress_statement &&
Tom Rini6b9709d2014-02-27 08:27:28 -05002279 $realcnt && $sline =~ /.\s*\S/) {
Joe Hershberger05622192011-10-18 10:06:59 +00002280 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2281 ctx_statement_block($linenr, $realcnt, 0);
2282 $stat =~ s/\n./\n /g;
2283 $cond =~ s/\n./\n /g;
2284
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002285#print "linenr<$linenr> <$stat>\n";
2286 # If this statement has no statement boundaries within
2287 # it there is no point in retrying a statement scan
2288 # until we hit end of it.
2289 my $frag = $stat; $frag =~ s/;+\s*$//;
2290 if ($frag !~ /(?:{|;)/) {
2291#print "skip<$line_nr_next>\n";
2292 $suppress_statement = $line_nr_next;
2293 }
2294
Joe Hershberger05622192011-10-18 10:06:59 +00002295 # Find the real next line.
2296 $realline_next = $line_nr_next;
2297 if (defined $realline_next &&
2298 (!defined $lines[$realline_next - 1] ||
2299 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2300 $realline_next++;
2301 }
2302
2303 my $s = $stat;
2304 $s =~ s/{.*$//s;
2305
2306 # Ignore goto labels.
2307 if ($s =~ /$Ident:\*$/s) {
2308
2309 # Ignore functions being called
2310 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2311
2312 } elsif ($s =~ /^.\s*else\b/s) {
2313
2314 # declarations always start with types
2315 } 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) {
2316 my $type = $1;
2317 $type =~ s/\s+/ /g;
2318 possible($type, "A:" . $s);
2319
2320 # definitions in global scope can only start with types
2321 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2322 possible($1, "B:" . $s);
2323 }
2324
2325 # any (foo ... *) is a pointer cast, and foo is a type
2326 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2327 possible($1, "C:" . $s);
2328 }
2329
2330 # Check for any sort of function declaration.
2331 # int foo(something bar, other baz);
2332 # void (*store_gdt)(x86_descr_ptr *);
2333 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2334 my ($name_len) = length($1);
2335
2336 my $ctx = $s;
2337 substr($ctx, 0, $name_len + 1, '');
2338 $ctx =~ s/\)[^\)]*$//;
2339
2340 for my $arg (split(/\s*,\s*/, $ctx)) {
2341 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2342
2343 possible($1, "D:" . $s);
2344 }
2345 }
2346 }
2347
2348 }
2349
2350#
2351# Checks which may be anchored in the context.
2352#
2353
2354# Check for switch () and associated case and default
2355# statements should be at the same indent.
2356 if ($line=~/\bswitch\s*\(.*\)/) {
2357 my $err = '';
2358 my $sep = '';
2359 my @ctx = ctx_block_outer($linenr, $realcnt);
2360 shift(@ctx);
2361 for my $ctx (@ctx) {
2362 my ($clen, $cindent) = line_stats($ctx);
2363 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2364 $indent != $cindent) {
2365 $err .= "$sep$ctx\n";
2366 $sep = '';
2367 } else {
2368 $sep = "[...]\n";
2369 }
2370 }
2371 if ($err ne '') {
2372 ERROR("SWITCH_CASE_INDENT_LEVEL",
2373 "switch and case should be at the same indent\n$hereline$err");
2374 }
2375 }
2376
2377# if/while/etc brace do not go on next line, unless defining a do while loop,
2378# or if that brace on the next line is for something else
2379 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2380 my $pre_ctx = "$1$2";
2381
2382 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002383
2384 if ($line =~ /^\+\t{6,}/) {
2385 WARN("DEEP_INDENTATION",
2386 "Too many leading tabs - consider code refactoring\n" . $herecurr);
2387 }
2388
Joe Hershberger05622192011-10-18 10:06:59 +00002389 my $ctx_cnt = $realcnt - $#ctx - 1;
2390 my $ctx = join("\n", @ctx);
2391
2392 my $ctx_ln = $linenr;
2393 my $ctx_skip = $realcnt;
2394
2395 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2396 defined $lines[$ctx_ln - 1] &&
2397 $lines[$ctx_ln - 1] =~ /^-/)) {
2398 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2399 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2400 $ctx_ln++;
2401 }
2402
2403 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2404 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2405
2406 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2407 ERROR("OPEN_BRACE",
2408 "that open brace { should be on the previous line\n" .
2409 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2410 }
2411 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2412 $ctx =~ /\)\s*\;\s*$/ &&
2413 defined $lines[$ctx_ln - 1])
2414 {
2415 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2416 if ($nindent > $indent) {
2417 WARN("TRAILING_SEMICOLON",
2418 "trailing semicolon indicates no statements, indent implies otherwise\n" .
2419 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2420 }
2421 }
2422 }
2423
2424# Check relative indent for conditionals and blocks.
2425 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002426 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2427 ctx_statement_block($linenr, $realcnt, 0)
2428 if (!defined $stat);
Joe Hershberger05622192011-10-18 10:06:59 +00002429 my ($s, $c) = ($stat, $cond);
2430
2431 substr($s, 0, length($c), '');
2432
2433 # Make sure we remove the line prefixes as we have
2434 # none on the first line, and are going to readd them
2435 # where necessary.
2436 $s =~ s/\n./\n/gs;
2437
2438 # Find out how long the conditional actually is.
2439 my @newlines = ($c =~ /\n/gs);
2440 my $cond_lines = 1 + $#newlines;
2441
2442 # We want to check the first line inside the block
2443 # starting at the end of the conditional, so remove:
2444 # 1) any blank line termination
2445 # 2) any opening brace { on end of the line
2446 # 3) any do (...) {
2447 my $continuation = 0;
2448 my $check = 0;
2449 $s =~ s/^.*\bdo\b//;
2450 $s =~ s/^\s*{//;
2451 if ($s =~ s/^\s*\\//) {
2452 $continuation = 1;
2453 }
2454 if ($s =~ s/^\s*?\n//) {
2455 $check = 1;
2456 $cond_lines++;
2457 }
2458
2459 # Also ignore a loop construct at the end of a
2460 # preprocessor statement.
2461 if (($prevline =~ /^.\s*#\s*define\s/ ||
2462 $prevline =~ /\\\s*$/) && $continuation == 0) {
2463 $check = 0;
2464 }
2465
2466 my $cond_ptr = -1;
2467 $continuation = 0;
2468 while ($cond_ptr != $cond_lines) {
2469 $cond_ptr = $cond_lines;
2470
2471 # If we see an #else/#elif then the code
2472 # is not linear.
2473 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2474 $check = 0;
2475 }
2476
2477 # Ignore:
2478 # 1) blank lines, they should be at 0,
2479 # 2) preprocessor lines, and
2480 # 3) labels.
2481 if ($continuation ||
2482 $s =~ /^\s*?\n/ ||
2483 $s =~ /^\s*#\s*?/ ||
2484 $s =~ /^\s*$Ident\s*:/) {
2485 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2486 if ($s =~ s/^.*?\n//) {
2487 $cond_lines++;
2488 }
2489 }
2490 }
2491
2492 my (undef, $sindent) = line_stats("+" . $s);
2493 my $stat_real = raw_line($linenr, $cond_lines);
2494
2495 # Check if either of these lines are modified, else
2496 # this is not this patch's fault.
2497 if (!defined($stat_real) ||
2498 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2499 $check = 0;
2500 }
2501 if (defined($stat_real) && $cond_lines > 1) {
2502 $stat_real = "[...]\n$stat_real";
2503 }
2504
2505 #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";
2506
2507 if ($check && (($sindent % 8) != 0 ||
2508 ($sindent <= $indent && $s ne ''))) {
2509 WARN("SUSPECT_CODE_INDENT",
2510 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2511 }
2512 }
2513
2514 # Track the 'values' across context and added lines.
2515 my $opline = $line; $opline =~ s/^./ /;
2516 my ($curr_values, $curr_vars) =
2517 annotate_values($opline . "\n", $prev_values);
2518 $curr_values = $prev_values . $curr_values;
2519 if ($dbg_values) {
2520 my $outline = $opline; $outline =~ s/\t/ /g;
2521 print "$linenr > .$outline\n";
2522 print "$linenr > $curr_values\n";
2523 print "$linenr > $curr_vars\n";
2524 }
2525 $prev_values = substr($curr_values, -1);
2526
2527#ignore lines not being added
Tom Rini6b9709d2014-02-27 08:27:28 -05002528 next if ($line =~ /^[^\+]/);
Joe Hershberger05622192011-10-18 10:06:59 +00002529
2530# TEST: allow direct testing of the type matcher.
2531 if ($dbg_type) {
2532 if ($line =~ /^.\s*$Declare\s*$/) {
2533 ERROR("TEST_TYPE",
2534 "TEST: is type\n" . $herecurr);
2535 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2536 ERROR("TEST_NOT_TYPE",
2537 "TEST: is not type ($1 is)\n". $herecurr);
2538 }
2539 next;
2540 }
2541# TEST: allow direct testing of the attribute matcher.
2542 if ($dbg_attr) {
2543 if ($line =~ /^.\s*$Modifier\s*$/) {
2544 ERROR("TEST_ATTR",
2545 "TEST: is attr\n" . $herecurr);
2546 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2547 ERROR("TEST_NOT_ATTR",
2548 "TEST: is not attr ($1 is)\n". $herecurr);
2549 }
2550 next;
2551 }
2552
2553# check for initialisation to aggregates open brace on the next line
2554 if ($line =~ /^.\s*{/ &&
2555 $prevline =~ /(?:^|[^=])=\s*$/) {
2556 ERROR("OPEN_BRACE",
2557 "that open brace { should be on the previous line\n" . $hereprev);
2558 }
2559
2560#
2561# Checks which are anchored on the added line.
2562#
2563
2564# check for malformed paths in #include statements (uses RAW line)
2565 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2566 my $path = $1;
2567 if ($path =~ m{//}) {
2568 ERROR("MALFORMED_INCLUDE",
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002569 "malformed #include filename\n" . $herecurr);
2570 }
2571 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2572 ERROR("UAPI_INCLUDE",
2573 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00002574 }
2575 }
2576
2577# no C99 // comments
2578 if ($line =~ m{//}) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002579 if (ERROR("C99_COMMENTS",
2580 "do not use C99 // comments\n" . $herecurr) &&
2581 $fix) {
2582 my $line = $fixed[$linenr - 1];
2583 if ($line =~ /\/\/(.*)$/) {
2584 my $comment = trim($1);
2585 $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;
2586 }
2587 }
Joe Hershberger05622192011-10-18 10:06:59 +00002588 }
2589 # Remove C99 comments.
2590 $line =~ s@//.*@@;
2591 $opline =~ s@//.*@@;
2592
2593# EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2594# the whole statement.
2595#print "APW <$lines[$realline_next - 1]>\n";
2596 if (defined $realline_next &&
2597 exists $lines[$realline_next - 1] &&
2598 !defined $suppress_export{$realline_next} &&
2599 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2600 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2601 # Handle definitions which produce identifiers with
2602 # a prefix:
2603 # XXX(foo);
2604 # EXPORT_SYMBOL(something_foo);
2605 my $name = $1;
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002606 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
Joe Hershberger05622192011-10-18 10:06:59 +00002607 $name =~ /^${Ident}_$2/) {
2608#print "FOO C name<$name>\n";
2609 $suppress_export{$realline_next} = 1;
2610
2611 } elsif ($stat !~ /(?:
2612 \n.}\s*$|
2613 ^.DEFINE_$Ident\(\Q$name\E\)|
2614 ^.DECLARE_$Ident\(\Q$name\E\)|
2615 ^.LIST_HEAD\(\Q$name\E\)|
2616 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2617 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
2618 )/x) {
2619#print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2620 $suppress_export{$realline_next} = 2;
2621 } else {
2622 $suppress_export{$realline_next} = 1;
2623 }
2624 }
2625 if (!defined $suppress_export{$linenr} &&
2626 $prevline =~ /^.\s*$/ &&
2627 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2628 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2629#print "FOO B <$lines[$linenr - 1]>\n";
2630 $suppress_export{$linenr} = 2;
2631 }
2632 if (defined $suppress_export{$linenr} &&
2633 $suppress_export{$linenr} == 2) {
2634 WARN("EXPORT_SYMBOL",
2635 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2636 }
2637
2638# check for global initialisers.
Tom Rini6b9709d2014-02-27 08:27:28 -05002639 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
2640 if (ERROR("GLOBAL_INITIALISERS",
2641 "do not initialise globals to 0 or NULL\n" .
2642 $herecurr) &&
2643 $fix) {
2644 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
2645 }
Joe Hershberger05622192011-10-18 10:06:59 +00002646 }
2647# check for static initialisers.
Tom Rini6b9709d2014-02-27 08:27:28 -05002648 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2649 if (ERROR("INITIALISED_STATIC",
2650 "do not initialise statics to 0 or NULL\n" .
2651 $herecurr) &&
2652 $fix) {
2653 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
2654 }
Joe Hershberger05622192011-10-18 10:06:59 +00002655 }
2656
2657# check for static const char * arrays.
2658 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2659 WARN("STATIC_CONST_CHAR_ARRAY",
2660 "static const char * array should probably be static const char * const\n" .
2661 $herecurr);
2662 }
2663
2664# check for static char foo[] = "bar" declarations.
2665 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2666 WARN("STATIC_CONST_CHAR_ARRAY",
2667 "static char array declaration should probably be static const char\n" .
2668 $herecurr);
2669 }
2670
Tom Rini6b9709d2014-02-27 08:27:28 -05002671# check for function declarations without arguments like "int foo()"
2672 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
2673 if (ERROR("FUNCTION_WITHOUT_ARGS",
2674 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
2675 $fix) {
2676 $fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
2677 }
2678 }
2679
2680# check for uses of DEFINE_PCI_DEVICE_TABLE
2681 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
2682 if (WARN("DEFINE_PCI_DEVICE_TABLE",
2683 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
2684 $fix) {
2685 $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
2686 }
Joe Hershberger05622192011-10-18 10:06:59 +00002687 }
2688
2689# check for new typedefs, only function parameters and sparse annotations
2690# make sense.
2691 if ($line =~ /\btypedef\s/ &&
2692 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2693 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2694 $line !~ /\b$typeTypedefs\b/ &&
2695 $line !~ /\b__bitwise(?:__|)\b/) {
2696 WARN("NEW_TYPEDEFS",
2697 "do not add new typedefs\n" . $herecurr);
2698 }
2699
2700# * goes on variable not on type
2701 # (char*[ const])
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002702 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
2703 #print "AA<$1>\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05002704 my ($ident, $from, $to) = ($1, $2, $2);
Joe Hershberger05622192011-10-18 10:06:59 +00002705
2706 # Should start with a space.
2707 $to =~ s/^(\S)/ $1/;
2708 # Should not end with a space.
2709 $to =~ s/\s+$//;
2710 # '*'s should not have spaces between.
2711 while ($to =~ s/\*\s+\*/\*\*/) {
2712 }
2713
Tom Rini6b9709d2014-02-27 08:27:28 -05002714## print "1: from<$from> to<$to> ident<$ident>\n";
Joe Hershberger05622192011-10-18 10:06:59 +00002715 if ($from ne $to) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002716 if (ERROR("POINTER_LOCATION",
2717 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
2718 $fix) {
2719 my $sub_from = $ident;
2720 my $sub_to = $ident;
2721 $sub_to =~ s/\Q$from\E/$to/;
2722 $fixed[$linenr - 1] =~
2723 s@\Q$sub_from\E@$sub_to@;
2724 }
Joe Hershberger05622192011-10-18 10:06:59 +00002725 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002726 }
2727 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
2728 #print "BB<$1>\n";
Tom Rini6b9709d2014-02-27 08:27:28 -05002729 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
Joe Hershberger05622192011-10-18 10:06:59 +00002730
2731 # Should start with a space.
2732 $to =~ s/^(\S)/ $1/;
2733 # Should not end with a space.
2734 $to =~ s/\s+$//;
2735 # '*'s should not have spaces between.
2736 while ($to =~ s/\*\s+\*/\*\*/) {
2737 }
2738 # Modifiers should have spaces.
2739 $to =~ s/(\b$Modifier$)/$1 /;
2740
Tom Rini6b9709d2014-02-27 08:27:28 -05002741## print "2: from<$from> to<$to> ident<$ident>\n";
Joe Hershberger05622192011-10-18 10:06:59 +00002742 if ($from ne $to && $ident !~ /^$Modifier$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002743 if (ERROR("POINTER_LOCATION",
2744 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
2745 $fix) {
2746
2747 my $sub_from = $match;
2748 my $sub_to = $match;
2749 $sub_to =~ s/\Q$from\E/$to/;
2750 $fixed[$linenr - 1] =~
2751 s@\Q$sub_from\E@$sub_to@;
2752 }
Joe Hershberger05622192011-10-18 10:06:59 +00002753 }
2754 }
2755
2756# # no BUG() or BUG_ON()
2757# if ($line =~ /\b(BUG|BUG_ON)\b/) {
2758# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2759# print "$herecurr";
2760# $clean = 0;
2761# }
2762
2763 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2764 WARN("LINUX_VERSION_CODE",
2765 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2766 }
2767
2768# check for uses of printk_ratelimit
2769 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2770 WARN("PRINTK_RATELIMITED",
2771"Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2772 }
2773
2774# printk should use KERN_* levels. Note that follow on printk's on the
2775# same line do not need a level, so we use the current block context
2776# to try and find and validate the current printk. In summary the current
2777# printk includes all preceding printk's which have no newline on the end.
2778# we assume the first bad printk is the one to report.
2779 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2780 my $ok = 0;
2781 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2782 #print "CHECK<$lines[$ln - 1]\n";
2783 # we have a preceding printk if it ends
2784 # with "\n" ignore it, else it is to blame
2785 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2786 if ($rawlines[$ln - 1] !~ m{\\n"}) {
2787 $ok = 1;
2788 }
2789 last;
2790 }
2791 }
2792 if ($ok == 0) {
2793 WARN("PRINTK_WITHOUT_KERN_LEVEL",
2794 "printk() should include KERN_ facility level\n" . $herecurr);
2795 }
2796 }
2797
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002798 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
2799 my $orig = $1;
2800 my $level = lc($orig);
2801 $level = "warn" if ($level eq "warning");
2802 my $level2 = $level;
2803 $level2 = "dbg" if ($level eq "debug");
2804 WARN("PREFER_PR_LEVEL",
2805 "Prefer netdev_$level2(netdev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
2806 }
2807
2808 if ($line =~ /\bpr_warning\s*\(/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002809 if (WARN("PREFER_PR_LEVEL",
2810 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
2811 $fix) {
2812 $fixed[$linenr - 1] =~
2813 s/\bpr_warning\b/pr_warn/;
2814 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002815 }
2816
2817 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
2818 my $orig = $1;
2819 my $level = lc($orig);
2820 $level = "warn" if ($level eq "warning");
2821 $level = "dbg" if ($level eq "debug");
2822 WARN("PREFER_DEV_LEVEL",
2823 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
2824 }
2825
Joe Hershberger05622192011-10-18 10:06:59 +00002826# function brace can't be on same line, except for #defines of do while,
2827# or if closed on same line
2828 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2829 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2830 ERROR("OPEN_BRACE",
2831 "open brace '{' following function declarations go on the next line\n" . $herecurr);
2832 }
2833
2834# open braces for enum, union and struct go on the same line.
2835 if ($line =~ /^.\s*{/ &&
2836 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2837 ERROR("OPEN_BRACE",
2838 "open brace '{' following $1 go on the same line\n" . $hereprev);
2839 }
2840
2841# missing space after union, struct or enum definition
Tom Rini6b9709d2014-02-27 08:27:28 -05002842 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
2843 if (WARN("SPACING",
2844 "missing space after $1 definition\n" . $herecurr) &&
2845 $fix) {
2846 $fixed[$linenr - 1] =~
2847 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
2848 }
2849 }
2850
2851# Function pointer declarations
2852# check spacing between type, funcptr, and args
2853# canonical declaration is "type (*funcptr)(args...)"
2854#
2855# the $Declare variable will capture all spaces after the type
2856# so check it for trailing missing spaces or multiple spaces
2857 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)$Ident(\s*)\)(\s*)\(/) {
2858 my $declare = $1;
2859 my $pre_pointer_space = $2;
2860 my $post_pointer_space = $3;
2861 my $funcname = $4;
2862 my $post_funcname_space = $5;
2863 my $pre_args_space = $6;
2864
2865 if ($declare !~ /\s$/) {
2866 WARN("SPACING",
2867 "missing space after return type\n" . $herecurr);
2868 }
2869
2870# unnecessary space "type (*funcptr)(args...)"
2871 elsif ($declare =~ /\s{2,}$/) {
2872 WARN("SPACING",
2873 "Multiple spaces after return type\n" . $herecurr);
2874 }
2875
2876# unnecessary space "type ( *funcptr)(args...)"
2877 if (defined $pre_pointer_space &&
2878 $pre_pointer_space =~ /^\s/) {
2879 WARN("SPACING",
2880 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
2881 }
2882
2883# unnecessary space "type (* funcptr)(args...)"
2884 if (defined $post_pointer_space &&
2885 $post_pointer_space =~ /^\s/) {
2886 WARN("SPACING",
2887 "Unnecessary space before function pointer name\n" . $herecurr);
2888 }
2889
2890# unnecessary space "type (*funcptr )(args...)"
2891 if (defined $post_funcname_space &&
2892 $post_funcname_space =~ /^\s/) {
2893 WARN("SPACING",
2894 "Unnecessary space after function pointer name\n" . $herecurr);
2895 }
2896
2897# unnecessary space "type (*funcptr) (args...)"
2898 if (defined $pre_args_space &&
2899 $pre_args_space =~ /^\s/) {
2900 WARN("SPACING",
2901 "Unnecessary space before function pointer arguments\n" . $herecurr);
2902 }
2903
2904 if (show_type("SPACING") && $fix) {
2905 $fixed[$linenr - 1] =~
2906 s/^(.\s*$Declare)\(\s*\*\s*($Ident)\s*\)\s*\(/rtrim($1) . " " . "\(\*$2\)\("/ex;
2907 }
Joe Hershberger05622192011-10-18 10:06:59 +00002908 }
2909
2910# check for spacing round square brackets; allowed:
2911# 1. with a type on the left -- int [] a;
2912# 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2913# 3. inside a curly brace -- = { [0...10] = 5 }
2914 while ($line =~ /(.*?\s)\[/g) {
2915 my ($where, $prefix) = ($-[1], $1);
2916 if ($prefix !~ /$Type\s+$/ &&
2917 ($where != 0 || $prefix !~ /^.\s+$/) &&
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002918 $prefix !~ /[{,]\s+$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002919 if (ERROR("BRACKET_SPACE",
2920 "space prohibited before open square bracket '['\n" . $herecurr) &&
2921 $fix) {
2922 $fixed[$linenr - 1] =~
2923 s/^(\+.*?)\s+\[/$1\[/;
2924 }
Joe Hershberger05622192011-10-18 10:06:59 +00002925 }
2926 }
2927
2928# check for spaces between functions and their parentheses.
2929 while ($line =~ /($Ident)\s+\(/g) {
2930 my $name = $1;
2931 my $ctx_before = substr($line, 0, $-[1]);
2932 my $ctx = "$ctx_before$name";
2933
2934 # Ignore those directives where spaces _are_ permitted.
2935 if ($name =~ /^(?:
2936 if|for|while|switch|return|case|
2937 volatile|__volatile__|
2938 __attribute__|format|__extension__|
2939 asm|__asm__)$/x)
2940 {
Joe Hershberger05622192011-10-18 10:06:59 +00002941 # cpp #define statements have non-optional spaces, ie
2942 # if there is a space between the name and the open
2943 # parenthesis it is simply not a parameter group.
2944 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
2945
2946 # cpp #elif statement condition may start with a (
2947 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
2948
2949 # If this whole things ends with a type its most
2950 # likely a typedef for a function.
2951 } elsif ($ctx =~ /$Type$/) {
2952
2953 } else {
Tom Rini6b9709d2014-02-27 08:27:28 -05002954 if (WARN("SPACING",
2955 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
2956 $fix) {
2957 $fixed[$linenr - 1] =~
2958 s/\b$name\s+\(/$name\(/;
2959 }
Joe Hershberger05622192011-10-18 10:06:59 +00002960 }
2961 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00002962
Joe Hershberger05622192011-10-18 10:06:59 +00002963# Check operator spacing.
2964 if (!($line=~/\#\s*include/)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002965 my $fixed_line = "";
2966 my $line_fixed = 0;
2967
Joe Hershberger05622192011-10-18 10:06:59 +00002968 my $ops = qr{
2969 <<=|>>=|<=|>=|==|!=|
2970 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
2971 =>|->|<<|>>|<|>|=|!|~|
2972 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
Tom Rini6b9709d2014-02-27 08:27:28 -05002973 \?:|\?|:
Joe Hershberger05622192011-10-18 10:06:59 +00002974 }x;
2975 my @elements = split(/($ops|;)/, $opline);
Tom Rini6b9709d2014-02-27 08:27:28 -05002976
2977## print("element count: <" . $#elements . ">\n");
2978## foreach my $el (@elements) {
2979## print("el: <$el>\n");
2980## }
2981
2982 my @fix_elements = ();
Joe Hershberger05622192011-10-18 10:06:59 +00002983 my $off = 0;
2984
Tom Rini6b9709d2014-02-27 08:27:28 -05002985 foreach my $el (@elements) {
2986 push(@fix_elements, substr($rawline, $off, length($el)));
2987 $off += length($el);
2988 }
2989
2990 $off = 0;
2991
Joe Hershberger05622192011-10-18 10:06:59 +00002992 my $blank = copy_spacing($opline);
Tom Rini6b9709d2014-02-27 08:27:28 -05002993 my $last_after = -1;
Joe Hershberger05622192011-10-18 10:06:59 +00002994
2995 for (my $n = 0; $n < $#elements; $n += 2) {
Tom Rini6b9709d2014-02-27 08:27:28 -05002996
2997 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
2998
2999## print("n: <$n> good: <$good>\n");
3000
Joe Hershberger05622192011-10-18 10:06:59 +00003001 $off += length($elements[$n]);
3002
3003 # Pick up the preceding and succeeding characters.
3004 my $ca = substr($opline, 0, $off);
3005 my $cc = '';
3006 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3007 $cc = substr($opline, $off + length($elements[$n + 1]));
3008 }
3009 my $cb = "$ca$;$cc";
3010
3011 my $a = '';
3012 $a = 'V' if ($elements[$n] ne '');
3013 $a = 'W' if ($elements[$n] =~ /\s$/);
3014 $a = 'C' if ($elements[$n] =~ /$;$/);
3015 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3016 $a = 'O' if ($elements[$n] eq '');
3017 $a = 'E' if ($ca =~ /^\s*$/);
3018
3019 my $op = $elements[$n + 1];
3020
3021 my $c = '';
3022 if (defined $elements[$n + 2]) {
3023 $c = 'V' if ($elements[$n + 2] ne '');
3024 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3025 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3026 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3027 $c = 'O' if ($elements[$n + 2] eq '');
3028 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3029 } else {
3030 $c = 'E';
3031 }
3032
3033 my $ctx = "${a}x${c}";
3034
3035 my $at = "(ctx:$ctx)";
3036
3037 my $ptr = substr($blank, 0, $off) . "^";
3038 my $hereptr = "$hereline$ptr\n";
3039
3040 # Pull out the value of this operator.
3041 my $op_type = substr($curr_values, $off + 1, 1);
3042
3043 # Get the full operator variant.
3044 my $opv = $op . substr($curr_vars, $off, 1);
3045
3046 # Ignore operators passed as parameters.
3047 if ($op_type ne 'V' &&
3048 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3049
3050# # Ignore comments
3051# } elsif ($op =~ /^$;+$/) {
3052
3053 # ; should have either the end of line or a space or \ after it
3054 } elsif ($op eq ';') {
3055 if ($ctx !~ /.x[WEBC]/ &&
3056 $cc !~ /^\\/ && $cc !~ /^;/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003057 if (ERROR("SPACING",
3058 "space required after that '$op' $at\n" . $hereptr)) {
3059 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3060 $line_fixed = 1;
3061 }
Joe Hershberger05622192011-10-18 10:06:59 +00003062 }
3063
3064 # // is a comment
3065 } elsif ($op eq '//') {
3066
3067 # No spaces for:
3068 # ->
3069 # : when part of a bitfield
3070 } elsif ($op eq '->' || $opv eq ':B') {
3071 if ($ctx =~ /Wx.|.xW/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003072 if (ERROR("SPACING",
3073 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3074 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3075 if (defined $fix_elements[$n + 2]) {
3076 $fix_elements[$n + 2] =~ s/^\s+//;
3077 }
3078 $line_fixed = 1;
3079 }
Joe Hershberger05622192011-10-18 10:06:59 +00003080 }
3081
3082 # , must have a space on the right.
3083 } elsif ($op eq ',') {
3084 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003085 if (ERROR("SPACING",
3086 "space required after that '$op' $at\n" . $hereptr)) {
3087 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3088 $line_fixed = 1;
3089 $last_after = $n;
3090 }
Joe Hershberger05622192011-10-18 10:06:59 +00003091 }
3092
3093 # '*' as part of a type definition -- reported already.
3094 } elsif ($opv eq '*_') {
3095 #warn "'*' is part of type\n";
3096
3097 # unary operators should have a space before and
3098 # none after. May be left adjacent to another
3099 # unary operator, or a cast
3100 } elsif ($op eq '!' || $op eq '~' ||
3101 $opv eq '*U' || $opv eq '-U' ||
3102 $opv eq '&U' || $opv eq '&&U') {
3103 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003104 if (ERROR("SPACING",
3105 "space required before that '$op' $at\n" . $hereptr)) {
3106 if ($n != $last_after + 2) {
3107 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3108 $line_fixed = 1;
3109 }
3110 }
Joe Hershberger05622192011-10-18 10:06:59 +00003111 }
3112 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3113 # A unary '*' may be const
3114
3115 } elsif ($ctx =~ /.xW/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003116 if (ERROR("SPACING",
3117 "space prohibited after that '$op' $at\n" . $hereptr)) {
3118 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3119 if (defined $fix_elements[$n + 2]) {
3120 $fix_elements[$n + 2] =~ s/^\s+//;
3121 }
3122 $line_fixed = 1;
3123 }
Joe Hershberger05622192011-10-18 10:06:59 +00003124 }
3125
3126 # unary ++ and unary -- are allowed no space on one side.
3127 } elsif ($op eq '++' or $op eq '--') {
3128 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003129 if (ERROR("SPACING",
3130 "space required one side of that '$op' $at\n" . $hereptr)) {
3131 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3132 $line_fixed = 1;
3133 }
Joe Hershberger05622192011-10-18 10:06:59 +00003134 }
3135 if ($ctx =~ /Wx[BE]/ ||
3136 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003137 if (ERROR("SPACING",
3138 "space prohibited before that '$op' $at\n" . $hereptr)) {
3139 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3140 $line_fixed = 1;
3141 }
Joe Hershberger05622192011-10-18 10:06:59 +00003142 }
3143 if ($ctx =~ /ExW/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003144 if (ERROR("SPACING",
3145 "space prohibited after that '$op' $at\n" . $hereptr)) {
3146 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3147 if (defined $fix_elements[$n + 2]) {
3148 $fix_elements[$n + 2] =~ s/^\s+//;
3149 }
3150 $line_fixed = 1;
3151 }
Joe Hershberger05622192011-10-18 10:06:59 +00003152 }
3153
Joe Hershberger05622192011-10-18 10:06:59 +00003154 # << and >> may either have or not have spaces both sides
3155 } elsif ($op eq '<<' or $op eq '>>' or
3156 $op eq '&' or $op eq '^' or $op eq '|' or
3157 $op eq '+' or $op eq '-' or
3158 $op eq '*' or $op eq '/' or
3159 $op eq '%')
3160 {
3161 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003162 if (ERROR("SPACING",
3163 "need consistent spacing around '$op' $at\n" . $hereptr)) {
3164 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3165 if (defined $fix_elements[$n + 2]) {
3166 $fix_elements[$n + 2] =~ s/^\s+//;
3167 }
3168 $line_fixed = 1;
3169 }
Joe Hershberger05622192011-10-18 10:06:59 +00003170 }
3171
3172 # A colon needs no spaces before when it is
3173 # terminating a case value or a label.
3174 } elsif ($opv eq ':C' || $opv eq ':L') {
3175 if ($ctx =~ /Wx./) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003176 if (ERROR("SPACING",
3177 "space prohibited before that '$op' $at\n" . $hereptr)) {
3178 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3179 $line_fixed = 1;
3180 }
Joe Hershberger05622192011-10-18 10:06:59 +00003181 }
3182
3183 # All the others need spaces both sides.
3184 } elsif ($ctx !~ /[EWC]x[CWE]/) {
3185 my $ok = 0;
3186
3187 # Ignore email addresses <foo@bar>
3188 if (($op eq '<' &&
3189 $cc =~ /^\S+\@\S+>/) ||
3190 ($op eq '>' &&
3191 $ca =~ /<\S+\@\S+$/))
3192 {
Tom Rini6b9709d2014-02-27 08:27:28 -05003193 $ok = 1;
Joe Hershberger05622192011-10-18 10:06:59 +00003194 }
3195
Tom Rini6b9709d2014-02-27 08:27:28 -05003196 # messages are ERROR, but ?: are CHK
Joe Hershberger05622192011-10-18 10:06:59 +00003197 if ($ok == 0) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003198 my $msg_type = \&ERROR;
3199 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3200
3201 if (&{$msg_type}("SPACING",
3202 "spaces required around that '$op' $at\n" . $hereptr)) {
3203 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3204 if (defined $fix_elements[$n + 2]) {
3205 $fix_elements[$n + 2] =~ s/^\s+//;
3206 }
3207 $line_fixed = 1;
3208 }
Joe Hershberger05622192011-10-18 10:06:59 +00003209 }
3210 }
3211 $off += length($elements[$n + 1]);
Tom Rini6b9709d2014-02-27 08:27:28 -05003212
3213## print("n: <$n> GOOD: <$good>\n");
3214
3215 $fixed_line = $fixed_line . $good;
3216 }
3217
3218 if (($#elements % 2) == 0) {
3219 $fixed_line = $fixed_line . $fix_elements[$#elements];
3220 }
3221
3222 if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {
3223 $fixed[$linenr - 1] = $fixed_line;
3224 }
3225
3226
3227 }
3228
3229# check for whitespace before a non-naked semicolon
3230 if ($line =~ /^\+.*\S\s+;\s*$/) {
3231 if (WARN("SPACING",
3232 "space prohibited before semicolon\n" . $herecurr) &&
3233 $fix) {
3234 1 while $fixed[$linenr - 1] =~
3235 s/^(\+.*\S)\s+;/$1;/;
Joe Hershberger05622192011-10-18 10:06:59 +00003236 }
3237 }
3238
3239# check for multiple assignments
3240 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3241 CHK("MULTIPLE_ASSIGNMENTS",
3242 "multiple assignments should be avoided\n" . $herecurr);
3243 }
3244
3245## # check for multiple declarations, allowing for a function declaration
3246## # continuation.
3247## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3248## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3249##
3250## # Remove any bracketed sections to ensure we do not
3251## # falsly report the parameters of functions.
3252## my $ln = $line;
3253## while ($ln =~ s/\([^\(\)]*\)//g) {
3254## }
3255## if ($ln =~ /,/) {
3256## WARN("MULTIPLE_DECLARATION",
3257## "declaring multiple variables together should be avoided\n" . $herecurr);
3258## }
3259## }
3260
3261#need space before brace following if, while, etc
3262 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3263 $line =~ /do{/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003264 if (ERROR("SPACING",
3265 "space required before the open brace '{'\n" . $herecurr) &&
3266 $fix) {
3267 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
3268 }
Joe Hershberger05622192011-10-18 10:06:59 +00003269 }
3270
Tom Rini6b9709d2014-02-27 08:27:28 -05003271## # check for blank lines before declarations
3272## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3273## $prevrawline =~ /^.\s*$/) {
3274## WARN("SPACING",
3275## "No blank lines before declarations\n" . $hereprev);
3276## }
3277##
3278
Joe Hershberger05622192011-10-18 10:06:59 +00003279# closing brace should have a space following it when it has anything
3280# on the line
3281 if ($line =~ /}(?!(?:,|;|\)))\S/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003282 if (ERROR("SPACING",
3283 "space required after that close brace '}'\n" . $herecurr) &&
3284 $fix) {
3285 $fixed[$linenr - 1] =~
3286 s/}((?!(?:,|;|\)))\S)/} $1/;
3287 }
Joe Hershberger05622192011-10-18 10:06:59 +00003288 }
3289
3290# check spacing on square brackets
3291 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003292 if (ERROR("SPACING",
3293 "space prohibited after that open square bracket '['\n" . $herecurr) &&
3294 $fix) {
3295 $fixed[$linenr - 1] =~
3296 s/\[\s+/\[/;
3297 }
Joe Hershberger05622192011-10-18 10:06:59 +00003298 }
3299 if ($line =~ /\s\]/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003300 if (ERROR("SPACING",
3301 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3302 $fix) {
3303 $fixed[$linenr - 1] =~
3304 s/\s+\]/\]/;
3305 }
Joe Hershberger05622192011-10-18 10:06:59 +00003306 }
3307
3308# check spacing on parentheses
3309 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3310 $line !~ /for\s*\(\s+;/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003311 if (ERROR("SPACING",
3312 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3313 $fix) {
3314 $fixed[$linenr - 1] =~
3315 s/\(\s+/\(/;
3316 }
Joe Hershberger05622192011-10-18 10:06:59 +00003317 }
3318 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3319 $line !~ /for\s*\(.*;\s+\)/ &&
3320 $line !~ /:\s+\)/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003321 if (ERROR("SPACING",
3322 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3323 $fix) {
3324 $fixed[$linenr - 1] =~
3325 s/\s+\)/\)/;
3326 }
Joe Hershberger05622192011-10-18 10:06:59 +00003327 }
3328
3329#goto labels aren't indented, allow a single space however
3330 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3331 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003332 if (WARN("INDENTED_LABEL",
3333 "labels should not be indented\n" . $herecurr) &&
3334 $fix) {
3335 $fixed[$linenr - 1] =~
3336 s/^(.)\s+/$1/;
3337 }
Joe Hershberger05622192011-10-18 10:06:59 +00003338 }
3339
3340# Return is not a function.
Tom Rini6b9709d2014-02-27 08:27:28 -05003341 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
Joe Hershberger05622192011-10-18 10:06:59 +00003342 my $spacing = $1;
Tom Rini6b9709d2014-02-27 08:27:28 -05003343 if ($^V && $^V ge 5.10.0 &&
3344 $stat =~ /^.\s*return\s*$balanced_parens\s*;\s*$/) {
Joe Hershberger05622192011-10-18 10:06:59 +00003345 ERROR("RETURN_PARENTHESES",
3346 "return is not a function, parentheses are not required\n" . $herecurr);
3347
3348 } elsif ($spacing !~ /\s+/) {
3349 ERROR("SPACING",
3350 "space required before the open parenthesis '('\n" . $herecurr);
3351 }
3352 }
Tom Rini6b9709d2014-02-27 08:27:28 -05003353
3354# if statements using unnecessary parentheses - ie: if ((foo == bar))
3355 if ($^V && $^V ge 5.10.0 &&
3356 $line =~ /\bif\s*((?:\(\s*){2,})/) {
3357 my $openparens = $1;
3358 my $count = $openparens =~ tr@\(@\(@;
3359 my $msg = "";
3360 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3361 my $comp = $4; #Not $1 because of $LvalOrFunc
3362 $msg = " - maybe == should be = ?" if ($comp eq "==");
3363 WARN("UNNECESSARY_PARENTHESES",
3364 "Unnecessary parentheses$msg\n" . $herecurr);
3365 }
3366 }
3367
Joe Hershberger05622192011-10-18 10:06:59 +00003368# Return of what appears to be an errno should normally be -'ve
3369 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3370 my $name = $1;
3371 if ($name ne 'EOF' && $name ne 'ERROR') {
3372 WARN("USE_NEGATIVE_ERRNO",
3373 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3374 }
3375 }
3376
Joe Hershberger05622192011-10-18 10:06:59 +00003377# Need a space before open parenthesis after if, while etc
Tom Rini6b9709d2014-02-27 08:27:28 -05003378 if ($line =~ /\b(if|while|for|switch)\(/) {
3379 if (ERROR("SPACING",
3380 "space required before the open parenthesis '('\n" . $herecurr) &&
3381 $fix) {
3382 $fixed[$linenr - 1] =~
3383 s/\b(if|while|for|switch)\(/$1 \(/;
3384 }
Joe Hershberger05622192011-10-18 10:06:59 +00003385 }
3386
3387# Check for illegal assignment in if conditional -- and check for trailing
3388# statements after the conditional.
3389 if ($line =~ /do\s*(?!{)/) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003390 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3391 ctx_statement_block($linenr, $realcnt, 0)
3392 if (!defined $stat);
Joe Hershberger05622192011-10-18 10:06:59 +00003393 my ($stat_next) = ctx_statement_block($line_nr_next,
3394 $remain_next, $off_next);
3395 $stat_next =~ s/\n./\n /g;
3396 ##print "stat<$stat> stat_next<$stat_next>\n";
3397
3398 if ($stat_next =~ /^\s*while\b/) {
3399 # If the statement carries leading newlines,
3400 # then count those as offsets.
3401 my ($whitespace) =
3402 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3403 my $offset =
3404 statement_rawlines($whitespace) - 1;
3405
3406 $suppress_whiletrailers{$line_nr_next +
3407 $offset} = 1;
3408 }
3409 }
3410 if (!defined $suppress_whiletrailers{$linenr} &&
Tom Rini6b9709d2014-02-27 08:27:28 -05003411 defined($stat) && defined($cond) &&
Joe Hershberger05622192011-10-18 10:06:59 +00003412 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3413 my ($s, $c) = ($stat, $cond);
3414
3415 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3416 ERROR("ASSIGN_IN_IF",
3417 "do not use assignment in if condition\n" . $herecurr);
3418 }
3419
3420 # Find out what is on the end of the line after the
3421 # conditional.
3422 substr($s, 0, length($c), '');
3423 $s =~ s/\n.*//g;
3424 $s =~ s/$;//g; # Remove any comments
3425 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3426 $c !~ /}\s*while\s*/)
3427 {
3428 # Find out how long the conditional actually is.
3429 my @newlines = ($c =~ /\n/gs);
3430 my $cond_lines = 1 + $#newlines;
3431 my $stat_real = '';
3432
3433 $stat_real = raw_line($linenr, $cond_lines)
3434 . "\n" if ($cond_lines);
3435 if (defined($stat_real) && $cond_lines > 1) {
3436 $stat_real = "[...]\n$stat_real";
3437 }
3438
3439 ERROR("TRAILING_STATEMENTS",
3440 "trailing statements should be on next line\n" . $herecurr . $stat_real);
3441 }
3442 }
3443
3444# Check for bitwise tests written as boolean
3445 if ($line =~ /
3446 (?:
3447 (?:\[|\(|\&\&|\|\|)
3448 \s*0[xX][0-9]+\s*
3449 (?:\&\&|\|\|)
3450 |
3451 (?:\&\&|\|\|)
3452 \s*0[xX][0-9]+\s*
3453 (?:\&\&|\|\||\)|\])
3454 )/x)
3455 {
3456 WARN("HEXADECIMAL_BOOLEAN_TEST",
3457 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3458 }
3459
3460# if and else should not have general statements after it
3461 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3462 my $s = $1;
3463 $s =~ s/$;//g; # Remove any comments
3464 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3465 ERROR("TRAILING_STATEMENTS",
3466 "trailing statements should be on next line\n" . $herecurr);
3467 }
3468 }
3469# if should not continue a brace
3470 if ($line =~ /}\s*if\b/) {
3471 ERROR("TRAILING_STATEMENTS",
3472 "trailing statements should be on next line\n" .
3473 $herecurr);
3474 }
3475# case and default should not have general statements after them
3476 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3477 $line !~ /\G(?:
3478 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3479 \s*return\s+
3480 )/xg)
3481 {
3482 ERROR("TRAILING_STATEMENTS",
3483 "trailing statements should be on next line\n" . $herecurr);
3484 }
3485
3486 # Check for }<nl>else {, these must be at the same
3487 # indent level to be relevant to each other.
3488 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3489 $previndent == $indent) {
3490 ERROR("ELSE_AFTER_BRACE",
3491 "else should follow close brace '}'\n" . $hereprev);
3492 }
3493
3494 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3495 $previndent == $indent) {
3496 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3497
3498 # Find out what is on the end of the line after the
3499 # conditional.
3500 substr($s, 0, length($c), '');
3501 $s =~ s/\n.*//g;
3502
3503 if ($s =~ /^\s*;/) {
3504 ERROR("WHILE_AFTER_BRACE",
3505 "while should follow close brace '}'\n" . $hereprev);
3506 }
3507 }
3508
Tom Rini6b9709d2014-02-27 08:27:28 -05003509#Specific variable tests
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003510 while ($line =~ m{($Constant|$Lval)}g) {
3511 my $var = $1;
Tom Rini6b9709d2014-02-27 08:27:28 -05003512
3513#gcc binary extension
3514 if ($var =~ /^$Binary$/) {
3515 if (WARN("GCC_BINARY_CONSTANT",
3516 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3517 $fix) {
3518 my $hexval = sprintf("0x%x", oct($var));
3519 $fixed[$linenr - 1] =~
3520 s/\b$var\b/$hexval/;
3521 }
3522 }
3523
3524#CamelCase
3525 if ($var !~ /^$Constant$/ &&
3526 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
3527#Ignore Page<foo> variants
3528 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
3529#Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3530 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
3531 while ($var =~ m{($Ident)}g) {
3532 my $word = $1;
3533 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
3534 if ($check) {
3535 seed_camelcase_includes();
3536 if (!$file && !$camelcase_file_seeded) {
3537 seed_camelcase_file($realfile);
3538 $camelcase_file_seeded = 1;
3539 }
3540 }
3541 if (!defined $camelcase{$word}) {
3542 $camelcase{$word} = 1;
3543 CHK("CAMELCASE",
3544 "Avoid CamelCase: <$word>\n" . $herecurr);
3545 }
3546 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003547 }
3548 }
Joe Hershberger05622192011-10-18 10:06:59 +00003549
3550#no spaces allowed after \ in define
Tom Rini6b9709d2014-02-27 08:27:28 -05003551 if ($line =~ /\#\s*define.*\\\s+$/) {
3552 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3553 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3554 $fix) {
3555 $fixed[$linenr - 1] =~ s/\s+$//;
3556 }
Joe Hershberger05622192011-10-18 10:06:59 +00003557 }
3558
3559#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3560 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
3561 my $file = "$1.h";
3562 my $checkfile = "include/linux/$file";
3563 if (-f "$root/$checkfile" &&
3564 $realfile ne $checkfile &&
3565 $1 !~ /$allowed_asm_includes/)
3566 {
3567 if ($realfile =~ m{^arch/}) {
3568 CHK("ARCH_INCLUDE_LINUX",
3569 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3570 } else {
3571 WARN("INCLUDE_LINUX",
3572 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3573 }
3574 }
3575 }
3576
3577# multi-statement macros should be enclosed in a do while loop, grab the
3578# first statement and ensure its the whole macro if its not enclosed
3579# in a known good container
3580 if ($realfile !~ m@/vmlinux.lds.h$@ &&
3581 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
3582 my $ln = $linenr;
3583 my $cnt = $realcnt;
3584 my ($off, $dstat, $dcond, $rest);
3585 my $ctx = '';
Joe Hershberger05622192011-10-18 10:06:59 +00003586 ($dstat, $dcond, $ln, $cnt, $off) =
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003587 ctx_statement_block($linenr, $realcnt, 0);
3588 $ctx = $dstat;
Joe Hershberger05622192011-10-18 10:06:59 +00003589 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3590 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3591
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003592 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
Joe Hershberger05622192011-10-18 10:06:59 +00003593 $dstat =~ s/$;//g;
3594 $dstat =~ s/\\\n.//g;
3595 $dstat =~ s/^\s*//s;
3596 $dstat =~ s/\s*$//s;
3597
3598 # Flatten any parentheses and braces
3599 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3600 $dstat =~ s/\{[^\{\}]*\}/1/ ||
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003601 $dstat =~ s/\[[^\[\]]*\]/1/)
3602 {
3603 }
3604
3605 # Flatten any obvious string concatentation.
3606 while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3607 $dstat =~ s/$Ident\s*("X*")/$1/)
Joe Hershberger05622192011-10-18 10:06:59 +00003608 {
3609 }
3610
3611 my $exceptions = qr{
3612 $Declare|
3613 module_param_named|
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003614 MODULE_PARM_DESC|
Joe Hershberger05622192011-10-18 10:06:59 +00003615 DECLARE_PER_CPU|
3616 DEFINE_PER_CPU|
3617 __typeof__\(|
3618 union|
3619 struct|
3620 \.$Ident\s*=\s*|
3621 ^\"|\"$
3622 }x;
3623 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003624 if ($dstat ne '' &&
3625 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
3626 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
Tom Rini6b9709d2014-02-27 08:27:28 -05003627 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003628 $dstat !~ /^'X'$/ && # character constants
3629 $dstat !~ /$exceptions/ &&
3630 $dstat !~ /^\.$Ident\s*=/ && # .foo =
Tom Rini6b9709d2014-02-27 08:27:28 -05003631 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003632 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
3633 $dstat !~ /^for\s*$Constant$/ && # for (...)
3634 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
3635 $dstat !~ /^do\s*{/ && # do {...
Tom Rini6b9709d2014-02-27 08:27:28 -05003636 $dstat !~ /^\({/ && # ({...
3637 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003638 {
3639 $ctx =~ s/\n*$//;
3640 my $herectx = $here . "\n";
3641 my $cnt = statement_rawlines($ctx);
3642
3643 for (my $n = 0; $n < $cnt; $n++) {
3644 $herectx .= raw_line($linenr, $n) . "\n";
Joe Hershberger05622192011-10-18 10:06:59 +00003645 }
3646
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003647 if ($dstat =~ /;/) {
3648 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3649 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3650 } else {
Joe Hershberger05622192011-10-18 10:06:59 +00003651 ERROR("COMPLEX_MACRO",
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003652 "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3653 }
3654 }
3655
3656# check for line continuations outside of #defines, preprocessor #, and asm
3657
3658 } else {
3659 if ($prevline !~ /^..*\\$/ &&
3660 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
3661 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
3662 $line =~ /^\+.*\\$/) {
3663 WARN("LINE_CONTINUATIONS",
3664 "Avoid unnecessary line continuations\n" . $herecurr);
3665 }
3666 }
3667
3668# do {} while (0) macro tests:
3669# single-statement macros do not need to be enclosed in do while (0) loop,
3670# macro should not end with a semicolon
3671 if ($^V && $^V ge 5.10.0 &&
3672 $realfile !~ m@/vmlinux.lds.h$@ &&
3673 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3674 my $ln = $linenr;
3675 my $cnt = $realcnt;
3676 my ($off, $dstat, $dcond, $rest);
3677 my $ctx = '';
3678 ($dstat, $dcond, $ln, $cnt, $off) =
3679 ctx_statement_block($linenr, $realcnt, 0);
3680 $ctx = $dstat;
3681
3682 $dstat =~ s/\\\n.//g;
3683
3684 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3685 my $stmts = $2;
3686 my $semis = $3;
3687
3688 $ctx =~ s/\n*$//;
3689 my $cnt = statement_rawlines($ctx);
3690 my $herectx = $here . "\n";
3691
3692 for (my $n = 0; $n < $cnt; $n++) {
3693 $herectx .= raw_line($linenr, $n) . "\n";
3694 }
3695
3696 if (($stmts =~ tr/;/;/) == 1 &&
3697 $stmts !~ /^\s*(if|while|for|switch)\b/) {
3698 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3699 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3700 }
3701 if (defined $semis && $semis ne "") {
3702 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3703 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
Joe Hershberger05622192011-10-18 10:06:59 +00003704 }
3705 }
3706 }
3707
3708# make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3709# all assignments may have only one of the following with an assignment:
3710# .
3711# ALIGN(...)
3712# VMLINUX_SYMBOL(...)
3713 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
3714 WARN("MISSING_VMLINUX_SYMBOL",
3715 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3716 }
3717
3718# check for redundant bracing round if etc
3719 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3720 my ($level, $endln, @chunks) =
3721 ctx_statement_full($linenr, $realcnt, 1);
3722 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3723 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3724 if ($#chunks > 0 && $level == 0) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003725 my @allowed = ();
3726 my $allow = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00003727 my $seen = 0;
3728 my $herectx = $here . "\n";
3729 my $ln = $linenr - 1;
3730 for my $chunk (@chunks) {
3731 my ($cond, $block) = @{$chunk};
3732
3733 # If the condition carries leading newlines, then count those as offsets.
3734 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3735 my $offset = statement_rawlines($whitespace) - 1;
3736
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003737 $allowed[$allow] = 0;
Joe Hershberger05622192011-10-18 10:06:59 +00003738 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3739
3740 # We have looked at and allowed this specific line.
3741 $suppress_ifbraces{$ln + $offset} = 1;
3742
3743 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3744 $ln += statement_rawlines($block) - 1;
3745
3746 substr($block, 0, length($cond), '');
3747
3748 $seen++ if ($block =~ /^\s*{/);
3749
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003750 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
Joe Hershberger05622192011-10-18 10:06:59 +00003751 if (statement_lines($cond) > 1) {
3752 #print "APW: ALLOWED: cond<$cond>\n";
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003753 $allowed[$allow] = 1;
Joe Hershberger05622192011-10-18 10:06:59 +00003754 }
3755 if ($block =~/\b(?:if|for|while)\b/) {
3756 #print "APW: ALLOWED: block<$block>\n";
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003757 $allowed[$allow] = 1;
Joe Hershberger05622192011-10-18 10:06:59 +00003758 }
3759 if (statement_block_size($block) > 1) {
3760 #print "APW: ALLOWED: lines block<$block>\n";
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003761 $allowed[$allow] = 1;
Joe Hershberger05622192011-10-18 10:06:59 +00003762 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003763 $allow++;
Joe Hershberger05622192011-10-18 10:06:59 +00003764 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003765 if ($seen) {
3766 my $sum_allowed = 0;
3767 foreach (@allowed) {
3768 $sum_allowed += $_;
3769 }
3770 if ($sum_allowed == 0) {
3771 WARN("BRACES",
3772 "braces {} are not necessary for any arm of this statement\n" . $herectx);
3773 } elsif ($sum_allowed != $allow &&
3774 $seen != $allow) {
3775 CHK("BRACES",
3776 "braces {} should be used on all arms of this statement\n" . $herectx);
3777 }
Joe Hershberger05622192011-10-18 10:06:59 +00003778 }
3779 }
3780 }
3781 if (!defined $suppress_ifbraces{$linenr - 1} &&
3782 $line =~ /\b(if|while|for|else)\b/) {
3783 my $allowed = 0;
3784
3785 # Check the pre-context.
3786 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3787 #print "APW: ALLOWED: pre<$1>\n";
3788 $allowed = 1;
3789 }
3790
3791 my ($level, $endln, @chunks) =
3792 ctx_statement_full($linenr, $realcnt, $-[0]);
3793
3794 # Check the condition.
3795 my ($cond, $block) = @{$chunks[0]};
3796 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3797 if (defined $cond) {
3798 substr($block, 0, length($cond), '');
3799 }
3800 if (statement_lines($cond) > 1) {
3801 #print "APW: ALLOWED: cond<$cond>\n";
3802 $allowed = 1;
3803 }
3804 if ($block =~/\b(?:if|for|while)\b/) {
3805 #print "APW: ALLOWED: block<$block>\n";
3806 $allowed = 1;
3807 }
3808 if (statement_block_size($block) > 1) {
3809 #print "APW: ALLOWED: lines block<$block>\n";
3810 $allowed = 1;
3811 }
3812 # Check the post-context.
3813 if (defined $chunks[1]) {
3814 my ($cond, $block) = @{$chunks[1]};
3815 if (defined $cond) {
3816 substr($block, 0, length($cond), '');
3817 }
3818 if ($block =~ /^\s*\{/) {
3819 #print "APW: ALLOWED: chunk-1 block<$block>\n";
3820 $allowed = 1;
3821 }
3822 }
3823 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003824 my $herectx = $here . "\n";
Joe Hershberger05622192011-10-18 10:06:59 +00003825 my $cnt = statement_rawlines($block);
3826
3827 for (my $n = 0; $n < $cnt; $n++) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003828 $herectx .= raw_line($linenr, $n) . "\n";
Joe Hershberger05622192011-10-18 10:06:59 +00003829 }
3830
3831 WARN("BRACES",
3832 "braces {} are not necessary for single statement blocks\n" . $herectx);
3833 }
3834 }
3835
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003836# check for unnecessary blank lines around braces
Tom Rini6b9709d2014-02-27 08:27:28 -05003837 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003838 CHK("BRACES",
3839 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
Joe Hershberger05622192011-10-18 10:06:59 +00003840 }
Tom Rini6b9709d2014-02-27 08:27:28 -05003841 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003842 CHK("BRACES",
3843 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
Joe Hershberger05622192011-10-18 10:06:59 +00003844 }
3845
3846# no volatiles please
3847 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
3848 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
3849 WARN("VOLATILE",
3850 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3851 }
3852
3853# warn about #if 0
3854 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
3855 CHK("REDUNDANT_CODE",
3856 "if this code is redundant consider removing it\n" .
3857 $herecurr);
3858 }
3859
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003860# check for needless "if (<foo>) fn(<foo>)" uses
3861 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
3862 my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
3863 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
3864 WARN('NEEDLESS_IF',
3865 "$1(NULL) is safe this check is probably not required\n" . $hereprev);
Joe Hershberger05622192011-10-18 10:06:59 +00003866 }
3867 }
3868
Tom Rini6b9709d2014-02-27 08:27:28 -05003869# check for bad placement of section $InitAttribute (e.g.: __initdata)
3870 if ($line =~ /(\b$InitAttribute\b)/) {
3871 my $attr = $1;
3872 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
3873 my $ptr = $1;
3874 my $var = $2;
3875 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
3876 ERROR("MISPLACED_INIT",
3877 "$attr should be placed after $var\n" . $herecurr)) ||
3878 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
3879 WARN("MISPLACED_INIT",
3880 "$attr should be placed after $var\n" . $herecurr))) &&
3881 $fix) {
3882 $fixed[$linenr - 1] =~ 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;
3883 }
3884 }
3885 }
3886
3887# check for $InitAttributeData (ie: __initdata) with const
3888 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
3889 my $attr = $1;
3890 $attr =~ /($InitAttributePrefix)(.*)/;
3891 my $attr_prefix = $1;
3892 my $attr_type = $2;
3893 if (ERROR("INIT_ATTRIBUTE",
3894 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
3895 $fix) {
3896 $fixed[$linenr - 1] =~
3897 s/$InitAttributeData/${attr_prefix}initconst/;
3898 }
3899 }
3900
3901# check for $InitAttributeConst (ie: __initconst) without const
3902 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
3903 my $attr = $1;
3904 if (ERROR("INIT_ATTRIBUTE",
3905 "Use of $attr requires a separate use of const\n" . $herecurr) &&
3906 $fix) {
3907 my $lead = $fixed[$linenr - 1] =~
3908 /(^\+\s*(?:static\s+))/;
3909 $lead = rtrim($1);
3910 $lead = "$lead " if ($lead !~ /^\+$/);
3911 $lead = "${lead}const ";
3912 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
3913 }
3914 }
3915
Joe Hershberger05622192011-10-18 10:06:59 +00003916# prefer usleep_range over udelay
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003917 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
Joe Hershberger05622192011-10-18 10:06:59 +00003918 # ignore udelay's < 10, however
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00003919 if (! ($1 < 10) ) {
Joe Hershberger05622192011-10-18 10:06:59 +00003920 CHK("USLEEP_RANGE",
3921 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);
3922 }
3923 }
3924
3925# warn about unexpectedly long msleep's
3926 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
3927 if ($1 < 20) {
3928 WARN("MSLEEP",
3929 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3930 }
3931 }
3932
Tom Rini6b9709d2014-02-27 08:27:28 -05003933# check for comparisons of jiffies
3934 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
3935 WARN("JIFFIES_COMPARISON",
3936 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
3937 }
3938
3939# check for comparisons of get_jiffies_64()
3940 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
3941 WARN("JIFFIES_COMPARISON",
3942 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
3943 }
3944
Joe Hershberger05622192011-10-18 10:06:59 +00003945# warn about #ifdefs in C files
3946# if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3947# print "#ifdef in C files should be avoided\n";
3948# print "$herecurr";
3949# $clean = 0;
3950# }
3951
3952# warn about spacing in #ifdefs
3953 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003954 if (ERROR("SPACING",
3955 "exactly one space required after that #$1\n" . $herecurr) &&
3956 $fix) {
3957 $fixed[$linenr - 1] =~
3958 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
3959 }
3960
Joe Hershberger05622192011-10-18 10:06:59 +00003961 }
3962
3963# check for spinlock_t definitions without a comment.
3964 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
3965 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
3966 my $which = $1;
3967 if (!ctx_has_comment($first_line, $linenr)) {
3968 CHK("UNCOMMENTED_DEFINITION",
3969 "$1 definition without comment\n" . $herecurr);
3970 }
3971 }
3972# check for memory barriers without a comment.
3973 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3974 if (!ctx_has_comment($first_line, $linenr)) {
Tom Rini6b9709d2014-02-27 08:27:28 -05003975 WARN("MEMORY_BARRIER",
3976 "memory barrier without comment\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00003977 }
3978 }
3979# check of hardware specific defines
3980 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
3981 CHK("ARCH_DEFINES",
3982 "architecture specific defines should be avoided\n" . $herecurr);
3983 }
3984
3985# Check that the storage class is at the beginning of a declaration
3986 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
3987 WARN("STORAGE_CLASS",
3988 "storage class should be at the beginning of the declaration\n" . $herecurr)
3989 }
3990
3991# check the location of the inline attribute, that it is between
3992# storage class and type.
3993 if ($line =~ /\b$Type\s+$Inline\b/ ||
3994 $line =~ /\b$Inline\s+$Storage\b/) {
3995 ERROR("INLINE_LOCATION",
3996 "inline keyword should sit between storage class and type\n" . $herecurr);
3997 }
3998
3999# Check for __inline__ and __inline, prefer inline
Tom Rini6b9709d2014-02-27 08:27:28 -05004000 if ($realfile !~ m@\binclude/uapi/@ &&
4001 $line =~ /\b(__inline__|__inline)\b/) {
4002 if (WARN("INLINE",
4003 "plain inline is preferred over $1\n" . $herecurr) &&
4004 $fix) {
4005 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4006
4007 }
Joe Hershberger05622192011-10-18 10:06:59 +00004008 }
4009
4010# Check for __attribute__ packed, prefer __packed
Tom Rini6b9709d2014-02-27 08:27:28 -05004011 if ($realfile !~ m@\binclude/uapi/@ &&
4012 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
Joe Hershberger05622192011-10-18 10:06:59 +00004013 WARN("PREFER_PACKED",
4014 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4015 }
Tom Rinif503cc42014-02-25 10:27:00 -05004016# Check for new packed members, warn to use care
4017 if ($line =~ /\b(__attribute__\s*\(\s*\(.*\bpacked|__packed)\b/) {
4018 WARN("NEW_PACKED",
4019 "Adding new packed members is to be done with care\n" . $herecurr);
4020 }
Joe Hershberger05622192011-10-18 10:06:59 +00004021
4022# Check for __attribute__ aligned, prefer __aligned
Tom Rini6b9709d2014-02-27 08:27:28 -05004023 if ($realfile !~ m@\binclude/uapi/@ &&
4024 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
Joe Hershberger05622192011-10-18 10:06:59 +00004025 WARN("PREFER_ALIGNED",
4026 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4027 }
4028
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004029# Check for __attribute__ format(printf, prefer __printf
Tom Rini6b9709d2014-02-27 08:27:28 -05004030 if ($realfile !~ m@\binclude/uapi/@ &&
4031 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4032 if (WARN("PREFER_PRINTF",
4033 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4034 $fix) {
4035 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4036
4037 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004038 }
4039
4040# Check for __attribute__ format(scanf, prefer __scanf
Tom Rini6b9709d2014-02-27 08:27:28 -05004041 if ($realfile !~ m@\binclude/uapi/@ &&
4042 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4043 if (WARN("PREFER_SCANF",
4044 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4045 $fix) {
4046 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4047 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004048 }
4049
Joe Hershberger05622192011-10-18 10:06:59 +00004050# check for sizeof(&)
4051 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4052 WARN("SIZEOF_ADDRESS",
4053 "sizeof(& should be avoided\n" . $herecurr);
4054 }
4055
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004056# check for sizeof without parenthesis
4057 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004058 if (WARN("SIZEOF_PARENTHESIS",
4059 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4060 $fix) {
4061 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4062 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004063 }
4064
Joe Hershberger05622192011-10-18 10:06:59 +00004065# check for line continuations in quoted strings with odd counts of "
4066 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4067 WARN("LINE_CONTINUATIONS",
4068 "Avoid line continuations in quoted strings\n" . $herecurr);
4069 }
4070
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004071# check for struct spinlock declarations
4072 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4073 WARN("USE_SPINLOCK_T",
4074 "struct spinlock should be spinlock_t\n" . $herecurr);
4075 }
4076
Tom Rini6b9709d2014-02-27 08:27:28 -05004077# check for seq_printf uses that could be seq_puts
4078 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4079 my $fmt = get_quoted_string($line, $rawline);
4080 if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4081 if (WARN("PREFER_SEQ_PUTS",
4082 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4083 $fix) {
4084 $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4085 }
4086 }
4087 }
4088
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004089# Check for misused memsets
4090 if ($^V && $^V ge 5.10.0 &&
4091 defined $stat &&
4092 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4093
4094 my $ms_addr = $2;
4095 my $ms_val = $7;
4096 my $ms_size = $12;
4097
4098 if ($ms_size =~ /^(0x|)0$/i) {
4099 ERROR("MEMSET",
4100 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4101 } elsif ($ms_size =~ /^(0x|)1$/i) {
4102 WARN("MEMSET",
4103 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4104 }
4105 }
4106
Tom Rini6b9709d2014-02-27 08:27:28 -05004107# Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4108 if ($^V && $^V ge 5.10.0 &&
4109 $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4110 if (WARN("PREFER_ETHER_ADDR_COPY",
4111 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4112 $fix) {
4113 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4114 }
4115 }
4116
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004117# typecasts on min/max could be min_t/max_t
4118 if ($^V && $^V ge 5.10.0 &&
4119 defined $stat &&
4120 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4121 if (defined $2 || defined $7) {
4122 my $call = $1;
4123 my $cast1 = deparenthesize($2);
4124 my $arg1 = $3;
4125 my $cast2 = deparenthesize($7);
4126 my $arg2 = $8;
4127 my $cast;
4128
4129 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4130 $cast = "$cast1 or $cast2";
4131 } elsif ($cast1 ne "") {
4132 $cast = $cast1;
4133 } else {
4134 $cast = $cast2;
4135 }
4136 WARN("MINMAX",
4137 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4138 }
4139 }
4140
4141# check usleep_range arguments
4142 if ($^V && $^V ge 5.10.0 &&
4143 defined $stat &&
4144 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4145 my $min = $1;
4146 my $max = $7;
4147 if ($min eq $max) {
4148 WARN("USLEEP_RANGE",
4149 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4150 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4151 $min > $max) {
4152 WARN("USLEEP_RANGE",
4153 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4154 }
4155 }
4156
Tom Rini6b9709d2014-02-27 08:27:28 -05004157# check for naked sscanf
4158 if ($^V && $^V ge 5.10.0 &&
4159 defined $stat &&
4160 $stat =~ /\bsscanf\b/ &&
4161 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4162 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4163 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4164 my $lc = $stat =~ tr@\n@@;
4165 $lc = $lc + $linenr;
4166 my $stat_real = raw_line($linenr, 0);
4167 for (my $count = $linenr + 1; $count <= $lc; $count++) {
4168 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4169 }
4170 WARN("NAKED_SSCANF",
4171 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4172 }
4173
4174# check for new externs in .h files.
4175 if ($realfile =~ /\.h$/ &&
4176 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4177 if (CHK("AVOID_EXTERNS",
4178 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4179 $fix) {
4180 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4181 }
4182 }
4183
Joe Hershberger05622192011-10-18 10:06:59 +00004184# check for new externs in .c files.
4185 if ($realfile =~ /\.c$/ && defined $stat &&
4186 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4187 {
4188 my $function_name = $1;
4189 my $paren_space = $2;
4190
4191 my $s = $stat;
4192 if (defined $cond) {
4193 substr($s, 0, length($cond), '');
4194 }
4195 if ($s =~ /^\s*;/ &&
4196 $function_name ne 'uninitialized_var')
4197 {
4198 WARN("AVOID_EXTERNS",
4199 "externs should be avoided in .c files\n" . $herecurr);
4200 }
4201
4202 if ($paren_space =~ /\n/) {
4203 WARN("FUNCTION_ARGUMENTS",
4204 "arguments for function declarations should follow identifier\n" . $herecurr);
4205 }
4206
4207 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4208 $stat =~ /^.\s*extern\s+/)
4209 {
4210 WARN("AVOID_EXTERNS",
4211 "externs should be avoided in .c files\n" . $herecurr);
4212 }
4213
4214# checks for new __setup's
4215 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4216 my $name = $1;
4217
4218 if (!grep(/$name/, @setup_docs)) {
4219 CHK("UNDOCUMENTED_SETUP",
4220 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4221 }
4222 }
4223
4224# check for pointless casting of kmalloc return
4225 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4226 WARN("UNNECESSARY_CASTS",
4227 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4228 }
4229
Tom Rini6b9709d2014-02-27 08:27:28 -05004230# alloc style
4231# p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4232 if ($^V && $^V ge 5.10.0 &&
4233 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4234 CHK("ALLOC_SIZEOF_STRUCT",
4235 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4236 }
4237
4238# check for krealloc arg reuse
4239 if ($^V && $^V ge 5.10.0 &&
4240 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4241 WARN("KREALLOC_ARG_REUSE",
4242 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4243 }
4244
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004245# check for alloc argument mismatch
4246 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4247 WARN("ALLOC_ARRAY_ARGS",
4248 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00004249 }
4250
Tom Rini6b9709d2014-02-27 08:27:28 -05004251# check for GFP_NOWAIT use
4252 if ($line =~ /\b__GFP_NOFAIL\b/) {
4253 WARN("__GFP_NOFAIL",
4254 "Use of __GFP_NOFAIL is deprecated, no new users should be added\n" . $herecurr);
4255 }
4256
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004257# check for multiple semicolons
4258 if ($line =~ /;\s*;\s*$/) {
Tom Rini6b9709d2014-02-27 08:27:28 -05004259 if (WARN("ONE_SEMICOLON",
4260 "Statements terminations use 1 semicolon\n" . $herecurr) &&
4261 $fix) {
4262 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4263 }
4264 }
4265
4266# check for case / default statements not preceeded by break/fallthrough/switch
4267 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4268 my $has_break = 0;
4269 my $has_statement = 0;
4270 my $count = 0;
4271 my $prevline = $linenr;
4272 while ($prevline > 1 && $count < 3 && !$has_break) {
4273 $prevline--;
4274 my $rline = $rawlines[$prevline - 1];
4275 my $fline = $lines[$prevline - 1];
4276 last if ($fline =~ /^\@\@/);
4277 next if ($fline =~ /^\-/);
4278 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4279 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4280 next if ($fline =~ /^.[\s$;]*$/);
4281 $has_statement = 1;
4282 $count++;
4283 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4284 }
4285 if (!$has_break && $has_statement) {
4286 WARN("MISSING_BREAK",
4287 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4288 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004289 }
4290
4291# check for switch/default statements without a break;
4292 if ($^V && $^V ge 5.10.0 &&
4293 defined $stat &&
4294 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4295 my $ctx = '';
4296 my $herectx = $here . "\n";
4297 my $cnt = statement_rawlines($stat);
4298 for (my $n = 0; $n < $cnt; $n++) {
4299 $herectx .= raw_line($linenr, $n) . "\n";
4300 }
4301 WARN("DEFAULT_NO_BREAK",
4302 "switch default: should use break\n" . $herectx);
Eric Nelson172a3a82012-05-02 20:32:18 -07004303 }
4304
Joe Hershberger05622192011-10-18 10:06:59 +00004305# check for gcc specific __FUNCTION__
Tom Rini6b9709d2014-02-27 08:27:28 -05004306 if ($line =~ /\b__FUNCTION__\b/) {
4307 if (WARN("USE_FUNC",
4308 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
4309 $fix) {
4310 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4311 }
Joe Hershberger05622192011-10-18 10:06:59 +00004312 }
4313
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004314# check for use of yield()
4315 if ($line =~ /\byield\s*\(\s*\)/) {
4316 WARN("YIELD",
4317 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
4318 }
4319
Tom Rini6b9709d2014-02-27 08:27:28 -05004320# check for comparisons against true and false
4321 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4322 my $lead = $1;
4323 my $arg = $2;
4324 my $test = $3;
4325 my $otype = $4;
4326 my $trail = $5;
4327 my $op = "!";
4328
4329 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4330
4331 my $type = lc($otype);
4332 if ($type =~ /^(?:true|false)$/) {
4333 if (("$test" eq "==" && "$type" eq "true") ||
4334 ("$test" eq "!=" && "$type" eq "false")) {
4335 $op = "";
4336 }
4337
4338 CHK("BOOL_COMPARISON",
4339 "Using comparison to $otype is error prone\n" . $herecurr);
4340
4341## maybe suggesting a correct construct would better
4342## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4343
4344 }
4345 }
4346
Joe Hershberger05622192011-10-18 10:06:59 +00004347# check for semaphores initialized locked
4348 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4349 WARN("CONSIDER_COMPLETION",
4350 "consider using a completion\n" . $herecurr);
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004351 }
Joe Hershberger05622192011-10-18 10:06:59 +00004352
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004353# recommend kstrto* over simple_strto* and strict_strto*
4354 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
Joe Hershberger05622192011-10-18 10:06:59 +00004355 WARN("CONSIDER_KSTRTO",
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004356 "$1 is obsolete, use k$3 instead\n" . $herecurr);
Joe Hershberger05622192011-10-18 10:06:59 +00004357 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004358
Joe Hershberger05622192011-10-18 10:06:59 +00004359# check for __initcall(), use device_initcall() explicitly please
4360 if ($line =~ /^.\s*__initcall\s*\(/) {
4361 WARN("USE_DEVICE_INITCALL",
4362 "please use device_initcall() instead of __initcall()\n" . $herecurr);
4363 }
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004364
Joe Hershberger05622192011-10-18 10:06:59 +00004365# check for various ops structs, ensure they are const.
4366 my $struct_ops = qr{acpi_dock_ops|
4367 address_space_operations|
4368 backlight_ops|
4369 block_device_operations|
4370 dentry_operations|
4371 dev_pm_ops|
4372 dma_map_ops|
4373 extent_io_ops|
4374 file_lock_operations|
4375 file_operations|
4376 hv_ops|
4377 ide_dma_ops|
4378 intel_dvo_dev_ops|
4379 item_operations|
4380 iwl_ops|
4381 kgdb_arch|
4382 kgdb_io|
4383 kset_uevent_ops|
4384 lock_manager_operations|
4385 microcode_ops|
4386 mtrr_ops|
4387 neigh_ops|
4388 nlmsvc_binding|
4389 pci_raw_ops|
4390 pipe_buf_operations|
4391 platform_hibernation_ops|
4392 platform_suspend_ops|
4393 proto_ops|
4394 rpc_pipe_ops|
4395 seq_operations|
4396 snd_ac97_build_ops|
4397 soc_pcmcia_socket_ops|
4398 stacktrace_ops|
4399 sysfs_ops|
4400 tty_operations|
4401 usb_mon_operations|
4402 wd_ops}x;
4403 if ($line !~ /\bconst\b/ &&
4404 $line =~ /\bstruct\s+($struct_ops)\b/) {
4405 WARN("CONST_STRUCT",
4406 "struct $1 should normally be const\n" .
4407 $herecurr);
4408 }
4409
4410# use of NR_CPUS is usually wrong
4411# ignore definitions of NR_CPUS and usage to define arrays as likely right
4412 if ($line =~ /\bNR_CPUS\b/ &&
4413 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4414 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4415 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4416 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4417 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4418 {
4419 WARN("NR_CPUS",
4420 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4421 }
4422
Tom Rini6b9709d2014-02-27 08:27:28 -05004423# Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4424 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4425 ERROR("DEFINE_ARCH_HAS",
4426 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4427 }
4428
Joe Hershberger05622192011-10-18 10:06:59 +00004429# check for %L{u,d,i} in strings
4430 my $string;
4431 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4432 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4433 $string =~ s/%%/__/g;
4434 if ($string =~ /(?<!%)%L[udi]/) {
4435 WARN("PRINTF_L",
4436 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4437 last;
4438 }
4439 }
4440
4441# whine mightly about in_atomic
4442 if ($line =~ /\bin_atomic\s*\(/) {
4443 if ($realfile =~ m@^drivers/@) {
4444 ERROR("IN_ATOMIC",
4445 "do not use in_atomic in drivers\n" . $herecurr);
4446 } elsif ($realfile !~ m@^kernel/@) {
4447 WARN("IN_ATOMIC",
4448 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
4449 }
4450 }
4451
4452# check for lockdep_set_novalidate_class
4453 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4454 $line =~ /__lockdep_no_validate__\s*\)/ ) {
4455 if ($realfile !~ m@^kernel/lockdep@ &&
4456 $realfile !~ m@^include/linux/lockdep@ &&
4457 $realfile !~ m@^drivers/base/core@) {
4458 ERROR("LOCKDEP",
4459 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
4460 }
4461 }
4462
4463 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4464 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
4465 WARN("EXPORTED_WORLD_WRITABLE",
4466 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4467 }
Joe Hershberger05622192011-10-18 10:06:59 +00004468 }
4469
4470 # If we have no input at all, then there is nothing to report on
4471 # so just keep quiet.
4472 if ($#rawlines == -1) {
4473 exit(0);
4474 }
4475
4476 # In mailback mode only produce a report in the negative, for
4477 # things that appear to be patches.
4478 if ($mailback && ($clean == 1 || !$is_patch)) {
4479 exit(0);
4480 }
4481
4482 # This is not a patch, and we are are in 'no-patch' mode so
4483 # just keep quiet.
4484 if (!$chk_patch && !$is_patch) {
4485 exit(0);
4486 }
4487
4488 if (!$is_patch) {
4489 ERROR("NOT_UNIFIED_DIFF",
4490 "Does not appear to be a unified-diff format patch\n");
4491 }
4492 if ($is_patch && $chk_signoff && $signoff == 0) {
4493 ERROR("MISSING_SIGN_OFF",
4494 "Missing Signed-off-by: line(s)\n");
4495 }
4496
4497 print report_dump();
4498 if ($summary && !($clean == 1 && $quiet == 1)) {
4499 print "$filename " if ($summary_file);
4500 print "total: $cnt_error errors, $cnt_warn warnings, " .
4501 (($check)? "$cnt_chk checks, " : "") .
4502 "$cnt_lines lines checked\n";
4503 print "\n" if ($quiet == 0);
4504 }
4505
4506 if ($quiet == 0) {
Kim Phillipsd45a6ae2013-02-28 12:53:52 +00004507
4508 if ($^V lt 5.10.0) {
4509 print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4510 print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4511 }
4512
Joe Hershberger05622192011-10-18 10:06:59 +00004513 # If there were whitespace errors which cleanpatch can fix
4514 # then suggest that.
4515 if ($rpt_cleaners) {
4516 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4517 print " scripts/cleanfile\n\n";
4518 $rpt_cleaners = 0;
4519 }
4520 }
4521
Tom Rini6b9709d2014-02-27 08:27:28 -05004522 hash_show_words(\%use_type, "Used");
4523 hash_show_words(\%ignore_type, "Ignored");
4524
4525 if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
4526 my $newfile = $filename;
4527 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
4528 my $linecount = 0;
4529 my $f;
4530
4531 open($f, '>', $newfile)
4532 or die "$P: Can't open $newfile for write\n";
4533 foreach my $fixed_line (@fixed) {
4534 $linecount++;
4535 if ($file) {
4536 if ($linecount > 3) {
4537 $fixed_line =~ s/^\+//;
4538 print $f $fixed_line. "\n";
4539 }
4540 } else {
4541 print $f $fixed_line . "\n";
4542 }
4543 }
4544 close($f);
4545
4546 if (!$quiet) {
4547 print << "EOM";
4548Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4549
4550Do _NOT_ trust the results written to this file.
4551Do _NOT_ submit these changes without inspecting them for correctness.
4552
4553This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4554No warranties, expressed or implied...
4555
4556EOM
4557 }
Joe Hershberger05622192011-10-18 10:06:59 +00004558 }
4559
4560 if ($clean == 1 && $quiet == 0) {
4561 print "$vname has no obvious style problems and is ready for submission.\n"
4562 }
4563 if ($clean == 0 && $quiet == 0) {
4564 print << "EOM";
4565$vname has style problems, please review.
4566
4567If any of these errors are false positives, please report
Tom Rini6b9709d2014-02-27 08:27:28 -05004568them to the maintainer, see CHECKPATCH in MAINTAINERS.
Joe Hershberger05622192011-10-18 10:06:59 +00004569EOM
4570 }
4571
4572 return $clean;
4573}