projects/linux·blob v2.6.22 · refs

982 lines · 24.8 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.06';
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;
21GetOptions(
22 'q|quiet' => \$quiet,
23 'tree!' => \$tree,
24 'signoff!' => \$chk_signoff,
25 'patch!' => \$chk_patch,
26 'test-type!' => \$tst_type,
27) or exit;
28
29my $exit = 0;
30
31if ($#ARGV < 0) {
32 print "usage: $P [options] patchfile\n";
33 print "version: $V\n";
34 print "options: -q => quiet\n";
35 print " --no-tree => run without a kernel tree\n";
36 exit(1);
37}
38
39if ($tree && !top_of_kernel_tree()) {
40 print "Must be run from the top-level dir. of a kernel tree\n";
41 exit(2);
42}
43
44my @dep_includes = ();
45my @dep_functions = ();
46my $removal = 'Documentation/feature-removal-schedule.txt';
47if ($tree && -f $removal) {
48 open(REMOVE, "<$removal") || die "$P: $removal: open failed - $!\n";
49 while (<REMOVE>) {
50 if (/^Files:\s+(.*\S)/) {
51 for my $file (split(/[, ]+/, $1)) {
52 if ($file =~ m@include/(.*)@) {
53 push(@dep_includes, $1);
54 }
55 }
56
57 } elsif (/^Funcs:\s+(.*\S)/) {
58 for my $func (split(/[, ]+/, $1)) {
59 push(@dep_functions, $func);
60 }
61 }
62 }
63}
64
65my @rawlines = ();
66while (<>) {
67 chomp;
68 push(@rawlines, $_);
69 if (eof(ARGV)) {
70 if (!process($ARGV, @rawlines)) {
71 $exit = 1;
72 }
73 @rawlines = ();
74 }
75}
76
77exit($exit);
78
79sub top_of_kernel_tree {
80 if ((-f "COPYING") && (-f "CREDITS") && (-f "Kbuild") &&
81 (-f "MAINTAINERS") && (-f "Makefile") && (-f "README") &&
82 (-d "Documentation") && (-d "arch") && (-d "include") &&
83 (-d "drivers") && (-d "fs") && (-d "init") && (-d "ipc") &&
84 (-d "kernel") && (-d "lib") && (-d "scripts")) {
85 return 1;
86 }
87 return 0;
88}
89
90sub expand_tabs {
91 my ($str) = @_;
92
93 my $res = '';
94 my $n = 0;
95 for my $c (split(//, $str)) {
96 if ($c eq "\t") {
97 $res .= ' ';
98 $n++;
99 for (; ($n % 8) != 0; $n++) {
100 $res .= ' ';
101 }
102 next;
103 }
104 $res .= $c;
105 $n++;
106 }
107
108 return $res;
109}
110
111sub line_stats {
112 my ($line) = @_;
113
114 # Drop the diff line leader and expand tabs
115 $line =~ s/^.//;
116 $line = expand_tabs($line);
117
118 # Pick the indent from the front of the line.
119 my ($white) = ($line =~ /^(\s*)/);
120
121 return (length($line), length($white));
122}
123
124sub sanitise_line {
125 my ($line) = @_;
126
127 my $res = '';
128 my $l = '';
129
130 my $quote = '';
131
132 foreach my $c (split(//, $line)) {
133 if ($l ne "\\" && ($c eq "'" || $c eq '"')) {
134 if ($quote eq '') {
135 $quote = $c;
136 $res .= $c;
137 $l = $c;
138 next;
139 } elsif ($quote eq $c) {
140 $quote = '';
141 }
142 }
143 if ($quote && $c ne "\t") {
144 $res .= "X";
145 } else {
146 $res .= $c;
147 }
148
149 $l = $c;
150 }
151
152 return $res;
153}
154
155sub ctx_block_get {
156 my ($linenr, $remain, $outer, $open, $close) = @_;
157 my $line;
158 my $start = $linenr - 1;
159 my $blk = '';
160 my @o;
161 my @c;
162 my @res = ();
163
164 for ($line = $start; $remain > 0; $line++) {
165 next if ($rawlines[$line] =~ /^-/);
166 $remain--;
167
168 $blk .= $rawlines[$line];
169
170 @o = ($blk =~ /$open/g);
171 @c = ($blk =~ /$close/g);
172
173 if (!$outer || (scalar(@o) - scalar(@c)) == 1) {
174 push(@res, $rawlines[$line]);
175 }
176
177 last if (scalar(@o) == scalar(@c));
178 }
179
180 return @res;
181}
182sub ctx_block_outer {
183 my ($linenr, $remain) = @_;
184
185 return ctx_block_get($linenr, $remain, 1, '\{', '\}');
186}
187sub ctx_block {
188 my ($linenr, $remain) = @_;
189
190 return ctx_block_get($linenr, $remain, 0, '\{', '\}');
191}
192sub ctx_statement {
193 my ($linenr, $remain) = @_;
194
195 return ctx_block_get($linenr, $remain, 0, '\(', '\)');
196}
197
198sub ctx_locate_comment {
199 my ($first_line, $end_line) = @_;
200
201 # Catch a comment on the end of the line itself.
202 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*$@);
203 return $current_comment if (defined $current_comment);
204
205 # Look through the context and try and figure out if there is a
206 # comment.
207 my $in_comment = 0;
208 $current_comment = '';
209 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
210 my $line = $rawlines[$linenr - 1];
211 #warn " $line\n";
212 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
213 $in_comment = 1;
214 }
215 if ($line =~ m@/\*@) {
216 $in_comment = 1;
217 }
218 if (!$in_comment && $current_comment ne '') {
219 $current_comment = '';
220 }
221 $current_comment .= $line . "\n" if ($in_comment);
222 if ($line =~ m@\*/@) {
223 $in_comment = 0;
224 }
225 }
226
227 chomp($current_comment);
228 return($current_comment);
229}
230sub ctx_has_comment {
231 my ($first_line, $end_line) = @_;
232 my $cmt = ctx_locate_comment($first_line, $end_line);
233
234 ##print "LINE: $rawlines[$end_line - 1 ]\n";
235 ##print "CMMT: $cmt\n";
236
237 return ($cmt ne '');
238}
239
240sub cat_vet {
241 my ($vet) = @_;
242
243 $vet =~ s/\t/^I/;
244 $vet =~ s/$/\$/;
245
246 return $vet;
247}
248
249sub process {
250 my $filename = shift;
251 my @lines = @_;
252
253 my $linenr=0;
254 my $prevline="";
255 my $stashline="";
256
257 my $length;
258 my $indent;
259 my $previndent=0;
260 my $stashindent=0;
261
262 my $clean = 1;
263 my $signoff = 0;
264 my $is_patch = 0;
265
266 # Trace the real file/line as we go.
267 my $realfile = '';
268 my $realline = 0;
269 my $realcnt = 0;
270 my $here = '';
271 my $in_comment = 0;
272 my $first_line = 0;
273
274 my $Ident = qr{[A-Za-z\d_]+};
275 my $Storage = qr{extern|static};
276 my $Sparse = qr{__user|__kernel|__force|__iomem};
277 my $NonptrType = qr{
278 \b
279 (?:const\s+)?
280 (?:unsigned\s+)?
281 (?:
282 void|
283 char|
284 short|
285 int|
286 long|
287 unsigned|
288 float|
289 double|
290 long\s+int|
291 long\s+long|
292 long\s+long\s+int|
293 struct\s+$Ident|
294 union\s+$Ident|
295 ${Ident}_t
296 )
297 (?:\s+$Sparse)*
298 \b
299 }x;
300 my $Type = qr{
301 \b$NonptrType\b
302 (?:\s*\*+\s*const|\s*\*+)?
303 }x;
304 my $Declare = qr{(?:$Storage\s+)?$Type};
305 my $Attribute = qr{__read_mostly|__init|__initdata};
306
307 foreach my $line (@lines) {
308 $linenr++;
309
310 my $rawline = $line;
311
312#extract the filename as it passes
313 if ($line=~/^\+\+\+\s+(\S+)/) {
314 $realfile=$1;
315 $realfile =~ s@^[^/]*/@@;
316 $in_comment = 0;
317 next;
318 }
319#extract the line range in the file after the patch is applied
320 if ($line=~/^\@\@ -\d+,\d+ \+(\d+)(,(\d+))? \@\@/) {
321 $is_patch = 1;
322 $first_line = $linenr + 1;
323 $in_comment = 0;
324 $realline=$1-1;
325 if (defined $2) {
326 $realcnt=$3+1;
327 } else {
328 $realcnt=1+1;
329 }
330 next;
331 }
332
333# track the line number as we move through the hunk, note that
334# new versions of GNU diff omit the leading space on completely
335# blank context lines so we need to count that too.
336 if ($line =~ /^( |\+|$)/) {
337 $realline++;
338 $realcnt-- if ($realcnt != 0);
339
340 # track any sort of multi-line comment. Obviously if
341 # the added text or context do not include the whole
342 # comment we will not see it. Such is life.
343 #
344 # Guestimate if this is a continuing comment. If this
345 # is the start of a diff block and this line starts
346 # ' *' then it is very likely a comment.
347 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
348 $in_comment = 1;
349 }
350 if ($line =~ m@/\*@) {
351 $in_comment = 1;
352 }
353 if ($line =~ m@\*/@) {
354 $in_comment = 0;
355 }
356
357 # Measure the line length and indent.
358 ($length, $indent) = line_stats($line);
359
360 # Track the previous line.
361 ($prevline, $stashline) = ($stashline, $line);
362 ($previndent, $stashindent) = ($stashindent, $indent);
363 } elsif ($realcnt == 1) {
364 $realcnt--;
365 }
366
367#make up the handle for any error we report on this line
368 $here = "#$linenr: ";
369 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
370
371 my $hereline = "$here\n$line\n";
372 my $herecurr = "$here\n$line\n\n";
373 my $hereprev = "$here\n$prevline\n$line\n\n";
374
375#check the patch for a signoff:
376 if ($line =~ /^\s*signed-off-by:/i) {
377 # This is a signoff, if ugly, so do not double report.
378 $signoff++;
379 if (!($line =~ /^\s*Signed-off-by:/)) {
380 print "Signed-off-by: is the preferred form\n";
381 print "$herecurr";
382 $clean = 0;
383 }
384 if ($line =~ /^\s*signed-off-by:\S/i) {
385 print "need space after Signed-off-by:\n";
386 print "$herecurr";
387 $clean = 0;
388 }
389 }
390
391# Check for wrappage within a valid hunk of the file
392 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |$)}) {
393 print "patch seems to be corrupt (line wrapped?) [$realcnt]\n";
394 print "$herecurr";
395 $clean = 0;
396 }
397
398#ignore lines being removed
399 if ($line=~/^-/) {next;}
400
401# check we are in a valid source file if not then ignore this hunk
402 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
403
404#trailing whitespace
405 if ($line =~ /^\+.*\S\s+$/ || $line =~ /^\+\s+$/) {
406 my $herevet = "$here\n" . cat_vet($line) . "\n\n";
407 print "trailing whitespace\n";
408 print "$herevet";
409 $clean = 0;
410 }
411#80 column limit
412 if ($line =~ /^\+/ && !($prevline=~/\/\*\*/) && $length > 80) {
413 print "line over 80 characters\n";
414 print "$herecurr";
415 $clean = 0;
416 }
417
418# check we are in a valid source file *.[hc] if not then ignore this hunk
419 next if ($realfile !~ /\.[hc]$/);
420
421# at the beginning of a line any tabs must come first and anything
422# more than 8 must use tabs.
423 if ($line=~/^\+\s* \t\s*\S/ or $line=~/^\+\s* \s*/) {
424 my $herevet = "$here\n" . cat_vet($line) . "\n\n";
425 print "use tabs not spaces\n";
426 print "$herevet";
427 $clean = 0;
428 }
429
430 #
431 # The rest of our checks refer specifically to C style
432 # only apply those _outside_ comments.
433 #
434 next if ($in_comment);
435
436# Remove comments from the line before processing.
437 $line =~ s@/\*.*\*/@@g;
438 $line =~ s@/\*.*@@;
439 $line =~ s@.*\*/@@;
440
441# Standardise the strings and chars within the input to simplify matching.
442 $line = sanitise_line($line);
443
444#
445# Checks which may be anchored in the context.
446#
447
448# Check for switch () and associated case and default
449# statements should be at the same indent.
450 if ($line=~/\bswitch\s*\(.*\)/) {
451 my $err = '';
452 my $sep = '';
453 my @ctx = ctx_block_outer($linenr, $realcnt);
454 shift(@ctx);
455 for my $ctx (@ctx) {
456 my ($clen, $cindent) = line_stats($ctx);
457 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
458 $indent != $cindent) {
459 $err .= "$sep$ctx\n";
460 $sep = '';
461 } else {
462 $sep = "[...]\n";
463 }
464 }
465 if ($err ne '') {
466 print "switch and case should be at the same indent\n";
467 print "$here\n$line\n$err\n";
468 $clean = 0;
469 }
470 }
471
472#ignore lines not being added
473 if ($line=~/^[^\+]/) {next;}
474
475# TEST: allow direct testing of the type matcher.
476 if ($tst_type && $line =~ /^.$Declare$/) {
477 print "TEST: is type $Declare\n";
478 print "$herecurr";
479 $clean = 0;
480 next;
481 }
482
483#
484# Checks which are anchored on the added line.
485#
486
487# check for malformed paths in #include statements (uses RAW line)
488 if ($rawline =~ m{^.#\s*include\s+[<"](.*)[">]}) {
489 my $path = $1;
490 if ($path =~ m{//}) {
491 print "malformed #include filename\n";
492 print "$herecurr";
493 $clean = 0;
494 }
495 # Sanitise this special form of string.
496 $path = 'X' x length($path);
497 $line =~ s{\<.*\>}{<$path>};
498 }
499
500# no C99 // comments
501 if ($line =~ m{//}) {
502 print "do not use C99 // comments\n";
503 print "$herecurr";
504 $clean = 0;
505 }
506 # Remove C99 comments.
507 $line =~ s@//.*@@;
508
509#EXPORT_SYMBOL should immediately follow its function closing }.
510 if (($line =~ /EXPORT_SYMBOL.*\((.*)\)/) ||
511 ($line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
512 my $name = $1;
513 if (($prevline !~ /^}/) &&
514 ($prevline !~ /^\+}/) &&
515 ($prevline !~ /^ }/) &&
516 ($prevline !~ /\s$name(?:\s+$Attribute)?\s*(?:;|=)/)) {
517 print "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n";
518 print "$herecurr";
519 $clean = 0;
520 }
521 }
522
523# check for static initialisers.
524 if ($line=~/\s*static\s.*=\s+(0|NULL);/) {
525 print "do not initialise statics to 0 or NULL\n";
526 print "$herecurr";
527 $clean = 0;
528 }
529
530# check for new typedefs, only function parameters and sparse annotations
531# make sense.
532 if ($line =~ /\btypedef\s/ &&
533 $line !~ /\btypedef\s+$Type\s+\(\s*$Ident\s*\)\s*\(/ &&
534 $line !~ /\b__bitwise(?:__|)\b/) {
535 print "do not add new typedefs\n";
536 print "$herecurr";
537 $clean = 0;
538 }
539
540# * goes on variable not on type
541 if ($line =~ m{\($NonptrType(\*+)(?:\s+const)?\)}) {
542 print "\"(foo$1)\" should be \"(foo $1)\"\n";
543 print "$herecurr";
544 $clean = 0;
545
546 } elsif ($line =~ m{\($NonptrType\s+(\*+)(?!\s+const)\s+\)}) {
547 print "\"(foo $1 )\" should be \"(foo $1)\"\n";
548 print "$herecurr";
549 $clean = 0;
550
551 } elsif ($line =~ m{$NonptrType(\*+)(?:\s+const)?\s+[A-Za-z\d_]+}) {
552 print "\"foo$1 bar\" should be \"foo $1bar\"\n";
553 print "$herecurr";
554 $clean = 0;
555
556 } elsif ($line =~ m{$NonptrType\s+(\*+)(?!\s+const)\s+[A-Za-z\d_]+}) {
557 print "\"foo $1 bar\" should be \"foo $1bar\"\n";
558 print "$herecurr";
559 $clean = 0;
560 }
561
562# # no BUG() or BUG_ON()
563# if ($line =~ /\b(BUG|BUG_ON)\b/) {
564# print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
565# print "$herecurr";
566# $clean = 0;
567# }
568
569# printk should use KERN_* levels. Note that follow on printk's on the
570# same line do not need a level, so we use the current block context
571# to try and find and validate the current printk. In summary the current
572# printk includes all preceeding printk's which have no newline on the end.
573# we assume the first bad printk is the one to report.
574 if ($line =~ /\bprintk\((?!KERN_)/) {
575 my $ok = 0;
576 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
577 #print "CHECK<$lines[$ln - 1]\n";
578 # we have a preceeding printk if it ends
579 # with "\n" ignore it, else it is to blame
580 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
581 if ($rawlines[$ln - 1] !~ m{\\n"}) {
582 $ok = 1;
583 }
584 last;
585 }
586 }
587 if ($ok == 0) {
588 print "printk() should include KERN_ facility level\n";
589 print "$herecurr";
590 $clean = 0;
591 }
592 }
593
594# function brace can't be on same line, except for #defines of do while,
595# or if closed on same line
596 if (($line=~/$Type\s*[A-Za-z\d_]+\(.*\).* {/) and
597 !($line=~/\#define.*do\s{/) and !($line=~/}/)) {
598 print "braces following function declarations go on the next line\n";
599 print "$herecurr";
600 $clean = 0;
601 }
602
603# Check operator spacing.
604 # Note we expand the line with the leading + as the real
605 # line will be displayed with the leading + and the tabs
606 # will therefore also expand that way.
607 my $opline = $line;
608 $opline = expand_tabs($opline);
609 $opline =~ s/^./ /;
610 if (!($line=~/\#\s*include/)) {
611 my @elements = split(/(<<=|>>=|<=|>=|==|!=|\+=|-=|\*=|\/=|%=|\^=|\|=|&=|->|<<|>>|<|>|=|!|~|&&|\|\||,|\^|\+\+|--|;|&|\||\+|-|\*|\/\/|\/)/, $opline);
612 my $off = 0;
613 for (my $n = 0; $n < $#elements; $n += 2) {
614 $off += length($elements[$n]);
615
616 my $a = '';
617 $a = 'V' if ($elements[$n] ne '');
618 $a = 'W' if ($elements[$n] =~ /\s$/);
619 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
620 $a = 'O' if ($elements[$n] eq '');
621 $a = 'E' if ($elements[$n] eq '' && $n == 0);
622
623 my $op = $elements[$n + 1];
624
625 my $c = '';
626 if (defined $elements[$n + 2]) {
627 $c = 'V' if ($elements[$n + 2] ne '');
628 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
629 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
630 $c = 'O' if ($elements[$n + 2] eq '');
631 } else {
632 $c = 'E';
633 }
634
635 # Pick up the preceeding and succeeding characters.
636 my $ca = substr($opline, $off - 1, 1);
637 my $cc = '';
638 if (length($opline) >= ($off + length($elements[$n + 1]))) {
639 $cc = substr($opline, $off + length($elements[$n + 1]));
640 }
641
642 my $ctx = "${a}x${c}";
643
644 my $at = "(ctx:$ctx)";
645
646 my $ptr = (" " x $off) . "^";
647 my $hereptr = "$hereline$ptr\n\n";
648
649 ##print "<$s1:$op:$s2> <$elements[$n]:$elements[$n + 1]:$elements[$n + 2]>\n";
650
651 # ; should have either the end of line or a space or \ after it
652 if ($op eq ';') {
653 if ($ctx !~ /.x[WE]/ && $cc !~ /^\\/) {
654 print "need space after that '$op' $at\n";
655 print "$hereptr";
656 $clean = 0;
657 }
658
659 # // is a comment
660 } elsif ($op eq '//') {
661
662 # -> should have no spaces
663 } elsif ($op eq '->') {
664 if ($ctx =~ /Wx.|.xW/) {
665 print "no spaces around that '$op' $at\n";
666 print "$hereptr";
667 $clean = 0;
668 }
669
670 # , must have a space on the right.
671 } elsif ($op eq ',') {
672 if ($ctx !~ /.xW|.xE/ && $cc !~ /^}/) {
673 print "need space after that '$op' $at\n";
674 print "$hereptr";
675 $clean = 0;
676 }
677
678 # unary ! and unary ~ are allowed no space on the right
679 } elsif ($op eq '!' or $op eq '~') {
680 if ($ctx !~ /[WOEB]x./) {
681 print "need space before that '$op' $at\n";
682 print "$hereptr";
683 $clean = 0;
684 }
685 if ($ctx =~ /.xW/) {
686 print "no space after that '$op' $at\n";
687 print "$hereptr";
688 $clean = 0;
689 }
690
691 # unary ++ and unary -- are allowed no space on one side.
692 } elsif ($op eq '++' or $op eq '--') {
693 if ($ctx !~ /[WOB]x[^W]/ && $ctx !~ /[^W]x[WOBE]/) {
694 print "need space one side of that '$op' $at\n";
695 print "$hereptr";
696 $clean = 0;
697 }
698 if ($ctx =~ /Wx./ && $cc =~ /^;/) {
699 print "no space before that '$op' $at\n";
700 print "$hereptr";
701 $clean = 0;
702 }
703
704 # & is both unary and binary
705 # unary:
706 # a &b
707 # binary (consistent spacing):
708 # a&b OK
709 # a & b OK
710 #
711 # boiling down to: if there is a space on the right then there
712 # should be one on the left.
713 #
714 # - is the same
715 #
716 } elsif ($op eq '&' or $op eq '-') {
717 if ($ctx !~ /VxV|[EW]x[WE]|[EWB]x[VO]/) {
718 print "need space before that '$op' $at\n";
719 print "$hereptr";
720 $clean = 0;
721 }
722
723 # * is the same as & only adding:
724 # type:
725 # (foo *)
726 # (foo **)
727 #
728 } elsif ($op eq '*') {
729 if ($ca eq '*') {
730 if ($cc =~ /^\s(?!\s*const)/) {
731 print "no space after that '$op' $at\n";
732 print "$hereptr";
733 $clean = 0;
734 }
735 } elsif ($ctx !~ /VxV|[EW]x[WE]|[EWB]x[VO]|OxV|WxB|BxB/) {
736 print "need space before that '$op' $at\n";
737 print "$hereptr";
738 $clean = 0;
739 }
740
741 # << and >> may either have or not have spaces both sides
742 } elsif ($op eq '<<' or $op eq '>>' or $op eq '+' or $op eq '/' or
743 $op eq '^' or $op eq '|')
744 {
745 if ($ctx !~ /VxV|WxW|VxE|WxE/) {
746 print "need consistent spacing around '$op' $at\n";
747 print "$hereptr";
748 $clean = 0;
749 }
750
751 # All the others need spaces both sides.
752 } elsif ($ctx !~ /[EW]x[WE]/) {
753 print "need spaces around that '$op' $at\n";
754 print "$hereptr";
755 $clean = 0;
756 }
757 $off += length($elements[$n + 1]);
758 }
759 }
760
761#need space before brace following if, while, etc
762 if ($line=~/\(.*\){/) {
763 print "need a space before the brace\n";
764 print "$herecurr";
765 $clean = 0;
766 }
767
768#goto labels aren't indented, allow a single space however
769 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
770 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
771 print "labels should not be indented\n";
772 print "$herecurr";
773 $clean = 0;
774 }
775
776# Need a space before open parenthesis after if, while etc
777 if ($line=~/\b(if|while|for|switch)\(/) {
778 print "need a space before the open parenthesis\n";
779 print "$herecurr";
780 $clean = 0;
781 }
782
783# Check for illegal assignment in if conditional.
784 if ($line=~/\bif\s*\(.*[^<>!=]=[^=].*\)/) {
785 #next if ($line=~/\".*\Q$op\E.*\"/ or $line=~/\'\Q$op\E\'/);
786 print "do not use assignment in if condition\n";
787 print "$herecurr";
788 $clean = 0;
789 }
790
791 # Check for }<nl>else {, these must be at the same
792 # indent level to be relevant to each other.
793 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
794 $previndent == $indent) {
795 print "else should follow close brace\n";
796 print "$hereprev";
797 $clean = 0;
798 }
799
800#studly caps, commented out until figure out how to distinguish between use of existing and adding new
801# if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
802# print "No studly caps, use _\n";
803# print "$herecurr";
804# $clean = 0;
805# }
806
807#no spaces allowed after \ in define
808 if ($line=~/\#define.*\\\s$/) {
809 print("Whitepspace after \\ makes next lines useless\n");
810 print "$herecurr";
811 $clean = 0;
812 }
813
814#warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
815 if ($tree && $rawline =~ m{^.\#\s*include\s*\<asm\/(.*)\.h\>}) {
816 my $checkfile = "include/linux/$1.h";
817 if (-f $checkfile) {
818 print "Use #include <linux/$1.h> instead of <asm/$1.h>\n";
819 print $herecurr;
820 $clean = 0;
821 }
822 }
823
824# if/while/etc brace do not go on next line, unless defining a do while loop,
825# or if that brace on the next line is for something else
826 if ($prevline=~/\b(?:(if|while|for|switch)\s*\(|do\b|else\b)/) {
827 my @opened = $prevline=~/\(/g;
828 my @closed = $prevline=~/\)/g;
829 my $nr_line = $linenr;
830 my $remaining = $realcnt - 1;
831 my $next_line = $line;
832 my $extra_lines = 0;
833 my $display_segment = $prevline;
834
835 while ($remaining > 0 && scalar @opened > scalar @closed) {
836 $prevline .= $next_line;
837 $display_segment .= "\n" . $next_line;
838 $next_line = $lines[$nr_line];
839 $nr_line++;
840 $remaining--;
841
842 @opened = $prevline=~/\(/g;
843 @closed = $prevline=~/\)/g;
844 }
845
846 if (($prevline=~/\b(?:(if|while|for|switch)\s*\(.*\)|do|else)\s*$/) and ($next_line=~/{/) and
847 !($next_line=~/\b(?:if|while|for|switch|do|else)\b/) and !($next_line=~/\#define.*do.*while/)) {
848 print "That { should be on the previous line\n";
849 print "$here\n$display_segment\n$next_line\n\n";
850 $clean = 0;
851 }
852 }
853
854# if and else should not have general statements after it
855 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/ &&
856 $1 !~ /^\s*(?:\sif|{|$)/) {
857 print "trailing statements should be on next line\n";
858 print "$herecurr";
859 $clean = 0;
860 }
861
862# multi-statement macros should be enclosed in a do while loop, grab the
863# first statement and ensure its the whole macro if its not enclosed
864# in a known goot container
865 if (($prevline=~/\#define.*\\/) and
866 !($prevline=~/do\s+{/) and !($prevline=~/\(\{/) and
867 !($line=~/do.*{/) and !($line=~/\(\{/) and
868 !($line=~/^.\s*$Declare\s/)) {
869 # Grab the first statement, if that is the entire macro
870 # its ok. This may start either on the #define line
871 # or the one below.
872 my $ln = $linenr;
873 my $cnt = $realcnt;
874
875 # If the macro starts on the define line start there.
876 if ($prevline !~ m{^.#\s*define\s*$Ident(?:\([^\)]*\))?\s*\\\s*$}) {
877 $ln--;
878 $cnt++;
879 }
880 my $ctx = join('', ctx_statement($ln, $cnt));
881
882 if ($ctx =~ /\\$/) {
883 if ($ctx =~ /;/) {
884 print "Macros with multiple statements should be enclosed in a do - while loop\n";
885 } else {
886 print "Macros with complex values should be enclosed in parenthesis\n";
887 }
888 print "$hereprev";
889 $clean = 0;
890 }
891 }
892
893# don't include deprecated include files (uses RAW line)
894 for my $inc (@dep_includes) {
895 if ($rawline =~ m@\#\s*include\s*\<$inc>@) {
896 print "Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n";
897 print "$herecurr";
898 $clean = 0;
899 }
900 }
901
902# don't use deprecated functions
903 for my $func (@dep_functions) {
904 if ($line =~ /\b$func\b/) {
905 print "Don't use $func(): see Documentation/feature-removal-schedule.txt\n";
906 print "$herecurr";
907 $clean = 0;
908 }
909 }
910
911# no volatiles please
912 if ($line =~ /\bvolatile\b/ && $line !~ /\basm\s+volatile\b/) {
913 print "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n";
914 print "$herecurr";
915 $clean = 0;
916 }
917
918# warn about #if 0
919 if ($line =~ /^.#\s*if\s+0\b/) {
920 print "#if 0 -- if this code redundant remove it\n";
921 print "$herecurr";
922 $clean = 0;
923 }
924
925# warn about #ifdefs in C files
926# if ($line =~ /^.#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
927# print "#ifdef in C files should be avoided\n";
928# print "$herecurr";
929# $clean = 0;
930# }
931
932# check for spinlock_t definitions without a comment.
933 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/) {
934 my $which = $1;
935 if (!ctx_has_comment($first_line, $linenr)) {
936 print "$1 definition without comment\n";
937 print "$herecurr";
938 $clean = 0;
939 }
940 }
941# check for memory barriers without a comment.
942 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
943 if (!ctx_has_comment($first_line, $linenr)) {
944 print "memory barrier without comment\n";
945 print "$herecurr";
946 $clean = 0;
947 }
948 }
949# check of hardware specific defines
950 if ($line =~ m@^.#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@) {
951 print "architecture specific defines should be avoided\n";
952 print "$herecurr";
953 $clean = 0;
954 }
955
956 if ($line =~ /$Type\s+(?:inline|__always_inline)\b/ ||
957 $line =~ /\b(?:inline|always_inline)\s+$Storage/) {
958 print "inline keyword should sit between storage class and type\n";
959 print "$herecurr";
960 $clean = 0;
961 }
962 }
963
964 if ($chk_patch && !$is_patch) {
965 $clean = 0;
966 print "Does not appear to be a unified-diff format patch\n";
967 }
968 if ($is_patch && $chk_signoff && $signoff == 0) {
969 $clean = 0;
970 print "Missing Signed-off-by: line(s)\n";
971 }
972
973 if ($clean == 1 && $quiet == 0) {
974 print "Your patch has no obvious style problems and is ready for submission.\n"
975 }
976 if ($clean == 0 && $quiet == 0) {
977 print "Your patch has style problems, please review. If any of these errors\n";
978 print "are false positives report them to the maintainer, see\n";
979 print "CHECKPATCH in MAINTAINERS.\n";
980 }
981 return $clean;
982}