Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
checkpatch: add logging functions
[openocd.git] / tools / 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
10 my $P = $0;
11 $P =~ s@.*/@@g;
12
13 my $V = '0.32';
14
15 use Getopt::Long qw(:config no_auto_abbrev);
16
17 my $quiet = 0;
18 my $tree = 1;
19 my $chk_signoff = 1;
20 my $chk_patch = 1;
21 my $tst_only;
22 my $emacs = 0;
23 my $terse = 0;
24 my $file = 0;
25 my $check = 0;
26 my $summary = 1;
27 my $mailback = 0;
28 my $summary_file = 0;
29 my $show_types = 0;
30 my $root;
31 my %debug;
32 my %ignore_type = ();
33 my @ignore = ();
34 my $help = 0;
35 my $configuration_file = ".checkpatch.conf";
36
37 sub help {
38 my ($exitcode) = @_;
39
40 print << "EOM";
41 Usage: $P [OPTION]... [FILE]...
42 Version: $V
43
44 Options:
45 -q, --quiet quiet
46 --no-tree run without a kernel tree
47 --no-signoff do not check for 'Signed-off-by' line
48 --patch treat FILE as patchfile (default)
49 --emacs emacs compile window format
50 --terse one line per report
51 -f, --file treat FILE as regular source file
52 --subjective, --strict enable more subjective tests
53 --ignore TYPE(,TYPE2...) ignore various comma separated message types
54 --show-types show the message "types" in the output
55 --root=PATH PATH to the kernel tree root
56 --no-summary suppress the per-file summary
57 --mailback only produce a report in case of warnings/errors
58 --summary-file include the filename in summary
59 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
60 'values', 'possible', 'type', and 'attr' (default
61 is all off)
62 --test-only=WORD report only warnings/errors containing WORD
63 literally
64 -h, --help, --version display this help and exit
65
66 When FILE is - read standard input.
67 EOM
68
69 exit($exitcode);
70 }
71
72 my $conf = which_conf($configuration_file);
73 if (-f $conf) {
74 my @conf_args;
75 open(my $conffile, '<', "$conf")
76 or warn "$P: Can't find a readable $configuration_file file $!\n";
77
78 while (<$conffile>) {
79 my $line = $_;
80
81 $line =~ s/\s*\n?$//g;
82 $line =~ s/^\s*//g;
83 $line =~ s/\s+/ /g;
84
85 next if ($line =~ m/^\s*#/);
86 next if ($line =~ m/^\s*$/);
87
88 my @words = split(" ", $line);
89 foreach my $word (@words) {
90 last if ($word =~ m/^#/);
91 push (@conf_args, $word);
92 }
93 }
94 close($conffile);
95 unshift(@ARGV, @conf_args) if @conf_args;
96 }
97
98 GetOptions(
99 'q|quiet+' => \$quiet,
100 'tree!' => \$tree,
101 'signoff!' => \$chk_signoff,
102 'patch!' => \$chk_patch,
103 'emacs!' => \$emacs,
104 'terse!' => \$terse,
105 'f|file!' => \$file,
106 'subjective!' => \$check,
107 'strict!' => \$check,
108 'ignore=s' => \@ignore,
109 'show-types!' => \$show_types,
110 'root=s' => \$root,
111 'summary!' => \$summary,
112 'mailback!' => \$mailback,
113 'summary-file!' => \$summary_file,
114
115 'debug=s' => \%debug,
116 'test-only=s' => \$tst_only,
117 'h|help' => \$help,
118 'version' => \$help
119 ) or help(1);
120
121 help(0) if ($help);
122
123 my $exit = 0;
124
125 if ($#ARGV < 0) {
126 print "$P: no input files\n";
127 exit(1);
128 }
129
130 @ignore = split(/,/, join(',',@ignore));
131 foreach my $word (@ignore) {
132 $word =~ s/\s*\n?$//g;
133 $word =~ s/^\s*//g;
134 $word =~ s/\s+/ /g;
135 $word =~ tr/[a-z]/[A-Z]/;
136
137 next if ($word =~ m/^\s*#/);
138 next if ($word =~ m/^\s*$/);
139
140 $ignore_type{$word}++;
141 }
142
143 my $dbg_values = 0;
144 my $dbg_possible = 0;
145 my $dbg_type = 0;
146 my $dbg_attr = 0;
147 for my $key (keys %debug) {
148 ## no critic
149 eval "\${dbg_$key} = '$debug{$key}';";
150 die "$@" if ($@);
151 }
152
153 my $rpt_cleaners = 0;
154
155 if ($terse) {
156 $emacs = 1;
157 $quiet++;
158 }
159
160 if ($tree) {
161 if (defined $root) {
162 if (!top_of_kernel_tree($root)) {
163 die "$P: $root: --root does not point at a valid tree\n";
164 }
165 } else {
166 if (top_of_kernel_tree('.')) {
167 $root = '.';
168 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
169 top_of_kernel_tree($1)) {
170 $root = $1;
171 }
172 }
173
174 if (!defined $root) {
175 print "Must be run from the top-level dir. of a kernel tree\n";
176 exit(2);
177 }
178 }
179
180 my $emitted_corrupt = 0;
181
182 our $Ident = qr{
183 [A-Za-z_][A-Za-z\d_]*
184 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
185 }x;
186 our $Storage = qr{extern|static|asmlinkage};
187 our $Sparse = qr{
188 __user|
189 __kernel|
190 __force|
191 __iomem|
192 __must_check|
193 __init_refok|
194 __kprobes|
195 __ref|
196 __rcu
197 }x;
198
199 # Notes to $Attribute:
200 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
201 our $Attribute = qr{
202 const|
203 __percpu|
204 __nocast|
205 __safe|
206 __bitwise__|
207 __packed__|
208 __packed2__|
209 __naked|
210 __maybe_unused|
211 __always_unused|
212 __noreturn|
213 __used|
214 __cold|
215 __noclone|
216 __deprecated|
217 __read_mostly|
218 __kprobes|
219 __(?:mem|cpu|dev|)(?:initdata|initconst|init\b)|
220 ____cacheline_aligned|
221 ____cacheline_aligned_in_smp|
222 ____cacheline_internodealigned_in_smp|
223 __weak
224 }x;
225 our $Modifier;
226 our $Inline = qr{inline|__always_inline|noinline};
227 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
228 our $Lval = qr{$Ident(?:$Member)*};
229
230 our $Constant = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
231 our $Assignment = qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
232 our $Compare = qr{<=|>=|==|!=|<|>};
233 our $Operators = qr{
234 <=|>=|==|!=|
235 =>|->|<<|>>|<|>|!|~|
236 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
237 }x;
238
239 our $NonptrType;
240 our $Type;
241 our $Declare;
242
243 our $UTF8 = qr {
244 [\x09\x0A\x0D\x20-\x7E] # ASCII
245 | [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
246 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
247 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
248 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
249 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
250 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
251 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
252 }x;
253
254 our $typeTypedefs = qr{(?x:
255 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
256 atomic_t
257 )};
258
259 our $logFunctions = qr{(?x:
260 printk(?:_ratelimited|_once|)|
261 [a-z0-9]+_(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
262 WARN(?:_RATELIMIT|_ONCE|)|
263 panic|
264 MODULE_[A-Z_]+|
265 LOG_(?:DEBUG|INFO|WARNING|ERROR|USER|USER_N|OUTPUT)+
266 )};
267
268 our $signature_tags = qr{(?xi:
269 Signed-off-by:|
270 Acked-by:|
271 Tested-by:|
272 Reviewed-by:|
273 Reported-by:|
274 To:|
275 Cc:
276 )};
277
278 our @typeList = (
279 qr{void},
280 qr{(?:unsigned\s+)?char},
281 qr{(?:unsigned\s+)?short},
282 qr{(?:unsigned\s+)?int},
283 qr{(?:unsigned\s+)?long},
284 qr{(?:unsigned\s+)?long\s+int},
285 qr{(?:unsigned\s+)?long\s+long},
286 qr{(?:unsigned\s+)?long\s+long\s+int},
287 qr{unsigned},
288 qr{float},
289 qr{double},
290 qr{bool},
291 qr{struct\s+$Ident},
292 qr{union\s+$Ident},
293 qr{enum\s+$Ident},
294 qr{${Ident}_t},
295 qr{${Ident}_handler},
296 qr{${Ident}_handler_fn},
297 );
298 our @modifierList = (
299 qr{fastcall},
300 );
301
302 our $allowed_asm_includes = qr{(?x:
303 irq|
304 memory
305 )};
306 # memory.h: ARM has a custom one
307
308 sub build_types {
309 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
310 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
311 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
312 $NonptrType = qr{
313 (?:$Modifier\s+|const\s+)*
314 (?:
315 (?:typeof|__typeof__)\s*\(\s*\**\s*$Ident\s*\)|
316 (?:$typeTypedefs\b)|
317 (?:${all}\b)
318 )
319 (?:\s+$Modifier|\s+const)*
320 }x;
321 $Type = qr{
322 $NonptrType
323 (?:[\s\*]+\s*const|[\s\*]+|(?:\s*\[\s*\])+)?
324 (?:\s+$Inline|\s+$Modifier)*
325 }x;
326 $Declare = qr{(?:$Storage\s+)?$Type};
327 }
328 build_types();
329
330 our $match_balanced_parentheses = qr/(\((?:[^\(\)]+|(-1))*\))/;
331
332 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
333 our $LvalOrFunc = qr{($Lval)\s*($match_balanced_parentheses{0,1})\s*};
334
335 sub deparenthesize {
336 my ($string) = @_;
337 return "" if (!defined($string));
338 $string =~ s@^\s*\(\s*@@g;
339 $string =~ s@\s*\)\s*$@@g;
340 $string =~ s@\s+@ @g;
341 return $string;
342 }
343
344 $chk_signoff = 0 if ($file);
345
346 my @dep_includes = ();
347 my @dep_functions = ();
348 my $removal = "Documentation/feature-removal-schedule.txt";
349 if ($tree && -f "$root/$removal") {
350 open(my $REMOVE, '<', "$root/$removal") ||
351 die "$P: $removal: open failed - $!\n";
352 while (<$REMOVE>) {
353 if (/^Check:\s+(.*\S)/) {
354 for my $entry (split(/[, ]+/, $1)) {
355 if ($entry =~ m@include/(.*)@) {
356 push(@dep_includes, $1);
357
358 } elsif ($entry !~ m@/@) {
359 push(@dep_functions, $entry);
360 }
361 }
362 }
363 }
364 close($REMOVE);
365 }
366
367 my @rawlines = ();
368 my @lines = ();
369 my $vname;
370 for my $filename (@ARGV) {
371 my $FILE;
372 if ($file) {
373 open($FILE, '-|', "diff -u /dev/null $filename") ||
374 die "$P: $filename: diff failed - $!\n";
375 } elsif ($filename eq '-') {
376 open($FILE, '<&STDIN');
377 } else {
378 open($FILE, '<', "$filename") ||
379 die "$P: $filename: open failed - $!\n";
380 }
381 if ($filename eq '-') {
382 $vname = 'Your patch';
383 } else {
384 $vname = $filename;
385 }
386 while (<$FILE>) {
387 chomp;
388 push(@rawlines, $_);
389 }
390 close($FILE);
391 if (!process($filename)) {
392 $exit = 1;
393 }
394 @rawlines = ();
395 @lines = ();
396 }
397
398 exit($exit);
399
400 sub top_of_kernel_tree {
401 my ($root) = @_;
402
403 my @tree_check = (
404 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
405 "README", "Documentation", "arch", "include", "drivers",
406 "fs", "init", "ipc", "kernel", "lib", "scripts",
407 );
408
409 foreach my $check (@tree_check) {
410 if (! -e $root . '/' . $check) {
411 return 0;
412 }
413 }
414 return 1;
415 }
416
417 sub parse_email {
418 my ($formatted_email) = @_;
419
420 my $name = "";
421 my $address = "";
422 my $comment = "";
423
424 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
425 $name = $1;
426 $address = $2;
427 $comment = $3 if defined $3;
428 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
429 $address = $1;
430 $comment = $2 if defined $2;
431 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
432 $address = $1;
433 $comment = $2 if defined $2;
434 $formatted_email =~ s/$address.*$//;
435 $name = $formatted_email;
436 $name =~ s/^\s+|\s+$//g;
437 $name =~ s/^\"|\"$//g;
438 # If there's a name left after stripping spaces and
439 # leading quotes, and the address doesn't have both
440 # leading and trailing angle brackets, the address
441 # is invalid. ie:
442 # "joe smith joe@smith.com" bad
443 # "joe smith <joe@smith.com" bad
444 if ($name ne "" && $address !~ /^<[^>]+>$/) {
445 $name = "";
446 $address = "";
447 $comment = "";
448 }
449 }
450
451 $name =~ s/^\s+|\s+$//g;
452 $name =~ s/^\"|\"$//g;
453 $address =~ s/^\s+|\s+$//g;
454 $address =~ s/^\<|\>$//g;
455
456 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
457 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
458 $name = "\"$name\"";
459 }
460
461 return ($name, $address, $comment);
462 }
463
464 sub format_email {
465 my ($name, $address) = @_;
466
467 my $formatted_email;
468
469 $name =~ s/^\s+|\s+$//g;
470 $name =~ s/^\"|\"$//g;
471 $address =~ s/^\s+|\s+$//g;
472
473 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
474 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
475 $name = "\"$name\"";
476 }
477
478 if ("$name" eq "") {
479 $formatted_email = "$address";
480 } else {
481 $formatted_email = "$name <$address>";
482 }
483
484 return $formatted_email;
485 }
486
487 sub which_conf {
488 my ($conf) = @_;
489
490 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
491 if (-e "$path/$conf") {
492 return "$path/$conf";
493 }
494 }
495
496 return "";
497 }
498
499 sub expand_tabs {
500 my ($str) = @_;
501
502 my $res = '';
503 my $n = 0;
504 for my $c (split(//, $str)) {
505 if ($c eq "\t") {
506 $res .= ' ';
507 $n++;
508 for (; ($n % 4) != 0; $n++) {
509 $res .= ' ';
510 }
511 next;
512 }
513 $res .= $c;
514 $n++;
515 }
516
517 return $res;
518 }
519 sub copy_spacing {
520 (my $res = shift) =~ tr/\t/ /c;
521 return $res;
522 }
523
524 sub line_stats {
525 my ($line) = @_;
526
527 # Drop the diff line leader and expand tabs
528 $line =~ s/^.//;
529 $line = expand_tabs($line);
530
531 # Pick the indent from the front of the line.
532 my ($white) = ($line =~ /^(\s*)/);
533
534 return (length($line), length($white));
535 }
536
537 my $sanitise_quote = '';
538
539 sub sanitise_line_reset {
540 my ($in_comment) = @_;
541
542 if ($in_comment) {
543 $sanitise_quote = '*/';
544 } else {
545 $sanitise_quote = '';
546 }
547 }
548 sub sanitise_line {
549 my ($line) = @_;
550
551 my $res = '';
552 my $l = '';
553
554 my $qlen = 0;
555 my $off = 0;
556 my $c;
557
558 # Always copy over the diff marker.
559 $res = substr($line, 0, 1);
560
561 for ($off = 1; $off < length($line); $off++) {
562 $c = substr($line, $off, 1);
563
564 # Comments we are wacking completly including the begin
565 # and end, all to $;.
566 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
567 $sanitise_quote = '*/';
568
569 substr($res, $off, 2, "$;$;");
570 $off++;
571 next;
572 }
573 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
574 $sanitise_quote = '';
575 substr($res, $off, 2, "$;$;");
576 $off++;
577 next;
578 }
579 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
580 $sanitise_quote = '//';
581
582 substr($res, $off, 2, $sanitise_quote);
583 $off++;
584 next;
585 }
586
587 # A \ in a string means ignore the next character.
588 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
589 $c eq "\\") {
590 substr($res, $off, 2, 'XX');
591 $off++;
592 next;
593 }
594 # Regular quotes.
595 if ($c eq "'" || $c eq '"') {
596 if ($sanitise_quote eq '') {
597 $sanitise_quote = $c;
598
599 substr($res, $off, 1, $c);
600 next;
601 } elsif ($sanitise_quote eq $c) {
602 $sanitise_quote = '';
603 }
604 }
605
606 #print "c<$c> SQ<$sanitise_quote>\n";
607 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
608 substr($res, $off, 1, $;);
609 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
610 substr($res, $off, 1, $;);
611 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
612 substr($res, $off, 1, 'X');
613 } else {
614 substr($res, $off, 1, $c);
615 }
616 }
617
618 if ($sanitise_quote eq '//') {
619 $sanitise_quote = '';
620 }
621
622 # The pathname on a #include may be surrounded by '<' and '>'.
623 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
624 my $clean = 'X' x length($1);
625 $res =~ s@\<.*\>@<$clean>@;
626
627 # The whole of a #error is a string.
628 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
629 my $clean = 'X' x length($1);
630 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
631 }
632
633 return $res;
634 }
635
636 sub ctx_statement_block {
637 my ($linenr, $remain, $off) = @_;
638 my $line = $linenr - 1;
639 my $blk = '';
640 my $soff = $off;
641 my $coff = $off - 1;
642 my $coff_set = 0;
643
644 my $loff = 0;
645
646 my $type = '';
647 my $level = 0;
648 my @stack = ();
649 my $p;
650 my $c;
651 my $len = 0;
652
653 my $remainder;
654 while (1) {
655 @stack = (['', 0]) if ($#stack == -1);
656
657 #warn "CSB: blk<$blk> remain<$remain>\n";
658 # If we are about to drop off the end, pull in more
659 # context.
660 if ($off >= $len) {
661 for (; $remain > 0; $line++) {
662 last if (!defined $lines[$line]);
663 next if ($lines[$line] =~ /^-/);
664 $remain--;
665 $loff = $len;
666 $blk .= $lines[$line] . "\n";
667 $len = length($blk);
668 $line++;
669 last;
670 }
671 # Bail if there is no further context.
672 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
673 if ($off >= $len) {
674 last;
675 }
676 }
677 $p = $c;
678 $c = substr($blk, $off, 1);
679 $remainder = substr($blk, $off);
680
681 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
682
683 # Handle nested #if/#else.
684 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
685 push(@stack, [ $type, $level ]);
686 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
687 ($type, $level) = @{$stack[$#stack - 1]};
688 } elsif ($remainder =~ /^#\s*endif\b/) {
689 ($type, $level) = @{pop(@stack)};
690 }
691
692 # Statement ends at the ';' or a close '}' at the
693 # outermost level.
694 if ($level == 0 && $c eq ';') {
695 last;
696 }
697
698 # An else is really a conditional as long as its not else if
699 if ($level == 0 && $coff_set == 0 &&
700 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
701 $remainder =~ /^(else)(?:\s|{)/ &&
702 $remainder !~ /^else\s+if\b/) {
703 $coff = $off + length($1) - 1;
704 $coff_set = 1;
705 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
706 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
707 }
708
709 if (($type eq '' || $type eq '(') && $c eq '(') {
710 $level++;
711 $type = '(';
712 }
713 if ($type eq '(' && $c eq ')') {
714 $level--;
715 $type = ($level != 0)? '(' : '';
716
717 if ($level == 0 && $coff < $soff) {
718 $coff = $off;
719 $coff_set = 1;
720 #warn "CSB: mark coff<$coff>\n";
721 }
722 }
723 if (($type eq '' || $type eq '{') && $c eq '{') {
724 $level++;
725 $type = '{';
726 }
727 if ($type eq '{' && $c eq '}') {
728 $level--;
729 $type = ($level != 0)? '{' : '';
730
731 if ($level == 0) {
732 if (substr($blk, $off + 1, 1) eq ';') {
733 $off++;
734 }
735 last;
736 }
737 }
738 $off++;
739 }
740 # We are truly at the end, so shuffle to the next line.
741 if ($off == $len) {
742 $loff = $len + 1;
743 $line++;
744 $remain--;
745 }
746
747 my $statement = substr($blk, $soff, $off - $soff + 1);
748 my $condition = substr($blk, $soff, $coff - $soff + 1);
749
750 #warn "STATEMENT<$statement>\n";
751 #warn "CONDITION<$condition>\n";
752
753 #print "coff<$coff> soff<$off> loff<$loff>\n";
754
755 return ($statement, $condition,
756 $line, $remain + 1, $off - $loff + 1, $level);
757 }
758
759 sub statement_lines {
760 my ($stmt) = @_;
761
762 # Strip the diff line prefixes and rip blank lines at start and end.
763 $stmt =~ s/(^|\n)./$1/g;
764 $stmt =~ s/^\s*//;
765 $stmt =~ s/\s*$//;
766
767 my @stmt_lines = ($stmt =~ /\n/g);
768
769 return $#stmt_lines + 2;
770 }
771
772 sub statement_rawlines {
773 my ($stmt) = @_;
774
775 my @stmt_lines = ($stmt =~ /\n/g);
776
777 return $#stmt_lines + 2;
778 }
779
780 sub statement_block_size {
781 my ($stmt) = @_;
782
783 $stmt =~ s/(^|\n)./$1/g;
784 $stmt =~ s/^\s*{//;
785 $stmt =~ s/}\s*$//;
786 $stmt =~ s/^\s*//;
787 $stmt =~ s/\s*$//;
788
789 my @stmt_lines = ($stmt =~ /\n/g);
790 my @stmt_statements = ($stmt =~ /;/g);
791
792 my $stmt_lines = $#stmt_lines + 2;
793 my $stmt_statements = $#stmt_statements + 1;
794
795 if ($stmt_lines > $stmt_statements) {
796 return $stmt_lines;
797 } else {
798 return $stmt_statements;
799 }
800 }
801
802 sub ctx_statement_full {
803 my ($linenr, $remain, $off) = @_;
804 my ($statement, $condition, $level);
805
806 my (@chunks);
807
808 # Grab the first conditional/block pair.
809 ($statement, $condition, $linenr, $remain, $off, $level) =
810 ctx_statement_block($linenr, $remain, $off);
811 #print "F: c<$condition> s<$statement> remain<$remain>\n";
812 push(@chunks, [ $condition, $statement ]);
813 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
814 return ($level, $linenr, @chunks);
815 }
816
817 # Pull in the following conditional/block pairs and see if they
818 # could continue the statement.
819 for (;;) {
820 ($statement, $condition, $linenr, $remain, $off, $level) =
821 ctx_statement_block($linenr, $remain, $off);
822 #print "C: c<$condition> s<$statement> remain<$remain>\n";
823 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
824 #print "C: push\n";
825 push(@chunks, [ $condition, $statement ]);
826 }
827
828 return ($level, $linenr, @chunks);
829 }
830
831 sub ctx_block_get {
832 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
833 my $line;
834 my $start = $linenr - 1;
835 my $blk = '';
836 my @o;
837 my @c;
838 my @res = ();
839
840 my $level = 0;
841 my @stack = ($level);
842 for ($line = $start; $remain > 0; $line++) {
843 next if ($rawlines[$line] =~ /^-/);
844 $remain--;
845
846 $blk .= $rawlines[$line];
847
848 # Handle nested #if/#else.
849 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
850 push(@stack, $level);
851 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
852 $level = $stack[$#stack - 1];
853 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
854 $level = pop(@stack);
855 }
856
857 foreach my $c (split(//, $lines[$line])) {
858 ##print "C<$c>L<$level><$open$close>O<$off>\n";
859 if ($off > 0) {
860 $off--;
861 next;
862 }
863
864 if ($c eq $close && $level > 0) {
865 $level--;
866 last if ($level == 0);
867 } elsif ($c eq $open) {
868 $level++;
869 }
870 }
871
872 if (!$outer || $level <= 1) {
873 push(@res, $rawlines[$line]);
874 }
875
876 last if ($level == 0);
877 }
878
879 return ($level, @res);
880 }
881 sub ctx_block_outer {
882 my ($linenr, $remain) = @_;
883
884 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
885 return @r;
886 }
887 sub ctx_block {
888 my ($linenr, $remain) = @_;
889
890 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
891 return @r;
892 }
893 sub ctx_statement {
894 my ($linenr, $remain, $off) = @_;
895
896 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
897 return @r;
898 }
899 sub ctx_block_level {
900 my ($linenr, $remain) = @_;
901
902 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
903 }
904 sub ctx_statement_level {
905 my ($linenr, $remain, $off) = @_;
906
907 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
908 }
909
910 sub ctx_locate_comment {
911 my ($first_line, $end_line) = @_;
912
913 # Catch a comment on the end of the line itself.
914 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
915 return $current_comment if (defined $current_comment);
916
917 # Look through the context and try and figure out if there is a
918 # comment.
919 my $in_comment = 0;
920 $current_comment = '';
921 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
922 my $line = $rawlines[$linenr - 1];
923 #warn " $line\n";
924 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
925 $in_comment = 1;
926 }
927 if ($line =~ m@/\*@) {
928 $in_comment = 1;
929 }
930 if (!$in_comment && $current_comment ne '') {
931 $current_comment = '';
932 }
933 $current_comment .= $line . "\n" if ($in_comment);
934 if ($line =~ m@\*/@) {
935 $in_comment = 0;
936 }
937 }
938
939 chomp($current_comment);
940 return($current_comment);
941 }
942 sub ctx_has_comment {
943 my ($first_line, $end_line) = @_;
944 my $cmt = ctx_locate_comment($first_line, $end_line);
945
946 ##print "LINE: $rawlines[$end_line - 1 ]\n";
947 ##print "CMMT: $cmt\n";
948
949 return ($cmt ne '');
950 }
951
952 sub raw_line {
953 my ($linenr, $cnt) = @_;
954
955 my $offset = $linenr - 1;
956 $cnt++;
957
958 my $line;
959 while ($cnt) {
960 $line = $rawlines[$offset++];
961 next if (defined($line) && $line =~ /^-/);
962 $cnt--;
963 }
964
965 return $line;
966 }
967
968 sub cat_vet {
969 my ($vet) = @_;
970 my ($res, $coded);
971
972 $res = '';
973 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
974 $res .= $1;
975 if ($2 ne '') {
976 $coded = sprintf("^%c", unpack('C', $2) + 64);
977 $res .= $coded;
978 }
979 }
980 $res =~ s/$/\$/;
981
982 return $res;
983 }
984
985 my $av_preprocessor = 0;
986 my $av_pending;
987 my @av_paren_type;
988 my $av_pend_colon;
989
990 sub annotate_reset {
991 $av_preprocessor = 0;
992 $av_pending = '_';
993 @av_paren_type = ('E');
994 $av_pend_colon = 'O';
995 }
996
997 sub annotate_values {
998 my ($stream, $type) = @_;
999
1000 my $res;
1001 my $var = '_' x length($stream);
1002 my $cur = $stream;
1003
1004 print "$stream\n" if ($dbg_values > 1);
1005
1006 while (length($cur)) {
1007 @av_paren_type = ('E') if ($#av_paren_type < 0);
1008 print " <" . join('', @av_paren_type) .
1009 "> <$type> <$av_pending>" if ($dbg_values > 1);
1010 if ($cur =~ /^(\s+)/o) {
1011 print "WS($1)\n" if ($dbg_values > 1);
1012 if ($1 =~ /\n/ && $av_preprocessor) {
1013 $type = pop(@av_paren_type);
1014 $av_preprocessor = 0;
1015 }
1016
1017 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1018 print "CAST($1)\n" if ($dbg_values > 1);
1019 push(@av_paren_type, $type);
1020 $type = 'C';
1021
1022 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1023 print "DECLARE($1)\n" if ($dbg_values > 1);
1024 $type = 'T';
1025
1026 } elsif ($cur =~ /^($Modifier)\s*/) {
1027 print "MODIFIER($1)\n" if ($dbg_values > 1);
1028 $type = 'T';
1029
1030 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1031 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1032 $av_preprocessor = 1;
1033 push(@av_paren_type, $type);
1034 if ($2 ne '') {
1035 $av_pending = 'N';
1036 }
1037 $type = 'E';
1038
1039 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1040 print "UNDEF($1)\n" if ($dbg_values > 1);
1041 $av_preprocessor = 1;
1042 push(@av_paren_type, $type);
1043
1044 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1045 print "PRE_START($1)\n" if ($dbg_values > 1);
1046 $av_preprocessor = 1;
1047
1048 push(@av_paren_type, $type);
1049 push(@av_paren_type, $type);
1050 $type = 'E';
1051
1052 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1053 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1054 $av_preprocessor = 1;
1055
1056 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1057
1058 $type = 'E';
1059
1060 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1061 print "PRE_END($1)\n" if ($dbg_values > 1);
1062
1063 $av_preprocessor = 1;
1064
1065 # Assume all arms of the conditional end as this
1066 # one does, and continue as if the #endif was not here.
1067 pop(@av_paren_type);
1068 push(@av_paren_type, $type);
1069 $type = 'E';
1070
1071 } elsif ($cur =~ /^(\\\n)/o) {
1072 print "PRECONT($1)\n" if ($dbg_values > 1);
1073
1074 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1075 print "ATTR($1)\n" if ($dbg_values > 1);
1076 $av_pending = $type;
1077 $type = 'N';
1078
1079 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1080 print "SIZEOF($1)\n" if ($dbg_values > 1);
1081 if (defined $2) {
1082 $av_pending = 'V';
1083 }
1084 $type = 'N';
1085
1086 } elsif ($cur =~ /^(if|while|for)\b/o) {
1087 print "COND($1)\n" if ($dbg_values > 1);
1088 $av_pending = 'E';
1089 $type = 'N';
1090
1091 } elsif ($cur =~/^(case)/o) {
1092 print "CASE($1)\n" if ($dbg_values > 1);
1093 $av_pend_colon = 'C';
1094 $type = 'N';
1095
1096 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1097 print "KEYWORD($1)\n" if ($dbg_values > 1);
1098 $type = 'N';
1099
1100 } elsif ($cur =~ /^(\()/o) {
1101 print "PAREN('$1')\n" if ($dbg_values > 1);
1102 push(@av_paren_type, $av_pending);
1103 $av_pending = '_';
1104 $type = 'N';
1105
1106 } elsif ($cur =~ /^(\))/o) {
1107 my $new_type = pop(@av_paren_type);
1108 if ($new_type ne '_') {
1109 $type = $new_type;
1110 print "PAREN('$1') -> $type\n"
1111 if ($dbg_values > 1);
1112 } else {
1113 print "PAREN('$1')\n" if ($dbg_values > 1);
1114 }
1115
1116 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1117 print "FUNC($1)\n" if ($dbg_values > 1);
1118 $type = 'V';
1119 $av_pending = 'V';
1120
1121 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1122 if (defined $2 && $type eq 'C' || $type eq 'T') {
1123 $av_pend_colon = 'B';
1124 } elsif ($type eq 'E') {
1125 $av_pend_colon = 'L';
1126 }
1127 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1128 $type = 'V';
1129
1130 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1131 print "IDENT($1)\n" if ($dbg_values > 1);
1132 $type = 'V';
1133
1134 } elsif ($cur =~ /^($Assignment)/o) {
1135 print "ASSIGN($1)\n" if ($dbg_values > 1);
1136 $type = 'N';
1137
1138 } elsif ($cur =~/^(;|{|})/) {
1139 print "END($1)\n" if ($dbg_values > 1);
1140 $type = 'E';
1141 $av_pend_colon = 'O';
1142
1143 } elsif ($cur =~/^(,)/) {
1144 print "COMMA($1)\n" if ($dbg_values > 1);
1145 $type = 'C';
1146
1147 } elsif ($cur =~ /^(\?)/o) {
1148 print "QUESTION($1)\n" if ($dbg_values > 1);
1149 $type = 'N';
1150
1151 } elsif ($cur =~ /^(:)/o) {
1152 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1153
1154 substr($var, length($res), 1, $av_pend_colon);
1155 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1156 $type = 'E';
1157 } else {
1158 $type = 'N';
1159 }
1160 $av_pend_colon = 'O';
1161
1162 } elsif ($cur =~ /^(\[)/o) {
1163 print "CLOSE($1)\n" if ($dbg_values > 1);
1164 $type = 'N';
1165
1166 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1167 my $variant;
1168
1169 print "OPV($1)\n" if ($dbg_values > 1);
1170 if ($type eq 'V') {
1171 $variant = 'B';
1172 } else {
1173 $variant = 'U';
1174 }
1175
1176 substr($var, length($res), 1, $variant);
1177 $type = 'N';
1178
1179 } elsif ($cur =~ /^($Operators)/o) {
1180 print "OP($1)\n" if ($dbg_values > 1);
1181 if ($1 ne '++' && $1 ne '--') {
1182 $type = 'N';
1183 }
1184
1185 } elsif ($cur =~ /(^.)/o) {
1186 print "C($1)\n" if ($dbg_values > 1);
1187 }
1188 if (defined $1) {
1189 $cur = substr($cur, length($1));
1190 $res .= $type x length($1);
1191 }
1192 }
1193
1194 return ($res, $var);
1195 }
1196
1197 sub possible {
1198 my ($possible, $line) = @_;
1199 my $notPermitted = qr{(?:
1200 ^(?:
1201 $Modifier|
1202 $Storage|
1203 $Type|
1204 DEFINE_\S+
1205 )$|
1206 ^(?:
1207 goto|
1208 return|
1209 case|
1210 else|
1211 asm|__asm__|
1212 do
1213 )(?:\s|$)|
1214 ^(?:typedef|struct|enum)\b
1215 )}x;
1216 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1217 if ($possible !~ $notPermitted) {
1218 # Check for modifiers.
1219 $possible =~ s/\s*$Storage\s*//g;
1220 $possible =~ s/\s*$Sparse\s*//g;
1221 if ($possible =~ /^\s*$/) {
1222
1223 } elsif ($possible =~ /\s/) {
1224 $possible =~ s/\s*$Type\s*//g;
1225 for my $modifier (split(' ', $possible)) {
1226 if ($modifier !~ $notPermitted) {
1227 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1228 push(@modifierList, $modifier);
1229 }
1230 }
1231
1232 } else {
1233 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1234 push(@typeList, $possible);
1235 }
1236 build_types();
1237 } else {
1238 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1239 }
1240 }
1241
1242 my $prefix = '';
1243
1244 sub show_type {
1245 return !defined $ignore_type{$_[0]};
1246 }
1247
1248 sub report {
1249 if (!show_type($_[1]) ||
1250 (defined $tst_only && $_[2] !~ /\Q$tst_only\E/)) {
1251 return 0;
1252 }
1253 my $line;
1254 if ($show_types) {
1255 $line = "$prefix$_[0]:$_[1]: $_[2]\n";
1256 } else {
1257 $line = "$prefix$_[0]: $_[2]\n";
1258 }
1259 $line = (split('\n', $line))[0] . "\n" if ($terse);
1260
1261 push(our @report, $line);
1262
1263 return 1;
1264 }
1265 sub report_dump {
1266 our @report;
1267 }
1268
1269 sub ERROR {
1270 if (report("ERROR", $_[0], $_[1])) {
1271 our $clean = 0;
1272 our $cnt_error++;
1273 }
1274 }
1275 sub WARN {
1276 if (report("WARNING", $_[0], $_[1])) {
1277 our $clean = 0;
1278 our $cnt_warn++;
1279 }
1280 }
1281 sub CHK {
1282 if ($check && report("CHECK", $_[0], $_[1])) {
1283 our $clean = 0;
1284 our $cnt_chk++;
1285 }
1286 }
1287
1288 sub check_absolute_file {
1289 my ($absolute, $herecurr) = @_;
1290 my $file = $absolute;
1291
1292 ##print "absolute<$absolute>\n";
1293
1294 # See if any suffix of this path is a path within the tree.
1295 while ($file =~ s@^[^/]*/@@) {
1296 if (-f "$root/$file") {
1297 ##print "file<$file>\n";
1298 last;
1299 }
1300 }
1301 if (! -f _) {
1302 return 0;
1303 }
1304
1305 # It is, so see if the prefix is acceptable.
1306 my $prefix = $absolute;
1307 substr($prefix, -length($file)) = '';
1308
1309 ##print "prefix<$prefix>\n";
1310 if ($prefix ne ".../") {
1311 WARN("USE_RELATIVE_PATH",
1312 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1313 }
1314 }
1315
1316 sub process {
1317 my $filename = shift;
1318
1319 my $linenr=0;
1320 my $prevline="";
1321 my $prevrawline="";
1322 my $stashline="";
1323 my $stashrawline="";
1324
1325 my $length;
1326 my $indent;
1327 my $previndent=0;
1328 my $stashindent=0;
1329
1330 our $clean = 1;
1331 my $signoff = 0;
1332 my $is_patch = 0;
1333
1334 our @report = ();
1335 our $cnt_lines = 0;
1336 our $cnt_error = 0;
1337 our $cnt_warn = 0;
1338 our $cnt_chk = 0;
1339
1340 # Trace the real file/line as we go.
1341 my $realfile = '';
1342 my $realline = 0;
1343 my $realcnt = 0;
1344 my $here = '';
1345 my $in_comment = 0;
1346 my $comment_edge = 0;
1347 my $first_line = 0;
1348 my $p1_prefix = '';
1349
1350 my $prev_values = 'E';
1351
1352 # suppression flags
1353 my %suppress_ifbraces;
1354 my %suppress_whiletrailers;
1355 my %suppress_export;
1356
1357 # Pre-scan the patch sanitizing the lines.
1358 # Pre-scan the patch looking for any __setup documentation.
1359 #
1360 my @setup_docs = ();
1361 my $setup_docs = 0;
1362
1363 sanitise_line_reset();
1364 my $line;
1365 foreach my $rawline (@rawlines) {
1366 $linenr++;
1367 $line = $rawline;
1368
1369 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1370 $setup_docs = 0;
1371 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1372 $setup_docs = 1;
1373 }
1374 #next;
1375 }
1376 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1377 $realline=$1-1;
1378 if (defined $2) {
1379 $realcnt=$3+1;
1380 } else {
1381 $realcnt=1+1;
1382 }
1383 $in_comment = 0;
1384
1385 # Guestimate if this is a continuing comment. Run
1386 # the context looking for a comment "edge". If this
1387 # edge is a close comment then we must be in a comment
1388 # at context start.
1389 my $edge;
1390 my $cnt = $realcnt;
1391 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1392 next if (defined $rawlines[$ln - 1] &&
1393 $rawlines[$ln - 1] =~ /^-/);
1394 $cnt--;
1395 #print "RAW<$rawlines[$ln - 1]>\n";
1396 last if (!defined $rawlines[$ln - 1]);
1397 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1398 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1399 ($edge) = $1;
1400 last;
1401 }
1402 }
1403 if (defined $edge && $edge eq '*/') {
1404 $in_comment = 1;
1405 }
1406
1407 # Guestimate if this is a continuing comment. If this
1408 # is the start of a diff block and this line starts
1409 # ' *' then it is very likely a comment.
1410 if (!defined $edge &&
1411 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1412 {
1413 $in_comment = 1;
1414 }
1415
1416 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1417 sanitise_line_reset($in_comment);
1418
1419 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1420 # Standardise the strings and chars within the input to
1421 # simplify matching -- only bother with positive lines.
1422 $line = sanitise_line($rawline);
1423 }
1424 push(@lines, $line);
1425
1426 if ($realcnt > 1) {
1427 $realcnt-- if ($line =~ /^(?:\+| |$)/);
1428 } else {
1429 $realcnt = 0;
1430 }
1431
1432 #print "==>$rawline\n";
1433 #print "-->$line\n";
1434
1435 if ($setup_docs && $line =~ /^\+/) {
1436 push(@setup_docs, $line);
1437 }
1438 }
1439
1440 $prefix = '';
1441
1442 $realcnt = 0;
1443 $linenr = 0;
1444 foreach my $line (@lines) {
1445 $linenr++;
1446
1447 my $rawline = $rawlines[$linenr - 1];
1448
1449 #extract the line range in the file after the patch is applied
1450 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1451 $is_patch = 1;
1452 $first_line = $linenr + 1;
1453 $realline=$1-1;
1454 if (defined $2) {
1455 $realcnt=$3+1;
1456 } else {
1457 $realcnt=1+1;
1458 }
1459 annotate_reset();
1460 $prev_values = 'E';
1461
1462 %suppress_ifbraces = ();
1463 %suppress_whiletrailers = ();
1464 %suppress_export = ();
1465 next;
1466
1467 # track the line number as we move through the hunk, note that
1468 # new versions of GNU diff omit the leading space on completely
1469 # blank context lines so we need to count that too.
1470 } elsif ($line =~ /^( |\+|$)/) {
1471 $realline++;
1472 $realcnt-- if ($realcnt != 0);
1473
1474 # Measure the line length and indent.
1475 ($length, $indent) = line_stats($rawline);
1476
1477 # Track the previous line.
1478 ($prevline, $stashline) = ($stashline, $line);
1479 ($previndent, $stashindent) = ($stashindent, $indent);
1480 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1481
1482 #warn "line<$line>\n";
1483
1484 } elsif ($realcnt == 1) {
1485 $realcnt--;
1486 }
1487
1488 my $hunk_line = ($realcnt != 0);
1489
1490 #make up the handle for any error we report on this line
1491 $prefix = "$filename:$realline: " if ($emacs && $file);
1492 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1493
1494 $here = "#$linenr: " if (!$file);
1495 $here = "#$realline: " if ($file);
1496
1497 # extract the filename as it passes
1498 if ($line =~ /^diff --git.*?(\S+)$/) {
1499 $realfile = $1;
1500 $realfile =~ s@^([^/]*)/@@;
1501
1502 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1503 $realfile = $1;
1504 $realfile =~ s@^([^/]*)/@@;
1505
1506 $p1_prefix = $1;
1507 if (!$file && $tree && $p1_prefix ne '' &&
1508 -e "$root/$p1_prefix") {
1509 WARN("PATCH_PREFIX",
1510 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1511 }
1512
1513 if ($realfile =~ m@^include/asm/@) {
1514 ERROR("MODIFIED_INCLUDE_ASM",
1515 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1516 }
1517 next;
1518 }
1519
1520 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1521
1522 my $hereline = "$here\n$rawline\n";
1523 my $herecurr = "$here\n$rawline\n";
1524 my $hereprev = "$here\n$prevrawline\n$rawline\n";
1525
1526 $cnt_lines++ if ($realcnt != 0);
1527
1528 # Check for incorrect file permissions
1529 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1530 my $permhere = $here . "FILE: $realfile\n";
1531 if ($realfile =~ /(Makefile|Kconfig|\.c|\.h|\.S|\.tmpl)$/) {
1532 ERROR("EXECUTE_PERMISSIONS",
1533 "do not set execute permissions for source files\n" . $permhere);
1534 }
1535 }
1536
1537 # Check the patch for a signoff:
1538 if ($line =~ /^\s*signed-off-by:/i) {
1539 $signoff++;
1540 }
1541
1542 # Check signature styles
1543 if ($line =~ /^(\s*)($signature_tags)(\s*)(.*)/) {
1544 my $space_before = $1;
1545 my $sign_off = $2;
1546 my $space_after = $3;
1547 my $email = $4;
1548 my $ucfirst_sign_off = ucfirst(lc($sign_off));
1549
1550 if (defined $space_before && $space_before ne "") {
1551 WARN("BAD_SIGN_OFF",
1552 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr);
1553 }
1554 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
1555 WARN("BAD_SIGN_OFF",
1556 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr);
1557 }
1558 if (!defined $space_after || $space_after ne " ") {
1559 WARN("BAD_SIGN_OFF",
1560 "Use a single space after $ucfirst_sign_off\n" . $herecurr);
1561 }
1562
1563 my ($email_name, $email_address, $comment) = parse_email($email);
1564 my $suggested_email = format_email(($email_name, $email_address));
1565 if ($suggested_email eq "") {
1566 ERROR("BAD_SIGN_OFF",
1567 "Unrecognized email address: '$email'\n" . $herecurr);
1568 } else {
1569 my $dequoted = $suggested_email;
1570 $dequoted =~ s/^"//;
1571 $dequoted =~ s/" </ </;
1572 # Don't force email to have quotes
1573 # Allow just an angle bracketed address
1574 if ("$dequoted$comment" ne $email &&
1575 "<$email_address>$comment" ne $email &&
1576 "$suggested_email$comment" ne $email) {
1577 WARN("BAD_SIGN_OFF",
1578 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1579 }
1580 }
1581 }
1582
1583 # Check for wrappage within a valid hunk of the file
1584 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1585 ERROR("CORRUPTED_PATCH",
1586 "patch seems to be corrupt (line wrapped?)\n" .
1587 $herecurr) if (!$emitted_corrupt++);
1588 }
1589
1590 # Check for absolute kernel paths.
1591 if ($tree) {
1592 while ($line =~ m{(?:^|\s)(/\S*)}g) {
1593 my $file = $1;
1594
1595 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1596 check_absolute_file($1, $herecurr)) {
1597 #
1598 } else {
1599 check_absolute_file($file, $herecurr);
1600 }
1601 }
1602 }
1603
1604 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1605 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1606 $rawline !~ m/^$UTF8*$/) {
1607 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1608
1609 my $blank = copy_spacing($rawline);
1610 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1611 my $hereptr = "$hereline$ptr\n";
1612
1613 CHK("INVALID_UTF8",
1614 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1615 }
1616
1617 # ignore non-hunk lines and lines being removed
1618 next if (!$hunk_line || $line =~ /^-/);
1619
1620 #trailing whitespace
1621 if ($line =~ /^\+.*\015/) {
1622 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1623 ERROR("DOS_LINE_ENDINGS",
1624 "DOS line endings\n" . $herevet);
1625
1626 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
1627 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1628 ERROR("TRAILING_WHITESPACE",
1629 "trailing whitespace\n" . $herevet);
1630 $rpt_cleaners = 1;
1631 }
1632
1633 # check for Kconfig help text having a real description
1634 # Only applies when adding the entry originally, after that we do not have
1635 # sufficient context to determine whether it is indeed long enough.
1636 if ($realfile =~ /Kconfig/ &&
1637 $line =~ /\+\s*(?:---)?help(?:---)?$/) {
1638 my $length = 0;
1639 my $cnt = $realcnt;
1640 my $ln = $linenr + 1;
1641 my $f;
1642 my $is_end = 0;
1643 while ($cnt > 0 && defined $lines[$ln - 1]) {
1644 $f = $lines[$ln - 1];
1645 $cnt-- if ($lines[$ln - 1] !~ /^-/);
1646 $is_end = $lines[$ln - 1] =~ /^\+/;
1647 $ln++;
1648
1649 next if ($f =~ /^-/);
1650 $f =~ s/^.//;
1651 $f =~ s/#.*//;
1652 $f =~ s/^\s+//;
1653 next if ($f =~ /^$/);
1654 if ($f =~ /^\s*config\s/) {
1655 $is_end = 1;
1656 last;
1657 }
1658 $length++;
1659 }
1660 WARN("CONFIG_DESCRIPTION",
1661 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_end && $length < 4);
1662 #print "is_end<$is_end> length<$length>\n";
1663 }
1664
1665 # check we are in a valid source file if not then ignore this hunk
1666 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
1667
1668 #120 column limit
1669 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
1670 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
1671 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
1672 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
1673 $length > 120)
1674 {
1675 WARN("LONG_LINE",
1676 "line over 120 characters\n" . $herecurr);
1677 }
1678
1679 # check for spaces before a quoted newline
1680 if ($rawline =~ /^.*\".*\s\\n/) {
1681 WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
1682 "unnecessary whitespace before a quoted newline\n" . $herecurr);
1683 }
1684
1685 # check for adding lines without a newline.
1686 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1687 WARN("MISSING_EOF_NEWLINE",
1688 "adding a line without newline at end of file\n" . $herecurr);
1689 }
1690
1691 # Blackfin: use hi/lo macros
1692 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
1693 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
1694 my $herevet = "$here\n" . cat_vet($line) . "\n";
1695 ERROR("LO_MACRO",
1696 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
1697 }
1698 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
1699 my $herevet = "$here\n" . cat_vet($line) . "\n";
1700 ERROR("HI_MACRO",
1701 "use the HI() macro, not (... >> 16)\n" . $herevet);
1702 }
1703 }
1704
1705 # check we are in a valid source file C or perl if not then ignore this hunk
1706 next if ($realfile !~ /\.(h|c|pl)$/);
1707
1708 # at the beginning of a line any tabs must come first and anything
1709 # more than 8 must use tabs.
1710 if ($rawline =~ /^\+\s* \t\s*\S/ ||
1711 $rawline =~ /^\+\s* \s*/) {
1712 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1713 ERROR("CODE_INDENT",
1714 "code indent should use tabs where possible\n" . $herevet);
1715 $rpt_cleaners = 1;
1716 }
1717
1718 # check for space before tabs.
1719 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
1720 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1721 WARN("SPACE_BEFORE_TAB",
1722 "please, no space before tabs\n" . $herevet);
1723 }
1724
1725 # check for spaces at the beginning of a line.
1726 # Exceptions:
1727 # 1) within comments
1728 # 2) indented preprocessor commands
1729 # 3) hanging labels
1730 if ($rawline =~ /^\+ / && $line !~ /\+ *(?:$;|#|$Ident:)/) {
1731 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1732 WARN("LEADING_SPACE",
1733 "please, no spaces at the start of a line\n" . $herevet);
1734 }
1735
1736 # check we are in a valid C source file if not then ignore this hunk
1737 next if ($realfile !~ /\.(h|c)$/);
1738
1739 # check for RCS/CVS revision markers
1740 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
1741 WARN("CVS_KEYWORD",
1742 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
1743 }
1744
1745 # Blackfin: don't use __builtin_bfin_[cs]sync
1746 if ($line =~ /__builtin_bfin_csync/) {
1747 my $herevet = "$here\n" . cat_vet($line) . "\n";
1748 ERROR("CSYNC",
1749 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
1750 }
1751 if ($line =~ /__builtin_bfin_ssync/) {
1752 my $herevet = "$here\n" . cat_vet($line) . "\n";
1753 ERROR("SSYNC",
1754 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
1755 }
1756
1757 # Check for potential 'bare' types
1758 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
1759 $realline_next);
1760 if ($realcnt && $line =~ /.\s*\S/) {
1761 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
1762 ctx_statement_block($linenr, $realcnt, 0);
1763 $stat =~ s/\n./\n /g;
1764 $cond =~ s/\n./\n /g;
1765
1766 # Find the real next line.
1767 $realline_next = $line_nr_next;
1768 if (defined $realline_next &&
1769 (!defined $lines[$realline_next - 1] ||
1770 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
1771 $realline_next++;
1772 }
1773
1774 my $s = $stat;
1775 $s =~ s/{.*$//s;
1776
1777 # Ignore goto labels.
1778 if ($s =~ /$Ident:\*$/s) {
1779
1780 # Ignore functions being called
1781 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
1782
1783 } elsif ($s =~ /^.\s*else\b/s) {
1784
1785 # declarations always start with types
1786 } 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) {
1787 my $type = $1;
1788 $type =~ s/\s+/ /g;
1789 possible($type, "A:" . $s);
1790
1791 # definitions in global scope can only start with types
1792 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
1793 possible($1, "B:" . $s);
1794 }
1795
1796 # any (foo ... *) is a pointer cast, and foo is a type
1797 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
1798 possible($1, "C:" . $s);
1799 }
1800
1801 # Check for any sort of function declaration.
1802 # int foo(something bar, other baz);
1803 # void (*store_gdt)(x86_descr_ptr *);
1804 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
1805 my ($name_len) = length($1);
1806
1807 my $ctx = $s;
1808 substr($ctx, 0, $name_len + 1, '');
1809 $ctx =~ s/\)[^\)]*$//;
1810
1811 for my $arg (split(/\s*,\s*/, $ctx)) {
1812 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
1813
1814 possible($1, "D:" . $s);
1815 }
1816 }
1817 }
1818
1819 }
1820
1821 #
1822 # Checks which may be anchored in the context.
1823 #
1824
1825 # Check for switch () and associated case and default
1826 # statements should be at the same indent.
1827 # if ($line=~/\bswitch\s*\(.*\)/) {
1828 # my $err = '';
1829 # my $sep = '';
1830 # my @ctx = ctx_block_outer($linenr, $realcnt);
1831 # shift(@ctx);
1832 # for my $ctx (@ctx) {
1833 # my ($clen, $cindent) = line_stats($ctx);
1834 # if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
1835 # $indent != $cindent) {
1836 # $err .= "$sep$ctx\n";
1837 # $sep = '';
1838 # } else {
1839 # $sep = "[...]\n";
1840 # }
1841 # }
1842 # if ($err ne '') {
1843 # ERROR("SWITCH_CASE_INDENT_LEVEL",
1844 # "switch and case should be at the same indent\n$hereline$err");
1845 # }
1846 # }
1847
1848 # if/while/etc brace do not go on next line, unless defining a do while loop,
1849 # or if that brace on the next line is for something else
1850 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
1851 my $pre_ctx = "$1$2";
1852
1853 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
1854 my $ctx_cnt = $realcnt - $#ctx - 1;
1855 my $ctx = join("\n", @ctx);
1856
1857 my $ctx_ln = $linenr;
1858 my $ctx_skip = $realcnt;
1859
1860 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
1861 defined $lines[$ctx_ln - 1] &&
1862 $lines[$ctx_ln - 1] =~ /^-/)) {
1863 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
1864 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
1865 $ctx_ln++;
1866 }
1867
1868 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
1869 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
1870
1871 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
1872 ERROR("OPEN_BRACE",
1873 "that open brace { should be on the previous line\n" .
1874 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
1875 }
1876 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
1877 $ctx =~ /\)\s*\;\s*$/ &&
1878 defined $lines[$ctx_ln - 1])
1879 {
1880 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
1881 if ($nindent > $indent) {
1882 WARN("TRAILING_SEMICOLON",
1883 "trailing semicolon indicates no statements, indent implies otherwise\n" .
1884 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
1885 }
1886 }
1887 }
1888
1889 # Check relative indent for conditionals and blocks.
1890 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
1891 my ($s, $c) = ($stat, $cond);
1892
1893 substr($s, 0, length($c), '');
1894
1895 # Make sure we remove the line prefixes as we have
1896 # none on the first line, and are going to readd them
1897 # where necessary.
1898 $s =~ s/\n./\n/gs;
1899
1900 # Find out how long the conditional actually is.
1901 my @newlines = ($c =~ /\n/gs);
1902 my $cond_lines = 1 + $#newlines;
1903
1904 # We want to check the first line inside the block
1905 # starting at the end of the conditional, so remove:
1906 # 1) any blank line termination
1907 # 2) any opening brace { on end of the line
1908 # 3) any do (...) {
1909 my $continuation = 0;
1910 my $check = 0;
1911 $s =~ s/^.*\bdo\b//;
1912 $s =~ s/^\s*{//;
1913 if ($s =~ s/^\s*\\//) {
1914 $continuation = 1;
1915 }
1916 if ($s =~ s/^\s*?\n//) {
1917 $check = 1;
1918 $cond_lines++;
1919 }
1920
1921 # Also ignore a loop construct at the end of a
1922 # preprocessor statement.
1923 if (($prevline =~ /^.\s*#\s*define\s/ ||
1924 $prevline =~ /\\\s*$/) && $continuation == 0) {
1925 $check = 0;
1926 }
1927
1928 my $cond_ptr = -1;
1929 $continuation = 0;
1930 while ($cond_ptr != $cond_lines) {
1931 $cond_ptr = $cond_lines;
1932
1933 # If we see an #else/#elif then the code
1934 # is not linear.
1935 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
1936 $check = 0;
1937 }
1938
1939 # Ignore:
1940 # 1) blank lines, they should be at 0,
1941 # 2) preprocessor lines, and
1942 # 3) labels.
1943 if ($continuation ||
1944 $s =~ /^\s*?\n/ ||
1945 $s =~ /^\s*#\s*?/ ||
1946 $s =~ /^\s*$Ident\s*:/) {
1947 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
1948 if ($s =~ s/^.*?\n//) {
1949 $cond_lines++;
1950 }
1951 }
1952 }
1953
1954 my (undef, $sindent) = line_stats("+" . $s);
1955 my $stat_real = raw_line($linenr, $cond_lines);
1956
1957 # Check if either of these lines are modified, else
1958 # this is not this patch's fault.
1959 if (!defined($stat_real) ||
1960 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
1961 $check = 0;
1962 }
1963 if (defined($stat_real) && $cond_lines > 1) {
1964 $stat_real = "[...]\n$stat_real";
1965 }
1966
1967 #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";
1968
1969 if ($check && (($sindent % 4) != 0 ||
1970 ($sindent <= $indent && $s ne ''))) {
1971 WARN("SUSPECT_CODE_INDENT",
1972 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
1973 }
1974 }
1975
1976 # Track the 'values' across context and added lines.
1977 my $opline = $line; $opline =~ s/^./ /;
1978 my ($curr_values, $curr_vars) =
1979 annotate_values($opline . "\n", $prev_values);
1980 $curr_values = $prev_values . $curr_values;
1981 if ($dbg_values) {
1982 my $outline = $opline; $outline =~ s/\t/ /g;
1983 print "$linenr > .$outline\n";
1984 print "$linenr > $curr_values\n";
1985 print "$linenr > $curr_vars\n";
1986 }
1987 $prev_values = substr($curr_values, -1);
1988
1989 #ignore lines not being added
1990 if ($line=~/^[^\+]/) {next;}
1991
1992 # TEST: allow direct testing of the type matcher.
1993 if ($dbg_type) {
1994 if ($line =~ /^.\s*$Declare\s*$/) {
1995 ERROR("TEST_TYPE",
1996 "TEST: is type\n" . $herecurr);
1997 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
1998 ERROR("TEST_NOT_TYPE",
1999 "TEST: is not type ($1 is)\n". $herecurr);
2000 }
2001 next;
2002 }
2003 # TEST: allow direct testing of the attribute matcher.
2004 if ($dbg_attr) {
2005 if ($line =~ /^.\s*$Modifier\s*$/) {
2006 ERROR("TEST_ATTR",
2007 "TEST: is attr\n" . $herecurr);
2008 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2009 ERROR("TEST_NOT_ATTR",
2010 "TEST: is not attr ($1 is)\n". $herecurr);
2011 }
2012 next;
2013 }
2014
2015 # check for initialisation to aggregates open brace on the next line
2016 if ($line =~ /^.\s*{/ &&
2017 $prevline =~ /(?:^|[^=])=\s*$/) {
2018 ERROR("OPEN_BRACE",
2019 "that open brace { should be on the previous line\n" . $hereprev);
2020 }
2021
2022 #
2023 # Checks which are anchored on the added line.
2024 #
2025
2026 # check for malformed paths in #include statements (uses RAW line)
2027 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2028 my $path = $1;
2029 if ($path =~ m{//}) {
2030 ERROR("MALFORMED_INCLUDE",
2031 "malformed #include filename\n" .
2032 $herecurr);
2033 }
2034 }
2035
2036 # no C99 // comments
2037 if ($line =~ m{//}) {
2038 ERROR("C99_COMMENTS",
2039 "do not use C99 // comments\n" . $herecurr);
2040 }
2041 # Remove C99 comments.
2042 $line =~ s@//.*@@;
2043 $opline =~ s@//.*@@;
2044
2045 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2046 # the whole statement.
2047 #print "APW <$lines[$realline_next - 1]>\n";
2048 if (defined $realline_next &&
2049 exists $lines[$realline_next - 1] &&
2050 !defined $suppress_export{$realline_next} &&
2051 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2052 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2053 # Handle definitions which produce identifiers with
2054 # a prefix:
2055 # XXX(foo);
2056 # EXPORT_SYMBOL(something_foo);
2057 my $name = $1;
2058 if ($stat =~ /^.([A-Z_]+)\s*\(\s*($Ident)/ &&
2059 $name =~ /^${Ident}_$2/) {
2060 #print "FOO C name<$name>\n";
2061 $suppress_export{$realline_next} = 1;
2062
2063 } elsif ($stat !~ /(?:
2064 \n.}\s*$|
2065 ^.DEFINE_$Ident\(\Q$name\E\)|
2066 ^.DECLARE_$Ident\(\Q$name\E\)|
2067 ^.LIST_HEAD\(\Q$name\E\)|
2068 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2069 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
2070 )/x) {
2071 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2072 $suppress_export{$realline_next} = 2;
2073 } else {
2074 $suppress_export{$realline_next} = 1;
2075 }
2076 }
2077 if (!defined $suppress_export{$linenr} &&
2078 $prevline =~ /^.\s*$/ &&
2079 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2080 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2081 #print "FOO B <$lines[$linenr - 1]>\n";
2082 $suppress_export{$linenr} = 2;
2083 }
2084 if (defined $suppress_export{$linenr} &&
2085 $suppress_export{$linenr} == 2) {
2086 WARN("EXPORT_SYMBOL",
2087 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2088 }
2089
2090 # check for global initialisers.
2091 if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) {
2092 ERROR("GLOBAL_INITIALISERS",
2093 "do not initialise globals to 0 or NULL\n" .
2094 $herecurr);
2095 }
2096 # check for static initialisers.
2097 if ($line =~ /\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2098 ERROR("INITIALISED_STATIC",
2099 "do not initialise statics to 0 or NULL\n" .
2100 $herecurr);
2101 }
2102
2103 # check for static const char * arrays.
2104 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2105 WARN("STATIC_CONST_CHAR_ARRAY",
2106 "static const char * array should probably be static const char * const\n" .
2107 $herecurr);
2108 }
2109
2110 # check for static char foo[] = "bar" declarations.
2111 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2112 WARN("STATIC_CONST_CHAR_ARRAY",
2113 "static char array declaration should probably be static const char\n" .
2114 $herecurr);
2115 }
2116
2117 # check for declarations of struct pci_device_id
2118 if ($line =~ /\bstruct\s+pci_device_id\s+\w+\s*\[\s*\]\s*\=\s*\{/) {
2119 WARN("DEFINE_PCI_DEVICE_TABLE",
2120 "Use DEFINE_PCI_DEVICE_TABLE for struct pci_device_id\n" . $herecurr);
2121 }
2122
2123 # check for new typedefs, only function parameters and sparse annotations
2124 # make sense.
2125 # if ($line =~ /\btypedef\s/ &&
2126 # $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2127 # $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2128 # $line !~ /\b$typeTypedefs\b/ &&
2129 # $line !~ /\b__bitwise(?:__|)\b/) {
2130 # WARN("NEW_TYPEDEFS",
2131 # "do not add new typedefs\n" . $herecurr);
2132 # }
2133
2134 # * goes on variable not on type
2135 # (char*[ const])
2136 if ($line =~ m{\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\)}) {
2137 my ($from, $to) = ($1, $1);
2138
2139 # Should start with a space.
2140 $to =~ s/^(\S)/ $1/;
2141 # Should not end with a space.
2142 $to =~ s/\s+$//;
2143 # '*'s should not have spaces between.
2144 while ($to =~ s/\*\s+\*/\*\*/) {
2145 }
2146
2147 #print "from<$from> to<$to>\n";
2148 if ($from ne $to) {
2149 ERROR("POINTER_LOCATION",
2150 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr);
2151 }
2152 } elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) {
2153 my ($from, $to, $ident) = ($1, $1, $2);
2154
2155 # Should start with a space.
2156 $to =~ s/^(\S)/ $1/;
2157 # Should not end with a space.
2158 $to =~ s/\s+$//;
2159 # '*'s should not have spaces between.
2160 while ($to =~ s/\*\s+\*/\*\*/) {
2161 }
2162 # Modifiers should have spaces.
2163 $to =~ s/(\b$Modifier$)/$1 /;
2164
2165 #print "from<$from> to<$to> ident<$ident>\n";
2166 if ($from ne $to && $ident !~ /^$Modifier$/) {
2167 ERROR("POINTER_LOCATION",
2168 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr);
2169 }
2170 }
2171
2172 # # no BUG() or BUG_ON()
2173 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2174 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2175 # print "$herecurr";
2176 # $clean = 0;
2177 # }
2178
2179 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2180 WARN("LINUX_VERSION_CODE",
2181 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2182 }
2183
2184 # check for uses of printk_ratelimit
2185 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2186 WARN("PRINTK_RATELIMITED",
2187 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2188 }
2189
2190 # printk should use KERN_* levels. Note that follow on printk's on the
2191 # same line do not need a level, so we use the current block context
2192 # to try and find and validate the current printk. In summary the current
2193 # printk includes all preceding printk's which have no newline on the end.
2194 # we assume the first bad printk is the one to report.
2195 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2196 my $ok = 0;
2197 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2198 #print "CHECK<$lines[$ln - 1]\n";
2199 # we have a preceding printk if it ends
2200 # with "\n" ignore it, else it is to blame
2201 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2202 if ($rawlines[$ln - 1] !~ m{\\n"}) {
2203 $ok = 1;
2204 }
2205 last;
2206 }
2207 }
2208 if ($ok == 0) {
2209 WARN("PRINTK_WITHOUT_KERN_LEVEL",
2210 "printk() should include KERN_ facility level\n" . $herecurr);
2211 }
2212 }
2213
2214 # function brace can't be on same line, except for #defines of do while,
2215 # or if closed on same line
2216 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2217 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2218 ERROR("OPEN_BRACE",
2219 "open brace '{' following function declarations go on the next line\n" . $herecurr);
2220 }
2221
2222 # open braces for enum, union and struct go on the same line.
2223 if ($line =~ /^.\s*{/ &&
2224 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2225 ERROR("OPEN_BRACE",
2226 "open brace '{' following $1 go on the same line\n" . $hereprev);
2227 }
2228
2229 # missing space after union, struct or enum definition
2230 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?(?:\s+$Ident)?[=\{]/) {
2231 WARN("SPACING",
2232 "missing space after $1 definition\n" . $herecurr);
2233 }
2234
2235 # check for spacing round square brackets; allowed:
2236 # 1. with a type on the left -- int [] a;
2237 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2238 # 3. inside a curly brace -- = { [0...10] = 5 }
2239 while ($line =~ /(.*?\s)\[/g) {
2240 my ($where, $prefix) = ($-[1], $1);
2241 if ($prefix !~ /$Type\s+$/ &&
2242 ($where != 0 || $prefix !~ /^.\s+$/) &&
2243 $prefix !~ /{\s+$/) {
2244 ERROR("BRACKET_SPACE",
2245 "space prohibited before open square bracket '['\n" . $herecurr);
2246 }
2247 }
2248
2249 # check for spaces between functions and their parentheses.
2250 while ($line =~ /($Ident)\s+\(/g) {
2251 my $name = $1;
2252 my $ctx_before = substr($line, 0, $-[1]);
2253 my $ctx = "$ctx_before$name";
2254
2255 # Ignore those directives where spaces _are_ permitted.
2256 if ($name =~ /^(?:
2257 if|for|while|switch|return|case|
2258 volatile|__volatile__|
2259 __attribute__|format|__extension__|
2260 asm|__asm__)$/x)
2261 {
2262
2263 # cpp #define statements have non-optional spaces, ie
2264 # if there is a space between the name and the open
2265 # parenthesis it is simply not a parameter group.
2266 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
2267
2268 # cpp #elif statement condition may start with a (
2269 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
2270
2271 # If this whole things ends with a type its most
2272 # likely a typedef for a function.
2273 } elsif ($ctx =~ /$Type$/) {
2274
2275 } else {
2276 WARN("SPACING",
2277 "space prohibited between function name and open parenthesis '('\n" . $herecurr);
2278 }
2279 }
2280 # Check operator spacing.
2281 if (!($line=~/\#\s*include/)) {
2282 my $ops = qr{
2283 <<=|>>=|<=|>=|==|!=|
2284 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
2285 =>|->|<<|>>|<|>|=|!|~|
2286 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
2287 \?|:
2288 }x;
2289 my @elements = split(/($ops|;)/, $opline);
2290 my $off = 0;
2291
2292 my $blank = copy_spacing($opline);
2293
2294 for (my $n = 0; $n < $#elements; $n += 2) {
2295 $off += length($elements[$n]);
2296
2297 # Pick up the preceding and succeeding characters.
2298 my $ca = substr($opline, 0, $off);
2299 my $cc = '';
2300 if (length($opline) >= ($off + length($elements[$n + 1]))) {
2301 $cc = substr($opline, $off + length($elements[$n + 1]));
2302 }
2303 my $cb = "$ca$;$cc";
2304
2305 my $a = '';
2306 $a = 'V' if ($elements[$n] ne '');
2307 $a = 'W' if ($elements[$n] =~ /\s$/);
2308 $a = 'C' if ($elements[$n] =~ /$;$/);
2309 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
2310 $a = 'O' if ($elements[$n] eq '');
2311 $a = 'E' if ($ca =~ /^\s*$/);
2312
2313 my $op = $elements[$n + 1];
2314
2315 my $c = '';
2316 if (defined $elements[$n + 2]) {
2317 $c = 'V' if ($elements[$n + 2] ne '');
2318 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
2319 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
2320 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
2321 $c = 'O' if ($elements[$n + 2] eq '');
2322 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
2323 } else {
2324 $c = 'E';
2325 }
2326
2327 my $ctx = "${a}x${c}";
2328
2329 my $at = "(ctx:$ctx)";
2330
2331 my $ptr = substr($blank, 0, $off) . "^";
2332 my $hereptr = "$hereline$ptr\n";
2333
2334 # Pull out the value of this operator.
2335 my $op_type = substr($curr_values, $off + 1, 1);
2336
2337 # Get the full operator variant.
2338 my $opv = $op . substr($curr_vars, $off, 1);
2339
2340 # Ignore operators passed as parameters.
2341 if ($op_type ne 'V' &&
2342 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
2343
2344 # # Ignore comments
2345 # } elsif ($op =~ /^$;+$/) {
2346
2347 # ; should have either the end of line or a space or \ after it
2348 } elsif ($op eq ';') {
2349 if ($ctx !~ /.x[WEBC]/ &&
2350 $cc !~ /^\\/ && $cc !~ /^;/) {
2351 ERROR("SPACING",
2352 "space required after that '$op' $at\n" . $hereptr);
2353 }
2354
2355 # // is a comment
2356 } elsif ($op eq '//') {
2357
2358 # No spaces for:
2359 # ->
2360 # : when part of a bitfield
2361 } elsif ($op eq '->' || $opv eq ':B') {
2362 if ($ctx =~ /Wx.|.xW/) {
2363 ERROR("SPACING",
2364 "spaces prohibited around that '$op' $at\n" . $hereptr);
2365 }
2366
2367 # , must have a space on the right.
2368 } elsif ($op eq ',') {
2369 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
2370 ERROR("SPACING",
2371 "space required after that '$op' $at\n" . $hereptr);
2372 }
2373
2374 # '*' as part of a type definition -- reported already.
2375 } elsif ($opv eq '*_') {
2376 #warn "'*' is part of type\n";
2377
2378 # unary operators should have a space before and
2379 # none after. May be left adjacent to another
2380 # unary operator, or a cast
2381 } elsif ($op eq '!' || $op eq '~' ||
2382 $opv eq '*U' || $opv eq '-U' ||
2383 $opv eq '&U' || $opv eq '&&U') {
2384 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
2385 ERROR("SPACING",
2386 "space required before that '$op' $at\n" . $hereptr);
2387 }
2388 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
2389 # A unary '*' may be const
2390
2391 } elsif ($ctx =~ /.xW/) {
2392 ERROR("SPACING",
2393 "space prohibited after that '$op' $at\n" . $hereptr);
2394 }
2395
2396 # unary ++ and unary -- are allowed no space on one side.
2397 } elsif ($op eq '++' or $op eq '--') {
2398 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
2399 ERROR("SPACING",
2400 "space required one side of that '$op' $at\n" . $hereptr);
2401 }
2402 if ($ctx =~ /Wx[BE]/ ||
2403 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
2404 ERROR("SPACING",
2405 "space prohibited before that '$op' $at\n" . $hereptr);
2406 }
2407 if ($ctx =~ /ExW/) {
2408 ERROR("SPACING",
2409 "space prohibited after that '$op' $at\n" . $hereptr);
2410 }
2411
2412
2413 # << and >> may either have or not have spaces both sides
2414 } elsif ($op eq '<<' or $op eq '>>' or
2415 $op eq '&' or $op eq '^' or $op eq '|' or
2416 $op eq '+' or $op eq '-' or
2417 $op eq '*' or $op eq '/' or
2418 $op eq '%')
2419 {
2420 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
2421 ERROR("SPACING",
2422 "need consistent spacing around '$op' $at\n" .
2423 $hereptr);
2424 }
2425
2426 # A colon needs no spaces before when it is
2427 # terminating a case value or a label.
2428 } elsif ($opv eq ':C' || $opv eq ':L') {
2429 if ($ctx =~ /Wx./) {
2430 ERROR("SPACING",
2431 "space prohibited before that '$op' $at\n" . $hereptr);
2432 }
2433
2434 # All the others need spaces both sides.
2435 } elsif ($ctx !~ /[EWC]x[CWE]/) {
2436 my $ok = 0;
2437
2438 # Ignore email addresses <foo@bar>
2439 if (($op eq '<' &&
2440 $cc =~ /^\S+\@\S+>/) ||
2441 ($op eq '>' &&
2442 $ca =~ /<\S+\@\S+$/))
2443 {
2444 $ok = 1;
2445 }
2446
2447 # Ignore ?:
2448 if (($opv eq ':O' && $ca =~ /\?$/) ||
2449 ($op eq '?' && $cc =~ /^:/)) {
2450 $ok = 1;
2451 }
2452
2453 if ($ok == 0) {
2454 ERROR("SPACING",
2455 "spaces required around that '$op' $at\n" . $hereptr);
2456 }
2457 }
2458 $off += length($elements[$n + 1]);
2459 }
2460 }
2461
2462 # check for multiple assignments
2463 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
2464 CHK("MULTIPLE_ASSIGNMENTS",
2465 "multiple assignments should be avoided\n" . $herecurr);
2466 }
2467
2468 ## # check for multiple declarations, allowing for a function declaration
2469 ## # continuation.
2470 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
2471 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
2472 ##
2473 ## # Remove any bracketed sections to ensure we do not
2474 ## # falsly report the parameters of functions.
2475 ## my $ln = $line;
2476 ## while ($ln =~ s/\([^\(\)]*\)//g) {
2477 ## }
2478 ## if ($ln =~ /,/) {
2479 ## WARN("MULTIPLE_DECLARATION",
2480 ## "declaring multiple variables together should be avoided\n" . $herecurr);
2481 ## }
2482 ## }
2483
2484 #need space before brace following if, while, etc
2485 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
2486 $line =~ /do{/) {
2487 ERROR("SPACING",
2488 "space required before the open brace '{'\n" . $herecurr);
2489 }
2490
2491 # closing brace should have a space following it when it has anything
2492 # on the line
2493 if ($line =~ /}(?!(?:,|;|\)))\S/) {
2494 ERROR("SPACING",
2495 "space required after that close brace '}'\n" . $herecurr);
2496 }
2497
2498 # check spacing on square brackets
2499 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
2500 ERROR("SPACING",
2501 "space prohibited after that open square bracket '['\n" . $herecurr);
2502 }
2503 if ($line =~ /\s\]/) {
2504 ERROR("SPACING",
2505 "space prohibited before that close square bracket ']'\n" . $herecurr);
2506 }
2507
2508 # check spacing on parentheses
2509 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
2510 $line !~ /for\s*\(\s+;/) {
2511 ERROR("SPACING",
2512 "space prohibited after that open parenthesis '('\n" . $herecurr);
2513 }
2514 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
2515 $line !~ /for\s*\(.*;\s+\)/ &&
2516 $line !~ /:\s+\)/) {
2517 ERROR("SPACING",
2518 "space prohibited before that close parenthesis ')'\n" . $herecurr);
2519 }
2520
2521 #goto labels aren't indented, allow a single space however
2522 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
2523 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
2524 WARN("INDENTED_LABEL",
2525 "labels should not be indented\n" . $herecurr);
2526 }
2527
2528 # Return is not a function.
2529 if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {
2530 my $spacing = $1;
2531 my $value = $2;
2532
2533 # Flatten any parentheses
2534 $value =~ s/\(/ \(/g;
2535 $value =~ s/\)/\) /g;
2536 while ($value =~ s/\[[^\{\}]*\]/1/ ||
2537 $value !~ /(?:$Ident|-?$Constant)\s*
2538 $Compare\s*
2539 (?:$Ident|-?$Constant)/x &&
2540 $value =~ s/\([^\(\)]*\)/1/) {
2541 }
2542 #print "value<$value>\n";
2543 if ($value =~ /^\s*(?:$Ident|-?$Constant)\s*$/) {
2544 ERROR("RETURN_PARENTHESES",
2545 "return is not a function, parentheses are not required\n" . $herecurr);
2546
2547 } elsif ($spacing !~ /\s+/) {
2548 ERROR("SPACING",
2549 "space required before the open parenthesis '('\n" . $herecurr);
2550 }
2551 }
2552 # Return of what appears to be an errno should normally be -'ve
2553 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
2554 my $name = $1;
2555 if ($name ne 'EOF' && $name ne 'ERROR') {
2556 WARN("USE_NEGATIVE_ERRNO",
2557 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
2558 }
2559 }
2560
2561 # typecasts on min/max could be min_t/max_t
2562 if ($line =~ /^\+(?:.*?)\b(min|max)\s*\($Typecast{0,1}($LvalOrFunc)\s*,\s*$Typecast{0,1}($LvalOrFunc)\s*\)/) {
2563 if (defined $2 || defined $8) {
2564 my $call = $1;
2565 my $cast1 = deparenthesize($2);
2566 my $arg1 = $3;
2567 my $cast2 = deparenthesize($8);
2568 my $arg2 = $9;
2569 my $cast;
2570
2571 if ($cast1 ne "" && $cast2 ne "") {
2572 $cast = "$cast1 or $cast2";
2573 } elsif ($cast1 ne "") {
2574 $cast = $cast1;
2575 } else {
2576 $cast = $cast2;
2577 }
2578 WARN("MINMAX",
2579 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . $herecurr);
2580 }
2581 }
2582
2583 # Need a space before open parenthesis after if, while etc
2584 if ($line=~/\b(if|while|for|switch)\(/) {
2585 ERROR("SPACING", "space required before the open parenthesis '('\n" . $herecurr);
2586 }
2587
2588 # Check for illegal assignment in if conditional -- and check for trailing
2589 # statements after the conditional.
2590 if ($line =~ /do\s*(?!{)/) {
2591 my ($stat_next) = ctx_statement_block($line_nr_next,
2592 $remain_next, $off_next);
2593 $stat_next =~ s/\n./\n /g;
2594 ##print "stat<$stat> stat_next<$stat_next>\n";
2595
2596 if ($stat_next =~ /^\s*while\b/) {
2597 # If the statement carries leading newlines,
2598 # then count those as offsets.
2599 my ($whitespace) =
2600 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
2601 my $offset =
2602 statement_rawlines($whitespace) - 1;
2603
2604 $suppress_whiletrailers{$line_nr_next +
2605 $offset} = 1;
2606 }
2607 }
2608 if (!defined $suppress_whiletrailers{$linenr} &&
2609 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
2610 my ($s, $c) = ($stat, $cond);
2611
2612 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
2613 ERROR("ASSIGN_IN_IF",
2614 "do not use assignment in if condition\n" . $herecurr);
2615 }
2616
2617 # Find out what is on the end of the line after the
2618 # conditional.
2619 substr($s, 0, length($c), '');
2620 $s =~ s/\n.*//g;
2621 $s =~ s/$;//g; # Remove any comments
2622 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
2623 $c !~ /}\s*while\s*/)
2624 {
2625 # Find out how long the conditional actually is.
2626 my @newlines = ($c =~ /\n/gs);
2627 my $cond_lines = 1 + $#newlines;
2628 my $stat_real = '';
2629
2630 $stat_real = raw_line($linenr, $cond_lines)
2631 . "\n" if ($cond_lines);
2632 if (defined($stat_real) && $cond_lines > 1) {
2633 $stat_real = "[...]\n$stat_real";
2634 }
2635
2636 ERROR("TRAILING_STATEMENTS",
2637 "trailing statements should be on next line\n" . $herecurr . $stat_real);
2638 }
2639 }
2640
2641 # Check for bitwise tests written as boolean
2642 if ($line =~ /
2643 (?:
2644 (?:\[|\(|\&\&|\|\|)
2645 \s*0[xX][0-9]+\s*
2646 (?:\&\&|\|\|)
2647 |
2648 (?:\&\&|\|\|)
2649 \s*0[xX][0-9]+\s*
2650 (?:\&\&|\|\||\)|\])
2651 )/x)
2652 {
2653 WARN("HEXADECIMAL_BOOLEAN_TEST",
2654 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
2655 }
2656
2657 # if and else should not have general statements after it
2658 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
2659 my $s = $1;
2660 $s =~ s/$;//g; # Remove any comments
2661 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
2662 ERROR("TRAILING_STATEMENTS",
2663 "trailing statements should be on next line\n" . $herecurr);
2664 }
2665 }
2666 # if should not continue a brace
2667 if ($line =~ /}\s*if\b/) {
2668 ERROR("TRAILING_STATEMENTS",
2669 "trailing statements should be on next line\n" .
2670 $herecurr);
2671 }
2672 # case and default should not have general statements after them
2673 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
2674 $line !~ /\G(?:
2675 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
2676 \s*return\s+
2677 )/xg)
2678 {
2679 ERROR("TRAILING_STATEMENTS",
2680 "trailing statements should be on next line\n" . $herecurr);
2681 }
2682
2683 # Check for }<nl>else {, these must be at the same
2684 # indent level to be relevant to each other.
2685 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
2686 $previndent == $indent) {
2687 ERROR("ELSE_AFTER_BRACE",
2688 "else should follow close brace '}'\n" . $hereprev);
2689 }
2690
2691 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
2692 $previndent == $indent) {
2693 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
2694
2695 # Find out what is on the end of the line after the
2696 # conditional.
2697 substr($s, 0, length($c), '');
2698 $s =~ s/\n.*//g;
2699
2700 if ($s =~ /^\s*;/) {
2701 ERROR("WHILE_AFTER_BRACE",
2702 "while should follow close brace '}'\n" . $hereprev);
2703 }
2704 }
2705
2706 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
2707 # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
2708 # print "No studly caps, use _\n";
2709 # print "$herecurr";
2710 # $clean = 0;
2711 # }
2712
2713 #no spaces allowed after \ in define
2714 if ($line=~/\#\s*define.*\\\s$/) {
2715 WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
2716 "Whitepspace after \\ makes next lines useless\n" . $herecurr);
2717 }
2718
2719 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
2720 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
2721 my $file = "$1.h";
2722 my $checkfile = "include/linux/$file";
2723 if (-f "$root/$checkfile" &&
2724 $realfile ne $checkfile &&
2725 $1 !~ /$allowed_asm_includes/)
2726 {
2727 if ($realfile =~ m{^arch/}) {
2728 CHK("ARCH_INCLUDE_LINUX",
2729 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2730 } else {
2731 WARN("INCLUDE_LINUX",
2732 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2733 }
2734 }
2735 }
2736
2737 # multi-statement macros should be enclosed in a do while loop, grab the
2738 # first statement and ensure its the whole macro if its not enclosed
2739 # in a known good container
2740 if ($realfile !~ m@/vmlinux.lds.h$@ &&
2741 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
2742 my $ln = $linenr;
2743 my $cnt = $realcnt;
2744 my ($off, $dstat, $dcond, $rest);
2745 my $ctx = '';
2746
2747 my $args = defined($1);
2748
2749 # Find the end of the macro and limit our statement
2750 # search to that.
2751 while ($cnt > 0 && defined $lines[$ln - 1] &&
2752 $lines[$ln - 1] =~ /^(?:-|..*\\$)/)
2753 {
2754 $ctx .= $rawlines[$ln - 1] . "\n";
2755 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2756 $ln++;
2757 }
2758 $ctx .= $rawlines[$ln - 1];
2759
2760 ($dstat, $dcond, $ln, $cnt, $off) =
2761 ctx_statement_block($linenr, $ln - $linenr + 1, 0);
2762 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
2763 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
2764
2765 # Extract the remainder of the define (if any) and
2766 # rip off surrounding spaces, and trailing \'s.
2767 $rest = '';
2768 while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) {
2769 #print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";
2770 if ($off != 0 || $lines[$ln - 1] !~ /^-/) {
2771 $rest .= substr($lines[$ln - 1], $off) . "\n";
2772 $cnt--;
2773 }
2774 $ln++;
2775 $off = 0;
2776 }
2777 $rest =~ s/\\\n.//g;
2778 $rest =~ s/^\s*//s;
2779 $rest =~ s/\s*$//s;
2780
2781 # Clean up the original statement.
2782 if ($args) {
2783 substr($dstat, 0, length($dcond), '');
2784 } else {
2785 $dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;
2786 }
2787 $dstat =~ s/$;//g;
2788 $dstat =~ s/\\\n.//g;
2789 $dstat =~ s/^\s*//s;
2790 $dstat =~ s/\s*$//s;
2791
2792 # Flatten any parentheses and braces
2793 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
2794 $dstat =~ s/\{[^\{\}]*\}/1/ ||
2795 $dstat =~ s/\[[^\{\}]*\]/1/)
2796 {
2797 }
2798
2799 my $exceptions = qr{
2800 $Declare|
2801 module_param_named|
2802 MODULE_PARAM_DESC|
2803 DECLARE_PER_CPU|
2804 DEFINE_PER_CPU|
2805 __typeof__\(|
2806 union|
2807 struct|
2808 \.$Ident\s*=\s*|
2809 ^\"|\"$
2810 }x;
2811 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
2812 if ($rest ne '' && $rest ne ',') {
2813 if ($rest !~ /while\s*\(/ &&
2814 $dstat !~ /$exceptions/)
2815 {
2816 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
2817 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
2818 }
2819
2820 } elsif ($ctx !~ /;/) {
2821 if ($dstat ne '' &&
2822 $dstat !~ /^(?:$Ident|-?$Constant)$/ &&
2823 $dstat !~ /$exceptions/ &&
2824 $dstat !~ /^\.$Ident\s*=/ &&
2825 $dstat =~ /$Operators/)
2826 {
2827 ERROR("COMPLEX_MACRO",
2828 "Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
2829 }
2830 }
2831 }
2832
2833 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
2834 # all assignments may have only one of the following with an assignment:
2835 # .
2836 # ALIGN(...)
2837 # VMLINUX_SYMBOL(...)
2838 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
2839 WARN("MISSING_VMLINUX_SYMBOL",
2840 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
2841 }
2842
2843 # check for redundant bracing round if etc
2844 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
2845 my ($level, $endln, @chunks) =
2846 ctx_statement_full($linenr, $realcnt, 1);
2847 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
2848 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
2849 if ($#chunks > 0 && $level == 0) {
2850 my $allowed = 0;
2851 my $seen = 0;
2852 my $herectx = $here . "\n";
2853 my $ln = $linenr - 1;
2854 for my $chunk (@chunks) {
2855 my ($cond, $block) = @{$chunk};
2856
2857 # If the condition carries leading newlines, then count those as offsets.
2858 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
2859 my $offset = statement_rawlines($whitespace) - 1;
2860
2861 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
2862
2863 # We have looked at and allowed this specific line.
2864 $suppress_ifbraces{$ln + $offset} = 1;
2865
2866 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
2867 $ln += statement_rawlines($block) - 1;
2868
2869 substr($block, 0, length($cond), '');
2870
2871 $seen++ if ($block =~ /^\s*{/);
2872
2873 #print "cond<$cond> block<$block> allowed<$allowed>\n";
2874 if (statement_lines($cond) > 1) {
2875 #print "APW: ALLOWED: cond<$cond>\n";
2876 $allowed = 1;
2877 }
2878 if ($block =~/\b(?:if|for|while)\b/) {
2879 #print "APW: ALLOWED: block<$block>\n";
2880 $allowed = 1;
2881 }
2882 if (statement_block_size($block) > 1) {
2883 #print "APW: ALLOWED: lines block<$block>\n";
2884 $allowed = 1;
2885 }
2886 }
2887 if ($seen && !$allowed) {
2888 WARN("BRACES",
2889 "braces {} are not necessary for any arm of this statement\n" . $herectx);
2890 }
2891 }
2892 }
2893 if (!defined $suppress_ifbraces{$linenr - 1} &&
2894 $line =~ /\b(if|while|for|else)\b/) {
2895 my $allowed = 0;
2896
2897 # Check the pre-context.
2898 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
2899 #print "APW: ALLOWED: pre<$1>\n";
2900 $allowed = 1;
2901 }
2902
2903 my ($level, $endln, @chunks) =
2904 ctx_statement_full($linenr, $realcnt, $-[0]);
2905
2906 # Check the condition.
2907 my ($cond, $block) = @{$chunks[0]};
2908 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
2909 if (defined $cond) {
2910 substr($block, 0, length($cond), '');
2911 }
2912 if (statement_lines($cond) > 1) {
2913 #print "APW: ALLOWED: cond<$cond>\n";
2914 $allowed = 1;
2915 }
2916 if ($block =~/\b(?:if|for|while)\b/) {
2917 #print "APW: ALLOWED: block<$block>\n";
2918 $allowed = 1;
2919 }
2920 if (statement_block_size($block) > 1) {
2921 #print "APW: ALLOWED: lines block<$block>\n";
2922 $allowed = 1;
2923 }
2924 # Check the post-context.
2925 if (defined $chunks[1]) {
2926 my ($cond, $block) = @{$chunks[1]};
2927 if (defined $cond) {
2928 substr($block, 0, length($cond), '');
2929 }
2930 if ($block =~ /^\s*\{/) {
2931 #print "APW: ALLOWED: chunk-1 block<$block>\n";
2932 $allowed = 1;
2933 }
2934 }
2935 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
2936 my $herectx = $here . "\n";
2937 my $cnt = statement_rawlines($block);
2938
2939 for (my $n = 0; $n < $cnt; $n++) {
2940 $herectx .= raw_line($linenr, $n) . "\n";
2941 }
2942
2943 WARN("BRACES",
2944 "braces {} are not necessary for single statement blocks\n" . $herectx);
2945 }
2946 }
2947
2948 # don't include deprecated include files (uses RAW line)
2949 for my $inc (@dep_includes) {
2950 if ($rawline =~ m@^.\s*\#\s*include\s*\<$inc>@) {
2951 ERROR("DEPRECATED_INCLUDE",
2952 "Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
2953 }
2954 }
2955
2956 # don't use deprecated functions
2957 for my $func (@dep_functions) {
2958 if ($line =~ /\b$func\b/) {
2959 ERROR("DEPRECATED_FUNCTION",
2960 "Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
2961 }
2962 }
2963
2964 # no volatiles please
2965 # my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
2966 # if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
2967 # WARN("VOLATILE",
2968 # "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
2969 # }
2970
2971 # warn about #if 0
2972 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
2973 CHK("REDUNDANT_CODE",
2974 "if this code is redundant consider removing it\n" .
2975 $herecurr);
2976 }
2977
2978 # check for needless kfree() checks
2979 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
2980 my $expr = $1;
2981 if ($line =~ /\bkfree\(\Q$expr\E\);/) {
2982 WARN("NEEDLESS_KFREE",
2983 "kfree(NULL) is safe this check is probably not required\n" . $hereprev);
2984 }
2985 }
2986 # check for needless usb_free_urb() checks
2987 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
2988 my $expr = $1;
2989 if ($line =~ /\busb_free_urb\(\Q$expr\E\);/) {
2990 WARN("NEEDLESS_USB_FREE_URB",
2991 "usb_free_urb(NULL) is safe this check is probably not required\n" . $hereprev);
2992 }
2993 }
2994
2995 # prefer usleep_range over udelay
2996 if ($line =~ /\budelay\s*\(\s*(\w+)\s*\)/) {
2997 # ignore udelay's < 10, however
2998 if (! (($1 =~ /(\d+)/) && ($1 < 10)) ) {
2999 CHK("USLEEP_RANGE",
3000 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);
3001 }
3002 }
3003
3004 # warn about unexpectedly long msleep's
3005 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
3006 if ($1 < 20) {
3007 WARN("MSLEEP",
3008 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3009 }
3010 }
3011
3012 # warn about #ifdefs in C files
3013 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3014 # print "#ifdef in C files should be avoided\n";
3015 # print "$herecurr";
3016 # $clean = 0;
3017 # }
3018
3019 # warn about spacing in #ifdefs
3020 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
3021 ERROR("SPACING",
3022 "exactly one space required after that #$1\n" . $herecurr);
3023 }
3024
3025 # check for spinlock_t definitions without a comment.
3026 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
3027 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
3028 my $which = $1;
3029 if (!ctx_has_comment($first_line, $linenr)) {
3030 CHK("UNCOMMENTED_DEFINITION",
3031 "$1 definition without comment\n" . $herecurr);
3032 }
3033 }
3034 # check for memory barriers without a comment.
3035 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3036 if (!ctx_has_comment($first_line, $linenr)) {
3037 CHK("MEMORY_BARRIER",
3038 "memory barrier without comment\n" . $herecurr);
3039 }
3040 }
3041 # check of hardware specific defines
3042 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
3043 CHK("ARCH_DEFINES",
3044 "architecture specific defines should be avoided\n" . $herecurr);
3045 }
3046
3047 # Check that the storage class is at the beginning of a declaration
3048 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
3049 WARN("STORAGE_CLASS",
3050 "storage class should be at the beginning of the declaration\n" . $herecurr)
3051 }
3052
3053 # check the location of the inline attribute, that it is between
3054 # storage class and type.
3055 if ($line =~ /\b$Type\s+$Inline\b/ ||
3056 $line =~ /\b$Inline\s+$Storage\b/) {
3057 ERROR("INLINE_LOCATION",
3058 "inline keyword should sit between storage class and type\n" . $herecurr);
3059 }
3060
3061 # Check for __inline__ and __inline, prefer inline
3062 if ($line =~ /\b(__inline__|__inline)\b/) {
3063 WARN("INLINE",
3064 "plain inline is preferred over $1\n" . $herecurr);
3065 }
3066
3067 # Check for __attribute__ packed, prefer __packed
3068 # if ($line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
3069 # WARN("PREFER_PACKED",
3070 # "__packed is preferred over __attribute__((packed))\n" . $herecurr);
3071 # }
3072
3073 # Check for __attribute__ aligned, prefer __aligned
3074 # if ($line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
3075 # WARN("PREFER_ALIGNED",
3076 # "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
3077 # }
3078
3079 # check for sizeof(&)
3080 if ($line =~ /\bsizeof\s*\(\s*\&/) {
3081 WARN("SIZEOF_ADDRESS",
3082 "sizeof(& should be avoided\n" . $herecurr);
3083 }
3084
3085 # check for line continuations in quoted strings with odd counts of "
3086 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
3087 WARN("LINE_CONTINUATIONS",
3088 "Avoid line continuations in quoted strings\n" . $herecurr);
3089 }
3090
3091 # check for new externs in .c files.
3092 # if ($realfile =~ /\.c$/ && defined $stat &&
3093 # $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
3094 # {
3095 # my $function_name = $1;
3096 # my $paren_space = $2;
3097 #
3098 # my $s = $stat;
3099 # if (defined $cond) {
3100 # substr($s, 0, length($cond), '');
3101 # }
3102 # if ($s =~ /^\s*;/ &&
3103 # $function_name ne 'uninitialized_var')
3104 # {
3105 # WARN("AVOID_EXTERNS",
3106 # "externs should be avoided in .c files\n" . $herecurr);
3107 # }
3108 #
3109 # if ($paren_space =~ /\n/) {
3110 # WARN("FUNCTION_ARGUMENTS",
3111 # "arguments for function declarations should follow identifier\n" . $herecurr);
3112 # }
3113 #
3114 # } elsif ($realfile =~ /\.c$/ && defined $stat &&
3115 # $stat =~ /^.\s*extern\s+/)
3116 # {
3117 # WARN("AVOID_EXTERNS",
3118 # "externs should be avoided in .c files\n" . $herecurr);
3119 # }
3120
3121 # checks for new __setup's
3122 if ($rawline =~ /\b__setup\("([^"]*)"/) {
3123 my $name = $1;
3124
3125 if (!grep(/$name/, @setup_docs)) {
3126 CHK("UNDOCUMENTED_SETUP",
3127 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
3128 }
3129 }
3130
3131 # check for pointless casting of kmalloc return
3132 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
3133 WARN("UNNECESSARY_CASTS",
3134 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
3135 }
3136
3137 # check for multiple semicolons
3138 if ($line =~ /;\s*;\s*$/) {
3139 WARN("ONE_SEMICOLON",
3140 "Statements terminations use 1 semicolon\n" . $herecurr);
3141 }
3142
3143 # check for gcc specific __FUNCTION__
3144 if ($line =~ /__FUNCTION__/) {
3145 WARN("USE_FUNC",
3146 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr);
3147 }
3148
3149 # check for semaphores initialized locked
3150 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
3151 WARN("CONSIDER_COMPLETION",
3152 "consider using a completion\n" . $herecurr);
3153
3154 }
3155 # recommend kstrto* over simple_strto*
3156 if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
3157 WARN("CONSIDER_KSTRTO",
3158 "consider using kstrto* in preference to simple_$1\n" . $herecurr);
3159 }
3160 # check for __initcall(), use device_initcall() explicitly please
3161 if ($line =~ /^.\s*__initcall\s*\(/) {
3162 WARN("USE_DEVICE_INITCALL",
3163 "please use device_initcall() instead of __initcall()\n" . $herecurr);
3164 }
3165 # check for various ops structs, ensure they are const.
3166 my $struct_ops = qr{acpi_dock_ops|
3167 address_space_operations|
3168 backlight_ops|
3169 block_device_operations|
3170 dentry_operations|
3171 dev_pm_ops|
3172 dma_map_ops|
3173 extent_io_ops|
3174 file_lock_operations|
3175 file_operations|
3176 hv_ops|
3177 ide_dma_ops|
3178 intel_dvo_dev_ops|
3179 item_operations|
3180 iwl_ops|
3181 kgdb_arch|
3182 kgdb_io|
3183 kset_uevent_ops|
3184 lock_manager_operations|
3185 microcode_ops|
3186 mtrr_ops|
3187 neigh_ops|
3188 nlmsvc_binding|
3189 pci_raw_ops|
3190 pipe_buf_operations|
3191 platform_hibernation_ops|
3192 platform_suspend_ops|
3193 proto_ops|
3194 rpc_pipe_ops|
3195 seq_operations|
3196 snd_ac97_build_ops|
3197 soc_pcmcia_socket_ops|
3198 stacktrace_ops|
3199 sysfs_ops|
3200 tty_operations|
3201 usb_mon_operations|
3202 wd_ops}x;
3203 if ($line !~ /\bconst\b/ &&
3204 $line =~ /\bstruct\s+($struct_ops)\b/) {
3205 WARN("CONST_STRUCT",
3206 "struct $1 should normally be const\n" .
3207 $herecurr);
3208 }
3209
3210 # use of NR_CPUS is usually wrong
3211 # ignore definitions of NR_CPUS and usage to define arrays as likely right
3212 if ($line =~ /\bNR_CPUS\b/ &&
3213 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
3214 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
3215 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
3216 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
3217 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
3218 {
3219 WARN("NR_CPUS",
3220 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
3221 }
3222
3223 # check for %L{u,d,i} in strings
3224 my $string;
3225 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
3226 $string = substr($rawline, $-[1], $+[1] - $-[1]);
3227 $string =~ s/%%/__/g;
3228 if ($string =~ /(?<!%)%L[udi]/) {
3229 WARN("PRINTF_L",
3230 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
3231 last;
3232 }
3233 }
3234
3235 # whine mightly about in_atomic
3236 if ($line =~ /\bin_atomic\s*\(/) {
3237 if ($realfile =~ m@^drivers/@) {
3238 ERROR("IN_ATOMIC",
3239 "do not use in_atomic in drivers\n" . $herecurr);
3240 } elsif ($realfile !~ m@^kernel/@) {
3241 WARN("IN_ATOMIC",
3242 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
3243 }
3244 }
3245
3246 # check for lockdep_set_novalidate_class
3247 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
3248 $line =~ /__lockdep_no_validate__\s*\)/ ) {
3249 if ($realfile !~ m@^kernel/lockdep@ &&
3250 $realfile !~ m@^include/linux/lockdep@ &&
3251 $realfile !~ m@^drivers/base/core@) {
3252 ERROR("LOCKDEP",
3253 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
3254 }
3255 }
3256
3257 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
3258 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
3259 WARN("EXPORTED_WORLD_WRITABLE",
3260 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
3261 }
3262
3263 # Check for memset with swapped arguments
3264 if ($line =~ /memset.*\,(\ |)(0x|)0(\ |0|)\);/) {
3265 ERROR("MEMSET",
3266 "memset size is 3rd argument, not the second.\n" . $herecurr);
3267 }
3268 }
3269
3270 # If we have no input at all, then there is nothing to report on
3271 # so just keep quiet.
3272 if ($#rawlines == -1) {
3273 exit(0);
3274 }
3275
3276 # In mailback mode only produce a report in the negative, for
3277 # things that appear to be patches.
3278 if ($mailback && ($clean == 1 || !$is_patch)) {
3279 exit(0);
3280 }
3281
3282 # This is not a patch, and we are are in 'no-patch' mode so
3283 # just keep quiet.
3284 if (!$chk_patch && !$is_patch) {
3285 exit(0);
3286 }
3287
3288 if (!$is_patch) {
3289 ERROR("NOT_UNIFIED_DIFF",
3290 "Does not appear to be a unified-diff format patch\n");
3291 }
3292 if ($is_patch && $chk_signoff && $signoff == 0) {
3293 ERROR("MISSING_SIGN_OFF",
3294 "Missing Signed-off-by: line(s)\n");
3295 }
3296
3297 print report_dump();
3298 if ($summary && !($clean == 1 && $quiet == 1)) {
3299 print "$filename " if ($summary_file);
3300 print "total: $cnt_error errors, $cnt_warn warnings, " .
3301 (($check)? "$cnt_chk checks, " : "") .
3302 "$cnt_lines lines checked\n";
3303 print "\n" if ($quiet == 0);
3304 }
3305
3306 if ($quiet == 0) {
3307 # If there were whitespace errors which cleanpatch can fix
3308 # then suggest that.
3309 if ($rpt_cleaners) {
3310 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
3311 print " scripts/cleanfile\n\n";
3312 $rpt_cleaners = 0;
3313 }
3314 }
3315
3316 if (keys %ignore_type) {
3317 print "NOTE: Ignored message types:";
3318 foreach my $ignore (sort keys %ignore_type) {
3319 print " $ignore";
3320 }
3321 print "\n";
3322 print "\n" if ($quiet == 0);
3323 }
3324
3325 if ($clean == 1 && $quiet == 0) {
3326 print "$vname has no obvious style problems and is ready for submission.\n"
3327 }
3328 if ($clean == 0 && $quiet == 0) {
3329 print << "EOM";
3330 $vname has style problems, please review.
3331
3332 If any of these errors are false positives, please report
3333 them to the maintainer, see CHECKPATCH in MAINTAINERS.
3334 EOM
3335 }
3336
3337 return $clean;
3338 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)