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