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
15 use Getopt
::Long
qw(:config no_auto_abbrev);
35 my $configuration_file = ".checkpatch.conf";
41 Usage
: $P [OPTION
]... [FILE
]...
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
62 --test
-only
=WORD report only warnings
/errors containing WORD
64 -h
, --help
, --version display this help
and exit
66 When FILE is
- read standard input
.
72 my $conf = which_conf
($configuration_file);
75 open(my $conffile, '<', "$conf")
76 or warn "$P: Can't find a readable $configuration_file file $!\n";
81 $line =~ s/\s*\n?$//g;
85 next if ($line =~ m/^\s*#/);
86 next if ($line =~ m/^\s*$/);
88 my @words = split(" ", $line);
89 foreach my $word (@words) {
90 last if ($word =~ m/^#/);
91 push (@conf_args, $word);
95 unshift(@ARGV, @conf_args) if @conf_args;
99 'q|quiet+' => \
$quiet,
101 'signoff!' => \
$chk_signoff,
102 'patch!' => \
$chk_patch,
106 'subjective!' => \
$check,
107 'strict!' => \
$check,
108 'ignore=s' => \
@ignore,
109 'show-types!' => \
$show_types,
111 'summary!' => \
$summary,
112 'mailback!' => \
$mailback,
113 'summary-file!' => \
$summary_file,
115 'debug=s' => \
%debug,
116 'test-only=s' => \
$tst_only,
126 print "$P: no input files\n";
130 @ignore = split(/,/, join(',',@ignore));
131 foreach my $word (@ignore) {
132 $word =~ s/\s*\n?$//g;
135 $word =~ tr/[a-z]/[A-Z]/;
137 next if ($word =~ m/^\s*#/);
138 next if ($word =~ m/^\s*$/);
140 $ignore_type{$word}++;
144 my $dbg_possible = 0;
147 for my $key (keys %debug) {
149 eval "\${dbg_$key} = '$debug{$key}';";
153 my $rpt_cleaners = 0;
162 if (!top_of_kernel_tree
($root)) {
163 die "$P: $root: --root does not point at a valid tree\n";
166 if (top_of_kernel_tree
('.')) {
168 } elsif ($0 =~ m@
(.*)/scripts/[^/]*$@
&&
169 top_of_kernel_tree
($1)) {
174 if (!defined $root) {
175 print "Must be run from the top-level dir. of a kernel tree\n";
180 my $emitted_corrupt = 0;
183 [A
-Za
-z_
][A
-Za
-z\d_
]*
184 (?
:\s
*\#\#\s
*[A
-Za
-z_
][A
-Za
-z\d_
]*)*
186 our $Storage = qr{extern|static|asmlinkage};
199 # Notes to $Attribute:
200 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
219 __
(?
:mem
|cpu
|dev
|)(?
:initdata
|initconst
|init
\b)|
220 ____cacheline_aligned
|
221 ____cacheline_aligned_in_smp
|
222 ____cacheline_internodealigned_in_smp
|
226 our $Inline = qr{inline|__always_inline|noinline};
227 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
228 our $Lval = qr{$Ident(?:$Member)*};
230 our $Constant = qr{(?:[0-9]+|0x[0-9a-fA-F]+)[UL]*};
231 our $Assignment = qr{(?:\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=)};
232 our $Compare = qr{<=|>=|==|!=|<|>};
236 &&|\
|\
||,|\
^|\
+\
+|--|&|\
||\
+|-|\
*|\
/|%
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
254 our $typeTypedefs = qr{(?x
:
255 (?
:__
)?
(?
:u
|s
|be
|le)(?
:8|16|32|64)|
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
|)|
267 our $signature_tags = qr{(?xi
:
279 qr{(?:unsigned\s+)?char},
280 qr{(?:unsigned\s+)?short},
281 qr{(?:unsigned\s+)?int},
282 qr{(?:unsigned\s+)?long},
283 qr{(?:unsigned\s+)?long\s+int},
284 qr{(?:unsigned\s+)?long\s+long},
285 qr{(?:unsigned\s+)?long\s+long\s+int},
294 qr{${Ident}_handler
},
295 qr{${Ident}_handler_fn
},
297 our @modifierList = (
301 our $allowed_asm_includes = qr{(?x
:
305 # memory.h: ARM has a custom one
308 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
309 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
310 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
312 (?
:$Modifier\s
+|const\s
+)*
314 (?
:typeof
|__typeof__
)\s
*\
(\s
*\
**\s
*$Ident\s
*\
)|
318 (?
:\s
+$Modifier|\s
+const
)*
322 (?
:[\s\
*]+\s
*const
|[\s\
*]+|(?
:\s
*\
[\s
*\
])+)?
323 (?
:\s
+$Inline|\s
+$Modifier)*
325 $Declare = qr{(?:$Storage\s+)?$Type};
329 our $match_balanced_parentheses = qr/(\((?:[^\(\)]+|(-1))*\))/;
331 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s
*};
332 our $LvalOrFunc = qr{($Lval)\s*($match_balanced_parentheses{0,1})\s
*};
336 return "" if (!defined($string));
337 $string =~ s@
^\s
*\
(\s
*@
@g;
338 $string =~ s@\s
*\
)\s
*$@
@g;
339 $string =~ s@\s
+@
@g;
343 $chk_signoff = 0 if ($file);
345 my @dep_includes = ();
346 my @dep_functions = ();
347 my $removal = "Documentation/feature-removal-schedule.txt";
348 if ($tree && -f
"$root/$removal") {
349 open(my $REMOVE, '<', "$root/$removal") ||
350 die "$P: $removal: open failed - $!\n";
352 if (/^Check:\s+(.*\S)/) {
353 for my $entry (split(/[, ]+/, $1)) {
354 if ($entry =~ m
@include/(.*)@
) {
355 push(@dep_includes, $1);
357 } elsif ($entry !~ m@
/@
) {
358 push(@dep_functions, $entry);
369 for my $filename (@ARGV) {
372 open($FILE, '-|', "diff -u /dev/null $filename") ||
373 die "$P: $filename: diff failed - $!\n";
374 } elsif ($filename eq '-') {
375 open($FILE, '<&STDIN');
377 open($FILE, '<', "$filename") ||
378 die "$P: $filename: open failed - $!\n";
380 if ($filename eq '-') {
381 $vname = 'Your patch';
390 if (!process
($filename)) {
399 sub top_of_kernel_tree
{
403 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
404 "README", "Documentation", "arch", "include", "drivers",
405 "fs", "init", "ipc", "kernel", "lib", "scripts",
408 foreach my $check (@tree_check) {
409 if (! -e
$root . '/' . $check) {
417 my ($formatted_email) = @_;
423 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
426 $comment = $3 if defined $3;
427 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
429 $comment = $2 if defined $2;
430 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
432 $comment = $2 if defined $2;
433 $formatted_email =~ s/$address.*$//;
434 $name = $formatted_email;
435 $name =~ s/^\s+|\s+$//g;
436 $name =~ s/^\"|\"$//g;
437 # If there's a name left after stripping spaces and
438 # leading quotes, and the address doesn't have both
439 # leading and trailing angle brackets, the address
441 # "joe smith joe@smith.com" bad
442 # "joe smith <joe@smith.com" bad
443 if ($name ne "" && $address !~ /^<[^>]+>$/) {
450 $name =~ s/^\s+|\s+$//g;
451 $name =~ s/^\"|\"$//g;
452 $address =~ s/^\s+|\s+$//g;
453 $address =~ s/^\<|\>$//g;
455 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
456 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
460 return ($name, $address, $comment);
464 my ($name, $address) = @_;
468 $name =~ s/^\s+|\s+$//g;
469 $name =~ s/^\"|\"$//g;
470 $address =~ s/^\s+|\s+$//g;
472 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
473 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
478 $formatted_email = "$address";
480 $formatted_email = "$name <$address>";
483 return $formatted_email;
489 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
490 if (-e
"$path/$conf") {
491 return "$path/$conf";
503 for my $c (split(//, $str)) {
507 for (; ($n % 4) != 0; $n++) {
519 (my $res = shift) =~ tr/\t/ /c;
526 # Drop the diff line leader and expand tabs
528 $line = expand_tabs
($line);
530 # Pick the indent from the front of the line.
531 my ($white) = ($line =~ /^(\s*)/);
533 return (length($line), length($white));
536 my $sanitise_quote = '';
538 sub sanitise_line_reset
{
539 my ($in_comment) = @_;
542 $sanitise_quote = '*/';
544 $sanitise_quote = '';
557 # Always copy over the diff marker.
558 $res = substr($line, 0, 1);
560 for ($off = 1; $off < length($line); $off++) {
561 $c = substr($line, $off, 1);
563 # Comments we are wacking completly including the begin
564 # and end, all to $;.
565 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
566 $sanitise_quote = '*/';
568 substr($res, $off, 2, "$;$;");
572 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
573 $sanitise_quote = '';
574 substr($res, $off, 2, "$;$;");
578 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
579 $sanitise_quote = '//';
581 substr($res, $off, 2, $sanitise_quote);
586 # A \ in a string means ignore the next character.
587 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
589 substr($res, $off, 2, 'XX');
594 if ($c eq "'" || $c eq '"') {
595 if ($sanitise_quote eq '') {
596 $sanitise_quote = $c;
598 substr($res, $off, 1, $c);
600 } elsif ($sanitise_quote eq $c) {
601 $sanitise_quote = '';
605 #print "c<$c> SQ<$sanitise_quote>\n";
606 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
607 substr($res, $off, 1, $;);
608 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
609 substr($res, $off, 1, $;);
610 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
611 substr($res, $off, 1, 'X');
613 substr($res, $off, 1, $c);
617 if ($sanitise_quote eq '//') {
618 $sanitise_quote = '';
621 # The pathname on a #include may be surrounded by '<' and '>'.
622 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
623 my $clean = 'X' x
length($1);
624 $res =~ s@\
<.*\
>@
<$clean>@
;
626 # The whole of a #error is a string.
627 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
628 my $clean = 'X' x
length($1);
629 $res =~ s@
(\#\s
*(?
:error
|warning
)\s
+).*@
$1$clean@
;
635 sub ctx_statement_block
{
636 my ($linenr, $remain, $off) = @_;
637 my $line = $linenr - 1;
654 @stack = (['', 0]) if ($#stack == -1);
656 #warn "CSB: blk<$blk> remain<$remain>\n";
657 # If we are about to drop off the end, pull in more
660 for (; $remain > 0; $line++) {
661 last if (!defined $lines[$line]);
662 next if ($lines[$line] =~ /^-/);
665 $blk .= $lines[$line] . "\n";
670 # Bail if there is no further context.
671 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
677 $c = substr($blk, $off, 1);
678 $remainder = substr($blk, $off);
680 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
682 # Handle nested #if/#else.
683 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
684 push(@stack, [ $type, $level ]);
685 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
686 ($type, $level) = @
{$stack[$#stack - 1]};
687 } elsif ($remainder =~ /^#\s*endif\b/) {
688 ($type, $level) = @
{pop(@stack)};
691 # Statement ends at the ';' or a close '}' at the
693 if ($level == 0 && $c eq ';') {
697 # An else is really a conditional as long as its not else if
698 if ($level == 0 && $coff_set == 0 &&
699 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
700 $remainder =~ /^(else)(?:\s|{)/ &&
701 $remainder !~ /^else\s+if\b/) {
702 $coff = $off + length($1) - 1;
704 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
705 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
708 if (($type eq '' || $type eq '(') && $c eq '(') {
712 if ($type eq '(' && $c eq ')') {
714 $type = ($level != 0)?
'(' : '';
716 if ($level == 0 && $coff < $soff) {
719 #warn "CSB: mark coff<$coff>\n";
722 if (($type eq '' || $type eq '{') && $c eq '{') {
726 if ($type eq '{' && $c eq '}') {
728 $type = ($level != 0)?
'{' : '';
731 if (substr($blk, $off + 1, 1) eq ';') {
739 # We are truly at the end, so shuffle to the next line.
746 my $statement = substr($blk, $soff, $off - $soff + 1);
747 my $condition = substr($blk, $soff, $coff - $soff + 1);
749 #warn "STATEMENT<$statement>\n";
750 #warn "CONDITION<$condition>\n";
752 #print "coff<$coff> soff<$off> loff<$loff>\n";
754 return ($statement, $condition,
755 $line, $remain + 1, $off - $loff + 1, $level);
758 sub statement_lines
{
761 # Strip the diff line prefixes and rip blank lines at start and end.
762 $stmt =~ s/(^|\n)./$1/g;
766 my @stmt_lines = ($stmt =~ /\n/g);
768 return $#stmt_lines + 2;
771 sub statement_rawlines
{
774 my @stmt_lines = ($stmt =~ /\n/g);
776 return $#stmt_lines + 2;
779 sub statement_block_size
{
782 $stmt =~ s/(^|\n)./$1/g;
788 my @stmt_lines = ($stmt =~ /\n/g);
789 my @stmt_statements = ($stmt =~ /;/g);
791 my $stmt_lines = $#stmt_lines + 2;
792 my $stmt_statements = $#stmt_statements + 1;
794 if ($stmt_lines > $stmt_statements) {
797 return $stmt_statements;
801 sub ctx_statement_full
{
802 my ($linenr, $remain, $off) = @_;
803 my ($statement, $condition, $level);
807 # Grab the first conditional/block pair.
808 ($statement, $condition, $linenr, $remain, $off, $level) =
809 ctx_statement_block
($linenr, $remain, $off);
810 #print "F: c<$condition> s<$statement> remain<$remain>\n";
811 push(@chunks, [ $condition, $statement ]);
812 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
813 return ($level, $linenr, @chunks);
816 # Pull in the following conditional/block pairs and see if they
817 # could continue the statement.
819 ($statement, $condition, $linenr, $remain, $off, $level) =
820 ctx_statement_block
($linenr, $remain, $off);
821 #print "C: c<$condition> s<$statement> remain<$remain>\n";
822 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
824 push(@chunks, [ $condition, $statement ]);
827 return ($level, $linenr, @chunks);
831 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
833 my $start = $linenr - 1;
840 my @stack = ($level);
841 for ($line = $start; $remain > 0; $line++) {
842 next if ($rawlines[$line] =~ /^-/);
845 $blk .= $rawlines[$line];
847 # Handle nested #if/#else.
848 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
849 push(@stack, $level);
850 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
851 $level = $stack[$#stack - 1];
852 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
853 $level = pop(@stack);
856 foreach my $c (split(//, $lines[$line])) {
857 ##print "C<$c>L<$level><$open$close>O<$off>\n";
863 if ($c eq $close && $level > 0) {
865 last if ($level == 0);
866 } elsif ($c eq $open) {
871 if (!$outer || $level <= 1) {
872 push(@res, $rawlines[$line]);
875 last if ($level == 0);
878 return ($level, @res);
880 sub ctx_block_outer
{
881 my ($linenr, $remain) = @_;
883 my ($level, @r) = ctx_block_get
($linenr, $remain, 1, '{', '}', 0);
887 my ($linenr, $remain) = @_;
889 my ($level, @r) = ctx_block_get
($linenr, $remain, 0, '{', '}', 0);
893 my ($linenr, $remain, $off) = @_;
895 my ($level, @r) = ctx_block_get
($linenr, $remain, 0, '(', ')', $off);
898 sub ctx_block_level
{
899 my ($linenr, $remain) = @_;
901 return ctx_block_get
($linenr, $remain, 0, '{', '}', 0);
903 sub ctx_statement_level
{
904 my ($linenr, $remain, $off) = @_;
906 return ctx_block_get
($linenr, $remain, 0, '(', ')', $off);
909 sub ctx_locate_comment
{
910 my ($first_line, $end_line) = @_;
912 # Catch a comment on the end of the line itself.
913 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@
.*(/\*.*\*/)\s
*(?
:\\\s
*)?
$@
);
914 return $current_comment if (defined $current_comment);
916 # Look through the context and try and figure out if there is a
919 $current_comment = '';
920 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
921 my $line = $rawlines[$linenr - 1];
923 if ($linenr == $first_line and $line =~ m@
^.\s
*\
*@
) {
926 if ($line =~ m@
/\
*@
) {
929 if (!$in_comment && $current_comment ne '') {
930 $current_comment = '';
932 $current_comment .= $line . "\n" if ($in_comment);
933 if ($line =~ m@\
*/@
) {
938 chomp($current_comment);
939 return($current_comment);
941 sub ctx_has_comment
{
942 my ($first_line, $end_line) = @_;
943 my $cmt = ctx_locate_comment
($first_line, $end_line);
945 ##print "LINE: $rawlines[$end_line - 1 ]\n";
946 ##print "CMMT: $cmt\n";
952 my ($linenr, $cnt) = @_;
954 my $offset = $linenr - 1;
959 $line = $rawlines[$offset++];
960 next if (defined($line) && $line =~ /^-/);
972 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
975 $coded = sprintf("^%c", unpack('C', $2) + 64);
984 my $av_preprocessor = 0;
990 $av_preprocessor = 0;
992 @av_paren_type = ('E');
993 $av_pend_colon = 'O';
996 sub annotate_values
{
997 my ($stream, $type) = @_;
1000 my $var = '_' x
length($stream);
1003 print "$stream\n" if ($dbg_values > 1);
1005 while (length($cur)) {
1006 @av_paren_type = ('E') if ($#av_paren_type < 0);
1007 print " <" . join('', @av_paren_type) .
1008 "> <$type> <$av_pending>" if ($dbg_values > 1);
1009 if ($cur =~ /^(\s+)/o) {
1010 print "WS($1)\n" if ($dbg_values > 1);
1011 if ($1 =~ /\n/ && $av_preprocessor) {
1012 $type = pop(@av_paren_type);
1013 $av_preprocessor = 0;
1016 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1017 print "CAST($1)\n" if ($dbg_values > 1);
1018 push(@av_paren_type, $type);
1021 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1022 print "DECLARE($1)\n" if ($dbg_values > 1);
1025 } elsif ($cur =~ /^($Modifier)\s*/) {
1026 print "MODIFIER($1)\n" if ($dbg_values > 1);
1029 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1030 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1031 $av_preprocessor = 1;
1032 push(@av_paren_type, $type);
1038 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1039 print "UNDEF($1)\n" if ($dbg_values > 1);
1040 $av_preprocessor = 1;
1041 push(@av_paren_type, $type);
1043 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1044 print "PRE_START($1)\n" if ($dbg_values > 1);
1045 $av_preprocessor = 1;
1047 push(@av_paren_type, $type);
1048 push(@av_paren_type, $type);
1051 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1052 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1053 $av_preprocessor = 1;
1055 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1059 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1060 print "PRE_END($1)\n" if ($dbg_values > 1);
1062 $av_preprocessor = 1;
1064 # Assume all arms of the conditional end as this
1065 # one does, and continue as if the #endif was not here.
1066 pop(@av_paren_type);
1067 push(@av_paren_type, $type);
1070 } elsif ($cur =~ /^(\\\n)/o) {
1071 print "PRECONT($1)\n" if ($dbg_values > 1);
1073 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1074 print "ATTR($1)\n" if ($dbg_values > 1);
1075 $av_pending = $type;
1078 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1079 print "SIZEOF($1)\n" if ($dbg_values > 1);
1085 } elsif ($cur =~ /^(if|while|for)\b/o) {
1086 print "COND($1)\n" if ($dbg_values > 1);
1090 } elsif ($cur =~/^(case)/o) {
1091 print "CASE($1)\n" if ($dbg_values > 1);
1092 $av_pend_colon = 'C';
1095 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1096 print "KEYWORD($1)\n" if ($dbg_values > 1);
1099 } elsif ($cur =~ /^(\()/o) {
1100 print "PAREN('$1')\n" if ($dbg_values > 1);
1101 push(@av_paren_type, $av_pending);
1105 } elsif ($cur =~ /^(\))/o) {
1106 my $new_type = pop(@av_paren_type);
1107 if ($new_type ne '_') {
1109 print "PAREN('$1') -> $type\n"
1110 if ($dbg_values > 1);
1112 print "PAREN('$1')\n" if ($dbg_values > 1);
1115 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1116 print "FUNC($1)\n" if ($dbg_values > 1);
1120 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1121 if (defined $2 && $type eq 'C' || $type eq 'T') {
1122 $av_pend_colon = 'B';
1123 } elsif ($type eq 'E') {
1124 $av_pend_colon = 'L';
1126 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1129 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1130 print "IDENT($1)\n" if ($dbg_values > 1);
1133 } elsif ($cur =~ /^($Assignment)/o) {
1134 print "ASSIGN($1)\n" if ($dbg_values > 1);
1137 } elsif ($cur =~/^(;|{|})/) {
1138 print "END($1)\n" if ($dbg_values > 1);
1140 $av_pend_colon = 'O';
1142 } elsif ($cur =~/^(,)/) {
1143 print "COMMA($1)\n" if ($dbg_values > 1);
1146 } elsif ($cur =~ /^(\?)/o) {
1147 print "QUESTION($1)\n" if ($dbg_values > 1);
1150 } elsif ($cur =~ /^(:)/o) {
1151 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1153 substr($var, length($res), 1, $av_pend_colon);
1154 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1159 $av_pend_colon = 'O';
1161 } elsif ($cur =~ /^(\[)/o) {
1162 print "CLOSE($1)\n" if ($dbg_values > 1);
1165 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1168 print "OPV($1)\n" if ($dbg_values > 1);
1175 substr($var, length($res), 1, $variant);
1178 } elsif ($cur =~ /^($Operators)/o) {
1179 print "OP($1)\n" if ($dbg_values > 1);
1180 if ($1 ne '++' && $1 ne '--') {
1184 } elsif ($cur =~ /(^.)/o) {
1185 print "C($1)\n" if ($dbg_values > 1);
1188 $cur = substr($cur, length($1));
1189 $res .= $type x
length($1);
1193 return ($res, $var);
1197 my ($possible, $line) = @_;
1198 my $notPermitted = qr{(?
:
1213 ^(?
:typedef
|struct
|enum
)\b
1215 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1216 if ($possible !~ $notPermitted) {
1217 # Check for modifiers.
1218 $possible =~ s/\s*$Storage\s*//g;
1219 $possible =~ s/\s*$Sparse\s*//g;
1220 if ($possible =~ /^\s*$/) {
1222 } elsif ($possible =~ /\s/) {
1223 $possible =~ s/\s*$Type\s*//g;
1224 for my $modifier (split(' ', $possible)) {
1225 if ($modifier !~ $notPermitted) {
1226 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1227 push(@modifierList, $modifier);
1232 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1233 push(@typeList, $possible);
1237 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1244 return !defined $ignore_type{$_[0]};
1248 if (!show_type
($_[1]) ||
1249 (defined $tst_only && $_[2] !~ /\Q$tst_only\E/)) {
1254 $line = "$prefix$_[0]:$_[1]: $_[2]\n";
1256 $line = "$prefix$_[0]: $_[2]\n";
1258 $line = (split('\n', $line))[0] . "\n" if ($terse);
1260 push(our @report, $line);
1269 if (report
("ERROR", $_[0], $_[1])) {
1275 if (report
("WARNING", $_[0], $_[1])) {
1281 if ($check && report
("CHECK", $_[0], $_[1])) {
1287 sub check_absolute_file
{
1288 my ($absolute, $herecurr) = @_;
1289 my $file = $absolute;
1291 ##print "absolute<$absolute>\n";
1293 # See if any suffix of this path is a path within the tree.
1294 while ($file =~ s@
^[^/]*/@@
) {
1295 if (-f
"$root/$file") {
1296 ##print "file<$file>\n";
1304 # It is, so see if the prefix is acceptable.
1305 my $prefix = $absolute;
1306 substr($prefix, -length($file)) = '';
1308 ##print "prefix<$prefix>\n";
1309 if ($prefix ne ".../") {
1310 WARN
("USE_RELATIVE_PATH",
1311 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1316 my $filename = shift;
1322 my $stashrawline="";
1339 # Trace the real file/line as we go.
1345 my $comment_edge = 0;
1349 my $prev_values = 'E';
1352 my %suppress_ifbraces;
1353 my %suppress_whiletrailers;
1354 my %suppress_export;
1356 # Pre-scan the patch sanitizing the lines.
1357 # Pre-scan the patch looking for any __setup documentation.
1359 my @setup_docs = ();
1362 sanitise_line_reset
();
1364 foreach my $rawline (@rawlines) {
1368 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1370 if ($1 =~ m
@Documentation/kernel
-parameters
.txt
$@
) {
1375 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1384 # Guestimate if this is a continuing comment. Run
1385 # the context looking for a comment "edge". If this
1386 # edge is a close comment then we must be in a comment
1390 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1391 next if (defined $rawlines[$ln - 1] &&
1392 $rawlines[$ln - 1] =~ /^-/);
1394 #print "RAW<$rawlines[$ln - 1]>\n";
1395 last if (!defined $rawlines[$ln - 1]);
1396 if ($rawlines[$ln - 1] =~ m@
(/\*|\*/)@
&&
1397 $rawlines[$ln - 1] !~ m@
"[^"]*(?
:/\*|\*/)[^"]*"@
) {
1402 if (defined $edge && $edge eq '*/') {
1406 # Guestimate if this is a continuing comment. If this
1407 # is the start of a diff block and this line starts
1408 # ' *' then it is very likely a comment.
1409 if (!defined $edge &&
1410 $rawlines[$linenr] =~ m@
^.\s
*(?
:\
*\
*+| \
*)(?
:\s
|$)@
)
1415 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1416 sanitise_line_reset
($in_comment);
1418 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1419 # Standardise the strings and chars within the input to
1420 # simplify matching -- only bother with positive lines.
1421 $line = sanitise_line
($rawline);
1423 push(@lines, $line);
1426 $realcnt-- if ($line =~ /^(?:\+| |$)/);
1431 #print "==>$rawline\n";
1432 #print "-->$line\n";
1434 if ($setup_docs && $line =~ /^\+/) {
1435 push(@setup_docs, $line);
1443 foreach my $line (@lines) {
1446 my $rawline = $rawlines[$linenr - 1];
1448 #extract the line range in the file after the patch is applied
1449 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1451 $first_line = $linenr + 1;
1461 %suppress_ifbraces = ();
1462 %suppress_whiletrailers = ();
1463 %suppress_export = ();
1466 # track the line number as we move through the hunk, note that
1467 # new versions of GNU diff omit the leading space on completely
1468 # blank context lines so we need to count that too.
1469 } elsif ($line =~ /^( |\+|$)/) {
1471 $realcnt-- if ($realcnt != 0);
1473 # Measure the line length and indent.
1474 ($length, $indent) = line_stats
($rawline);
1476 # Track the previous line.
1477 ($prevline, $stashline) = ($stashline, $line);
1478 ($previndent, $stashindent) = ($stashindent, $indent);
1479 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1481 #warn "line<$line>\n";
1483 } elsif ($realcnt == 1) {
1487 my $hunk_line = ($realcnt != 0);
1489 #make up the handle for any error we report on this line
1490 $prefix = "$filename:$realline: " if ($emacs && $file);
1491 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1493 $here = "#$linenr: " if (!$file);
1494 $here = "#$realline: " if ($file);
1496 # extract the filename as it passes
1497 if ($line =~ /^diff --git.*?(\S+)$/) {
1499 $realfile =~ s@
^([^/]*)/@@
;
1501 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1503 $realfile =~ s@
^([^/]*)/@@
;
1506 if (!$file && $tree && $p1_prefix ne '' &&
1507 -e
"$root/$p1_prefix") {
1508 WARN
("PATCH_PREFIX",
1509 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1512 if ($realfile =~ m@
^include
/asm/@
) {
1513 ERROR
("MODIFIED_INCLUDE_ASM",
1514 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1519 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1521 my $hereline = "$here\n$rawline\n";
1522 my $herecurr = "$here\n$rawline\n";
1523 my $hereprev = "$here\n$prevrawline\n$rawline\n";
1525 $cnt_lines++ if ($realcnt != 0);
1527 # Check for incorrect file permissions
1528 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1529 my $permhere = $here . "FILE: $realfile\n";
1530 if ($realfile =~ /(Makefile|Kconfig|\.c|\.h|\.S|\.tmpl)$/) {
1531 ERROR
("EXECUTE_PERMISSIONS",
1532 "do not set execute permissions for source files\n" . $permhere);
1536 # Check the patch for a signoff:
1537 if ($line =~ /^\s*signed-off-by:/i) {
1541 # Check signature styles
1542 if ($line =~ /^(\s*)($signature_tags)(\s*)(.*)/) {
1543 my $space_before = $1;
1545 my $space_after = $3;
1547 my $ucfirst_sign_off = ucfirst(lc($sign_off));
1549 if (defined $space_before && $space_before ne "") {
1550 WARN
("BAD_SIGN_OFF",
1551 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr);
1553 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
1554 WARN
("BAD_SIGN_OFF",
1555 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr);
1557 if (!defined $space_after || $space_after ne " ") {
1558 WARN
("BAD_SIGN_OFF",
1559 "Use a single space after $ucfirst_sign_off\n" . $herecurr);
1562 my ($email_name, $email_address, $comment) = parse_email
($email);
1563 my $suggested_email = format_email
(($email_name, $email_address));
1564 if ($suggested_email eq "") {
1565 ERROR
("BAD_SIGN_OFF",
1566 "Unrecognized email address: '$email'\n" . $herecurr);
1568 my $dequoted = $suggested_email;
1569 $dequoted =~ s/^"//;
1570 $dequoted =~ s/" </ </;
1571 # Don't force email to have quotes
1572 # Allow just an angle bracketed address
1573 if ("$dequoted$comment" ne $email &&
1574 "<$email_address>$comment" ne $email &&
1575 "$suggested_email$comment" ne $email) {
1576 WARN
("BAD_SIGN_OFF",
1577 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1582 # Check for wrappage within a valid hunk of the file
1583 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1584 ERROR
("CORRUPTED_PATCH",
1585 "patch seems to be corrupt (line wrapped?)\n" .
1586 $herecurr) if (!$emitted_corrupt++);
1589 # Check for absolute kernel paths.
1591 while ($line =~ m{(?:^|\s)(/\S*)}g) {
1594 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1595 check_absolute_file
($1, $herecurr)) {
1598 check_absolute_file
($file, $herecurr);
1603 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1604 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1605 $rawline !~ m/^$UTF8*$/) {
1606 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1608 my $blank = copy_spacing
($rawline);
1609 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1610 my $hereptr = "$hereline$ptr\n";
1613 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1616 # ignore non-hunk lines and lines being removed
1617 next if (!$hunk_line || $line =~ /^-/);
1619 #trailing whitespace
1620 if ($line =~ /^\+.*\015/) {
1621 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1622 ERROR
("DOS_LINE_ENDINGS",
1623 "DOS line endings\n" . $herevet);
1625 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
1626 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1627 ERROR
("TRAILING_WHITESPACE",
1628 "trailing whitespace\n" . $herevet);
1632 # check for Kconfig help text having a real description
1633 # Only applies when adding the entry originally, after that we do not have
1634 # sufficient context to determine whether it is indeed long enough.
1635 if ($realfile =~ /Kconfig/ &&
1636 $line =~ /\+\s*(?:---)?help(?:---)?$/) {
1639 my $ln = $linenr + 1;
1642 while ($cnt > 0 && defined $lines[$ln - 1]) {
1643 $f = $lines[$ln - 1];
1644 $cnt-- if ($lines[$ln - 1] !~ /^-/);
1645 $is_end = $lines[$ln - 1] =~ /^\+/;
1648 next if ($f =~ /^-/);
1652 next if ($f =~ /^$/);
1653 if ($f =~ /^\s*config\s/) {
1659 WARN
("CONFIG_DESCRIPTION",
1660 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_end && $length < 4);
1661 #print "is_end<$is_end> length<$length>\n";
1664 # check we are in a valid source file if not then ignore this hunk
1665 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
1668 if ($line =~ /^\+/ && $prevrawline !~ /\/\
*\
*/ &&
1669 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
1670 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
1671 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
1675 "line over 120 characters\n" . $herecurr);
1678 # check for spaces before a quoted newline
1679 if ($rawline =~ /^.*\".*\s\\n/) {
1680 WARN
("QUOTED_WHITESPACE_BEFORE_NEWLINE",
1681 "unnecessary whitespace before a quoted newline\n" . $herecurr);
1684 # check for adding lines without a newline.
1685 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1686 WARN
("MISSING_EOF_NEWLINE",
1687 "adding a line without newline at end of file\n" . $herecurr);
1690 # Blackfin: use hi/lo macros
1691 if ($realfile =~ m
@arch/blackfin/.*\
.S
$@
) {
1692 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
1693 my $herevet = "$here\n" . cat_vet
($line) . "\n";
1695 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
1697 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
1698 my $herevet = "$here\n" . cat_vet
($line) . "\n";
1700 "use the HI() macro, not (... >> 16)\n" . $herevet);
1704 # check we are in a valid source file C or perl if not then ignore this hunk
1705 next if ($realfile !~ /\.(h|c|pl)$/);
1707 # at the beginning of a line any tabs must come first and anything
1708 # more than 8 must use tabs.
1709 if ($rawline =~ /^\+\s* \t\s*\S/ ||
1710 $rawline =~ /^\+\s* \s*/) {
1711 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1712 ERROR
("CODE_INDENT",
1713 "code indent should use tabs where possible\n" . $herevet);
1717 # check for space before tabs.
1718 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
1719 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1720 WARN
("SPACE_BEFORE_TAB",
1721 "please, no space before tabs\n" . $herevet);
1724 # check for spaces at the beginning of a line.
1726 # 1) within comments
1727 # 2) indented preprocessor commands
1729 if ($rawline =~ /^\+ / && $line !~ /\+ *(?:$;|#|$Ident:)/) {
1730 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1731 WARN
("LEADING_SPACE",
1732 "please, no spaces at the start of a line\n" . $herevet);
1735 # check we are in a valid C source file if not then ignore this hunk
1736 next if ($realfile !~ /\.(h|c)$/);
1738 # check for RCS/CVS revision markers
1739 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
1741 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
1744 # Blackfin: don't use __builtin_bfin_[cs]sync
1745 if ($line =~ /__builtin_bfin_csync/) {
1746 my $herevet = "$here\n" . cat_vet
($line) . "\n";
1748 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
1750 if ($line =~ /__builtin_bfin_ssync/) {
1751 my $herevet = "$here\n" . cat_vet
($line) . "\n";
1753 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
1756 # Check for potential 'bare' types
1757 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
1759 if ($realcnt && $line =~ /.\s*\S/) {
1760 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
1761 ctx_statement_block
($linenr, $realcnt, 0);
1762 $stat =~ s/\n./\n /g;
1763 $cond =~ s/\n./\n /g;
1765 # Find the real next line.
1766 $realline_next = $line_nr_next;
1767 if (defined $realline_next &&
1768 (!defined $lines[$realline_next - 1] ||
1769 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
1776 # Ignore goto labels.
1777 if ($s =~ /$Ident:\*$/s) {
1779 # Ignore functions being called
1780 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
1782 } elsif ($s =~ /^.\s*else\b/s) {
1784 # declarations always start with types
1785 } 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) {
1788 possible
($type, "A:" . $s);
1790 # definitions in global scope can only start with types
1791 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
1792 possible
($1, "B:" . $s);
1795 # any (foo ... *) is a pointer cast, and foo is a type
1796 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
1797 possible
($1, "C:" . $s);
1800 # Check for any sort of function declaration.
1801 # int foo(something bar, other baz);
1802 # void (*store_gdt)(x86_descr_ptr *);
1803 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
1804 my ($name_len) = length($1);
1807 substr($ctx, 0, $name_len + 1, '');
1808 $ctx =~ s/\)[^\)]*$//;
1810 for my $arg (split(/\s*,\s*/, $ctx)) {
1811 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
1813 possible
($1, "D:" . $s);
1821 # Checks which may be anchored in the context.
1824 # Check for switch () and associated case and default
1825 # statements should be at the same indent.
1826 # if ($line=~/\bswitch\s*\(.*\)/) {
1829 # my @ctx = ctx_block_outer($linenr, $realcnt);
1831 # for my $ctx (@ctx) {
1832 # my ($clen, $cindent) = line_stats($ctx);
1833 # if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
1834 # $indent != $cindent) {
1835 # $err .= "$sep$ctx\n";
1842 # ERROR("SWITCH_CASE_INDENT_LEVEL",
1843 # "switch and case should be at the same indent\n$hereline$err");
1847 # if/while/etc brace do not go on next line, unless defining a do while loop,
1848 # or if that brace on the next line is for something else
1849 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
1850 my $pre_ctx = "$1$2";
1852 my ($level, @ctx) = ctx_statement_level
($linenr, $realcnt, 0);
1853 my $ctx_cnt = $realcnt - $#ctx - 1;
1854 my $ctx = join("\n", @ctx);
1856 my $ctx_ln = $linenr;
1857 my $ctx_skip = $realcnt;
1859 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
1860 defined $lines[$ctx_ln - 1] &&
1861 $lines[$ctx_ln - 1] =~ /^-/)) {
1862 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
1863 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
1867 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
1868 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
1870 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
1872 "that open brace { should be on the previous line\n" .
1873 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
1875 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
1876 $ctx =~ /\)\s*\;\s*$/ &&
1877 defined $lines[$ctx_ln - 1])
1879 my ($nlength, $nindent) = line_stats
($lines[$ctx_ln - 1]);
1880 if ($nindent > $indent) {
1881 WARN
("TRAILING_SEMICOLON",
1882 "trailing semicolon indicates no statements, indent implies otherwise\n" .
1883 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
1888 # Check relative indent for conditionals and blocks.
1889 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
1890 my ($s, $c) = ($stat, $cond);
1892 substr($s, 0, length($c), '');
1894 # Make sure we remove the line prefixes as we have
1895 # none on the first line, and are going to readd them
1899 # Find out how long the conditional actually is.
1900 my @newlines = ($c =~ /\n/gs);
1901 my $cond_lines = 1 + $#newlines;
1903 # We want to check the first line inside the block
1904 # starting at the end of the conditional, so remove:
1905 # 1) any blank line termination
1906 # 2) any opening brace { on end of the line
1908 my $continuation = 0;
1910 $s =~ s/^.*\bdo\b//;
1912 if ($s =~ s/^\s*\\//) {
1915 if ($s =~ s/^\s*?\n//) {
1920 # Also ignore a loop construct at the end of a
1921 # preprocessor statement.
1922 if (($prevline =~ /^.\s*#\s*define\s/ ||
1923 $prevline =~ /\\\s*$/) && $continuation == 0) {
1929 while ($cond_ptr != $cond_lines) {
1930 $cond_ptr = $cond_lines;
1932 # If we see an #else/#elif then the code
1934 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
1939 # 1) blank lines, they should be at 0,
1940 # 2) preprocessor lines, and
1942 if ($continuation ||
1944 $s =~ /^\s*#\s*?/ ||
1945 $s =~ /^\s*$Ident\s*:/) {
1946 $continuation = ($s =~ /^.*?\\\n/) ?
1 : 0;
1947 if ($s =~ s/^.*?\n//) {
1953 my (undef, $sindent) = line_stats
("+" . $s);
1954 my $stat_real = raw_line
($linenr, $cond_lines);
1956 # Check if either of these lines are modified, else
1957 # this is not this patch's fault.
1958 if (!defined($stat_real) ||
1959 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
1962 if (defined($stat_real) && $cond_lines > 1) {
1963 $stat_real = "[...]\n$stat_real";
1966 #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 if ($check && (($sindent % 4) != 0 ||
1969 ($sindent <= $indent && $s ne ''))) {
1970 WARN
("SUSPECT_CODE_INDENT",
1971 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
1975 # Track the 'values' across context and added lines.
1976 my $opline = $line; $opline =~ s/^./ /;
1977 my ($curr_values, $curr_vars) =
1978 annotate_values
($opline . "\n", $prev_values);
1979 $curr_values = $prev_values . $curr_values;
1981 my $outline = $opline; $outline =~ s/\t/ /g;
1982 print "$linenr > .$outline\n";
1983 print "$linenr > $curr_values\n";
1984 print "$linenr > $curr_vars\n";
1986 $prev_values = substr($curr_values, -1);
1988 #ignore lines not being added
1989 if ($line=~/^[^\+]/) {next;}
1991 # TEST: allow direct testing of the type matcher.
1993 if ($line =~ /^.\s*$Declare\s*$/) {
1995 "TEST: is type\n" . $herecurr);
1996 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
1997 ERROR
("TEST_NOT_TYPE",
1998 "TEST: is not type ($1 is)\n". $herecurr);
2002 # TEST: allow direct testing of the attribute matcher.
2004 if ($line =~ /^.\s*$Modifier\s*$/) {
2006 "TEST: is attr\n" . $herecurr);
2007 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2008 ERROR
("TEST_NOT_ATTR",
2009 "TEST: is not attr ($1 is)\n". $herecurr);
2014 # check for initialisation to aggregates open brace on the next line
2015 if ($line =~ /^.\s*{/ &&
2016 $prevline =~ /(?:^|[^=])=\s*$/) {
2018 "that open brace { should be on the previous line\n" . $hereprev);
2022 # Checks which are anchored on the added line.
2025 # check for malformed paths in #include statements (uses RAW line)
2026 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2028 if ($path =~ m{//}) {
2029 ERROR
("MALFORMED_INCLUDE",
2030 "malformed #include filename\n" .
2035 # no C99 // comments
2036 if ($line =~ m{//}) {
2037 ERROR
("C99_COMMENTS",
2038 "do not use C99 // comments\n" . $herecurr);
2040 # Remove C99 comments.
2042 $opline =~ s@
//.*@@
;
2044 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2045 # the whole statement.
2046 #print "APW <$lines[$realline_next - 1]>\n";
2047 if (defined $realline_next &&
2048 exists $lines[$realline_next - 1] &&
2049 !defined $suppress_export{$realline_next} &&
2050 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2051 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2052 # Handle definitions which produce identifiers with
2055 # EXPORT_SYMBOL(something_foo);
2057 if ($stat =~ /^.([A-Z_]+)\s*\(\s*($Ident)/ &&
2058 $name =~ /^${Ident}_$2/) {
2059 #print "FOO C name<$name>\n";
2060 $suppress_export{$realline_next} = 1;
2062 } elsif ($stat !~ /(?
:
2064 ^.DEFINE_
$Ident\
(\Q
$name\E\
)|
2065 ^.DECLARE_
$Ident\
(\Q
$name\E\
)|
2066 ^.LIST_HEAD\
(\Q
$name\E\
)|
2067 ^.(?
:$Storage\s
+)?
$Type\s
*\
(\s
*\
*\s
*\Q
$name\E\s
*\
)\s
*\
(|
2068 \b\Q
$name\E
(?
:\s
+$Attribute)*\s
*(?
:;|=|\
[|\
()
2070 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2071 $suppress_export{$realline_next} = 2;
2073 $suppress_export{$realline_next} = 1;
2076 if (!defined $suppress_export{$linenr} &&
2077 $prevline =~ /^.\s*$/ &&
2078 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2079 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2080 #print "FOO B <$lines[$linenr - 1]>\n";
2081 $suppress_export{$linenr} = 2;
2083 if (defined $suppress_export{$linenr} &&
2084 $suppress_export{$linenr} == 2) {
2085 WARN
("EXPORT_SYMBOL",
2086 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2089 # check for global initialisers.
2090 if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) {
2091 ERROR
("GLOBAL_INITIALISERS",
2092 "do not initialise globals to 0 or NULL\n" .
2095 # check for static initialisers.
2096 if ($line =~ /\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2097 ERROR
("INITIALISED_STATIC",
2098 "do not initialise statics to 0 or NULL\n" .
2102 # check for static const char * arrays.
2103 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2104 WARN
("STATIC_CONST_CHAR_ARRAY",
2105 "static const char * array should probably be static const char * const\n" .
2109 # check for static char foo[] = "bar" declarations.
2110 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2111 WARN
("STATIC_CONST_CHAR_ARRAY",
2112 "static char array declaration should probably be static const char\n" .
2116 # check for declarations of struct pci_device_id
2117 if ($line =~ /\bstruct\s+pci_device_id\s+\w+\s*\[\s*\]\s*\=\s*\{/) {
2118 WARN
("DEFINE_PCI_DEVICE_TABLE",
2119 "Use DEFINE_PCI_DEVICE_TABLE for struct pci_device_id\n" . $herecurr);
2122 # check for new typedefs, only function parameters and sparse annotations
2124 # if ($line =~ /\btypedef\s/ &&
2125 # $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2126 # $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2127 # $line !~ /\b$typeTypedefs\b/ &&
2128 # $line !~ /\b__bitwise(?:__|)\b/) {
2129 # WARN("NEW_TYPEDEFS",
2130 # "do not add new typedefs\n" . $herecurr);
2133 # * goes on variable not on type
2135 if ($line =~ m{\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\)}) {
2136 my ($from, $to) = ($1, $1);
2138 # Should start with a space.
2139 $to =~ s/^(\S)/ $1/;
2140 # Should not end with a space.
2142 # '*'s should not have spaces between.
2143 while ($to =~ s/\*\s+\*/\*\*/) {
2146 #print "from<$from> to<$to>\n";
2148 ERROR
("POINTER_LOCATION",
2149 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr);
2151 } elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) {
2152 my ($from, $to, $ident) = ($1, $1, $2);
2154 # Should start with a space.
2155 $to =~ s/^(\S)/ $1/;
2156 # Should not end with a space.
2158 # '*'s should not have spaces between.
2159 while ($to =~ s/\*\s+\*/\*\*/) {
2161 # Modifiers should have spaces.
2162 $to =~ s/(\b$Modifier$)/$1 /;
2164 #print "from<$from> to<$to> ident<$ident>\n";
2165 if ($from ne $to && $ident !~ /^$Modifier$/) {
2166 ERROR
("POINTER_LOCATION",
2167 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr);
2171 # # no BUG() or BUG_ON()
2172 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2173 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2174 # print "$herecurr";
2178 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2179 WARN
("LINUX_VERSION_CODE",
2180 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2183 # check for uses of printk_ratelimit
2184 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2185 WARN
("PRINTK_RATELIMITED",
2186 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2189 # printk should use KERN_* levels. Note that follow on printk's on the
2190 # same line do not need a level, so we use the current block context
2191 # to try and find and validate the current printk. In summary the current
2192 # printk includes all preceding printk's which have no newline on the end.
2193 # we assume the first bad printk is the one to report.
2194 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2196 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2197 #print "CHECK<$lines[$ln - 1]\n";
2198 # we have a preceding printk if it ends
2199 # with "\n" ignore it, else it is to blame
2200 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2201 if ($rawlines[$ln - 1] !~ m{\\n"}) {
2208 WARN
("PRINTK_WITHOUT_KERN_LEVEL",
2209 "printk() should include KERN_ facility level\n" . $herecurr);
2213 # function brace can't be on same line, except for #defines of do while,
2214 # or if closed on same line
2215 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2216 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2218 "open brace '{' following function declarations go on the next line\n" . $herecurr);
2221 # open braces for enum, union and struct go on the same line.
2222 if ($line =~ /^.\s*{/ &&
2223 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2225 "open brace '{' following $1 go on the same line\n" . $hereprev);
2228 # missing space after union, struct or enum definition
2229 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?(?:\s+$Ident)?[=\{]/) {
2231 "missing space after $1 definition\n" . $herecurr);
2234 # check for spacing round square brackets; allowed:
2235 # 1. with a type on the left -- int [] a;
2236 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2237 # 3. inside a curly brace -- = { [0...10] = 5 }
2238 while ($line =~ /(.*?\s)\[/g) {
2239 my ($where, $prefix) = ($-[1], $1);
2240 if ($prefix !~ /$Type\s+$/ &&
2241 ($where != 0 || $prefix !~ /^.\s+$/) &&
2242 $prefix !~ /{\s+$/) {
2243 ERROR
("BRACKET_SPACE",
2244 "space prohibited before open square bracket '['\n" . $herecurr);
2248 # check for spaces between functions and their parentheses.
2249 while ($line =~ /($Ident)\s+\(/g) {
2251 my $ctx_before = substr($line, 0, $-[1]);
2252 my $ctx = "$ctx_before$name";
2254 # Ignore those directives where spaces _are_ permitted.
2256 if|for|while|switch
|return|case
|
2257 volatile
|__volatile__
|
2258 __attribute__
|format
|__extension__
|
2262 # cpp #define statements have non-optional spaces, ie
2263 # if there is a space between the name and the open
2264 # parenthesis it is simply not a parameter group.
2265 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
2267 # cpp #elif statement condition may start with a (
2268 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
2270 # If this whole things ends with a type its most
2271 # likely a typedef for a function.
2272 } elsif ($ctx =~ /$Type$/) {
2276 "space prohibited between function name and open parenthesis '('\n" . $herecurr);
2279 # Check operator spacing.
2280 if (!($line=~/\#\s*include/)) {
2282 <<=|>>=|<=|>=|==|!=|
2283 \
+=|-=|\
*=|\
/=|%=|\
^=|\
|=|&=|
2284 =>|->|<<|>>|<|>|=|!|~|
2285 &&|\
|\
||,|\
^|\
+\
+|--|&|\
||\
+|-|\
*|\
/|%|
2288 my @elements = split(/($ops|;)/, $opline);
2291 my $blank = copy_spacing
($opline);
2293 for (my $n = 0; $n < $#elements; $n += 2) {
2294 $off += length($elements[$n]);
2296 # Pick up the preceding and succeeding characters.
2297 my $ca = substr($opline, 0, $off);
2299 if (length($opline) >= ($off + length($elements[$n + 1]))) {
2300 $cc = substr($opline, $off + length($elements[$n + 1]));
2302 my $cb = "$ca$;$cc";
2305 $a = 'V' if ($elements[$n] ne '');
2306 $a = 'W' if ($elements[$n] =~ /\s$/);
2307 $a = 'C' if ($elements[$n] =~ /$;$/);
2308 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
2309 $a = 'O' if ($elements[$n] eq '');
2310 $a = 'E' if ($ca =~ /^\s*$/);
2312 my $op = $elements[$n + 1];
2315 if (defined $elements[$n + 2]) {
2316 $c = 'V' if ($elements[$n + 2] ne '');
2317 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
2318 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
2319 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
2320 $c = 'O' if ($elements[$n + 2] eq '');
2321 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
2326 my $ctx = "${a}x${c}";
2328 my $at = "(ctx:$ctx)";
2330 my $ptr = substr($blank, 0, $off) . "^";
2331 my $hereptr = "$hereline$ptr\n";
2333 # Pull out the value of this operator.
2334 my $op_type = substr($curr_values, $off + 1, 1);
2336 # Get the full operator variant.
2337 my $opv = $op . substr($curr_vars, $off, 1);
2339 # Ignore operators passed as parameters.
2340 if ($op_type ne 'V' &&
2341 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
2344 # } elsif ($op =~ /^$;+$/) {
2346 # ; should have either the end of line or a space or \ after it
2347 } elsif ($op eq ';') {
2348 if ($ctx !~ /.x[WEBC]/ &&
2349 $cc !~ /^\\/ && $cc !~ /^;/) {
2351 "space required after that '$op' $at\n" . $hereptr);
2355 } elsif ($op eq '//') {
2359 # : when part of a bitfield
2360 } elsif ($op eq '->' || $opv eq ':B') {
2361 if ($ctx =~ /Wx.|.xW/) {
2363 "spaces prohibited around that '$op' $at\n" . $hereptr);
2366 # , must have a space on the right.
2367 } elsif ($op eq ',') {
2368 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
2370 "space required after that '$op' $at\n" . $hereptr);
2373 # '*' as part of a type definition -- reported already.
2374 } elsif ($opv eq '*_') {
2375 #warn "'*' is part of type\n";
2377 # unary operators should have a space before and
2378 # none after. May be left adjacent to another
2379 # unary operator, or a cast
2380 } elsif ($op eq '!' || $op eq '~' ||
2381 $opv eq '*U' || $opv eq '-U' ||
2382 $opv eq '&U' || $opv eq '&&U') {
2383 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
2385 "space required before that '$op' $at\n" . $hereptr);
2387 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
2388 # A unary '*' may be const
2390 } elsif ($ctx =~ /.xW/) {
2392 "space prohibited after that '$op' $at\n" . $hereptr);
2395 # unary ++ and unary -- are allowed no space on one side.
2396 } elsif ($op eq '++' or $op eq '--') {
2397 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
2399 "space required one side of that '$op' $at\n" . $hereptr);
2401 if ($ctx =~ /Wx[BE]/ ||
2402 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
2404 "space prohibited before that '$op' $at\n" . $hereptr);
2406 if ($ctx =~ /ExW/) {
2408 "space prohibited after that '$op' $at\n" . $hereptr);
2412 # << and >> may either have or not have spaces both sides
2413 } elsif ($op eq '<<' or $op eq '>>' or
2414 $op eq '&' or $op eq '^' or $op eq '|' or
2415 $op eq '+' or $op eq '-' or
2416 $op eq '*' or $op eq '/' or
2419 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
2421 "need consistent spacing around '$op' $at\n" .
2425 # A colon needs no spaces before when it is
2426 # terminating a case value or a label.
2427 } elsif ($opv eq ':C' || $opv eq ':L') {
2428 if ($ctx =~ /Wx./) {
2430 "space prohibited before that '$op' $at\n" . $hereptr);
2433 # All the others need spaces both sides.
2434 } elsif ($ctx !~ /[EWC]x[CWE]/) {
2437 # Ignore email addresses <foo@bar>
2439 $cc =~ /^\S+\@\S+>/) ||
2441 $ca =~ /<\S+\@\S+$/))
2447 if (($opv eq ':O' && $ca =~ /\?$/) ||
2448 ($op eq '?' && $cc =~ /^:/)) {
2454 "spaces required around that '$op' $at\n" . $hereptr);
2457 $off += length($elements[$n + 1]);
2461 # check for multiple assignments
2462 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
2463 CHK
("MULTIPLE_ASSIGNMENTS",
2464 "multiple assignments should be avoided\n" . $herecurr);
2467 ## # check for multiple declarations, allowing for a function declaration
2469 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
2470 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
2472 ## # Remove any bracketed sections to ensure we do not
2473 ## # falsly report the parameters of functions.
2475 ## while ($ln =~ s/\([^\(\)]*\)//g) {
2477 ## if ($ln =~ /,/) {
2478 ## WARN("MULTIPLE_DECLARATION",
2479 ## "declaring multiple variables together should be avoided\n" . $herecurr);
2483 #need space before brace following if, while, etc
2484 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
2487 "space required before the open brace '{'\n" . $herecurr);
2490 # closing brace should have a space following it when it has anything
2492 if ($line =~ /}(?!(?:,|;|\)))\S/) {
2494 "space required after that close brace '}'\n" . $herecurr);
2497 # check spacing on square brackets
2498 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
2500 "space prohibited after that open square bracket '['\n" . $herecurr);
2502 if ($line =~ /\s\]/) {
2504 "space prohibited before that close square bracket ']'\n" . $herecurr);
2507 # check spacing on parentheses
2508 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
2509 $line !~ /for\s*\(\s+;/) {
2511 "space prohibited after that open parenthesis '('\n" . $herecurr);
2513 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
2514 $line !~ /for\s*\(.*;\s+\)/ &&
2515 $line !~ /:\s+\)/) {
2517 "space prohibited before that close parenthesis ')'\n" . $herecurr);
2520 #goto labels aren't indented, allow a single space however
2521 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
2522 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
2523 WARN
("INDENTED_LABEL",
2524 "labels should not be indented\n" . $herecurr);
2527 # Return is not a function.
2528 if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {
2532 # Flatten any parentheses
2533 $value =~ s/\(/ \(/g;
2534 $value =~ s/\)/\) /g;
2535 while ($value =~ s/\[[^\{\}]*\]/1/ ||
2536 $value !~ /(?
:$Ident|-?
$Constant)\s
*
2538 (?
:$Ident|-?
$Constant)/x
&&
2539 $value =~ s/\([^\(\)]*\)/1/) {
2541 #print "value<$value>\n";
2542 if ($value =~ /^\s*(?:$Ident|-?$Constant)\s*$/) {
2543 ERROR
("RETURN_PARENTHESES",
2544 "return is not a function, parentheses are not required\n" . $herecurr);
2546 } elsif ($spacing !~ /\s+/) {
2548 "space required before the open parenthesis '('\n" . $herecurr);
2551 # Return of what appears to be an errno should normally be -'ve
2552 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
2554 if ($name ne 'EOF' && $name ne 'ERROR') {
2555 WARN
("USE_NEGATIVE_ERRNO",
2556 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
2560 # typecasts on min/max could be min_t/max_t
2561 if ($line =~ /^\+(?:.*?)\b(min|max)\s*\($Typecast{0,1}($LvalOrFunc)\s*,\s*$Typecast{0,1}($LvalOrFunc)\s*\)/) {
2562 if (defined $2 || defined $8) {
2564 my $cast1 = deparenthesize
($2);
2566 my $cast2 = deparenthesize
($8);
2570 if ($cast1 ne "" && $cast2 ne "") {
2571 $cast = "$cast1 or $cast2";
2572 } elsif ($cast1 ne "") {
2578 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . $herecurr);
2582 # Need a space before open parenthesis after if, while etc
2583 if ($line=~/\b(if|while|for|switch)\(/) {
2584 ERROR
("SPACING", "space required before the open parenthesis '('\n" . $herecurr);
2587 # Check for illegal assignment in if conditional -- and check for trailing
2588 # statements after the conditional.
2589 if ($line =~ /do\s*(?!{)/) {
2590 my ($stat_next) = ctx_statement_block
($line_nr_next,
2591 $remain_next, $off_next);
2592 $stat_next =~ s/\n./\n /g;
2593 ##print "stat<$stat> stat_next<$stat_next>\n";
2595 if ($stat_next =~ /^\s*while\b/) {
2596 # If the statement carries leading newlines,
2597 # then count those as offsets.
2599 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
2601 statement_rawlines
($whitespace) - 1;
2603 $suppress_whiletrailers{$line_nr_next +
2607 if (!defined $suppress_whiletrailers{$linenr} &&
2608 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
2609 my ($s, $c) = ($stat, $cond);
2611 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
2612 ERROR
("ASSIGN_IN_IF",
2613 "do not use assignment in if condition\n" . $herecurr);
2616 # Find out what is on the end of the line after the
2618 substr($s, 0, length($c), '');
2620 $s =~ s/$;//g; # Remove any comments
2621 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
2622 $c !~ /}\s*while\s*/)
2624 # Find out how long the conditional actually is.
2625 my @newlines = ($c =~ /\n/gs);
2626 my $cond_lines = 1 + $#newlines;
2629 $stat_real = raw_line
($linenr, $cond_lines)
2630 . "\n" if ($cond_lines);
2631 if (defined($stat_real) && $cond_lines > 1) {
2632 $stat_real = "[...]\n$stat_real";
2635 ERROR
("TRAILING_STATEMENTS",
2636 "trailing statements should be on next line\n" . $herecurr . $stat_real);
2640 # Check for bitwise tests written as boolean
2652 WARN
("HEXADECIMAL_BOOLEAN_TEST",
2653 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
2656 # if and else should not have general statements after it
2657 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
2659 $s =~ s/$;//g; # Remove any comments
2660 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
2661 ERROR
("TRAILING_STATEMENTS",
2662 "trailing statements should be on next line\n" . $herecurr);
2665 # if should not continue a brace
2666 if ($line =~ /}\s*if\b/) {
2667 ERROR
("TRAILING_STATEMENTS",
2668 "trailing statements should be on next line\n" .
2671 # case and default should not have general statements after them
2672 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
2674 (?
:\s
*$;*)(?
:\s
*{)?
(?
:\s
*$;*)(?
:\s
*\\)?\s
*$|
2678 ERROR
("TRAILING_STATEMENTS",
2679 "trailing statements should be on next line\n" . $herecurr);
2682 # Check for }<nl>else {, these must be at the same
2683 # indent level to be relevant to each other.
2684 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
2685 $previndent == $indent) {
2686 ERROR
("ELSE_AFTER_BRACE",
2687 "else should follow close brace '}'\n" . $hereprev);
2690 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
2691 $previndent == $indent) {
2692 my ($s, $c) = ctx_statement_block
($linenr, $realcnt, 0);
2694 # Find out what is on the end of the line after the
2696 substr($s, 0, length($c), '');
2699 if ($s =~ /^\s*;/) {
2700 ERROR
("WHILE_AFTER_BRACE",
2701 "while should follow close brace '}'\n" . $hereprev);
2705 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
2706 # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
2707 # print "No studly caps, use _\n";
2708 # print "$herecurr";
2712 #no spaces allowed after \ in define
2713 if ($line=~/\#\s*define.*\\\s$/) {
2714 WARN
("WHITESPACE_AFTER_LINE_CONTINUATION",
2715 "Whitepspace after \\ makes next lines useless\n" . $herecurr);
2718 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
2719 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
2721 my $checkfile = "include/linux/$file";
2722 if (-f
"$root/$checkfile" &&
2723 $realfile ne $checkfile &&
2724 $1 !~ /$allowed_asm_includes/)
2726 if ($realfile =~ m{^arch/}) {
2727 CHK
("ARCH_INCLUDE_LINUX",
2728 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2730 WARN
("INCLUDE_LINUX",
2731 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2736 # multi-statement macros should be enclosed in a do while loop, grab the
2737 # first statement and ensure its the whole macro if its not enclosed
2738 # in a known good container
2739 if ($realfile !~ m@
/vmlinux
.lds
.h
$@
&&
2740 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
2743 my ($off, $dstat, $dcond, $rest);
2746 my $args = defined($1);
2748 # Find the end of the macro and limit our statement
2750 while ($cnt > 0 && defined $lines[$ln - 1] &&
2751 $lines[$ln - 1] =~ /^(?:-|..*\\$)/)
2753 $ctx .= $rawlines[$ln - 1] . "\n";
2754 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2757 $ctx .= $rawlines[$ln - 1];
2759 ($dstat, $dcond, $ln, $cnt, $off) =
2760 ctx_statement_block
($linenr, $ln - $linenr + 1, 0);
2761 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
2762 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
2764 # Extract the remainder of the define (if any) and
2765 # rip off surrounding spaces, and trailing \'s.
2767 while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) {
2768 #print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";
2769 if ($off != 0 || $lines[$ln - 1] !~ /^-/) {
2770 $rest .= substr($lines[$ln - 1], $off) . "\n";
2776 $rest =~ s/\\\n.//g;
2780 # Clean up the original statement.
2782 substr($dstat, 0, length($dcond), '');
2784 $dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;
2787 $dstat =~ s/\\\n.//g;
2788 $dstat =~ s/^\s*//s;
2789 $dstat =~ s/\s*$//s;
2791 # Flatten any parentheses and braces
2792 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
2793 $dstat =~ s/\{[^\{\}]*\}/1/ ||
2794 $dstat =~ s/\[[^\{\}]*\]/1/)
2798 my $exceptions = qr{
2810 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
2811 if ($rest ne '' && $rest ne ',') {
2812 if ($rest !~ /while\s*\(/ &&
2813 $dstat !~ /$exceptions/)
2815 ERROR
("MULTISTATEMENT_MACRO_USE_DO_WHILE",
2816 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
2819 } elsif ($ctx !~ /;/) {
2821 $dstat !~ /^(?:$Ident|-?$Constant)$/ &&
2822 $dstat !~ /$exceptions/ &&
2823 $dstat !~ /^\.$Ident\s*=/ &&
2824 $dstat =~ /$Operators/)
2826 ERROR
("COMPLEX_MACRO",
2827 "Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
2832 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
2833 # all assignments may have only one of the following with an assignment:
2836 # VMLINUX_SYMBOL(...)
2837 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
2838 WARN
("MISSING_VMLINUX_SYMBOL",
2839 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
2842 # check for redundant bracing round if etc
2843 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
2844 my ($level, $endln, @chunks) =
2845 ctx_statement_full
($linenr, $realcnt, 1);
2846 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
2847 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
2848 if ($#chunks > 0 && $level == 0) {
2851 my $herectx = $here . "\n";
2852 my $ln = $linenr - 1;
2853 for my $chunk (@chunks) {
2854 my ($cond, $block) = @
{$chunk};
2856 # If the condition carries leading newlines, then count those as offsets.
2857 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
2858 my $offset = statement_rawlines
($whitespace) - 1;
2860 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
2862 # We have looked at and allowed this specific line.
2863 $suppress_ifbraces{$ln + $offset} = 1;
2865 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
2866 $ln += statement_rawlines
($block) - 1;
2868 substr($block, 0, length($cond), '');
2870 $seen++ if ($block =~ /^\s*{/);
2872 #print "cond<$cond> block<$block> allowed<$allowed>\n";
2873 if (statement_lines
($cond) > 1) {
2874 #print "APW: ALLOWED: cond<$cond>\n";
2877 if ($block =~/\b(?:if|for|while)\b/) {
2878 #print "APW: ALLOWED: block<$block>\n";
2881 if (statement_block_size
($block) > 1) {
2882 #print "APW: ALLOWED: lines block<$block>\n";
2886 if ($seen && !$allowed) {
2888 "braces {} are not necessary for any arm of this statement\n" . $herectx);
2892 if (!defined $suppress_ifbraces{$linenr - 1} &&
2893 $line =~ /\b(if|while|for|else)\b/) {
2896 # Check the pre-context.
2897 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
2898 #print "APW: ALLOWED: pre<$1>\n";
2902 my ($level, $endln, @chunks) =
2903 ctx_statement_full
($linenr, $realcnt, $-[0]);
2905 # Check the condition.
2906 my ($cond, $block) = @
{$chunks[0]};
2907 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
2908 if (defined $cond) {
2909 substr($block, 0, length($cond), '');
2911 if (statement_lines
($cond) > 1) {
2912 #print "APW: ALLOWED: cond<$cond>\n";
2915 if ($block =~/\b(?:if|for|while)\b/) {
2916 #print "APW: ALLOWED: block<$block>\n";
2919 if (statement_block_size
($block) > 1) {
2920 #print "APW: ALLOWED: lines block<$block>\n";
2923 # Check the post-context.
2924 if (defined $chunks[1]) {
2925 my ($cond, $block) = @
{$chunks[1]};
2926 if (defined $cond) {
2927 substr($block, 0, length($cond), '');
2929 if ($block =~ /^\s*\{/) {
2930 #print "APW: ALLOWED: chunk-1 block<$block>\n";
2934 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
2935 my $herectx = $here . "\n";
2936 my $cnt = statement_rawlines
($block);
2938 for (my $n = 0; $n < $cnt; $n++) {
2939 $herectx .= raw_line
($linenr, $n) . "\n";
2943 "braces {} are not necessary for single statement blocks\n" . $herectx);
2947 # don't include deprecated include files (uses RAW line)
2948 for my $inc (@dep_includes) {
2949 if ($rawline =~ m@
^.\s
*\#\s
*include\s
*\
<$inc>@
) {
2950 ERROR
("DEPRECATED_INCLUDE",
2951 "Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
2955 # don't use deprecated functions
2956 for my $func (@dep_functions) {
2957 if ($line =~ /\b$func\b/) {
2958 ERROR
("DEPRECATED_FUNCTION",
2959 "Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
2963 # no volatiles please
2964 # my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
2965 # if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
2967 # "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
2971 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
2972 CHK
("REDUNDANT_CODE",
2973 "if this code is redundant consider removing it\n" .
2977 # check for needless kfree() checks
2978 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
2980 if ($line =~ /\bkfree\(\Q$expr\E\);/) {
2981 WARN
("NEEDLESS_KFREE",
2982 "kfree(NULL) is safe this check is probably not required\n" . $hereprev);
2985 # check for needless usb_free_urb() checks
2986 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
2988 if ($line =~ /\busb_free_urb\(\Q$expr\E\);/) {
2989 WARN
("NEEDLESS_USB_FREE_URB",
2990 "usb_free_urb(NULL) is safe this check is probably not required\n" . $hereprev);
2994 # prefer usleep_range over udelay
2995 if ($line =~ /\budelay\s*\(\s*(\w+)\s*\)/) {
2996 # ignore udelay's < 10, however
2997 if (! (($1 =~ /(\d+)/) && ($1 < 10)) ) {
2999 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);
3003 # warn about unexpectedly long msleep's
3004 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
3007 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3011 # warn about #ifdefs in C files
3012 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3013 # print "#ifdef in C files should be avoided\n";
3014 # print "$herecurr";
3018 # warn about spacing in #ifdefs
3019 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
3021 "exactly one space required after that #$1\n" . $herecurr);
3024 # check for spinlock_t definitions without a comment.
3025 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
3026 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
3028 if (!ctx_has_comment
($first_line, $linenr)) {
3029 CHK
("UNCOMMENTED_DEFINITION",
3030 "$1 definition without comment\n" . $herecurr);
3033 # check for memory barriers without a comment.
3034 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3035 if (!ctx_has_comment
($first_line, $linenr)) {
3036 CHK
("MEMORY_BARRIER",
3037 "memory barrier without comment\n" . $herecurr);
3040 # check of hardware specific defines
3041 if ($line =~ m@
^.\s
*\#\s
*if.*\b(__i386__
|__powerpc64__
|__sun__
|__s390x__
)\b@
&& $realfile !~ m
@include/asm
-@
) {
3043 "architecture specific defines should be avoided\n" . $herecurr);
3046 # Check that the storage class is at the beginning of a declaration
3047 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
3048 WARN
("STORAGE_CLASS",
3049 "storage class should be at the beginning of the declaration\n" . $herecurr)
3052 # check the location of the inline attribute, that it is between
3053 # storage class and type.
3054 if ($line =~ /\b$Type\s+$Inline\b/ ||
3055 $line =~ /\b$Inline\s+$Storage\b/) {
3056 ERROR
("INLINE_LOCATION",
3057 "inline keyword should sit between storage class and type\n" . $herecurr);
3060 # Check for __inline__ and __inline, prefer inline
3061 if ($line =~ /\b(__inline__|__inline)\b/) {
3063 "plain inline is preferred over $1\n" . $herecurr);
3066 # Check for __attribute__ packed, prefer __packed
3067 if ($line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
3068 WARN
("PREFER_PACKED",
3069 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
3072 # Check for __attribute__ aligned, prefer __aligned
3073 if ($line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
3074 WARN
("PREFER_ALIGNED",
3075 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
3078 # check for sizeof(&)
3079 if ($line =~ /\bsizeof\s*\(\s*\&/) {
3080 WARN
("SIZEOF_ADDRESS",
3081 "sizeof(& should be avoided\n" . $herecurr);
3084 # check for line continuations in quoted strings with odd counts of "
3085 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
3086 WARN
("LINE_CONTINUATIONS",
3087 "Avoid line continuations in quoted strings\n" . $herecurr);
3090 # check for new externs in .c files.
3091 # if ($realfile =~ /\.c$/ && defined $stat &&
3092 # $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
3094 # my $function_name = $1;
3095 # my $paren_space = $2;
3098 # if (defined $cond) {
3099 # substr($s, 0, length($cond), '');
3101 # if ($s =~ /^\s*;/ &&
3102 # $function_name ne 'uninitialized_var')
3104 # WARN("AVOID_EXTERNS",
3105 # "externs should be avoided in .c files\n" . $herecurr);
3108 # if ($paren_space =~ /\n/) {
3109 # WARN("FUNCTION_ARGUMENTS",
3110 # "arguments for function declarations should follow identifier\n" . $herecurr);
3113 # } elsif ($realfile =~ /\.c$/ && defined $stat &&
3114 # $stat =~ /^.\s*extern\s+/)
3116 # WARN("AVOID_EXTERNS",
3117 # "externs should be avoided in .c files\n" . $herecurr);
3120 # checks for new __setup's
3121 if ($rawline =~ /\b__setup\("([^"]*)"/) {
3124 if (!grep(/$name/, @setup_docs)) {
3125 CHK
("UNDOCUMENTED_SETUP",
3126 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
3130 # check for pointless casting of kmalloc return
3131 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
3132 WARN
("UNNECESSARY_CASTS",
3133 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
3136 # check for multiple semicolons
3137 if ($line =~ /;\s*;\s*$/) {
3138 WARN
("ONE_SEMICOLON",
3139 "Statements terminations use 1 semicolon\n" . $herecurr);
3142 # check for gcc specific __FUNCTION__
3143 if ($line =~ /__FUNCTION__/) {
3145 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr);
3148 # check for semaphores initialized locked
3149 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
3150 WARN
("CONSIDER_COMPLETION",
3151 "consider using a completion\n" . $herecurr);
3154 # recommend kstrto* over simple_strto*
3155 if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
3156 WARN
("CONSIDER_KSTRTO",
3157 "consider using kstrto* in preference to simple_$1\n" . $herecurr);
3159 # check for __initcall(), use device_initcall() explicitly please
3160 if ($line =~ /^.\s*__initcall\s*\(/) {
3161 WARN
("USE_DEVICE_INITCALL",
3162 "please use device_initcall() instead of __initcall()\n" . $herecurr);
3164 # check for various ops structs, ensure they are const.
3165 my $struct_ops = qr{acpi_dock_ops
|
3166 address_space_operations
|
3168 block_device_operations
|
3173 file_lock_operations
|
3183 lock_manager_operations
|
3189 pipe_buf_operations
|
3190 platform_hibernation_ops
|
3191 platform_suspend_ops
|
3196 soc_pcmcia_socket_ops
|
3202 if ($line !~ /\bconst\b/ &&
3203 $line =~ /\bstruct\s+($struct_ops)\b/) {
3204 WARN
("CONST_STRUCT",
3205 "struct $1 should normally be const\n" .
3209 # use of NR_CPUS is usually wrong
3210 # ignore definitions of NR_CPUS and usage to define arrays as likely right
3211 if ($line =~ /\bNR_CPUS\b/ &&
3212 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
3213 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
3214 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
3215 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
3216 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
3219 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
3222 # check for %L{u,d,i} in strings
3224 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
3225 $string = substr($rawline, $-[1], $+[1] - $-[1]);
3226 $string =~ s/%%/__/g;
3227 if ($string =~ /(?<!%)%L[udi]/) {
3229 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
3234 # whine mightly about in_atomic
3235 if ($line =~ /\bin_atomic\s*\(/) {
3236 if ($realfile =~ m@
^drivers
/@
) {
3238 "do not use in_atomic in drivers\n" . $herecurr);
3239 } elsif ($realfile !~ m@
^kernel
/@
) {
3241 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
3245 # check for lockdep_set_novalidate_class
3246 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
3247 $line =~ /__lockdep_no_validate__\s*\)/ ) {
3248 if ($realfile !~ m@
^kernel
/lockdep@
&&
3249 $realfile !~ m@
^include
/linux/lockdep@
&&
3250 $realfile !~ m@
^drivers
/base/core@
) {
3252 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
3256 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
3257 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
3258 WARN
("EXPORTED_WORLD_WRITABLE",
3259 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
3262 # Check for memset with swapped arguments
3263 if ($line =~ /memset.*\,(\ |)(0x|)0(\ |0|)\);/) {
3265 "memset size is 3rd argument, not the second.\n" . $herecurr);
3269 # If we have no input at all, then there is nothing to report on
3270 # so just keep quiet.
3271 if ($#rawlines == -1) {
3275 # In mailback mode only produce a report in the negative, for
3276 # things that appear to be patches.
3277 if ($mailback && ($clean == 1 || !$is_patch)) {
3281 # This is not a patch, and we are are in 'no-patch' mode so
3283 if (!$chk_patch && !$is_patch) {
3288 ERROR
("NOT_UNIFIED_DIFF",
3289 "Does not appear to be a unified-diff format patch\n");
3291 if ($is_patch && $chk_signoff && $signoff == 0) {
3292 ERROR
("MISSING_SIGN_OFF",
3293 "Missing Signed-off-by: line(s)\n");
3296 print report_dump
();
3297 if ($summary && !($clean == 1 && $quiet == 1)) {
3298 print "$filename " if ($summary_file);
3299 print "total: $cnt_error errors, $cnt_warn warnings, " .
3300 (($check)?
"$cnt_chk checks, " : "") .
3301 "$cnt_lines lines checked\n";
3302 print "\n" if ($quiet == 0);
3306 # If there were whitespace errors which cleanpatch can fix
3307 # then suggest that.
3308 if ($rpt_cleaners) {
3309 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
3310 print " scripts/cleanfile\n\n";
3315 if (keys %ignore_type) {
3316 print "NOTE: Ignored message types:";
3317 foreach my $ignore (sort keys %ignore_type) {
3321 print "\n" if ($quiet == 0);
3324 if ($clean == 1 && $quiet == 0) {
3325 print "$vname has no obvious style problems and is ready for submission.\n"
3327 if ($clean == 0 && $quiet == 0) {
3329 $vname has style problems
, please review
.
3331 If any of these errors are false positives
, please report
3332 them to the maintainer
, see CHECKPATCH
in MAINTAINERS
.
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)