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
|)|
265 LOG_
(?
:DEBUG
|INFO
|WARNING
|ERROR
|USER
|USER_N
|OUTPUT
)+
268 our $signature_tags = qr{(?xi
:
280 qr{(?:unsigned\s+)?char},
281 qr{(?:unsigned\s+)?short},
282 qr{(?:unsigned\s+)?int},
283 qr{(?:unsigned\s+)?long},
284 qr{(?:unsigned\s+)?long\s+int},
285 qr{(?:unsigned\s+)?long\s+long},
286 qr{(?:unsigned\s+)?long\s+long\s+int},
295 qr{${Ident}_handler
},
296 qr{${Ident}_handler_fn
},
298 our @modifierList = (
302 our $allowed_asm_includes = qr{(?x
:
306 # memory.h: ARM has a custom one
309 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
310 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
311 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
313 (?
:$Modifier\s
+|const\s
+)*
315 (?
:typeof
|__typeof__
)\s
*\
(\s
*\
**\s
*$Ident\s
*\
)|
319 (?
:\s
+$Modifier|\s
+const
)*
323 (?
:[\s\
*]+\s
*const
|[\s\
*]+|(?
:\s
*\
[\s
*\
])+)?
324 (?
:\s
+$Inline|\s
+$Modifier)*
326 $Declare = qr{(?:$Storage\s+)?$Type};
330 our $match_balanced_parentheses = qr/(\((?:[^\(\)]+|(-1))*\))/;
332 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s
*};
333 our $LvalOrFunc = qr{($Lval)\s*($match_balanced_parentheses{0,1})\s
*};
337 return "" if (!defined($string));
338 $string =~ s@
^\s
*\
(\s
*@
@g;
339 $string =~ s@\s
*\
)\s
*$@
@g;
340 $string =~ s@\s
+@
@g;
344 $chk_signoff = 0 if ($file);
346 my @dep_includes = ();
347 my @dep_functions = ();
348 my $removal = "Documentation/feature-removal-schedule.txt";
349 if ($tree && -f
"$root/$removal") {
350 open(my $REMOVE, '<', "$root/$removal") ||
351 die "$P: $removal: open failed - $!\n";
353 if (/^Check:\s+(.*\S)/) {
354 for my $entry (split(/[, ]+/, $1)) {
355 if ($entry =~ m
@include/(.*)@
) {
356 push(@dep_includes, $1);
358 } elsif ($entry !~ m@
/@
) {
359 push(@dep_functions, $entry);
370 for my $filename (@ARGV) {
373 open($FILE, '-|', "diff -u /dev/null $filename") ||
374 die "$P: $filename: diff failed - $!\n";
375 } elsif ($filename eq '-') {
376 open($FILE, '<&STDIN');
378 open($FILE, '<', "$filename") ||
379 die "$P: $filename: open failed - $!\n";
381 if ($filename eq '-') {
382 $vname = 'Your patch';
391 if (!process
($filename)) {
400 sub top_of_kernel_tree
{
404 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
405 "README", "Documentation", "arch", "include", "drivers",
406 "fs", "init", "ipc", "kernel", "lib", "scripts",
409 foreach my $check (@tree_check) {
410 if (! -e
$root . '/' . $check) {
418 my ($formatted_email) = @_;
424 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
427 $comment = $3 if defined $3;
428 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
430 $comment = $2 if defined $2;
431 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
433 $comment = $2 if defined $2;
434 $formatted_email =~ s/$address.*$//;
435 $name = $formatted_email;
436 $name =~ s/^\s+|\s+$//g;
437 $name =~ s/^\"|\"$//g;
438 # If there's a name left after stripping spaces and
439 # leading quotes, and the address doesn't have both
440 # leading and trailing angle brackets, the address
442 # "joe smith joe@smith.com" bad
443 # "joe smith <joe@smith.com" bad
444 if ($name ne "" && $address !~ /^<[^>]+>$/) {
451 $name =~ s/^\s+|\s+$//g;
452 $name =~ s/^\"|\"$//g;
453 $address =~ s/^\s+|\s+$//g;
454 $address =~ s/^\<|\>$//g;
456 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
457 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
461 return ($name, $address, $comment);
465 my ($name, $address) = @_;
469 $name =~ s/^\s+|\s+$//g;
470 $name =~ s/^\"|\"$//g;
471 $address =~ s/^\s+|\s+$//g;
473 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
474 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
479 $formatted_email = "$address";
481 $formatted_email = "$name <$address>";
484 return $formatted_email;
490 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
491 if (-e
"$path/$conf") {
492 return "$path/$conf";
504 for my $c (split(//, $str)) {
508 for (; ($n % 4) != 0; $n++) {
520 (my $res = shift) =~ tr/\t/ /c;
527 # Drop the diff line leader and expand tabs
529 $line = expand_tabs
($line);
531 # Pick the indent from the front of the line.
532 my ($white) = ($line =~ /^(\s*)/);
534 return (length($line), length($white));
537 my $sanitise_quote = '';
539 sub sanitise_line_reset
{
540 my ($in_comment) = @_;
543 $sanitise_quote = '*/';
545 $sanitise_quote = '';
558 # Always copy over the diff marker.
559 $res = substr($line, 0, 1);
561 for ($off = 1; $off < length($line); $off++) {
562 $c = substr($line, $off, 1);
564 # Comments we are wacking completly including the begin
565 # and end, all to $;.
566 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
567 $sanitise_quote = '*/';
569 substr($res, $off, 2, "$;$;");
573 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
574 $sanitise_quote = '';
575 substr($res, $off, 2, "$;$;");
579 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
580 $sanitise_quote = '//';
582 substr($res, $off, 2, $sanitise_quote);
587 # A \ in a string means ignore the next character.
588 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
590 substr($res, $off, 2, 'XX');
595 if ($c eq "'" || $c eq '"') {
596 if ($sanitise_quote eq '') {
597 $sanitise_quote = $c;
599 substr($res, $off, 1, $c);
601 } elsif ($sanitise_quote eq $c) {
602 $sanitise_quote = '';
606 #print "c<$c> SQ<$sanitise_quote>\n";
607 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
608 substr($res, $off, 1, $;);
609 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
610 substr($res, $off, 1, $;);
611 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
612 substr($res, $off, 1, 'X');
614 substr($res, $off, 1, $c);
618 if ($sanitise_quote eq '//') {
619 $sanitise_quote = '';
622 # The pathname on a #include may be surrounded by '<' and '>'.
623 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
624 my $clean = 'X' x
length($1);
625 $res =~ s@\
<.*\
>@
<$clean>@
;
627 # The whole of a #error is a string.
628 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
629 my $clean = 'X' x
length($1);
630 $res =~ s@
(\#\s
*(?
:error
|warning
)\s
+).*@
$1$clean@
;
636 sub ctx_statement_block
{
637 my ($linenr, $remain, $off) = @_;
638 my $line = $linenr - 1;
655 @stack = (['', 0]) if ($#stack == -1);
657 #warn "CSB: blk<$blk> remain<$remain>\n";
658 # If we are about to drop off the end, pull in more
661 for (; $remain > 0; $line++) {
662 last if (!defined $lines[$line]);
663 next if ($lines[$line] =~ /^-/);
666 $blk .= $lines[$line] . "\n";
671 # Bail if there is no further context.
672 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
678 $c = substr($blk, $off, 1);
679 $remainder = substr($blk, $off);
681 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
683 # Handle nested #if/#else.
684 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
685 push(@stack, [ $type, $level ]);
686 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
687 ($type, $level) = @
{$stack[$#stack - 1]};
688 } elsif ($remainder =~ /^#\s*endif\b/) {
689 ($type, $level) = @
{pop(@stack)};
692 # Statement ends at the ';' or a close '}' at the
694 if ($level == 0 && $c eq ';') {
698 # An else is really a conditional as long as its not else if
699 if ($level == 0 && $coff_set == 0 &&
700 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
701 $remainder =~ /^(else)(?:\s|{)/ &&
702 $remainder !~ /^else\s+if\b/) {
703 $coff = $off + length($1) - 1;
705 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
706 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
709 if (($type eq '' || $type eq '(') && $c eq '(') {
713 if ($type eq '(' && $c eq ')') {
715 $type = ($level != 0)?
'(' : '';
717 if ($level == 0 && $coff < $soff) {
720 #warn "CSB: mark coff<$coff>\n";
723 if (($type eq '' || $type eq '{') && $c eq '{') {
727 if ($type eq '{' && $c eq '}') {
729 $type = ($level != 0)?
'{' : '';
732 if (substr($blk, $off + 1, 1) eq ';') {
740 # We are truly at the end, so shuffle to the next line.
747 my $statement = substr($blk, $soff, $off - $soff + 1);
748 my $condition = substr($blk, $soff, $coff - $soff + 1);
750 #warn "STATEMENT<$statement>\n";
751 #warn "CONDITION<$condition>\n";
753 #print "coff<$coff> soff<$off> loff<$loff>\n";
755 return ($statement, $condition,
756 $line, $remain + 1, $off - $loff + 1, $level);
759 sub statement_lines
{
762 # Strip the diff line prefixes and rip blank lines at start and end.
763 $stmt =~ s/(^|\n)./$1/g;
767 my @stmt_lines = ($stmt =~ /\n/g);
769 return $#stmt_lines + 2;
772 sub statement_rawlines
{
775 my @stmt_lines = ($stmt =~ /\n/g);
777 return $#stmt_lines + 2;
780 sub statement_block_size
{
783 $stmt =~ s/(^|\n)./$1/g;
789 my @stmt_lines = ($stmt =~ /\n/g);
790 my @stmt_statements = ($stmt =~ /;/g);
792 my $stmt_lines = $#stmt_lines + 2;
793 my $stmt_statements = $#stmt_statements + 1;
795 if ($stmt_lines > $stmt_statements) {
798 return $stmt_statements;
802 sub ctx_statement_full
{
803 my ($linenr, $remain, $off) = @_;
804 my ($statement, $condition, $level);
808 # Grab the first conditional/block pair.
809 ($statement, $condition, $linenr, $remain, $off, $level) =
810 ctx_statement_block
($linenr, $remain, $off);
811 #print "F: c<$condition> s<$statement> remain<$remain>\n";
812 push(@chunks, [ $condition, $statement ]);
813 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
814 return ($level, $linenr, @chunks);
817 # Pull in the following conditional/block pairs and see if they
818 # could continue the statement.
820 ($statement, $condition, $linenr, $remain, $off, $level) =
821 ctx_statement_block
($linenr, $remain, $off);
822 #print "C: c<$condition> s<$statement> remain<$remain>\n";
823 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
825 push(@chunks, [ $condition, $statement ]);
828 return ($level, $linenr, @chunks);
832 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
834 my $start = $linenr - 1;
841 my @stack = ($level);
842 for ($line = $start; $remain > 0; $line++) {
843 next if ($rawlines[$line] =~ /^-/);
846 $blk .= $rawlines[$line];
848 # Handle nested #if/#else.
849 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
850 push(@stack, $level);
851 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
852 $level = $stack[$#stack - 1];
853 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
854 $level = pop(@stack);
857 foreach my $c (split(//, $lines[$line])) {
858 ##print "C<$c>L<$level><$open$close>O<$off>\n";
864 if ($c eq $close && $level > 0) {
866 last if ($level == 0);
867 } elsif ($c eq $open) {
872 if (!$outer || $level <= 1) {
873 push(@res, $rawlines[$line]);
876 last if ($level == 0);
879 return ($level, @res);
881 sub ctx_block_outer
{
882 my ($linenr, $remain) = @_;
884 my ($level, @r) = ctx_block_get
($linenr, $remain, 1, '{', '}', 0);
888 my ($linenr, $remain) = @_;
890 my ($level, @r) = ctx_block_get
($linenr, $remain, 0, '{', '}', 0);
894 my ($linenr, $remain, $off) = @_;
896 my ($level, @r) = ctx_block_get
($linenr, $remain, 0, '(', ')', $off);
899 sub ctx_block_level
{
900 my ($linenr, $remain) = @_;
902 return ctx_block_get
($linenr, $remain, 0, '{', '}', 0);
904 sub ctx_statement_level
{
905 my ($linenr, $remain, $off) = @_;
907 return ctx_block_get
($linenr, $remain, 0, '(', ')', $off);
910 sub ctx_locate_comment
{
911 my ($first_line, $end_line) = @_;
913 # Catch a comment on the end of the line itself.
914 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@
.*(/\*.*\*/)\s
*(?
:\\\s
*)?
$@
);
915 return $current_comment if (defined $current_comment);
917 # Look through the context and try and figure out if there is a
920 $current_comment = '';
921 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
922 my $line = $rawlines[$linenr - 1];
924 if ($linenr == $first_line and $line =~ m@
^.\s
*\
*@
) {
927 if ($line =~ m@
/\
*@
) {
930 if (!$in_comment && $current_comment ne '') {
931 $current_comment = '';
933 $current_comment .= $line . "\n" if ($in_comment);
934 if ($line =~ m@\
*/@
) {
939 chomp($current_comment);
940 return($current_comment);
942 sub ctx_has_comment
{
943 my ($first_line, $end_line) = @_;
944 my $cmt = ctx_locate_comment
($first_line, $end_line);
946 ##print "LINE: $rawlines[$end_line - 1 ]\n";
947 ##print "CMMT: $cmt\n";
953 my ($linenr, $cnt) = @_;
955 my $offset = $linenr - 1;
960 $line = $rawlines[$offset++];
961 next if (defined($line) && $line =~ /^-/);
973 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
976 $coded = sprintf("^%c", unpack('C', $2) + 64);
985 my $av_preprocessor = 0;
991 $av_preprocessor = 0;
993 @av_paren_type = ('E');
994 $av_pend_colon = 'O';
997 sub annotate_values
{
998 my ($stream, $type) = @_;
1001 my $var = '_' x
length($stream);
1004 print "$stream\n" if ($dbg_values > 1);
1006 while (length($cur)) {
1007 @av_paren_type = ('E') if ($#av_paren_type < 0);
1008 print " <" . join('', @av_paren_type) .
1009 "> <$type> <$av_pending>" if ($dbg_values > 1);
1010 if ($cur =~ /^(\s+)/o) {
1011 print "WS($1)\n" if ($dbg_values > 1);
1012 if ($1 =~ /\n/ && $av_preprocessor) {
1013 $type = pop(@av_paren_type);
1014 $av_preprocessor = 0;
1017 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1018 print "CAST($1)\n" if ($dbg_values > 1);
1019 push(@av_paren_type, $type);
1022 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1023 print "DECLARE($1)\n" if ($dbg_values > 1);
1026 } elsif ($cur =~ /^($Modifier)\s*/) {
1027 print "MODIFIER($1)\n" if ($dbg_values > 1);
1030 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1031 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1032 $av_preprocessor = 1;
1033 push(@av_paren_type, $type);
1039 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1040 print "UNDEF($1)\n" if ($dbg_values > 1);
1041 $av_preprocessor = 1;
1042 push(@av_paren_type, $type);
1044 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1045 print "PRE_START($1)\n" if ($dbg_values > 1);
1046 $av_preprocessor = 1;
1048 push(@av_paren_type, $type);
1049 push(@av_paren_type, $type);
1052 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1053 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1054 $av_preprocessor = 1;
1056 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1060 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1061 print "PRE_END($1)\n" if ($dbg_values > 1);
1063 $av_preprocessor = 1;
1065 # Assume all arms of the conditional end as this
1066 # one does, and continue as if the #endif was not here.
1067 pop(@av_paren_type);
1068 push(@av_paren_type, $type);
1071 } elsif ($cur =~ /^(\\\n)/o) {
1072 print "PRECONT($1)\n" if ($dbg_values > 1);
1074 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1075 print "ATTR($1)\n" if ($dbg_values > 1);
1076 $av_pending = $type;
1079 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1080 print "SIZEOF($1)\n" if ($dbg_values > 1);
1086 } elsif ($cur =~ /^(if|while|for)\b/o) {
1087 print "COND($1)\n" if ($dbg_values > 1);
1091 } elsif ($cur =~/^(case)/o) {
1092 print "CASE($1)\n" if ($dbg_values > 1);
1093 $av_pend_colon = 'C';
1096 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1097 print "KEYWORD($1)\n" if ($dbg_values > 1);
1100 } elsif ($cur =~ /^(\()/o) {
1101 print "PAREN('$1')\n" if ($dbg_values > 1);
1102 push(@av_paren_type, $av_pending);
1106 } elsif ($cur =~ /^(\))/o) {
1107 my $new_type = pop(@av_paren_type);
1108 if ($new_type ne '_') {
1110 print "PAREN('$1') -> $type\n"
1111 if ($dbg_values > 1);
1113 print "PAREN('$1')\n" if ($dbg_values > 1);
1116 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1117 print "FUNC($1)\n" if ($dbg_values > 1);
1121 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1122 if (defined $2 && $type eq 'C' || $type eq 'T') {
1123 $av_pend_colon = 'B';
1124 } elsif ($type eq 'E') {
1125 $av_pend_colon = 'L';
1127 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1130 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1131 print "IDENT($1)\n" if ($dbg_values > 1);
1134 } elsif ($cur =~ /^($Assignment)/o) {
1135 print "ASSIGN($1)\n" if ($dbg_values > 1);
1138 } elsif ($cur =~/^(;|{|})/) {
1139 print "END($1)\n" if ($dbg_values > 1);
1141 $av_pend_colon = 'O';
1143 } elsif ($cur =~/^(,)/) {
1144 print "COMMA($1)\n" if ($dbg_values > 1);
1147 } elsif ($cur =~ /^(\?)/o) {
1148 print "QUESTION($1)\n" if ($dbg_values > 1);
1151 } elsif ($cur =~ /^(:)/o) {
1152 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1154 substr($var, length($res), 1, $av_pend_colon);
1155 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1160 $av_pend_colon = 'O';
1162 } elsif ($cur =~ /^(\[)/o) {
1163 print "CLOSE($1)\n" if ($dbg_values > 1);
1166 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1169 print "OPV($1)\n" if ($dbg_values > 1);
1176 substr($var, length($res), 1, $variant);
1179 } elsif ($cur =~ /^($Operators)/o) {
1180 print "OP($1)\n" if ($dbg_values > 1);
1181 if ($1 ne '++' && $1 ne '--') {
1185 } elsif ($cur =~ /(^.)/o) {
1186 print "C($1)\n" if ($dbg_values > 1);
1189 $cur = substr($cur, length($1));
1190 $res .= $type x
length($1);
1194 return ($res, $var);
1198 my ($possible, $line) = @_;
1199 my $notPermitted = qr{(?
:
1214 ^(?
:typedef
|struct
|enum
)\b
1216 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1217 if ($possible !~ $notPermitted) {
1218 # Check for modifiers.
1219 $possible =~ s/\s*$Storage\s*//g;
1220 $possible =~ s/\s*$Sparse\s*//g;
1221 if ($possible =~ /^\s*$/) {
1223 } elsif ($possible =~ /\s/) {
1224 $possible =~ s/\s*$Type\s*//g;
1225 for my $modifier (split(' ', $possible)) {
1226 if ($modifier !~ $notPermitted) {
1227 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1228 push(@modifierList, $modifier);
1233 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1234 push(@typeList, $possible);
1238 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1245 return !defined $ignore_type{$_[0]};
1249 if (!show_type
($_[1]) ||
1250 (defined $tst_only && $_[2] !~ /\Q$tst_only\E/)) {
1255 $line = "$prefix$_[0]:$_[1]: $_[2]\n";
1257 $line = "$prefix$_[0]: $_[2]\n";
1259 $line = (split('\n', $line))[0] . "\n" if ($terse);
1261 push(our @report, $line);
1270 if (report
("ERROR", $_[0], $_[1])) {
1276 if (report
("WARNING", $_[0], $_[1])) {
1282 if ($check && report
("CHECK", $_[0], $_[1])) {
1288 sub check_absolute_file
{
1289 my ($absolute, $herecurr) = @_;
1290 my $file = $absolute;
1292 ##print "absolute<$absolute>\n";
1294 # See if any suffix of this path is a path within the tree.
1295 while ($file =~ s@
^[^/]*/@@
) {
1296 if (-f
"$root/$file") {
1297 ##print "file<$file>\n";
1305 # It is, so see if the prefix is acceptable.
1306 my $prefix = $absolute;
1307 substr($prefix, -length($file)) = '';
1309 ##print "prefix<$prefix>\n";
1310 if ($prefix ne ".../") {
1311 WARN
("USE_RELATIVE_PATH",
1312 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1317 my $filename = shift;
1323 my $stashrawline="";
1340 # Trace the real file/line as we go.
1346 my $comment_edge = 0;
1350 my $prev_values = 'E';
1353 my %suppress_ifbraces;
1354 my %suppress_whiletrailers;
1355 my %suppress_export;
1357 # Pre-scan the patch sanitizing the lines.
1358 # Pre-scan the patch looking for any __setup documentation.
1360 my @setup_docs = ();
1363 sanitise_line_reset
();
1365 foreach my $rawline (@rawlines) {
1369 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1371 if ($1 =~ m
@Documentation/kernel
-parameters
.txt
$@
) {
1376 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1385 # Guestimate if this is a continuing comment. Run
1386 # the context looking for a comment "edge". If this
1387 # edge is a close comment then we must be in a comment
1391 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1392 next if (defined $rawlines[$ln - 1] &&
1393 $rawlines[$ln - 1] =~ /^-/);
1395 #print "RAW<$rawlines[$ln - 1]>\n";
1396 last if (!defined $rawlines[$ln - 1]);
1397 if ($rawlines[$ln - 1] =~ m@
(/\*|\*/)@
&&
1398 $rawlines[$ln - 1] !~ m@
"[^"]*(?
:/\*|\*/)[^"]*"@
) {
1403 if (defined $edge && $edge eq '*/') {
1407 # Guestimate if this is a continuing comment. If this
1408 # is the start of a diff block and this line starts
1409 # ' *' then it is very likely a comment.
1410 if (!defined $edge &&
1411 $rawlines[$linenr] =~ m@
^.\s
*(?
:\
*\
*+| \
*)(?
:\s
|$)@
)
1416 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1417 sanitise_line_reset
($in_comment);
1419 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1420 # Standardise the strings and chars within the input to
1421 # simplify matching -- only bother with positive lines.
1422 $line = sanitise_line
($rawline);
1424 push(@lines, $line);
1427 $realcnt-- if ($line =~ /^(?:\+| |$)/);
1432 #print "==>$rawline\n";
1433 #print "-->$line\n";
1435 if ($setup_docs && $line =~ /^\+/) {
1436 push(@setup_docs, $line);
1444 foreach my $line (@lines) {
1447 my $rawline = $rawlines[$linenr - 1];
1449 #extract the line range in the file after the patch is applied
1450 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1452 $first_line = $linenr + 1;
1462 %suppress_ifbraces = ();
1463 %suppress_whiletrailers = ();
1464 %suppress_export = ();
1467 # track the line number as we move through the hunk, note that
1468 # new versions of GNU diff omit the leading space on completely
1469 # blank context lines so we need to count that too.
1470 } elsif ($line =~ /^( |\+|$)/) {
1472 $realcnt-- if ($realcnt != 0);
1474 # Measure the line length and indent.
1475 ($length, $indent) = line_stats
($rawline);
1477 # Track the previous line.
1478 ($prevline, $stashline) = ($stashline, $line);
1479 ($previndent, $stashindent) = ($stashindent, $indent);
1480 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1482 #warn "line<$line>\n";
1484 } elsif ($realcnt == 1) {
1488 my $hunk_line = ($realcnt != 0);
1490 #make up the handle for any error we report on this line
1491 $prefix = "$filename:$realline: " if ($emacs && $file);
1492 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1494 $here = "#$linenr: " if (!$file);
1495 $here = "#$realline: " if ($file);
1497 # extract the filename as it passes
1498 if ($line =~ /^diff --git.*?(\S+)$/) {
1500 $realfile =~ s@
^([^/]*)/@@
;
1502 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1504 $realfile =~ s@
^([^/]*)/@@
;
1507 if (!$file && $tree && $p1_prefix ne '' &&
1508 -e
"$root/$p1_prefix") {
1509 WARN
("PATCH_PREFIX",
1510 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1513 if ($realfile =~ m@
^include
/asm/@
) {
1514 ERROR
("MODIFIED_INCLUDE_ASM",
1515 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1520 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1522 my $hereline = "$here\n$rawline\n";
1523 my $herecurr = "$here\n$rawline\n";
1524 my $hereprev = "$here\n$prevrawline\n$rawline\n";
1526 $cnt_lines++ if ($realcnt != 0);
1528 # Check for incorrect file permissions
1529 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1530 my $permhere = $here . "FILE: $realfile\n";
1531 if ($realfile =~ /(Makefile|Kconfig|\.c|\.h|\.S|\.tmpl)$/) {
1532 ERROR
("EXECUTE_PERMISSIONS",
1533 "do not set execute permissions for source files\n" . $permhere);
1537 # Check the patch for a signoff:
1538 if ($line =~ /^\s*signed-off-by:/i) {
1542 # Check signature styles
1543 if ($line =~ /^(\s*)($signature_tags)(\s*)(.*)/) {
1544 my $space_before = $1;
1546 my $space_after = $3;
1548 my $ucfirst_sign_off = ucfirst(lc($sign_off));
1550 if (defined $space_before && $space_before ne "") {
1551 WARN
("BAD_SIGN_OFF",
1552 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr);
1554 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
1555 WARN
("BAD_SIGN_OFF",
1556 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr);
1558 if (!defined $space_after || $space_after ne " ") {
1559 WARN
("BAD_SIGN_OFF",
1560 "Use a single space after $ucfirst_sign_off\n" . $herecurr);
1563 my ($email_name, $email_address, $comment) = parse_email
($email);
1564 my $suggested_email = format_email
(($email_name, $email_address));
1565 if ($suggested_email eq "") {
1566 ERROR
("BAD_SIGN_OFF",
1567 "Unrecognized email address: '$email'\n" . $herecurr);
1569 my $dequoted = $suggested_email;
1570 $dequoted =~ s/^"//;
1571 $dequoted =~ s/" </ </;
1572 # Don't force email to have quotes
1573 # Allow just an angle bracketed address
1574 if ("$dequoted$comment" ne $email &&
1575 "<$email_address>$comment" ne $email &&
1576 "$suggested_email$comment" ne $email) {
1577 WARN
("BAD_SIGN_OFF",
1578 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1583 # Check for wrappage within a valid hunk of the file
1584 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1585 ERROR
("CORRUPTED_PATCH",
1586 "patch seems to be corrupt (line wrapped?)\n" .
1587 $herecurr) if (!$emitted_corrupt++);
1590 # Check for absolute kernel paths.
1592 while ($line =~ m{(?:^|\s)(/\S*)}g) {
1595 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1596 check_absolute_file
($1, $herecurr)) {
1599 check_absolute_file
($file, $herecurr);
1604 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1605 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1606 $rawline !~ m/^$UTF8*$/) {
1607 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1609 my $blank = copy_spacing
($rawline);
1610 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1611 my $hereptr = "$hereline$ptr\n";
1614 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1617 # ignore non-hunk lines and lines being removed
1618 next if (!$hunk_line || $line =~ /^-/);
1620 #trailing whitespace
1621 if ($line =~ /^\+.*\015/) {
1622 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1623 ERROR
("DOS_LINE_ENDINGS",
1624 "DOS line endings\n" . $herevet);
1626 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
1627 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1628 ERROR
("TRAILING_WHITESPACE",
1629 "trailing whitespace\n" . $herevet);
1633 # check for Kconfig help text having a real description
1634 # Only applies when adding the entry originally, after that we do not have
1635 # sufficient context to determine whether it is indeed long enough.
1636 if ($realfile =~ /Kconfig/ &&
1637 $line =~ /\+\s*(?:---)?help(?:---)?$/) {
1640 my $ln = $linenr + 1;
1643 while ($cnt > 0 && defined $lines[$ln - 1]) {
1644 $f = $lines[$ln - 1];
1645 $cnt-- if ($lines[$ln - 1] !~ /^-/);
1646 $is_end = $lines[$ln - 1] =~ /^\+/;
1649 next if ($f =~ /^-/);
1653 next if ($f =~ /^$/);
1654 if ($f =~ /^\s*config\s/) {
1660 WARN
("CONFIG_DESCRIPTION",
1661 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_end && $length < 4);
1662 #print "is_end<$is_end> length<$length>\n";
1665 # check we are in a valid source file if not then ignore this hunk
1666 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
1669 if ($line =~ /^\+/ && $prevrawline !~ /\/\
*\
*/ &&
1670 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
1671 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
1672 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
1676 "line over 120 characters\n" . $herecurr);
1679 # check for spaces before a quoted newline
1680 if ($rawline =~ /^.*\".*\s\\n/) {
1681 WARN
("QUOTED_WHITESPACE_BEFORE_NEWLINE",
1682 "unnecessary whitespace before a quoted newline\n" . $herecurr);
1685 # check for adding lines without a newline.
1686 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1687 WARN
("MISSING_EOF_NEWLINE",
1688 "adding a line without newline at end of file\n" . $herecurr);
1691 # Blackfin: use hi/lo macros
1692 if ($realfile =~ m
@arch/blackfin/.*\
.S
$@
) {
1693 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
1694 my $herevet = "$here\n" . cat_vet
($line) . "\n";
1696 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
1698 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
1699 my $herevet = "$here\n" . cat_vet
($line) . "\n";
1701 "use the HI() macro, not (... >> 16)\n" . $herevet);
1705 # check we are in a valid source file C or perl if not then ignore this hunk
1706 next if ($realfile !~ /\.(h|c|pl)$/);
1708 # at the beginning of a line any tabs must come first and anything
1709 # more than 8 must use tabs.
1710 if ($rawline =~ /^\+\s* \t\s*\S/ ||
1711 $rawline =~ /^\+\s* \s*/) {
1712 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1713 ERROR
("CODE_INDENT",
1714 "code indent should use tabs where possible\n" . $herevet);
1718 # check for space before tabs.
1719 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
1720 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1721 WARN
("SPACE_BEFORE_TAB",
1722 "please, no space before tabs\n" . $herevet);
1725 # check for spaces at the beginning of a line.
1727 # 1) within comments
1728 # 2) indented preprocessor commands
1730 if ($rawline =~ /^\+ / && $line !~ /\+ *(?:$;|#|$Ident:)/) {
1731 my $herevet = "$here\n" . cat_vet
($rawline) . "\n";
1732 WARN
("LEADING_SPACE",
1733 "please, no spaces at the start of a line\n" . $herevet);
1736 # check we are in a valid C source file if not then ignore this hunk
1737 next if ($realfile !~ /\.(h|c)$/);
1739 # check for RCS/CVS revision markers
1740 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
1742 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
1745 # Blackfin: don't use __builtin_bfin_[cs]sync
1746 if ($line =~ /__builtin_bfin_csync/) {
1747 my $herevet = "$here\n" . cat_vet
($line) . "\n";
1749 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
1751 if ($line =~ /__builtin_bfin_ssync/) {
1752 my $herevet = "$here\n" . cat_vet
($line) . "\n";
1754 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
1757 # Check for potential 'bare' types
1758 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
1760 if ($realcnt && $line =~ /.\s*\S/) {
1761 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
1762 ctx_statement_block
($linenr, $realcnt, 0);
1763 $stat =~ s/\n./\n /g;
1764 $cond =~ s/\n./\n /g;
1766 # Find the real next line.
1767 $realline_next = $line_nr_next;
1768 if (defined $realline_next &&
1769 (!defined $lines[$realline_next - 1] ||
1770 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
1777 # Ignore goto labels.
1778 if ($s =~ /$Ident:\*$/s) {
1780 # Ignore functions being called
1781 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
1783 } elsif ($s =~ /^.\s*else\b/s) {
1785 # declarations always start with types
1786 } elsif ($prev_values eq 'E' && $s =~ /^.\s*(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?((?:\s*$Ident)+?)\b(?:\s+$Sparse)?\s*\**\s*(?:$Ident|\(\*[^\)]*\))(?:\s*$Modifier)?\s*(?:;|=|,|\()/s) {
1789 possible
($type, "A:" . $s);
1791 # definitions in global scope can only start with types
1792 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
1793 possible
($1, "B:" . $s);
1796 # any (foo ... *) is a pointer cast, and foo is a type
1797 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
1798 possible
($1, "C:" . $s);
1801 # Check for any sort of function declaration.
1802 # int foo(something bar, other baz);
1803 # void (*store_gdt)(x86_descr_ptr *);
1804 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
1805 my ($name_len) = length($1);
1808 substr($ctx, 0, $name_len + 1, '');
1809 $ctx =~ s/\)[^\)]*$//;
1811 for my $arg (split(/\s*,\s*/, $ctx)) {
1812 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
1814 possible
($1, "D:" . $s);
1822 # Checks which may be anchored in the context.
1825 # Check for switch () and associated case and default
1826 # statements should be at the same indent.
1827 # if ($line=~/\bswitch\s*\(.*\)/) {
1830 # my @ctx = ctx_block_outer($linenr, $realcnt);
1832 # for my $ctx (@ctx) {
1833 # my ($clen, $cindent) = line_stats($ctx);
1834 # if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
1835 # $indent != $cindent) {
1836 # $err .= "$sep$ctx\n";
1843 # ERROR("SWITCH_CASE_INDENT_LEVEL",
1844 # "switch and case should be at the same indent\n$hereline$err");
1848 # if/while/etc brace do not go on next line, unless defining a do while loop,
1849 # or if that brace on the next line is for something else
1850 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
1851 my $pre_ctx = "$1$2";
1853 my ($level, @ctx) = ctx_statement_level
($linenr, $realcnt, 0);
1854 my $ctx_cnt = $realcnt - $#ctx - 1;
1855 my $ctx = join("\n", @ctx);
1857 my $ctx_ln = $linenr;
1858 my $ctx_skip = $realcnt;
1860 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
1861 defined $lines[$ctx_ln - 1] &&
1862 $lines[$ctx_ln - 1] =~ /^-/)) {
1863 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
1864 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
1868 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
1869 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
1871 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
1873 "that open brace { should be on the previous line\n" .
1874 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
1876 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
1877 $ctx =~ /\)\s*\;\s*$/ &&
1878 defined $lines[$ctx_ln - 1])
1880 my ($nlength, $nindent) = line_stats
($lines[$ctx_ln - 1]);
1881 if ($nindent > $indent) {
1882 WARN
("TRAILING_SEMICOLON",
1883 "trailing semicolon indicates no statements, indent implies otherwise\n" .
1884 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
1889 # Check relative indent for conditionals and blocks.
1890 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
1891 my ($s, $c) = ($stat, $cond);
1893 substr($s, 0, length($c), '');
1895 # Make sure we remove the line prefixes as we have
1896 # none on the first line, and are going to readd them
1900 # Find out how long the conditional actually is.
1901 my @newlines = ($c =~ /\n/gs);
1902 my $cond_lines = 1 + $#newlines;
1904 # We want to check the first line inside the block
1905 # starting at the end of the conditional, so remove:
1906 # 1) any blank line termination
1907 # 2) any opening brace { on end of the line
1909 my $continuation = 0;
1911 $s =~ s/^.*\bdo\b//;
1913 if ($s =~ s/^\s*\\//) {
1916 if ($s =~ s/^\s*?\n//) {
1921 # Also ignore a loop construct at the end of a
1922 # preprocessor statement.
1923 if (($prevline =~ /^.\s*#\s*define\s/ ||
1924 $prevline =~ /\\\s*$/) && $continuation == 0) {
1930 while ($cond_ptr != $cond_lines) {
1931 $cond_ptr = $cond_lines;
1933 # If we see an #else/#elif then the code
1935 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
1940 # 1) blank lines, they should be at 0,
1941 # 2) preprocessor lines, and
1943 if ($continuation ||
1945 $s =~ /^\s*#\s*?/ ||
1946 $s =~ /^\s*$Ident\s*:/) {
1947 $continuation = ($s =~ /^.*?\\\n/) ?
1 : 0;
1948 if ($s =~ s/^.*?\n//) {
1954 my (undef, $sindent) = line_stats
("+" . $s);
1955 my $stat_real = raw_line
($linenr, $cond_lines);
1957 # Check if either of these lines are modified, else
1958 # this is not this patch's fault.
1959 if (!defined($stat_real) ||
1960 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
1963 if (defined($stat_real) && $cond_lines > 1) {
1964 $stat_real = "[...]\n$stat_real";
1967 #print "line<$line> prevline<$prevline> indent<$indent> sindent<$sindent> check<$check> continuation<$continuation> s<$s> cond_lines<$cond_lines> stat_real<$stat_real> stat<$stat>\n";
1969 if ($check && (($sindent % 4) != 0 ||
1970 ($sindent <= $indent && $s ne ''))) {
1971 WARN
("SUSPECT_CODE_INDENT",
1972 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
1976 # Track the 'values' across context and added lines.
1977 my $opline = $line; $opline =~ s/^./ /;
1978 my ($curr_values, $curr_vars) =
1979 annotate_values
($opline . "\n", $prev_values);
1980 $curr_values = $prev_values . $curr_values;
1982 my $outline = $opline; $outline =~ s/\t/ /g;
1983 print "$linenr > .$outline\n";
1984 print "$linenr > $curr_values\n";
1985 print "$linenr > $curr_vars\n";
1987 $prev_values = substr($curr_values, -1);
1989 #ignore lines not being added
1990 if ($line=~/^[^\+]/) {next;}
1992 # TEST: allow direct testing of the type matcher.
1994 if ($line =~ /^.\s*$Declare\s*$/) {
1996 "TEST: is type\n" . $herecurr);
1997 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
1998 ERROR
("TEST_NOT_TYPE",
1999 "TEST: is not type ($1 is)\n". $herecurr);
2003 # TEST: allow direct testing of the attribute matcher.
2005 if ($line =~ /^.\s*$Modifier\s*$/) {
2007 "TEST: is attr\n" . $herecurr);
2008 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2009 ERROR
("TEST_NOT_ATTR",
2010 "TEST: is not attr ($1 is)\n". $herecurr);
2015 # check for initialisation to aggregates open brace on the next line
2016 if ($line =~ /^.\s*{/ &&
2017 $prevline =~ /(?:^|[^=])=\s*$/) {
2019 "that open brace { should be on the previous line\n" . $hereprev);
2023 # Checks which are anchored on the added line.
2026 # check for malformed paths in #include statements (uses RAW line)
2027 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2029 if ($path =~ m{//}) {
2030 ERROR
("MALFORMED_INCLUDE",
2031 "malformed #include filename\n" .
2036 # no C99 // comments
2037 if ($line =~ m{//}) {
2038 ERROR
("C99_COMMENTS",
2039 "do not use C99 // comments\n" . $herecurr);
2041 # Remove C99 comments.
2043 $opline =~ s@
//.*@@
;
2045 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2046 # the whole statement.
2047 #print "APW <$lines[$realline_next - 1]>\n";
2048 if (defined $realline_next &&
2049 exists $lines[$realline_next - 1] &&
2050 !defined $suppress_export{$realline_next} &&
2051 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2052 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2053 # Handle definitions which produce identifiers with
2056 # EXPORT_SYMBOL(something_foo);
2058 if ($stat =~ /^.([A-Z_]+)\s*\(\s*($Ident)/ &&
2059 $name =~ /^${Ident}_$2/) {
2060 #print "FOO C name<$name>\n";
2061 $suppress_export{$realline_next} = 1;
2063 } elsif ($stat !~ /(?
:
2065 ^.DEFINE_
$Ident\
(\Q
$name\E\
)|
2066 ^.DECLARE_
$Ident\
(\Q
$name\E\
)|
2067 ^.LIST_HEAD\
(\Q
$name\E\
)|
2068 ^.(?
:$Storage\s
+)?
$Type\s
*\
(\s
*\
*\s
*\Q
$name\E\s
*\
)\s
*\
(|
2069 \b\Q
$name\E
(?
:\s
+$Attribute)*\s
*(?
:;|=|\
[|\
()
2071 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2072 $suppress_export{$realline_next} = 2;
2074 $suppress_export{$realline_next} = 1;
2077 if (!defined $suppress_export{$linenr} &&
2078 $prevline =~ /^.\s*$/ &&
2079 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2080 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2081 #print "FOO B <$lines[$linenr - 1]>\n";
2082 $suppress_export{$linenr} = 2;
2084 if (defined $suppress_export{$linenr} &&
2085 $suppress_export{$linenr} == 2) {
2086 WARN
("EXPORT_SYMBOL",
2087 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2090 # check for global initialisers.
2091 if ($line =~ /^.$Type\s*$Ident\s*(?:\s+$Modifier)*\s*=\s*(0|NULL|false)\s*;/) {
2092 ERROR
("GLOBAL_INITIALISERS",
2093 "do not initialise globals to 0 or NULL\n" .
2096 # check for static initialisers.
2097 if ($line =~ /\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2098 ERROR
("INITIALISED_STATIC",
2099 "do not initialise statics to 0 or NULL\n" .
2103 # check for static const char * arrays.
2104 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2105 WARN
("STATIC_CONST_CHAR_ARRAY",
2106 "static const char * array should probably be static const char * const\n" .
2110 # check for static char foo[] = "bar" declarations.
2111 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2112 WARN
("STATIC_CONST_CHAR_ARRAY",
2113 "static char array declaration should probably be static const char\n" .
2117 # check for declarations of struct pci_device_id
2118 if ($line =~ /\bstruct\s+pci_device_id\s+\w+\s*\[\s*\]\s*\=\s*\{/) {
2119 WARN
("DEFINE_PCI_DEVICE_TABLE",
2120 "Use DEFINE_PCI_DEVICE_TABLE for struct pci_device_id\n" . $herecurr);
2123 # check for new typedefs, only function parameters and sparse annotations
2125 # if ($line =~ /\btypedef\s/ &&
2126 # $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2127 # $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2128 # $line !~ /\b$typeTypedefs\b/ &&
2129 # $line !~ /\b__bitwise(?:__|)\b/) {
2130 # WARN("NEW_TYPEDEFS",
2131 # "do not add new typedefs\n" . $herecurr);
2134 # * goes on variable not on type
2136 if ($line =~ m{\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\)}) {
2137 my ($from, $to) = ($1, $1);
2139 # Should start with a space.
2140 $to =~ s/^(\S)/ $1/;
2141 # Should not end with a space.
2143 # '*'s should not have spaces between.
2144 while ($to =~ s/\*\s+\*/\*\*/) {
2147 #print "from<$from> to<$to>\n";
2149 ERROR
("POINTER_LOCATION",
2150 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr);
2152 } elsif ($line =~ m{\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident)}) {
2153 my ($from, $to, $ident) = ($1, $1, $2);
2155 # Should start with a space.
2156 $to =~ s/^(\S)/ $1/;
2157 # Should not end with a space.
2159 # '*'s should not have spaces between.
2160 while ($to =~ s/\*\s+\*/\*\*/) {
2162 # Modifiers should have spaces.
2163 $to =~ s/(\b$Modifier$)/$1 /;
2165 #print "from<$from> to<$to> ident<$ident>\n";
2166 if ($from ne $to && $ident !~ /^$Modifier$/) {
2167 ERROR
("POINTER_LOCATION",
2168 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr);
2172 # # no BUG() or BUG_ON()
2173 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2174 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2175 # print "$herecurr";
2179 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2180 WARN
("LINUX_VERSION_CODE",
2181 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2184 # check for uses of printk_ratelimit
2185 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2186 WARN
("PRINTK_RATELIMITED",
2187 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2190 # printk should use KERN_* levels. Note that follow on printk's on the
2191 # same line do not need a level, so we use the current block context
2192 # to try and find and validate the current printk. In summary the current
2193 # printk includes all preceding printk's which have no newline on the end.
2194 # we assume the first bad printk is the one to report.
2195 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2197 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2198 #print "CHECK<$lines[$ln - 1]\n";
2199 # we have a preceding printk if it ends
2200 # with "\n" ignore it, else it is to blame
2201 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2202 if ($rawlines[$ln - 1] !~ m{\\n"}) {
2209 WARN
("PRINTK_WITHOUT_KERN_LEVEL",
2210 "printk() should include KERN_ facility level\n" . $herecurr);
2214 # function brace can't be on same line, except for #defines of do while,
2215 # or if closed on same line
2216 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2217 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2219 "open brace '{' following function declarations go on the next line\n" . $herecurr);
2222 # open braces for enum, union and struct go on the same line.
2223 if ($line =~ /^.\s*{/ &&
2224 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2226 "open brace '{' following $1 go on the same line\n" . $hereprev);
2229 # missing space after union, struct or enum definition
2230 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?(?:\s+$Ident)?[=\{]/) {
2232 "missing space after $1 definition\n" . $herecurr);
2235 # check for spacing round square brackets; allowed:
2236 # 1. with a type on the left -- int [] a;
2237 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2238 # 3. inside a curly brace -- = { [0...10] = 5 }
2239 while ($line =~ /(.*?\s)\[/g) {
2240 my ($where, $prefix) = ($-[1], $1);
2241 if ($prefix !~ /$Type\s+$/ &&
2242 ($where != 0 || $prefix !~ /^.\s+$/) &&
2243 $prefix !~ /{\s+$/) {
2244 ERROR
("BRACKET_SPACE",
2245 "space prohibited before open square bracket '['\n" . $herecurr);
2249 # check for spaces between functions and their parentheses.
2250 while ($line =~ /($Ident)\s+\(/g) {
2252 my $ctx_before = substr($line, 0, $-[1]);
2253 my $ctx = "$ctx_before$name";
2255 # Ignore those directives where spaces _are_ permitted.
2257 if|for|while|switch
|return|case
|
2258 volatile
|__volatile__
|
2259 __attribute__
|format
|__extension__
|
2263 # cpp #define statements have non-optional spaces, ie
2264 # if there is a space between the name and the open
2265 # parenthesis it is simply not a parameter group.
2266 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
2268 # cpp #elif statement condition may start with a (
2269 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
2271 # If this whole things ends with a type its most
2272 # likely a typedef for a function.
2273 } elsif ($ctx =~ /$Type$/) {
2277 "space prohibited between function name and open parenthesis '('\n" . $herecurr);
2280 # Check operator spacing.
2281 if (!($line=~/\#\s*include/)) {
2283 <<=|>>=|<=|>=|==|!=|
2284 \
+=|-=|\
*=|\
/=|%=|\
^=|\
|=|&=|
2285 =>|->|<<|>>|<|>|=|!|~|
2286 &&|\
|\
||,|\
^|\
+\
+|--|&|\
||\
+|-|\
*|\
/|%|
2289 my @elements = split(/($ops|;)/, $opline);
2292 my $blank = copy_spacing
($opline);
2294 for (my $n = 0; $n < $#elements; $n += 2) {
2295 $off += length($elements[$n]);
2297 # Pick up the preceding and succeeding characters.
2298 my $ca = substr($opline, 0, $off);
2300 if (length($opline) >= ($off + length($elements[$n + 1]))) {
2301 $cc = substr($opline, $off + length($elements[$n + 1]));
2303 my $cb = "$ca$;$cc";
2306 $a = 'V' if ($elements[$n] ne '');
2307 $a = 'W' if ($elements[$n] =~ /\s$/);
2308 $a = 'C' if ($elements[$n] =~ /$;$/);
2309 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
2310 $a = 'O' if ($elements[$n] eq '');
2311 $a = 'E' if ($ca =~ /^\s*$/);
2313 my $op = $elements[$n + 1];
2316 if (defined $elements[$n + 2]) {
2317 $c = 'V' if ($elements[$n + 2] ne '');
2318 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
2319 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
2320 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
2321 $c = 'O' if ($elements[$n + 2] eq '');
2322 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
2327 my $ctx = "${a}x${c}";
2329 my $at = "(ctx:$ctx)";
2331 my $ptr = substr($blank, 0, $off) . "^";
2332 my $hereptr = "$hereline$ptr\n";
2334 # Pull out the value of this operator.
2335 my $op_type = substr($curr_values, $off + 1, 1);
2337 # Get the full operator variant.
2338 my $opv = $op . substr($curr_vars, $off, 1);
2340 # Ignore operators passed as parameters.
2341 if ($op_type ne 'V' &&
2342 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
2345 # } elsif ($op =~ /^$;+$/) {
2347 # ; should have either the end of line or a space or \ after it
2348 } elsif ($op eq ';') {
2349 if ($ctx !~ /.x[WEBC]/ &&
2350 $cc !~ /^\\/ && $cc !~ /^;/) {
2352 "space required after that '$op' $at\n" . $hereptr);
2356 } elsif ($op eq '//') {
2360 # : when part of a bitfield
2361 } elsif ($op eq '->' || $opv eq ':B') {
2362 if ($ctx =~ /Wx.|.xW/) {
2364 "spaces prohibited around that '$op' $at\n" . $hereptr);
2367 # , must have a space on the right.
2368 } elsif ($op eq ',') {
2369 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
2371 "space required after that '$op' $at\n" . $hereptr);
2374 # '*' as part of a type definition -- reported already.
2375 } elsif ($opv eq '*_') {
2376 #warn "'*' is part of type\n";
2378 # unary operators should have a space before and
2379 # none after. May be left adjacent to another
2380 # unary operator, or a cast
2381 } elsif ($op eq '!' || $op eq '~' ||
2382 $opv eq '*U' || $opv eq '-U' ||
2383 $opv eq '&U' || $opv eq '&&U') {
2384 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
2386 "space required before that '$op' $at\n" . $hereptr);
2388 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
2389 # A unary '*' may be const
2391 } elsif ($ctx =~ /.xW/) {
2393 "space prohibited after that '$op' $at\n" . $hereptr);
2396 # unary ++ and unary -- are allowed no space on one side.
2397 } elsif ($op eq '++' or $op eq '--') {
2398 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
2400 "space required one side of that '$op' $at\n" . $hereptr);
2402 if ($ctx =~ /Wx[BE]/ ||
2403 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
2405 "space prohibited before that '$op' $at\n" . $hereptr);
2407 if ($ctx =~ /ExW/) {
2409 "space prohibited after that '$op' $at\n" . $hereptr);
2413 # << and >> may either have or not have spaces both sides
2414 } elsif ($op eq '<<' or $op eq '>>' or
2415 $op eq '&' or $op eq '^' or $op eq '|' or
2416 $op eq '+' or $op eq '-' or
2417 $op eq '*' or $op eq '/' or
2420 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
2422 "need consistent spacing around '$op' $at\n" .
2426 # A colon needs no spaces before when it is
2427 # terminating a case value or a label.
2428 } elsif ($opv eq ':C' || $opv eq ':L') {
2429 if ($ctx =~ /Wx./) {
2431 "space prohibited before that '$op' $at\n" . $hereptr);
2434 # All the others need spaces both sides.
2435 } elsif ($ctx !~ /[EWC]x[CWE]/) {
2438 # Ignore email addresses <foo@bar>
2440 $cc =~ /^\S+\@\S+>/) ||
2442 $ca =~ /<\S+\@\S+$/))
2448 if (($opv eq ':O' && $ca =~ /\?$/) ||
2449 ($op eq '?' && $cc =~ /^:/)) {
2455 "spaces required around that '$op' $at\n" . $hereptr);
2458 $off += length($elements[$n + 1]);
2462 # check for multiple assignments
2463 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
2464 CHK
("MULTIPLE_ASSIGNMENTS",
2465 "multiple assignments should be avoided\n" . $herecurr);
2468 ## # check for multiple declarations, allowing for a function declaration
2470 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
2471 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
2473 ## # Remove any bracketed sections to ensure we do not
2474 ## # falsly report the parameters of functions.
2476 ## while ($ln =~ s/\([^\(\)]*\)//g) {
2478 ## if ($ln =~ /,/) {
2479 ## WARN("MULTIPLE_DECLARATION",
2480 ## "declaring multiple variables together should be avoided\n" . $herecurr);
2484 #need space before brace following if, while, etc
2485 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
2488 "space required before the open brace '{'\n" . $herecurr);
2491 # closing brace should have a space following it when it has anything
2493 if ($line =~ /}(?!(?:,|;|\)))\S/) {
2495 "space required after that close brace '}'\n" . $herecurr);
2498 # check spacing on square brackets
2499 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
2501 "space prohibited after that open square bracket '['\n" . $herecurr);
2503 if ($line =~ /\s\]/) {
2505 "space prohibited before that close square bracket ']'\n" . $herecurr);
2508 # check spacing on parentheses
2509 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
2510 $line !~ /for\s*\(\s+;/) {
2512 "space prohibited after that open parenthesis '('\n" . $herecurr);
2514 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
2515 $line !~ /for\s*\(.*;\s+\)/ &&
2516 $line !~ /:\s+\)/) {
2518 "space prohibited before that close parenthesis ')'\n" . $herecurr);
2521 #goto labels aren't indented, allow a single space however
2522 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
2523 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
2524 WARN
("INDENTED_LABEL",
2525 "labels should not be indented\n" . $herecurr);
2528 # Return is not a function.
2529 if (defined($stat) && $stat =~ /^.\s*return(\s*)(\(.*);/s) {
2533 # Flatten any parentheses
2534 $value =~ s/\(/ \(/g;
2535 $value =~ s/\)/\) /g;
2536 while ($value =~ s/\[[^\{\}]*\]/1/ ||
2537 $value !~ /(?
:$Ident|-?
$Constant)\s
*
2539 (?
:$Ident|-?
$Constant)/x
&&
2540 $value =~ s/\([^\(\)]*\)/1/) {
2542 #print "value<$value>\n";
2543 if ($value =~ /^\s*(?:$Ident|-?$Constant)\s*$/) {
2544 ERROR
("RETURN_PARENTHESES",
2545 "return is not a function, parentheses are not required\n" . $herecurr);
2547 } elsif ($spacing !~ /\s+/) {
2549 "space required before the open parenthesis '('\n" . $herecurr);
2552 # Return of what appears to be an errno should normally be -'ve
2553 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
2555 if ($name ne 'EOF' && $name ne 'ERROR') {
2556 WARN
("USE_NEGATIVE_ERRNO",
2557 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
2561 # typecasts on min/max could be min_t/max_t
2562 if ($line =~ /^\+(?:.*?)\b(min|max)\s*\($Typecast{0,1}($LvalOrFunc)\s*,\s*$Typecast{0,1}($LvalOrFunc)\s*\)/) {
2563 if (defined $2 || defined $8) {
2565 my $cast1 = deparenthesize
($2);
2567 my $cast2 = deparenthesize
($8);
2571 if ($cast1 ne "" && $cast2 ne "") {
2572 $cast = "$cast1 or $cast2";
2573 } elsif ($cast1 ne "") {
2579 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . $herecurr);
2583 # Need a space before open parenthesis after if, while etc
2584 if ($line=~/\b(if|while|for|switch)\(/) {
2585 ERROR
("SPACING", "space required before the open parenthesis '('\n" . $herecurr);
2588 # Check for illegal assignment in if conditional -- and check for trailing
2589 # statements after the conditional.
2590 if ($line =~ /do\s*(?!{)/) {
2591 my ($stat_next) = ctx_statement_block
($line_nr_next,
2592 $remain_next, $off_next);
2593 $stat_next =~ s/\n./\n /g;
2594 ##print "stat<$stat> stat_next<$stat_next>\n";
2596 if ($stat_next =~ /^\s*while\b/) {
2597 # If the statement carries leading newlines,
2598 # then count those as offsets.
2600 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
2602 statement_rawlines
($whitespace) - 1;
2604 $suppress_whiletrailers{$line_nr_next +
2608 if (!defined $suppress_whiletrailers{$linenr} &&
2609 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
2610 my ($s, $c) = ($stat, $cond);
2612 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
2613 ERROR
("ASSIGN_IN_IF",
2614 "do not use assignment in if condition\n" . $herecurr);
2617 # Find out what is on the end of the line after the
2619 substr($s, 0, length($c), '');
2621 $s =~ s/$;//g; # Remove any comments
2622 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
2623 $c !~ /}\s*while\s*/)
2625 # Find out how long the conditional actually is.
2626 my @newlines = ($c =~ /\n/gs);
2627 my $cond_lines = 1 + $#newlines;
2630 $stat_real = raw_line
($linenr, $cond_lines)
2631 . "\n" if ($cond_lines);
2632 if (defined($stat_real) && $cond_lines > 1) {
2633 $stat_real = "[...]\n$stat_real";
2636 ERROR
("TRAILING_STATEMENTS",
2637 "trailing statements should be on next line\n" . $herecurr . $stat_real);
2641 # Check for bitwise tests written as boolean
2653 WARN
("HEXADECIMAL_BOOLEAN_TEST",
2654 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
2657 # if and else should not have general statements after it
2658 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
2660 $s =~ s/$;//g; # Remove any comments
2661 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
2662 ERROR
("TRAILING_STATEMENTS",
2663 "trailing statements should be on next line\n" . $herecurr);
2666 # if should not continue a brace
2667 if ($line =~ /}\s*if\b/) {
2668 ERROR
("TRAILING_STATEMENTS",
2669 "trailing statements should be on next line\n" .
2672 # case and default should not have general statements after them
2673 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
2675 (?
:\s
*$;*)(?
:\s
*{)?
(?
:\s
*$;*)(?
:\s
*\\)?\s
*$|
2679 ERROR
("TRAILING_STATEMENTS",
2680 "trailing statements should be on next line\n" . $herecurr);
2683 # Check for }<nl>else {, these must be at the same
2684 # indent level to be relevant to each other.
2685 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
2686 $previndent == $indent) {
2687 ERROR
("ELSE_AFTER_BRACE",
2688 "else should follow close brace '}'\n" . $hereprev);
2691 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
2692 $previndent == $indent) {
2693 my ($s, $c) = ctx_statement_block
($linenr, $realcnt, 0);
2695 # Find out what is on the end of the line after the
2697 substr($s, 0, length($c), '');
2700 if ($s =~ /^\s*;/) {
2701 ERROR
("WHILE_AFTER_BRACE",
2702 "while should follow close brace '}'\n" . $hereprev);
2706 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
2707 # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
2708 # print "No studly caps, use _\n";
2709 # print "$herecurr";
2713 #no spaces allowed after \ in define
2714 if ($line=~/\#\s*define.*\\\s$/) {
2715 WARN
("WHITESPACE_AFTER_LINE_CONTINUATION",
2716 "Whitepspace after \\ makes next lines useless\n" . $herecurr);
2719 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
2720 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
2722 my $checkfile = "include/linux/$file";
2723 if (-f
"$root/$checkfile" &&
2724 $realfile ne $checkfile &&
2725 $1 !~ /$allowed_asm_includes/)
2727 if ($realfile =~ m{^arch/}) {
2728 CHK
("ARCH_INCLUDE_LINUX",
2729 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2731 WARN
("INCLUDE_LINUX",
2732 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
2737 # multi-statement macros should be enclosed in a do while loop, grab the
2738 # first statement and ensure its the whole macro if its not enclosed
2739 # in a known good container
2740 if ($realfile !~ m@
/vmlinux
.lds
.h
$@
&&
2741 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
2744 my ($off, $dstat, $dcond, $rest);
2747 my $args = defined($1);
2749 # Find the end of the macro and limit our statement
2751 while ($cnt > 0 && defined $lines[$ln - 1] &&
2752 $lines[$ln - 1] =~ /^(?:-|..*\\$)/)
2754 $ctx .= $rawlines[$ln - 1] . "\n";
2755 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2758 $ctx .= $rawlines[$ln - 1];
2760 ($dstat, $dcond, $ln, $cnt, $off) =
2761 ctx_statement_block
($linenr, $ln - $linenr + 1, 0);
2762 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
2763 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
2765 # Extract the remainder of the define (if any) and
2766 # rip off surrounding spaces, and trailing \'s.
2768 while ($off != 0 || ($cnt > 0 && $rest =~ /\\\s*$/)) {
2769 #print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";
2770 if ($off != 0 || $lines[$ln - 1] !~ /^-/) {
2771 $rest .= substr($lines[$ln - 1], $off) . "\n";
2777 $rest =~ s/\\\n.//g;
2781 # Clean up the original statement.
2783 substr($dstat, 0, length($dcond), '');
2785 $dstat =~ s/^.\s*\#\s*define\s+$Ident\s*//;
2788 $dstat =~ s/\\\n.//g;
2789 $dstat =~ s/^\s*//s;
2790 $dstat =~ s/\s*$//s;
2792 # Flatten any parentheses and braces
2793 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
2794 $dstat =~ s/\{[^\{\}]*\}/1/ ||
2795 $dstat =~ s/\[[^\{\}]*\]/1/)
2799 my $exceptions = qr{
2811 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
2812 if ($rest ne '' && $rest ne ',') {
2813 if ($rest !~ /while\s*\(/ &&
2814 $dstat !~ /$exceptions/)
2816 ERROR
("MULTISTATEMENT_MACRO_USE_DO_WHILE",
2817 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
2820 } elsif ($ctx !~ /;/) {
2822 $dstat !~ /^(?:$Ident|-?$Constant)$/ &&
2823 $dstat !~ /$exceptions/ &&
2824 $dstat !~ /^\.$Ident\s*=/ &&
2825 $dstat =~ /$Operators/)
2827 ERROR
("COMPLEX_MACRO",
2828 "Macros with complex values should be enclosed in parenthesis\n" . "$here\n$ctx\n");
2833 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
2834 # all assignments may have only one of the following with an assignment:
2837 # VMLINUX_SYMBOL(...)
2838 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
2839 WARN
("MISSING_VMLINUX_SYMBOL",
2840 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
2843 # check for redundant bracing round if etc
2844 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
2845 my ($level, $endln, @chunks) =
2846 ctx_statement_full
($linenr, $realcnt, 1);
2847 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
2848 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
2849 if ($#chunks > 0 && $level == 0) {
2852 my $herectx = $here . "\n";
2853 my $ln = $linenr - 1;
2854 for my $chunk (@chunks) {
2855 my ($cond, $block) = @
{$chunk};
2857 # If the condition carries leading newlines, then count those as offsets.
2858 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
2859 my $offset = statement_rawlines
($whitespace) - 1;
2861 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
2863 # We have looked at and allowed this specific line.
2864 $suppress_ifbraces{$ln + $offset} = 1;
2866 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
2867 $ln += statement_rawlines
($block) - 1;
2869 substr($block, 0, length($cond), '');
2871 $seen++ if ($block =~ /^\s*{/);
2873 #print "cond<$cond> block<$block> allowed<$allowed>\n";
2874 if (statement_lines
($cond) > 1) {
2875 #print "APW: ALLOWED: cond<$cond>\n";
2878 if ($block =~/\b(?:if|for|while)\b/) {
2879 #print "APW: ALLOWED: block<$block>\n";
2882 if (statement_block_size
($block) > 1) {
2883 #print "APW: ALLOWED: lines block<$block>\n";
2887 if ($seen && !$allowed) {
2889 "braces {} are not necessary for any arm of this statement\n" . $herectx);
2893 if (!defined $suppress_ifbraces{$linenr - 1} &&
2894 $line =~ /\b(if|while|for|else)\b/) {
2897 # Check the pre-context.
2898 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
2899 #print "APW: ALLOWED: pre<$1>\n";
2903 my ($level, $endln, @chunks) =
2904 ctx_statement_full
($linenr, $realcnt, $-[0]);
2906 # Check the condition.
2907 my ($cond, $block) = @
{$chunks[0]};
2908 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
2909 if (defined $cond) {
2910 substr($block, 0, length($cond), '');
2912 if (statement_lines
($cond) > 1) {
2913 #print "APW: ALLOWED: cond<$cond>\n";
2916 if ($block =~/\b(?:if|for|while)\b/) {
2917 #print "APW: ALLOWED: block<$block>\n";
2920 if (statement_block_size
($block) > 1) {
2921 #print "APW: ALLOWED: lines block<$block>\n";
2924 # Check the post-context.
2925 if (defined $chunks[1]) {
2926 my ($cond, $block) = @
{$chunks[1]};
2927 if (defined $cond) {
2928 substr($block, 0, length($cond), '');
2930 if ($block =~ /^\s*\{/) {
2931 #print "APW: ALLOWED: chunk-1 block<$block>\n";
2935 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
2936 my $herectx = $here . "\n";
2937 my $cnt = statement_rawlines
($block);
2939 for (my $n = 0; $n < $cnt; $n++) {
2940 $herectx .= raw_line
($linenr, $n) . "\n";
2944 "braces {} are not necessary for single statement blocks\n" . $herectx);
2948 # don't include deprecated include files (uses RAW line)
2949 for my $inc (@dep_includes) {
2950 if ($rawline =~ m@
^.\s
*\#\s
*include\s
*\
<$inc>@
) {
2951 ERROR
("DEPRECATED_INCLUDE",
2952 "Don't use <$inc>: see Documentation/feature-removal-schedule.txt\n" . $herecurr);
2956 # don't use deprecated functions
2957 for my $func (@dep_functions) {
2958 if ($line =~ /\b$func\b/) {
2959 ERROR
("DEPRECATED_FUNCTION",
2960 "Don't use $func(): see Documentation/feature-removal-schedule.txt\n" . $herecurr);
2964 # no volatiles please
2965 # my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
2966 # if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
2968 # "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
2972 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
2973 CHK
("REDUNDANT_CODE",
2974 "if this code is redundant consider removing it\n" .
2978 # check for needless kfree() checks
2979 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
2981 if ($line =~ /\bkfree\(\Q$expr\E\);/) {
2982 WARN
("NEEDLESS_KFREE",
2983 "kfree(NULL) is safe this check is probably not required\n" . $hereprev);
2986 # check for needless usb_free_urb() checks
2987 if ($prevline =~ /\bif\s*\(([^\)]*)\)/) {
2989 if ($line =~ /\busb_free_urb\(\Q$expr\E\);/) {
2990 WARN
("NEEDLESS_USB_FREE_URB",
2991 "usb_free_urb(NULL) is safe this check is probably not required\n" . $hereprev);
2995 # prefer usleep_range over udelay
2996 if ($line =~ /\budelay\s*\(\s*(\w+)\s*\)/) {
2997 # ignore udelay's < 10, however
2998 if (! (($1 =~ /(\d+)/) && ($1 < 10)) ) {
3000 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);
3004 # warn about unexpectedly long msleep's
3005 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
3008 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3012 # warn about #ifdefs in C files
3013 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3014 # print "#ifdef in C files should be avoided\n";
3015 # print "$herecurr";
3019 # warn about spacing in #ifdefs
3020 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
3022 "exactly one space required after that #$1\n" . $herecurr);
3025 # check for spinlock_t definitions without a comment.
3026 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
3027 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
3029 if (!ctx_has_comment
($first_line, $linenr)) {
3030 CHK
("UNCOMMENTED_DEFINITION",
3031 "$1 definition without comment\n" . $herecurr);
3034 # check for memory barriers without a comment.
3035 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3036 if (!ctx_has_comment
($first_line, $linenr)) {
3037 CHK
("MEMORY_BARRIER",
3038 "memory barrier without comment\n" . $herecurr);
3041 # check of hardware specific defines
3042 if ($line =~ m@
^.\s
*\#\s
*if.*\b(__i386__
|__powerpc64__
|__sun__
|__s390x__
)\b@
&& $realfile !~ m
@include/asm
-@
) {
3044 "architecture specific defines should be avoided\n" . $herecurr);
3047 # Check that the storage class is at the beginning of a declaration
3048 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
3049 WARN
("STORAGE_CLASS",
3050 "storage class should be at the beginning of the declaration\n" . $herecurr)
3053 # check the location of the inline attribute, that it is between
3054 # storage class and type.
3055 if ($line =~ /\b$Type\s+$Inline\b/ ||
3056 $line =~ /\b$Inline\s+$Storage\b/) {
3057 ERROR
("INLINE_LOCATION",
3058 "inline keyword should sit between storage class and type\n" . $herecurr);
3061 # Check for __inline__ and __inline, prefer inline
3062 if ($line =~ /\b(__inline__|__inline)\b/) {
3064 "plain inline is preferred over $1\n" . $herecurr);
3067 # Check for __attribute__ packed, prefer __packed
3068 # if ($line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
3069 # WARN("PREFER_PACKED",
3070 # "__packed is preferred over __attribute__((packed))\n" . $herecurr);
3073 # Check for __attribute__ aligned, prefer __aligned
3074 # if ($line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
3075 # WARN("PREFER_ALIGNED",
3076 # "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
3079 # check for sizeof(&)
3080 if ($line =~ /\bsizeof\s*\(\s*\&/) {
3081 WARN
("SIZEOF_ADDRESS",
3082 "sizeof(& should be avoided\n" . $herecurr);
3085 # check for line continuations in quoted strings with odd counts of "
3086 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
3087 WARN
("LINE_CONTINUATIONS",
3088 "Avoid line continuations in quoted strings\n" . $herecurr);
3091 # check for new externs in .c files.
3092 # if ($realfile =~ /\.c$/ && defined $stat &&
3093 # $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
3095 # my $function_name = $1;
3096 # my $paren_space = $2;
3099 # if (defined $cond) {
3100 # substr($s, 0, length($cond), '');
3102 # if ($s =~ /^\s*;/ &&
3103 # $function_name ne 'uninitialized_var')
3105 # WARN("AVOID_EXTERNS",
3106 # "externs should be avoided in .c files\n" . $herecurr);
3109 # if ($paren_space =~ /\n/) {
3110 # WARN("FUNCTION_ARGUMENTS",
3111 # "arguments for function declarations should follow identifier\n" . $herecurr);
3114 # } elsif ($realfile =~ /\.c$/ && defined $stat &&
3115 # $stat =~ /^.\s*extern\s+/)
3117 # WARN("AVOID_EXTERNS",
3118 # "externs should be avoided in .c files\n" . $herecurr);
3121 # checks for new __setup's
3122 if ($rawline =~ /\b__setup\("([^"]*)"/) {
3125 if (!grep(/$name/, @setup_docs)) {
3126 CHK
("UNDOCUMENTED_SETUP",
3127 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
3131 # check for pointless casting of kmalloc return
3132 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
3133 WARN
("UNNECESSARY_CASTS",
3134 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
3137 # check for multiple semicolons
3138 if ($line =~ /;\s*;\s*$/) {
3139 WARN
("ONE_SEMICOLON",
3140 "Statements terminations use 1 semicolon\n" . $herecurr);
3143 # check for gcc specific __FUNCTION__
3144 if ($line =~ /__FUNCTION__/) {
3146 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr);
3149 # check for semaphores initialized locked
3150 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
3151 WARN
("CONSIDER_COMPLETION",
3152 "consider using a completion\n" . $herecurr);
3155 # recommend kstrto* over simple_strto*
3156 if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
3157 WARN
("CONSIDER_KSTRTO",
3158 "consider using kstrto* in preference to simple_$1\n" . $herecurr);
3160 # check for __initcall(), use device_initcall() explicitly please
3161 if ($line =~ /^.\s*__initcall\s*\(/) {
3162 WARN
("USE_DEVICE_INITCALL",
3163 "please use device_initcall() instead of __initcall()\n" . $herecurr);
3165 # check for various ops structs, ensure they are const.
3166 my $struct_ops = qr{acpi_dock_ops
|
3167 address_space_operations
|
3169 block_device_operations
|
3174 file_lock_operations
|
3184 lock_manager_operations
|
3190 pipe_buf_operations
|
3191 platform_hibernation_ops
|
3192 platform_suspend_ops
|
3197 soc_pcmcia_socket_ops
|
3203 if ($line !~ /\bconst\b/ &&
3204 $line =~ /\bstruct\s+($struct_ops)\b/) {
3205 WARN
("CONST_STRUCT",
3206 "struct $1 should normally be const\n" .
3210 # use of NR_CPUS is usually wrong
3211 # ignore definitions of NR_CPUS and usage to define arrays as likely right
3212 if ($line =~ /\bNR_CPUS\b/ &&
3213 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
3214 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
3215 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
3216 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
3217 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
3220 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
3223 # check for %L{u,d,i} in strings
3225 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
3226 $string = substr($rawline, $-[1], $+[1] - $-[1]);
3227 $string =~ s/%%/__/g;
3228 if ($string =~ /(?<!%)%L[udi]/) {
3230 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
3235 # whine mightly about in_atomic
3236 if ($line =~ /\bin_atomic\s*\(/) {
3237 if ($realfile =~ m@
^drivers
/@
) {
3239 "do not use in_atomic in drivers\n" . $herecurr);
3240 } elsif ($realfile !~ m@
^kernel
/@
) {
3242 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
3246 # check for lockdep_set_novalidate_class
3247 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
3248 $line =~ /__lockdep_no_validate__\s*\)/ ) {
3249 if ($realfile !~ m@
^kernel
/lockdep@
&&
3250 $realfile !~ m@
^include
/linux/lockdep@
&&
3251 $realfile !~ m@
^drivers
/base/core@
) {
3253 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
3257 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
3258 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
3259 WARN
("EXPORTED_WORLD_WRITABLE",
3260 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
3263 # Check for memset with swapped arguments
3264 if ($line =~ /memset.*\,(\ |)(0x|)0(\ |0|)\);/) {
3266 "memset size is 3rd argument, not the second.\n" . $herecurr);
3270 # If we have no input at all, then there is nothing to report on
3271 # so just keep quiet.
3272 if ($#rawlines == -1) {
3276 # In mailback mode only produce a report in the negative, for
3277 # things that appear to be patches.
3278 if ($mailback && ($clean == 1 || !$is_patch)) {
3282 # This is not a patch, and we are are in 'no-patch' mode so
3284 if (!$chk_patch && !$is_patch) {
3289 ERROR
("NOT_UNIFIED_DIFF",
3290 "Does not appear to be a unified-diff format patch\n");
3292 if ($is_patch && $chk_signoff && $signoff == 0) {
3293 ERROR
("MISSING_SIGN_OFF",
3294 "Missing Signed-off-by: line(s)\n");
3297 print report_dump
();
3298 if ($summary && !($clean == 1 && $quiet == 1)) {
3299 print "$filename " if ($summary_file);
3300 print "total: $cnt_error errors, $cnt_warn warnings, " .
3301 (($check)?
"$cnt_chk checks, " : "") .
3302 "$cnt_lines lines checked\n";
3303 print "\n" if ($quiet == 0);
3307 # If there were whitespace errors which cleanpatch can fix
3308 # then suggest that.
3309 if ($rpt_cleaners) {
3310 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
3311 print " scripts/cleanfile\n\n";
3316 if (keys %ignore_type) {
3317 print "NOTE: Ignored message types:";
3318 foreach my $ignore (sort keys %ignore_type) {
3322 print "\n" if ($quiet == 0);
3325 if ($clean == 1 && $quiet == 0) {
3326 print "$vname has no obvious style problems and is ready for submission.\n"
3328 if ($clean == 0 && $quiet == 0) {
3330 $vname has style problems
, please review
.
3332 If any of these errors are false positives
, please report
3333 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)