projects/linux·blob v2.6.25-rc3 · refs

1842 lines · 48.6 KiB

1#!/usr/bin/perl -w
2# (c) 2001, Dave Jones. <[email protected]> (the file handling bit)
3# (c) 2005, Joel Schopp <[email protected]> (the ugly bit)
4# (c) 2007, Andy Whitcroft <[email protected]> (new conditions, test suite, etc)
5# Licensed under the terms of the GNU GPL License version 2
6
7use strict;
8
9my $P = $0;
10$P =~ s@.*/@@g;
11
12my $V = '0.14';
13
14use Getopt::Long qw(:config no_auto_abbrev);
15
16my $quiet = 0;
17my $tree = 1;
18my $chk_signoff = 1;
19my $chk_patch = 1;
20my $tst_type = 0;
21my $emacs = 0;
22my $terse = 0;
23my $file = 0;
24my $check = 0;
25my $summary = 1;
26my $mailback = 0;
27my $summary_file = 0;
28my $root;
29my %debug;
30GetOptions(
31 'q|quiet+' => \$quiet,
32 'tree!' => \$tree,
33 'signoff!' => \$chk_signoff,
34 'patch!' => \$chk_patch,
35 'emacs!' => \$emacs,
36 'terse!' => \$terse,
37 'file!' => \$file,
38 'subjective!' => \$check,
39 'strict!' => \$check,
40 'root=s' => \$root,
41 'summary!' => \$summary,
42 'mailback!' => \$mailback,
43 'summary-file!' => \$summary_file,
44
45 'debug=s' => \%debug,
46 'test-type!' => \$tst_type,
47) or exit;
48
49my $exit = 0;
50
51if ($#ARGV < 0) {
52 print "usage: $P [options] patchfile\n";
53 print "version: $V\n";
54 print "options: -q => quiet\n";
55 print " --no-tree => run without a kernel tree\n";
56 print " --terse => one line per report\n";
57 print " --emacs => emacs compile window format\n";
58 print " --file => check a source file\n";
59 print " --strict => enable more subjective tests\n";
60 print " --root => path to the kernel tree root\n";
61 print " --no-summary => suppress the per-file summary\n";
62 print " --summary-file => include the filename in summary\n";
63 exit(1);
64}
65
66my $dbg_values = 0;
67my $dbg_possible = 0;
68for my $key (keys %debug) {
69 eval "\${dbg_$key} = '$debug{$key}';"
70}
71
72if ($terse) {
73 $emacs = 1;
74 $quiet++;
75}
76
77if ($tree) {
78 if (defined $root) {
79 if (!top_of_kernel_tree($root)) {
80 die "$P: $root: --root does not point at a valid tree\n";
81 }
82 } else {
83 if (top_of_kernel_tree('.')) {
84 $root = '.';
85 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
86 top_of_kernel_tree($1)) {
87 $root = $1;
88 }
89 }
90
91 if (!defined $root) {
92 print "Must be run from the top-level dir. of a kernel tree\n";
93 exit(2);
94 }
95}
96
97my $emitted_corrupt = 0;
98
99our $Ident = qr{[A-Za-z_][A-Za-z\d_]*};
100our $Storage = qr{extern|static|asmlinkage};
101our $Sparse = qr{
102 __user|
103 __kernel|
104 __force|
105 __iomem|
106 __must_check|
107 __init_refok|
108 __kprobes|
109 fastcall
110 }x;
111our $Attribute = qr{
112 const|
113 __read_mostly|
114 __kprobes|
115 __(?:mem|cpu|dev|)(?:initdata|init)
116 }x;
117our $Inline = qr{inline|__always_inline|noinline};
118our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
119our $Lval = qr{$Ident(?:$Member)*};
120
121our $Constant = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
122our $Assignment = qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
123our $Operators = qr{
124 <=|>=|==|!=|
125 =>|->|<<|>>|<|>|!|~|
126 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
127 }x;
128
129our $NonptrType;
130our $Type;
131our $Declare;
132
133our @typeList = (
134 qr{void},
135 qr{char},
136 qr{short},
137 qr{int},
138 qr{long},
139 qr{unsigned},
140 qr{float},
141 qr{double},
142 qr{bool},
143 qr{long\s+int},
144 qr{long\s+long},
145 qr{long\s+long\s+int},
146 qr{(?:__)?(?:u|s|be|le)(?:8|16|32|64)},
147 qr{struct\s+$Ident},
148 qr{union\s+$Ident},
149 qr{enum\s+$Ident},
150 qr{${Ident}_t},
151 qr{${Ident}_handler},
152 qr{${Ident}_handler_fn},
153);
154
155sub build_types {
156 my $all = "(?: \n" . join("|\n ", @typeList) . "\n)";
157 $NonptrType = qr{
158 \b
159 (?:const\s+)?
160 (?:unsigned\s+)?
161 $all
162 (?:\s+$Sparse|\s+const)*
163 \b
164 }x;
165 $Type = qr{
166 \b$NonptrType\b
167 (?:\s*\*+\s*const|\s*\*+|(?:\s*\[\s*\])+)?
168 (?:\s+$Inline|\s+$Sparse|\s+$Attribute)*
169 }x;
170 $Declare = qr{(?:$Storage\s+)?$Type};
171}
172build_types();
173
174$chk_signoff = 0 if ($file);
175
176my @dep_includes = ();
177my @dep_functions = ();
178my $removal = "Documentation/feature-removal-schedule.txt";
179if ($tree && -f "$root/$removal") {
180 open(REMOVE, "<$root/$removal") ||
181 die "$P: $removal: open failed - $!\n";
182 while (<REMOVE>) {
183 if (/^Check:\s+(.*\S)/) {
184 for my $entry (split(/[, ]+/, $1)) {
185 if ($entry =~ m@include/(.*)@) {
186 push(@dep_includes, $1);
187
188 } elsif ($entry !~ m@/@) {
189 push(@dep_functions, $entry);
190 }
191 }
192 }
193 }
194}
195
196my @rawlines = ();
197my @lines = ();
198my $vname;
199for my $filename (@ARGV) {
200 if ($file) {
201 open(FILE, "diff -u /dev/null $filename|") ||
202 die "$P: $filename: diff failed - $!\n";
203 } else {
204 open(FILE, "<$filename") ||
205 die "$P: $filename: open failed - $!\n";
206 }
207 if ($filename eq '-') {
208 $vname = 'Your patch';
209 } else {
210 $vname = $filename;
211 }
212 while (<FILE>) {
213 chomp;
214 push(@rawlines, $_);
215 }
216 close(FILE);
217 if (!process($filename)) {
218 $exit = 1;
219 }
220 @rawlines = ();
221 @lines = ();
222}
223
224exit($exit);
225
226sub top_of_kernel_tree {
227 my ($root) = @_;
228
229 my @tree_check = (
230 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
231 "README", "Documentation", "arch", "include", "drivers",
232 "fs", "init", "ipc", "kernel", "lib", "scripts",
233 );
234
235 foreach my $check (@tree_check) {
236 if (! -e $root . '/' . $check) {
237 return 0;
238 }
239 }
240 return 1;
241}
242
243sub expand_tabs {
244 my ($str) = @_;
245
246 my $res = '';
247 my $n = 0;
248 for my $c (split(//, $str)) {
249 if ($c eq "\t") {
250 $res .= ' ';
251 $n++;
252 for (; ($n % 8) != 0; $n++) {
253 $res .= ' ';
254 }
255 next;
256 }
257 $res .= $c;
258 $n++;
259 }
260
261 return $res;
262}
263sub copy_spacing {
264 my ($str) = @_;
265
266 my $res = '';
267 for my $c (split(//, $str)) {
268 if ($c eq "\t") {
269 $res .= $c;
270 } else {
271 $res .= ' ';
272 }
273 }
274
275 return $res;
276}
277
278sub line_stats {
279 my ($line) = @_;
280
281 # Drop the diff line leader and expand tabs
282 $line =~ s/^.//;
283 $line = expand_tabs($line);
284
285 # Pick the indent from the front of the line.
286 my ($white) = ($line =~ /^(\s*)/);
287
288 return (length($line), length($white));
289}
290
291sub sanitise_line {
292 my ($line) = @_;
293
294 my $res = '';
295 my $l = '';
296
297 my $quote = '';
298 my $qlen = 0;
299
300 foreach my $c (split(//, $line)) {
301 # The second backslash of a pair is not a "quote".
302 if ($l eq "\\" && $c eq "\\") {
303 $c = 'X';
304 }
305 if ($l ne "\\" && ($c eq "'" || $c eq '"')) {
306 if ($quote eq '') {
307 $quote = $c;
308 $res .= $c;
309 $l = $c;
310 $qlen = 0;
311 next;
312 } elsif ($quote eq $c) {
313 $quote = '';
314 }
315 }
316 if ($quote eq "'" && $qlen > 1) {
317 $quote = '';
318 }
319 if ($quote && $c ne "\t") {
320 $res .= "X";
321 $qlen++;
322 } else {
323 $res .= $c;
324 }
325
326 $l = $c;
327 }
328
329 # Clear out the comments.
330 while ($res =~ m@(/\*.*?\*/)@g) {
331 substr($res, $-[1], $+[1] - $-[1]) = $; x ($+[1] - $-[1]);
332 }
333 if ($res =~ m@(/\*.*)@) {
334 substr($res, $-[1], $+[1] - $-[1]) = $; x ($+[1] - $-[1]);
335 }
336 if ($res =~ m@^.(.*\*/)@) {
337 substr($res, $-[1], $+[1] - $-[1]) = $; x ($+[1] - $-[1]);
338 }
339
340 # The pathname on a #include may be surrounded by '<' and '>'.
341 if ($res =~ /^.#\s*include\s+\<(.*)\>/) {
342 my $clean = 'X' x length($1);
343 $res =~ s@\<.*\>@<$clean>@;
344
345 # The whole of a #error is a string.
346 } elsif ($res =~ /^.#\s*(?:error|warning)\s+(.*)\b/) {
347 my $clean = 'X' x length($1);
348 $res =~ s@(#\s*(?:error|warning)\s+).*@$1$clean@;
349 }
350
351 return $res;
352}
353
354sub ctx_statement_block {
355 my ($linenr, $remain, $off) = @_;
356 my $line = $linenr - 1;
357 my $blk = '';
358 my $soff = $off;
359 my $coff = $off - 1;
360
361 my $loff = 0;
362
363 my $type = '';
364 my $level = 0;
365 my $c;
366 my $len = 0;
367
368 my $remainder;
369 while (1) {
370 #warn "CSB: blk<$blk>\n";
371 # If we are about to drop off the end, pull in more
372 # context.
373 if ($off >= $len) {
374 for (; $remain > 0; $line++) {
375 next if ($lines[$line] =~ /^-/);
376 $remain--;
377 $loff = $len;
378 $blk .= $lines[$line] . "\n";
379 $len = length($blk);
380 $line++;
381 last;
382 }
383 # Bail if there is no further context.
384 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
385 if ($off >= $len) {
386 last;
387 }
388 }
389 $c = substr($blk, $off, 1);
390 $remainder = substr($blk, $off);
391
392 #warn "CSB: c<$c> type<$type> level<$level>\n";
393 # Statement ends at the ';' or a close '}' at the
394 # outermost level.
395 if ($level == 0 && $c eq ';') {
396 last;
397 }
398
399 # An else is really a conditional as long as its not else if
400 if ($level == 0 && $remainder =~ /(\s+else)(?:\s|{)/ &&
401 $remainder !~ /\s+else\s+if\b/) {
402 $coff = $off + length($1);
403 }
404
405 if (($type eq '' || $type eq '(') && $c eq '(') {
406 $level++;
407 $type = '(';
408 }
409 if ($type eq '(' && $c eq ')') {
410 $level--;
411 $type = ($level != 0)? '(' : '';
412
413 if ($level == 0 && $coff < $soff) {
414 $coff = $off;
415 }
416 }
417 if (($type eq '' || $type eq '{') && $c eq '{') {
418 $level++;
419 $type = '{';
420 }
421 if ($type eq '{' && $c eq '}') {
422 $level--;
423 $type = ($level != 0)? '{' : '';
424
425 if ($level == 0) {
426 last;
427 }
428 }
429 $off++;
430 }
431 if ($off == $len) {
432 $line++;
433 $remain--;
434 }
435
436 my $statement = substr($blk, $soff, $off - $soff + 1);
437 my $condition = substr($blk, $soff, $coff - $soff + 1);
438
439 #warn "STATEMENT<$statement>\n";
440 #warn "CONDITION<$condition>\n";
441
442 #print "off<$off> loff<$loff>\n";
443
444 return ($statement, $condition,
445 $line, $remain + 1, $off - $loff + 1, $level);
446}
447
448sub ctx_statement_full {
449 my ($linenr, $remain, $off) = @_;
450 my ($statement, $condition, $level);
451
452 my (@chunks);
453
454 ($statement, $condition, $linenr, $remain, $off, $level) =
455 ctx_statement_block($linenr, $remain, $off);
456 #print "F: c<$condition> s<$statement>\n";
457 for (;;) {
458 push(@chunks, [ $condition, $statement ]);
459 last if (!($remain > 0 && $condition =~ /^.\s*(?:if|else|do)/));
460 ($statement, $condition, $linenr, $remain, $off, $level) =
461 ctx_statement_block($linenr, $remain, $off);
462 #print "C: c<$condition> s<$statement>\n";
463 }
464
465 return ($level, $linenr, @chunks);
466}
467
468sub ctx_block_get {
469 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
470 my $line;
471 my $start = $linenr - 1;
472 my $blk = '';
473 my @o;
474 my @c;
475 my @res = ();
476
477 my $level = 0;
478 for ($line = $start; $remain > 0; $line++) {
479 next if ($rawlines[$line] =~ /^-/);
480 $remain--;
481
482 $blk .= $rawlines[$line];
483 foreach my $c (split(//, $rawlines[$line])) {
484 ##print "C<$c>L<$level><$open$close>O<$off>\n";
485 if ($off > 0) {
486 $off--;
487 next;
488 }
489
490 if ($c eq $close && $level > 0) {
491 $level--;
492 last if ($level == 0);
493 } elsif ($c eq $open) {
494 $level++;
495 }
496 }
497
498 if (!$outer || $level <= 1) {
499 push(@res, $rawlines[$line]);
500 }
501
502 last if ($level == 0);
503 }
504
505 return ($level, @res);
506}
507sub ctx_block_outer {
508 my ($linenr, $remain) = @_;
509
510 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
511 return @r;
512}
513sub ctx_block {
514 my ($linenr, $remain) = @_;
515
516 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
517 return @r;
518}
519sub ctx_statement {
520 my ($linenr, $remain, $off) = @_;
521
522 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
523 return @r;
524}
525sub ctx_block_level {
526 my ($linenr, $remain) = @_;
527
528 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
529}
530sub ctx_statement_level {
531 my ($linenr, $remain, $off) = @_;
532
533 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
534}
535
536sub ctx_locate_comment {
537 my ($first_line, $end_line) = @_;
538
539 # Catch a comment on the end of the line itself.
540 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
541 return $current_comment if (defined $current_comment);
542
543 # Look through the context and try and figure out if there is a
544 # comment.
545 my $in_comment = 0;
546 $current_comment = '';
547 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
548 my $line = $rawlines[$linenr - 1];
549 #warn " $line\n";
550 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
551 $in_comment = 1;
552 }
553 if ($line =~ m@/\*@) {
554 $in_comment = 1;
555 }
556 if (!$in_comment && $current_comment ne '') {
557 $current_comment = '';
558 }
559 $current_comment .= $line . "\n" if ($in_comment);
560 if ($line =~ m@\*/@) {
561 $in_comment = 0;
562 }
563 }
564
565 chomp($current_comment);
566 return($current_comment);
567}
568sub ctx_has_comment {
569 my ($first_line, $end_line) = @_;
570 my $cmt = ctx_locate_comment($first_line, $end_line);
571
572 ##print "LINE: $rawlines[$end_line - 1 ]\n";
573 ##print "CMMT: $cmt\n";
574
575 return ($cmt ne '');
576}
577
578sub cat_vet {
579 my ($vet) = @_;
580 my ($res, $coded);
581
582 $res = '';
583 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
584 $res .= $1;
585 if ($2 ne '') {
586 $coded = sprintf("^%c", unpack('C', $2) + 64);
587 $res .= $coded;
588 }
589 }
590 $res =~ s/$/\$/;
591
592 return $res;
593}
594
595my $av_preprocessor = 0;
596my $av_paren = 0;
597my @av_paren_type;
598
599sub annotate_reset {
600 $av_preprocessor = 0;
601 $av_paren = 0;
602 @av_paren_type = ();
603}
604
605sub annotate_values {
606 my ($stream, $type) = @_;
607
608 my $res;
609 my $cur = $stream;
610
611 print "$stream\n" if ($dbg_values > 1);
612
613 while (length($cur)) {
614 print " <$type> " if ($dbg_values > 1);
615 if ($cur =~ /^(\s+)/o) {
616 print "WS($1)\n" if ($dbg_values > 1);
617 if ($1 =~ /\n/ && $av_preprocessor) {
618 $av_preprocessor = 0;
619 $type = 'N';
620 }
621
622 } elsif ($cur =~ /^($Type)/) {
623 print "DECLARE($1)\n" if ($dbg_values > 1);
624 $type = 'T';
625
626 } elsif ($cur =~ /^(#\s*define\s*$Ident)(\(?)/o) {
627 print "DEFINE($1)\n" if ($dbg_values > 1);
628 $av_preprocessor = 1;
629 $av_paren_type[$av_paren] = 'N';
630
631 } elsif ($cur =~ /^(#\s*(?:ifdef|ifndef|if|else|elif|endif))/o) {
632 print "PRE($1)\n" if ($dbg_values > 1);
633 $av_preprocessor = 1;
634 $type = 'N';
635
636 } elsif ($cur =~ /^(\\\n)/o) {
637 print "PRECONT($1)\n" if ($dbg_values > 1);
638
639 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
640 print "SIZEOF($1)\n" if ($dbg_values > 1);
641 if (defined $2) {
642 $av_paren_type[$av_paren] = 'V';
643 }
644 $type = 'N';
645
646 } elsif ($cur =~ /^(if|while|typeof|__typeof__|for)\b/o) {
647 print "COND($1)\n" if ($dbg_values > 1);
648 $av_paren_type[$av_paren] = 'N';
649 $type = 'N';
650
651 } elsif ($cur =~/^(return|case|else)/o) {
652 print "KEYWORD($1)\n" if ($dbg_values > 1);
653 $type = 'N';
654
655 } elsif ($cur =~ /^(\()/o) {
656 print "PAREN('$1')\n" if ($dbg_values > 1);
657 $av_paren++;
658 $type = 'N';
659
660 } elsif ($cur =~ /^(\))/o) {
661 $av_paren-- if ($av_paren > 0);
662 if (defined $av_paren_type[$av_paren]) {
663 $type = $av_paren_type[$av_paren];
664 undef $av_paren_type[$av_paren];
665 print "PAREN('$1') -> $type\n"
666 if ($dbg_values > 1);
667 } else {
668 print "PAREN('$1')\n" if ($dbg_values > 1);
669 }
670
671 } elsif ($cur =~ /^($Ident)\(/o) {
672 print "FUNC($1)\n" if ($dbg_values > 1);
673 $av_paren_type[$av_paren] = 'V';
674
675 } elsif ($cur =~ /^($Ident|$Constant)/o) {
676 print "IDENT($1)\n" if ($dbg_values > 1);
677 $type = 'V';
678
679 } elsif ($cur =~ /^($Assignment)/o) {
680 print "ASSIGN($1)\n" if ($dbg_values > 1);
681 $type = 'N';
682
683 } elsif ($cur =~/^(;)/) {
684 print "END($1)\n" if ($dbg_values > 1);
685 $type = 'E';
686
687 } elsif ($cur =~ /^(;|{|}|\?|:|\[)/o) {
688 print "CLOSE($1)\n" if ($dbg_values > 1);
689 $type = 'N';
690
691 } elsif ($cur =~ /^($Operators)/o) {
692 print "OP($1)\n" if ($dbg_values > 1);
693 if ($1 ne '++' && $1 ne '--') {
694 $type = 'N';
695 }
696
697 } elsif ($cur =~ /(^.)/o) {
698 print "C($1)\n" if ($dbg_values > 1);
699 }
700 if (defined $1) {
701 $cur = substr($cur, length($1));
702 $res .= $type x length($1);
703 }
704 }
705
706 return $res;
707}
708
709sub possible {
710 my ($possible, $line) = @_;
711
712 #print "CHECK<$possible>\n";
713 if ($possible !~ /^(?:$Storage|$Type|DEFINE_\S+)$/ &&
714 $possible ne 'goto' && $possible ne 'return' &&
715 $possible ne 'struct' && $possible ne 'enum' &&
716 $possible ne 'case' && $possible ne 'else' &&
717 $possible ne 'typedef') {
718 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
719 push(@typeList, $possible);
720 build_types();
721 }
722}
723
724my $prefix = '';
725
726sub report {
727 my $line = $prefix . $_[0];
728
729 $line = (split('\n', $line))[0] . "\n" if ($terse);
730
731 push(our @report, $line);
732}
733sub report_dump {
734 our @report;
735}
736sub ERROR {
737 report("ERROR: $_[0]\n");
738 our $clean = 0;
739 our $cnt_error++;
740}
741sub WARN {
742 report("WARNING: $_[0]\n");
743 our $clean = 0;
744 our $cnt_warn++;
745}
746sub CHK {
747 if ($check) {
748 report("CHECK: $_[0]\n");
749 our $clean = 0;
750 our $cnt_chk++;
751 }
752}
753
754sub process {
755 my $filename = shift;
756
757 my $linenr=0;
758 my $prevline="";
759 my $prevrawline="";
760 my $stashline="";
761 my $stashrawline="";
762
763 my $length;
764 my $indent;
765 my $previndent=0;
766 my $stashindent=0;
767
768 our $clean = 1;
769 my $signoff = 0;
770 my $is_patch = 0;
771
772 our @report = ();
773 our $cnt_lines = 0;
774 our $cnt_error = 0;
775 our $cnt_warn = 0;
776 our $cnt_chk = 0;
777
778 # Trace the real file/line as we go.
779 my $realfile = '';
780 my $realline = 0;
781 my $realcnt = 0;
782 my $here = '';
783 my $in_comment = 0;
784 my $comment_edge = 0;
785 my $first_line = 0;
786
787 my $prev_values = 'E';
788
789 # suppression flags
790 my $suppress_ifbraces = 0;
791
792 # Pre-scan the patch sanitizing the lines.
793 # Pre-scan the patch looking for any __setup documentation.
794 #
795 my @setup_docs = ();
796 my $setup_docs = 0;
797 my $line;
798 foreach my $rawline (@rawlines) {
799 # Standardise the strings and chars within the input to
800 # simplify matching.
801 $line = sanitise_line($rawline);
802 push(@lines, $line);
803
804 ##print "==>$rawline\n";
805 ##print "-->$line\n";
806
807 if ($line=~/^\+\+\+\s+(\S+)/) {
808 $setup_docs = 0;
809 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
810 $setup_docs = 1;
811 }
812 next;
813 }
814
815 if ($setup_docs && $line =~ /^\+/) {
816 push(@setup_docs, $line);
817 }
818 }
819
820 $prefix = '';
821
822 foreach my $line (@lines) {
823 $linenr++;
824
825 my $rawline = $rawlines[$linenr - 1];
826
827#extract the filename as it passes
828 if ($line=~/^\+\+\+\s+(\S+)/) {
829 $realfile=$1;
830 $realfile =~ s@^[^/]*/@@;
831 $in_comment = 0;
832 next;
833 }
834#extract the line range in the file after the patch is applied
835 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
836 $is_patch = 1;
837 $first_line = $linenr + 1;
838 $in_comment = 0;
839 $realline=$1-1;
840 if (defined $2) {
841 $realcnt=$3+1;
842 } else {
843 $realcnt=1+1;
844 }
845 annotate_reset();
846 $prev_values = 'E';
847
848 $suppress_ifbraces = $linenr - 1;
849 next;
850 }
851
852# track the line number as we move through the hunk, note that
853# new versions of GNU diff omit the leading space on completely
854# blank context lines so we need to count that too.
855 if ($line =~ /^( |\+|$)/) {
856 $realline++;
857 $realcnt-- if ($realcnt != 0);
858
859 # Guestimate if this is a continuing comment. Run
860 # the context looking for a comment "edge". If this
861 # edge is a close comment then we must be in a comment
862 # at context start.
863 if ($linenr == $first_line) {
864 my $edge;
865 for (my $ln = $first_line; $ln < ($linenr + $realcnt); $ln++) {
866 ($edge) = ($rawlines[$ln - 1] =~ m@(/\*|\*/)@);
867 last if (defined $edge);
868 }
869 if (defined $edge && $edge eq '*/') {
870 $in_comment = 1;
871 }
872 }
873
874 # Guestimate if this is a continuing comment. If this
875 # is the start of a diff block and this line starts
876 # ' *' then it is very likely a comment.
877 if ($linenr == $first_line and $rawline =~ m@^.\s* \*(?:\s|$)@) {
878 $in_comment = 1;
879 }
880
881 # Find the last comment edge on _this_ line.
882 $comment_edge = 0;
883 while (($rawline =~ m@(/\*|\*/)@g)) {
884 if ($1 eq '/*') {
885 $in_comment = 1;
886 } else {
887 $in_comment = 0;
888 }
889 $comment_edge = 1;
890 }
891
892 # Measure the line length and indent.
893 ($length, $indent) = line_stats($rawline);
894
895 # Track the previous line.
896 ($prevline, $stashline) = ($stashline, $line);
897 ($previndent, $stashindent) = ($stashindent, $indent);
898 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
899
900 #warn "ic<$in_comment> ce<$comment_edge> line<$line>\n";
901
902 } elsif ($realcnt == 1) {
903 $realcnt--;
904 }
905
906#make up the handle for any error we report on this line
907 $here = "#$linenr: " if (!$file);
908 $here = "#$realline: " if ($file);
909 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
910
911 my $hereline = "$here\n$rawline\n";
912 my $herecurr = "$here\n$rawline\n";
913 my $hereprev = "$here\n$prevrawline\n$rawline\n";
914
915 $prefix = "$filename:$realline: " if ($emacs && $file);
916 $prefix = "$filename:$linenr: " if ($emacs && !$file);
917 $cnt_lines++ if ($realcnt != 0);
918
919#check the patch for a signoff:
920 if ($line =~ /^\s*signed-off-by:/i) {
921 # This is a signoff, if ugly, so do not double report.
922 $signoff++;
923 if (!($line =~ /^\s*Signed-off-by:/)) {
924 WARN("Signed-off-by: is the preferred form\n" .
925 $herecurr);
926 }
927 if ($line =~ /^\s*signed-off-by:\S/i) {
928 WARN("need space after Signed-off-by:\n" .
929 $herecurr);
930 }
931 }
932
933# Check for wrappage within a valid hunk of the file
934 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
935 ERROR("patch seems to be corrupt (line wrapped?)\n" .
936 $herecurr) if (!$emitted_corrupt++);
937 }
938
939# UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
940 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
941 !($rawline =~ m/^(
942 [\x09\x0A\x0D\x20-\x7E] # ASCII
943 | [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
944 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
945 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
946 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
947 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
948 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
949 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
950 )*$/x )) {
951 ERROR("Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $herecurr);
952 }
953
954#ignore lines being removed
955 if ($line=~/^-/) {next;}
956
957# check we are in a valid source file if not then ignore this hunk
958 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
959
960#trailing whitespace
961 if ($line =~ /^\+.*\015/) {
962 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
963 ERROR("DOS line endings\n" . $herevet);
964
965 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
966 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
967 ERROR("trailing whitespace\n" . $herevet);
968 }
969#80 column limit
970 if ($line =~ /^\+/ && !($prevrawline=~/\/\*\*/) && $length > 80) {
971 WARN("line over 80 characters\n" . $herecurr);
972 }
973
974# check for adding lines without a newline.
975 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
976 WARN("adding a line without newline at end of file\n" . $herecurr);
977 }
978
979# check we are in a valid source file *.[hc] if not then ignore this hunk
980 next if ($realfile !~ /\.[hc]$/);
981
982# at the beginning of a line any tabs must come first and anything
983# more than 8 must use tabs.
984 if ($rawline =~ /^\+\s* \t\s*\S/ ||
985 $rawline =~ /^\+\s* \s*/) {
986 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
987 ERROR("use tabs not spaces\n" . $herevet);
988 }
989
990# check for RCS/CVS revision markers
991 if ($rawline =~ /\$(Revision|Log|Id)(?:\$|)/) {
992 WARN("CVS style keyword markers, these will _not_ be updated\n". $herecurr);
993 }
994
995# The rest of our checks refer specifically to C style
996# only apply those _outside_ comments. Only skip
997# lines in the middle of comments.
998 next if (!$comment_edge && $in_comment);
999
1000# Check for potential 'bare' types
1001 if ($realcnt) {
1002 # Ignore goto labels.
1003 if ($line =~ /$Ident:\*$/) {
1004
1005 # Ignore functions being called
1006 } elsif ($line =~ /^.\s*$Ident\s*\(/) {
1007
1008 # definitions in global scope can only start with types
1009 } elsif ($line =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b/) {
1010 possible($1, $line);
1011
1012 # declarations always start with types
1013 } elsif ($prev_values eq 'E' && $line =~ /^.\s*(?:$Storage\s+)?(?:const\s+)?($Ident)\b(:?\s+$Sparse)?\s*\**\s*$Ident\s*(?:;|=|,)/) {
1014 possible($1);
1015 }
1016
1017 # any (foo ... *) is a pointer cast, and foo is a type
1018 while ($line =~ /\(($Ident)(?:\s+$Sparse)*\s*\*+\s*\)/g) {
1019 possible($1, $line);
1020 }
1021
1022 # Check for any sort of function declaration.
1023 # int foo(something bar, other baz);
1024 # void (*store_gdt)(x86_descr_ptr *);
1025 if ($prev_values eq 'E' && $line =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/) {
1026 my ($name_len) = length($1);
1027 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, $name_len);
1028 my $ctx = join("\n", @ctx);
1029
1030 $ctx =~ s/\n.//;
1031 substr($ctx, 0, $name_len + 1) = '';
1032 $ctx =~ s/\)[^\)]*$//;
1033 for my $arg (split(/\s*,\s*/, $ctx)) {
1034 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/ || $arg =~ /^($Ident)$/) {
1035
1036 possible($1, $line);
1037 }
1038 }
1039 }
1040
1041 }
1042
1043#
1044# Checks which may be anchored in the context.
1045#
1046
1047# Check for switch () and associated case and default
1048# statements should be at the same indent.
1049 if ($line=~/\bswitch\s*\(.*\)/) {
1050 my $err = '';
1051 my $sep = '';
1052 my @ctx = ctx_block_outer($linenr, $realcnt);
1053 shift(@ctx);
1054 for my $ctx (@ctx) {
1055 my ($clen, $cindent) = line_stats($ctx);
1056 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
1057 $indent != $cindent) {
1058 $err .= "$sep$ctx\n";
1059 $sep = '';
1060 } else {
1061 $sep = "[...]\n";
1062 }
1063 }
1064 if ($err ne '') {
1065 ERROR("switch and case should be at the same indent\n$hereline$err");
1066 }
1067 }
1068
1069# if/while/etc brace do not go on next line, unless defining a do while loop,
1070# or if that brace on the next line is for something else
1071 if ($line =~ /\b(?:(if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.#/) {
1072 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
1073 my $ctx_ln = $linenr + $#ctx + 1;
1074 my $ctx_cnt = $realcnt - $#ctx - 1;
1075 my $ctx = join("\n", @ctx);
1076
1077 # Skip over any removed lines in the context following statement.
1078 while ($ctx_cnt > 0 && $lines[$ctx_ln - 1] =~ /^-/) {
1079 $ctx_ln++;
1080 $ctx_cnt--;
1081 }
1082 ##warn "line<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>";
1083
1084 if ($ctx !~ /{\s*/ && $ctx_cnt > 0 && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
1085 ERROR("That open brace { should be on the previous line\n" .
1086 "$here\n$ctx\n$lines[$ctx_ln - 1]");
1087 }
1088 if ($level == 0 && $ctx =~ /\)\s*\;\s*$/ && defined $lines[$ctx_ln - 1]) {
1089 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
1090 if ($nindent > $indent) {
1091 WARN("Trailing semicolon indicates no statements, indent implies otherwise\n" .
1092 "$here\n$ctx\n$lines[$ctx_ln - 1]");
1093 }
1094 }
1095 }
1096
1097 # Track the 'values' across context and added lines.
1098 my $opline = $line; $opline =~ s/^./ /;
1099 my $curr_values = annotate_values($opline . "\n", $prev_values);
1100 $curr_values = $prev_values . $curr_values;
1101 if ($dbg_values) {
1102 my $outline = $opline; $outline =~ s/\t/ /g;
1103 warn "--> .$outline\n";
1104 warn "--> $curr_values\n";
1105 }
1106 $prev_values = substr($curr_values, -1);
1107
1108#ignore lines not being added
1109 if ($line=~/^[^\+]/) {next;}
1110
1111# TEST: allow direct testing of the type matcher.
1112 if ($tst_type && $line =~ /^.$Declare$/) {
1113 ERROR("TEST: is type $Declare\n" . $herecurr);
1114 next;
1115 }
1116
1117# check for initialisation to aggregates open brace on the next line
1118 if ($prevline =~ /$Declare\s*$Ident\s*=\s*$/ &&
1119 $line =~ /^.\s*{/) {
1120 ERROR("That open brace { should be on the previous line\n" . $hereprev);
1121 }
1122
1123#
1124# Checks which are anchored on the added line.
1125#
1126
1127# check for malformed paths in #include statements (uses RAW line)
1128 if ($rawline =~ m{^.#\s*include\s+[<"](.*)[">]}) {
1129 my $path = $1;
1130 if ($path =~ m{//}) {
1131 ERROR("malformed #include filename\n" .
1132 $herecurr);
1133 }
1134 }
1135
1136# no C99 // comments
1137 if ($line =~ m{//}) {
1138 ERROR("do not use C99 // comments\n" . $herecurr);
1139 }
1140 # Remove C99 comments.
1141 $line =~ s@//.*@@;
1142 $opline =~ s@//.*@@;
1143
1144#EXPORT_SYMBOL should immediately follow its function closing }.
1145 if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) ||
1146 ($line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
1147 my $name = $1;
1148 if (($prevline !~ /^}/) &&
1149 ($prevline !~ /^\+}/) &&
1150 ($prevline !~ /^ }/) &&
1151 ($prevline !~ /\b\Q$name\E(?:\s+$Attribute)?\s*(?:;|=)/)) {
1152 WARN("EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
1153 }
1154 }
1155
1156# check for external initialisers.
1157 if ($line =~ /^.$Type\s*$Ident\s*=\s*(0|NULL);/) {
1158 ERROR("do not initialise externals to 0 or NULL\n" .
1159 $herecurr);
1160 }
1161# check for static initialisers.
1162 if ($line =~ /\s*static\s.*=\s*(0|NULL);/) {
1163 ERROR("do not initialise statics to 0 or NULL\n" .
1164 $herecurr);
1165 }
1166
1167# check for new typedefs, only function parameters and sparse annotations
1168# make sense.
1169 if ($line =~ /\btypedef\s/ &&
1170 $line !~ /\btypedef\s+$Type\s+\(\s*\*?$Ident\s*\)\s*\(/ &&
1171 $line !~ /\b__bitwise(?:__|)\b/) {
1172 WARN("do not add new typedefs\n" . $herecurr);
1173 }
1174
1175# * goes on variable not on type
1176 if ($line =~ m{\($NonptrType(\*+)(?:\s+const)?\)}) {
1177 ERROR("\"(foo$1)\" should be \"(foo $1)\"\n" .
1178 $herecurr);
1179
1180 } elsif ($line =~ m{\($NonptrType\s+(\*+)(?!\s+const)\s+\)}) {
1181 ERROR("\"(foo $1 )\" should be \"(foo $1)\"\n" .
1182 $herecurr);
1183
1184 } elsif ($line =~ m{$NonptrType(\*+)(?:\s+(?:$Attribute|$Sparse))?\s+[A-Za-z\d_]+}) {
1185 ERROR("\"foo$1 bar\" should be \"foo $1bar\"\n" .
1186 $herecurr);
1187
1188 } elsif ($line =~ m{$NonptrType\s+(\*+)(?!\s+(?:$Attribute|$Sparse))\s+[A-Za-z\d_]+}) {
1189 ERROR("\"foo $1 bar\" should be \"foo $1bar\"\n" .
1190 $herecurr);
1191 }
1192
1193# # no BUG() or BUG_ON()
1194# if ($line =~ /\b(BUG|BUG_ON)\b/) {
1195# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
1196# print "$herecurr";
1197# $clean = 0;
1198# }
1199
1200 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
1201 WARN("LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
1202 }
1203
1204# printk should use KERN_* levels. Note that follow on printk's on the
1205# same line do not need a level, so we use the current block context
1206# to try and find and validate the current printk. In summary the current
1207# printk includes all preceeding printk's which have no newline on the end.
1208# we assume the first bad printk is the one to report.
1209 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
1210 my $ok = 0;
1211 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
1212 #print "CHECK<$lines[$ln - 1]\n";
1213 # we have a preceeding printk if it ends
1214 # with "\n" ignore it, else it is to blame
1215 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
1216 if ($rawlines[$ln - 1] !~ m{\\n"}) {
1217 $ok = 1;
1218 }
1219 last;
1220 }
1221 }
1222 if ($ok == 0) {
1223 WARN("printk() should include KERN_ facility level\n" . $herecurr);
1224 }
1225 }
1226
1227# function brace can't be on same line, except for #defines of do while,
1228# or if closed on same line
1229 if (($line=~/$Type\s*[A-Za-z\d_]+\(.*\).*\s{/) and
1230 !($line=~/\#define.*do\s{/) and !($line=~/}/)) {
1231 ERROR("open brace '{' following function declarations go on the next line\n" . $herecurr);
1232 }
1233
1234# open braces for enum, union and struct go on the same line.
1235 if ($line =~ /^.\s*{/ &&
1236 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
1237 ERROR("open brace '{' following $1 go on the same line\n" . $hereprev);
1238 }
1239
1240# check for spaces between functions and their parentheses.
1241 while ($line =~ /($Ident)\s+\(/g) {
1242 my $name = $1;
1243 my $ctx = substr($line, 0, $-[1]);
1244
1245 # Ignore those directives where spaces _are_ permitted.
1246 if ($name =~ /^(?:if|for|while|switch|return|volatile|__volatile__|__attribute__|format|__extension__|Copyright|case|__asm__)$/) {
1247
1248 # cpp #define statements have non-optional spaces, ie
1249 # if there is a space between the name and the open
1250 # parenthesis it is simply not a parameter group.
1251 } elsif ($ctx =~ /^.\#\s*define\s*$/) {
1252
1253 # If this whole things ends with a type its most
1254 # likely a typedef for a function.
1255 } elsif ("$ctx$name" =~ /$Type$/) {
1256
1257 } else {
1258 WARN("no space between function name and open parenthesis '('\n" . $herecurr);
1259 }
1260 }
1261# Check operator spacing.
1262 if (!($line=~/\#\s*include/)) {
1263 my $ops = qr{
1264 <<=|>>=|<=|>=|==|!=|
1265 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
1266 =>|->|<<|>>|<|>|=|!|~|
1267 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%
1268 }x;
1269 my @elements = split(/($;+|$ops|;)/, $opline);
1270 my $off = 0;
1271
1272 my $blank = copy_spacing($opline);
1273
1274 for (my $n = 0; $n < $#elements; $n += 2) {
1275 $off += length($elements[$n]);
1276
1277 my $a = '';
1278 $a = 'V' if ($elements[$n] ne '');
1279 $a = 'W' if ($elements[$n] =~ /\s$/);
1280 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
1281 $a = 'O' if ($elements[$n] eq '');
1282 $a = 'E' if ($elements[$n] eq '' && $n == 0);
1283
1284 my $op = $elements[$n + 1];
1285
1286 my $c = '';
1287 if (defined $elements[$n + 2]) {
1288 $c = 'V' if ($elements[$n + 2] ne '');
1289 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
1290 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
1291 $c = 'O' if ($elements[$n + 2] eq '');
1292 $c = 'E' if ($elements[$n + 2] =~ /\s*\\$/);
1293 } else {
1294 $c = 'E';
1295 }
1296
1297 # Pick up the preceeding and succeeding characters.
1298 my $ca = substr($opline, 0, $off);
1299 my $cc = '';
1300 if (length($opline) >= ($off + length($elements[$n + 1]))) {
1301 $cc = substr($opline, $off + length($elements[$n + 1]));
1302 }
1303 my $cb = "$ca$;$cc";
1304
1305 my $ctx = "${a}x${c}";
1306
1307 my $at = "(ctx:$ctx)";
1308
1309 my $ptr = substr($blank, 0, $off) . "^";
1310 my $hereptr = "$hereline$ptr\n";
1311
1312 # Classify operators into binary, unary, or
1313 # definitions (* only) where they have more
1314 # than one mode.
1315 my $op_type = substr($curr_values, $off + 1, 1);
1316 my $op_left = substr($curr_values, $off, 1);
1317 my $is_unary;
1318 if ($op_type eq 'T') {
1319 $is_unary = 2;
1320 } elsif ($op_left eq 'V') {
1321 $is_unary = 0;
1322 } else {
1323 $is_unary = 1;
1324 }
1325 #if ($op eq '-' || $op eq '&' || $op eq '*') {
1326 # print "UNARY: <$op_left$op_type $is_unary $a:$op:$c> <$ca:$op:$cc> <$unary_ctx>\n";
1327 #}
1328
1329 # Ignore operators passed as parameters.
1330 if ($op_type ne 'V' &&
1331 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
1332
1333 # Ignore comments
1334 } elsif ($op =~ /^$;+$/) {
1335
1336 # ; should have either the end of line or a space or \ after it
1337 } elsif ($op eq ';') {
1338 if ($ctx !~ /.x[WEB]/ && $cc !~ /^\\/ &&
1339 $cc !~ /^;/) {
1340 ERROR("need space after that '$op' $at\n" . $hereptr);
1341 }
1342
1343 # // is a comment
1344 } elsif ($op eq '//') {
1345
1346 # -> should have no spaces
1347 } elsif ($op eq '->') {
1348 if ($ctx =~ /Wx.|.xW/) {
1349 ERROR("no spaces around that '$op' $at\n" . $hereptr);
1350 }
1351
1352 # , must have a space on the right.
1353 } elsif ($op eq ',') {
1354 if ($ctx !~ /.xW|.xE/ && $cc !~ /^}/) {
1355 ERROR("need space after that '$op' $at\n" . $hereptr);
1356 }
1357
1358 # '*' as part of a type definition -- reported already.
1359 } elsif ($op eq '*' && $is_unary == 2) {
1360 #warn "'*' is part of type\n";
1361
1362 # unary operators should have a space before and
1363 # none after. May be left adjacent to another
1364 # unary operator, or a cast
1365 } elsif ($op eq '!' || $op eq '~' ||
1366 ($is_unary && ($op eq '*' || $op eq '-' || $op eq '&'))) {
1367 if ($ctx !~ /[WEB]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
1368 ERROR("need space before that '$op' $at\n" . $hereptr);
1369 }
1370 if ($ctx =~ /.xW/) {
1371 ERROR("no space after that '$op' $at\n" . $hereptr);
1372 }
1373
1374 # unary ++ and unary -- are allowed no space on one side.
1375 } elsif ($op eq '++' or $op eq '--') {
1376 if ($ctx !~ /[WOB]x[^W]/ && $ctx !~ /[^W]x[WOBE]/) {
1377 ERROR("need space one side of that '$op' $at\n" . $hereptr);
1378 }
1379 if ($ctx =~ /WxB/ || ($ctx =~ /Wx./ && $cc =~ /^;/)) {
1380 ERROR("no space before that '$op' $at\n" . $hereptr);
1381 }
1382
1383 # << and >> may either have or not have spaces both sides
1384 } elsif ($op eq '<<' or $op eq '>>' or
1385 $op eq '&' or $op eq '^' or $op eq '|' or
1386 $op eq '+' or $op eq '-' or
1387 $op eq '*' or $op eq '/' or
1388 $op eq '%')
1389 {
1390 if ($ctx !~ /VxV|WxW|VxE|WxE|VxO/) {
1391 ERROR("need consistent spacing around '$op' $at\n" .
1392 $hereptr);
1393 }
1394
1395 # All the others need spaces both sides.
1396 } elsif ($ctx !~ /[EW]x[WE]/) {
1397 # Ignore email addresses <foo@bar>
1398 if (!($op eq '<' && $cb =~ /$;\S+\@\S+>/) &&
1399 !($op eq '>' && $cb =~ /<\S+\@\S+$;/)) {
1400 ERROR("need spaces around that '$op' $at\n" . $hereptr);
1401 }
1402 }
1403 $off += length($elements[$n + 1]);
1404 }
1405 }
1406
1407# check for multiple assignments
1408 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
1409 CHK("multiple assignments should be avoided\n" . $herecurr);
1410 }
1411
1412## # check for multiple declarations, allowing for a function declaration
1413## # continuation.
1414## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
1415## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
1416##
1417## # Remove any bracketed sections to ensure we do not
1418## # falsly report the parameters of functions.
1419## my $ln = $line;
1420## while ($ln =~ s/\([^\(\)]*\)//g) {
1421## }
1422## if ($ln =~ /,/) {
1423## WARN("declaring multiple variables together should be avoided\n" . $herecurr);
1424## }
1425## }
1426
1427#need space before brace following if, while, etc
1428 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
1429 $line =~ /do{/) {
1430 ERROR("need a space before the open brace '{'\n" . $herecurr);
1431 }
1432
1433# closing brace should have a space following it when it has anything
1434# on the line
1435 if ($line =~ /}(?!(?:,|;|\)))\S/) {
1436 ERROR("need a space after that close brace '}'\n" . $herecurr);
1437 }
1438
1439# check spacing on square brackets
1440 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
1441 ERROR("no space after that open square bracket '['\n" . $herecurr);
1442 }
1443 if ($line =~ /\s\]/) {
1444 ERROR("no space before that close square bracket ']'\n" . $herecurr);
1445 }
1446
1447# check spacing on paretheses
1448 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
1449 $line !~ /for\s*\(\s+;/) {
1450 ERROR("no space after that open parenthesis '('\n" . $herecurr);
1451 }
1452 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
1453 $line !~ /for\s*\(.*;\s+\)/) {
1454 ERROR("no space before that close parenthesis ')'\n" . $herecurr);
1455 }
1456
1457#goto labels aren't indented, allow a single space however
1458 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
1459 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
1460 WARN("labels should not be indented\n" . $herecurr);
1461 }
1462
1463# Need a space before open parenthesis after if, while etc
1464 if ($line=~/\b(if|while|for|switch)\(/) {
1465 ERROR("need a space before the open parenthesis '('\n" . $herecurr);
1466 }
1467
1468# Check for illegal assignment in if conditional.
1469 if ($line =~ /\bif\s*\(/) {
1470 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
1471
1472 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/) {
1473 ERROR("do not use assignment in if condition\n" . $herecurr);
1474 }
1475
1476 # Find out what is on the end of the line after the
1477 # conditional.
1478 substr($s, 0, length($c)) = '';
1479 $s =~ s/\n.*//g;
1480 $s =~ s/$;//g; # Remove any comments
1481 if (length($c) && $s !~ /^\s*({|;|)\s*\\*\s*$/) {
1482 ERROR("trailing statements should be on next line\n" . $herecurr);
1483 }
1484 }
1485
1486# Check for bitwise tests written as boolean
1487 if ($line =~ /
1488 (?:
1489 (?:\[|\(|\&\&|\|\|)
1490 \s*0[xX][0-9]+\s*
1491 (?:\&\&|\|\|)
1492 |
1493 (?:\&\&|\|\|)
1494 \s*0[xX][0-9]+\s*
1495 (?:\&\&|\|\||\)|\])
1496 )/x)
1497 {
1498 WARN("boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
1499 }
1500
1501# if and else should not have general statements after it
1502 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
1503 my $s = $1;
1504 $s =~ s/$;//g; # Remove any comments
1505 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
1506 ERROR("trailing statements should be on next line\n" . $herecurr);
1507 }
1508 }
1509
1510 # Check for }<nl>else {, these must be at the same
1511 # indent level to be relevant to each other.
1512 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
1513 $previndent == $indent) {
1514 ERROR("else should follow close brace '}'\n" . $hereprev);
1515 }
1516
1517 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
1518 $previndent == $indent) {
1519 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
1520
1521 # Find out what is on the end of the line after the
1522 # conditional.
1523 substr($s, 0, length($c)) = '';
1524 $s =~ s/\n.*//g;
1525
1526 if ($s =~ /^\s*;/) {
1527 ERROR("while should follow close brace '}'\n" . $hereprev);
1528 }
1529 }
1530
1531#studly caps, commented out until figure out how to distinguish between use of existing and adding new
1532# if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
1533# print "No studly caps, use _\n";
1534# print "$herecurr";
1535# $clean = 0;
1536# }
1537
1538#no spaces allowed after \ in define
1539 if ($line=~/\#define.*\\\s$/) {
1540 WARN("Whitepspace after \\ makes next lines useless\n" . $herecurr);
1541 }
1542
1543#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
1544 if ($tree && $rawline =~ m{^.\#\s*include\s*\<asm\/(.*)\.h\>}) {
1545 my $checkfile = "$root/include/linux/$1.h";
1546 if (-f $checkfile && $1 ne 'irq.h') {
1547 CHK("Use #include <linux/$1.h> instead of <asm/$1.h>\n" .
1548 $herecurr);
1549 }
1550 }
1551
1552# multi-statement macros should be enclosed in a do while loop, grab the
1553# first statement and ensure its the whole macro if its not enclosed
1554# in a known goot container
1555 if ($prevline =~ /\#define.*\\/ &&
1556 $prevline !~/(?:do\s+{|\(\{|\{)/ &&
1557 $line !~ /(?:do\s+{|\(\{|\{)/ &&
1558 $line !~ /^.\s*$Declare\s/) {
1559 # Grab the first statement, if that is the entire macro
1560 # its ok. This may start either on the #define line
1561 # or the one below.
1562 my $ln = $linenr;
1563 my $cnt = $realcnt;
1564 my $off = 0;
1565
1566 # If the macro starts on the define line start
1567 # grabbing the statement after the identifier
1568 $prevline =~ m{^(.#\s*define\s*$Ident(?:\([^\)]*\))?\s*)(.*)\\\s*$};
1569 ##print "1<$1> 2<$2>\n";
1570 if (defined $2 && $2 ne '') {
1571 $off = length($1);
1572 $ln--;
1573 $cnt++;
1574 while ($lines[$ln - 1] =~ /^-/) {
1575 $ln--;
1576 $cnt++;
1577 }
1578 }
1579 my @ctx = ctx_statement($ln, $cnt, $off);
1580 my $ctx_ln = $ln + $#ctx + 1;
1581 my $ctx = join("\n", @ctx);
1582
1583 # Pull in any empty extension lines.
1584 while ($ctx =~ /\\$/ &&
1585 $lines[$ctx_ln - 1] =~ /^.\s*(?:\\)?$/) {
1586 $ctx .= $lines[$ctx_ln - 1];
1587 $ctx_ln++;
1588 }
1589
1590 if ($ctx =~ /\\$/) {
1591 if ($ctx =~ /;/) {
1592 ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
1593 } else {
1594 ERROR("Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
1595 }
1596 }
1597 }
1598
1599# check for redundant bracing round if etc
1600 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
1601 my ($level, $endln, @chunks) =
1602 ctx_statement_full($linenr, $realcnt, 0);
1603 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
1604 if ($#chunks > 1 && $level == 0) {
1605 my $allowed = 0;
1606 my $seen = 0;
1607 for my $chunk (@chunks) {
1608 my ($cond, $block) = @{$chunk};
1609
1610 substr($block, 0, length($cond)) = '';
1611
1612 $seen++ if ($block =~ /^\s*{/);
1613
1614 $block =~ s/(^|\n)./$1/g;
1615 $block =~ s/^\s*{//;
1616 $block =~ s/}\s*$//;
1617 $block =~ s/^\s*//;
1618 $block =~ s/\s*$//;
1619
1620 my @lines = ($block =~ /\n/g);
1621 my @statements = ($block =~ /;/g);
1622
1623 #print "cond<$cond> block<$block> lines<" . scalar(@lines) . "> statements<" . scalar(@statements) . "> seen<$seen> allowed<$allowed>\n";
1624 if (scalar(@lines) != 0) {
1625 $allowed = 1;
1626 }
1627 if ($block =~/\b(?:if|for|while)\b/) {
1628 $allowed = 1;
1629 }
1630 if (scalar(@statements) > 1) {
1631 $allowed = 1;
1632 }
1633 }
1634 if ($seen && !$allowed) {
1635 WARN("braces {} are not necessary for any arm of this statement\n" . $herecurr);
1636 $suppress_ifbraces = $endln;
1637 }
1638 }
1639 }
1640 if ($linenr > $suppress_ifbraces &&
1641 $line =~ /\b(if|while|for|else)\b/) {
1642 # Locate the end of the opening statement.
1643 my @control = ctx_statement($linenr, $realcnt, 0);
1644 my $nr = $linenr + (scalar(@control) - 1);
1645 my $cnt = $realcnt - (scalar(@control) - 1);
1646
1647 my $off = $realcnt - $cnt;
1648 #print "$off: line<$line>end<" . $lines[$nr - 1] . ">\n";
1649
1650 # If this is is a braced statement group check it
1651 if ($lines[$nr - 1] =~ /{\s*$/) {
1652 my ($lvl, @block) = ctx_block_level($nr, $cnt);
1653
1654 my $stmt = join("\n", @block);
1655 # Drop the diff line leader.
1656 $stmt =~ s/\n./\n/g;
1657 # Drop the code outside the block.
1658 $stmt =~ s/(^[^{]*){\s*//;
1659 my $before = $1;
1660 $stmt =~ s/\s*}([^}]*$)//;
1661 my $after = $1;
1662
1663 #print "block<" . join(' ', @block) . "><" . scalar(@block) . ">\n";
1664 #print "before<$before> stmt<$stmt> after<$after>\n\n";
1665
1666 # Count the newlines, if there is only one
1667 # then the block should not have {}'s.
1668 my @lines = ($stmt =~ /\n/g);
1669 my @statements = ($stmt =~ /;/g);
1670 #print "lines<" . scalar(@lines) . ">\n";
1671 #print "statements<" . scalar(@statements) . ">\n";
1672 if ($lvl == 0 && scalar(@lines) == 0 &&
1673 scalar(@statements) < 2 &&
1674 $stmt !~ /{/ && $stmt !~ /\bif\b/ &&
1675 $before !~ /}/ && $after !~ /{/) {
1676 my $herectx = "$here\n" . join("\n", @control, @block[1 .. $#block]) . "\n";
1677 shift(@block);
1678 WARN("braces {} are not necessary for single statement blocks\n" . $herectx);
1679 }
1680 }
1681 }
1682
1683# don't include deprecated include files (uses RAW line)
1684 for my $inc (@dep_includes) {
1685 if ($rawline =~ m@\#\s*include\s*\<$inc>@) {
1686 ERROR("Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
1687 }
1688 }
1689
1690# don't use deprecated functions
1691 for my $func (@dep_functions) {
1692 if ($line =~ /\b$func\b/) {
1693 ERROR("Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
1694 }
1695 }
1696
1697# no volatiles please
1698 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
1699 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
1700 WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
1701 }
1702
1703# SPIN_LOCK_UNLOCKED & RW_LOCK_UNLOCKED are deprecated
1704 if ($line =~ /\b(SPIN_LOCK_UNLOCKED|RW_LOCK_UNLOCKED)/) {
1705 ERROR("Use of $1 is deprecated: see Documentation/spinlocks.txt\n" . $herecurr);
1706 }
1707
1708# warn about #if 0
1709 if ($line =~ /^.#\s*if\s+0\b/) {
1710 CHK("if this code is redundant consider removing it\n" .
1711 $herecurr);
1712 }
1713
1714# check for needless kfree() checks
1715 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
1716 my $expr = $1;
1717 if ($line =~ /\bkfree\(\Q$expr\E\);/) {
1718 WARN("kfree(NULL) is safe this check is probabally not required\n" . $hereprev);
1719 }
1720 }
1721
1722# warn about #ifdefs in C files
1723# if ($line =~ /^.#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
1724# print "#ifdef in C files should be avoided\n";
1725# print "$herecurr";
1726# $clean = 0;
1727# }
1728
1729# warn about spacing in #ifdefs
1730 if ($line =~ /^.#\s*(ifdef|ifndef|elif)\s\s+/) {
1731 ERROR("exactly one space required after that #$1\n" . $herecurr);
1732 }
1733
1734# check for spinlock_t definitions without a comment.
1735 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/) {
1736 my $which = $1;
1737 if (!ctx_has_comment($first_line, $linenr)) {
1738 CHK("$1 definition without comment\n" . $herecurr);
1739 }
1740 }
1741# check for memory barriers without a comment.
1742 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
1743 if (!ctx_has_comment($first_line, $linenr)) {
1744 CHK("memory barrier without comment\n" . $herecurr);
1745 }
1746 }
1747# check of hardware specific defines
1748 if ($line =~ m@^.#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
1749 CHK("architecture specific defines should be avoided\n" . $herecurr);
1750 }
1751
1752# check the location of the inline attribute, that it is between
1753# storage class and type.
1754 if ($line =~ /\b$Type\s+$Inline\b/ ||
1755 $line =~ /\b$Inline\s+$Storage\b/) {
1756 ERROR("inline keyword should sit between storage class and type\n" . $herecurr);
1757 }
1758
1759# Check for __inline__ and __inline, prefer inline
1760 if ($line =~ /\b(__inline__|__inline)\b/) {
1761 WARN("plain inline is preferred over $1\n" . $herecurr);
1762 }
1763
1764# check for new externs in .c files.
1765 if ($line =~ /^.\s*extern\s/ && ($realfile =~ /\.c$/)) {
1766 WARN("externs should be avoided in .c files\n" . $herecurr);
1767 }
1768
1769# checks for new __setup's
1770 if ($rawline =~ /\b__setup\("([^"]*)"/) {
1771 my $name = $1;
1772
1773 if (!grep(/$name/, @setup_docs)) {
1774 CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
1775 }
1776 }
1777
1778# check for pointless casting of kmalloc return
1779 if ($line =~ /\*\s*\)\s*k[czm]alloc\b/) {
1780 WARN("unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
1781 }
1782
1783# check for gcc specific __FUNCTION__
1784 if ($line =~ /__FUNCTION__/) {
1785 WARN("__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr);
1786 }
1787 }
1788
1789 # If we have no input at all, then there is nothing to report on
1790 # so just keep quiet.
1791 if ($#rawlines == -1) {
1792 exit(0);
1793 }
1794
1795 # In mailback mode only produce a report in the negative, for
1796 # things that appear to be patches.
1797 if ($mailback && ($clean == 1 || !$is_patch)) {
1798 exit(0);
1799 }
1800
1801 # This is not a patch, and we are are in 'no-patch' mode so
1802 # just keep quiet.
1803 if (!$chk_patch && !$is_patch) {
1804 exit(0);
1805 }
1806
1807 if (!$is_patch) {
1808 ERROR("Does not appear to be a unified-diff format patch\n");
1809 }
1810 if ($is_patch && $chk_signoff && $signoff == 0) {
1811 ERROR("Missing Signed-off-by: line(s)\n");
1812 }
1813
1814 print report_dump();
1815 if ($summary && !($clean == 1 && $quiet == 1)) {
1816 print "$filename " if ($summary_file);
1817 print "total: $cnt_error errors, $cnt_warn warnings, " .
1818 (($check)? "$cnt_chk checks, " : "") .
1819 "$cnt_lines lines checked\n";
1820 print "\n" if ($quiet == 0);
1821 }
1822
1823 if ($clean == 1 && $quiet == 0) {
1824 print "$vname has no obvious style problems and is ready for submission.\n"
1825 }
1826 if ($clean == 0 && $quiet == 0) {
1827 print "$vname has style problems, please review. If any of these errors\n";
1828 print "are false positives report them to the maintainer, see\n";
1829 print "CHECKPATCH in MAINTAINERS.\n";
1830 }
1831 print <<EOL if ($file == 1 && $quiet == 0);
1832
1833WARNING: Using --file mode. Please do not send patches to linux-kernel
1834that change whole existing files if you did not significantly change most
1835of the the file for other reasons anyways or just wrote the file newly
1836from scratch. Pure code style patches have a significant cost in a
1837quickly changing code base like Linux because they cause rejects
1838with other changes.
1839EOL
1840
1841 return $clean;
1842}