| blob | ca05ba217f5fd4038bcc511adff8a5b95823fb3e |
1 #!/usr/bin/perl -w
2 # (c) 2001, Dave Jones. (the file handling bit)
3 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
5 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
6 # Licensed under the terms of the GNU GPL License version 2
44 Options:
49 --emacs emacs compile window format
50 --terse one line per report
61 is all off)
63 literally
67 EOM
70 }
92 }
93 }
96 }
98 GetOptions(
128 }
141 }
148 ## no critic
151 }
158 }
164 }
171 }
172 }
177 }
178 }
188 __user|
189 __kernel|
190 __force|
191 __iomem|
192 __must_check|
193 __init_refok|
194 __kprobes|
195 __ref|
196 __rcu
199 # Notes to $Attribute:
200 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
202 const|
203 __percpu|
204 __nocast|
205 __safe|
206 __bitwise__|
207 __packed__|
208 __packed2__|
209 __naked|
210 __maybe_unused|
211 __always_unused|
212 __noreturn|
213 __used|
214 __cold|
215 __noclone|
216 __deprecated|
217 __read_mostly|
218 __kprobes|
220 ____cacheline_aligned|
221 ____cacheline_aligned_in_smp|
222 ____cacheline_internodealigned_in_smp|
223 __weak
234 <=|>=|==|!=|
235 =>|->|<<|>>|<|>|!|~|
260 atomic_t
261 )};
265 [a-z0-9]+_(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
267 panic|
269 )};
277 To:|
278 Cc:
279 )};
300 );
303 );
306 irq|
307 memory
308 )};
309 # memory.h: ARM has a custom one
321 )
325 $NonptrType
330 }
331 build_types();
336 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
337 # requires at least perl version v5.10.0
338 # Any use must be runtime checked with $^V
351 }
369 }
370 }
371 }
372 }
374 }
389 }
394 }
398 }
402 }
405 }
416 );
421 }
422 }
424 }
447 # If there's a name left after stripping spaces and
448 # leading quotes, and the address doesn't have both
449 # leading and trailing angle brackets, the address
450 # is invalid. ie:
451 # "joe smith joe@smith.com" bad
452 # "joe smith <joe@smith.com" bad
457 }
458 }
468 }
471 }
485 }
491 }
494 }
502 }
503 }
506 }
519 }
521 }
524 }
527 }
531 }
536 # Drop the diff line leader and expand tabs
540 # Pick the indent from the front of the line.
544 }
555 }
556 }
567 # Always copy over the diff marker.
573 # Comments we are wacking completly including the begin
574 # and end, all to $;.
581 }
587 }
594 }
596 # A \ in a string means ignore the next character.
602 }
603 # Regular quotes.
612 }
613 }
615 #print "c<$c> SQ<$sanitise_quote>\n";
624 }
625 }
629 }
631 # The pathname on a #include may be surrounded by '<' and '>'.
636 # The whole of a #error is a string.
640 }
643 }
666 #warn "CSB: blk<$blk> remain<$remain>\n";
667 # If we are about to drop off the end, pull in more
668 # context.
679 }
680 # Bail if there is no further context.
681 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
684 }
688 }
689 }
694 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
696 # Handle nested #if/#else.
703 }
705 # Statement ends at the ';' or a close '}' at the
706 # outermost level.
709 }
711 # An else is really a conditional as long as its not else if
718 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
719 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
720 }
725 }
733 #warn "CSB: mark coff<$coff>\n";
734 }
735 }
739 }
747 }
749 }
750 }
751 # Preprocessor commands end at the newline unless escaped.
757 }
759 }
760 # We are truly at the end, so shuffle to the next line.
765 }
770 #warn "STATEMENT<$statement>\n";
771 #warn "CONDITION<$condition>\n";
773 #print "coff<$coff> soff<$off> loff<$loff>\n";
777 }
782 # Strip the diff line prefixes and rip blank lines at start and end.
790 }
798 }
819 }
820 }
828 # Grab the first conditional/block pair.
831 #print "F: c<$condition> s<$statement> remain<$remain>\n";
835 }
837 # Pull in the following conditional/block pairs and see if they
838 # could continue the statement.
842 #print "C: c<$condition> s<$statement> remain<$remain>\n";
844 #print "C: push\n";
846 }
849 }
868 # Handle nested #if/#else.
875 }
878 ##print "C<$c>L<$level><$open$close>O<$off>\n";
882 }
889 }
890 }
894 }
897 }
900 }
906 }
912 }
918 }
923 }
928 }
933 # Catch a comment on the end of the line itself.
937 # Look through the context and try and figure out if there is a
938 # comment.
943 #warn " $line\n";
946 }
949 }
952 }
956 }
957 }
961 }
966 ##print "LINE: $rawlines[$end_line - 1 ]\n";
967 ##print "CMMT: $cmt\n";
970 }
983 }
986 }
998 }
999 }
1003 }
1015 }
1035 }
1056 }
1085 # Assume all arms of the conditional end as this
1086 # one does, and continue as if the #endif was not here.
1103 }
1134 }
1146 }
1179 }
1194 }
1203 }
1207 }
1211 }
1212 }
1215 }
1224 DEFINE_\S+
1225 )$|
1229 case|
1233 \#|
1234 \#\#|
1240 # Check for modifiers.
1251 }
1252 }
1257 }
1258 build_types();
1261 }
1262 }
1268 }
1274 }
1280 }
1286 }
1289 }
1295 }
1296 }
1301 }
1302 }
1307 }
1308 }
1314 ##print "absolute<$absolute>\n";
1316 # See if any suffix of this path is a path within the tree.
1319 ##print "file<$file>\n";
1321 }
1322 }
1325 }
1327 # It is, so see if the prefix is acceptable.
1331 ##print "prefix<$prefix>\n";
1335 }
1336 }
1350 }
1362 }
1363 }
1366 }
1395 # Trace the real file/line as we go.
1407 # suppression flags
1413 # Pre-scan the patch sanitizing the lines.
1414 # Pre-scan the patch looking for any __setup documentation.
1415 #
1419 sanitise_line_reset();
1429 }
1430 #next;
1431 }
1438 }
1441 # Guestimate if this is a continuing comment. Run
1442 # the context looking for a comment "edge". If this
1443 # edge is a close comment then we must be in a comment
1444 # at context start.
1451 #print "RAW<$rawlines[$ln - 1]>\n";
1457 }
1458 }
1461 }
1463 # Guestimate if this is a continuing comment. If this
1464 # is the start of a diff block and this line starts
1465 # ' *' then it is very likely a comment.
1468 {
1470 }
1472 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1476 # Standardise the strings and chars within the input to
1477 # simplify matching -- only bother with positive lines.
1479 }
1486 }
1488 #print "==>$rawline\n";
1489 #print "-->$line\n";
1493 }
1494 }
1505 #extract the line range in the file after the patch is applied
1514 }
1515 annotate_reset();
1524 # track the line number as we move through the hunk, note that
1525 # new versions of GNU diff omit the leading space on completely
1526 # blank context lines so we need to count that too.
1531 # Measure the line length and indent.
1534 # Track the previous line.
1539 #warn "line<$line>\n";
1543 }
1547 #make up the handle for any error we report on this line
1554 # extract the filename as it passes
1569 }
1573 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1574 }
1576 }
1586 # Check for incorrect file permissions
1592 }
1593 }
1595 # Check the patch for a signoff:
1599 }
1601 # Check signature styles
1613 }
1617 }
1621 }
1625 }
1636 # Don't force email to have quotes
1637 # Allow just an angle bracketed address
1643 }
1644 }
1645 }
1647 # Check for wrappage within a valid hunk of the file
1652 }
1654 # Check for absolute kernel paths.
1661 #
1664 }
1665 }
1666 }
1668 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1679 }
1681 # Check if it's the start of a commit log
1682 # (not a header line and we haven't seen the patch filename)
1687 }
1689 # Still not yet in a patch, check for any UTF-8
1694 }
1696 # ignore non-hunk lines and lines being removed
1699 #trailing whitespace
1710 }
1712 # check for Kconfig help text having a real description
1713 # Only applies when adding the entry originally, after that we do not have
1714 # sufficient context to determine whether it is indeed long enough.
1734 }
1743 }
1745 }
1747 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
1748 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
1749 }
1759 };
1762 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
1763 }
1765 # check we are in a valid source file if not then ignore this hunk
1768 #80 column limit
1771 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
1774 {
1777 }
1779 # Check for user-visible strings broken across lines, which breaks the ability
1780 # to grep for the string. Limited to strings used as parameters (those
1781 # following an open parenthesis), which almost completely eliminates false
1782 # positives, as well as warning only once per parameter rather than once per
1783 # line of the string. Make an exception when the previous string ends in a
1784 # newline (multiple lines in one string constant) or \n\t (common in inline
1785 # assembly to indent the instruction on the following line).
1792 }
1794 # check for spaces before a quoted newline
1798 }
1800 # check for adding lines without a newline.
1801 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1804 }
1806 # Blackfin: use hi/lo macros
1812 }
1817 }
1818 }
1820 # check we are in a valid source file C or perl if not then ignore this hunk
1823 # at the beginning of a line any tabs must come first and anything
1824 # more than 8 must use tabs.
1831 }
1833 # check for space before tabs.
1838 }
1840 # check for && or || at the start of a line
1844 }
1846 # check multi-line statement indentation matches previous line
1867 }
1868 }
1869 }
1874 }
1876 # check for spaces at the beginning of a line.
1877 # Exceptions:
1878 # 1) within comments
1879 # 2) indented preprocessor commands
1880 # 3) hanging labels
1885 }
1887 # check we are in a valid C source file if not then ignore this hunk
1890 # check for RCS/CVS revision markers
1894 }
1896 # Blackfin: don't use __builtin_bfin_[cs]sync
1901 }
1906 }
1908 # Check for potential 'bare' types
1911 #print "LINE<$line>\n";
1919 #print "linenr<$linenr> <$stat>\n";
1920 # If this statement has no statement boundaries within
1921 # it there is no point in retrying a statement scan
1922 # until we hit end of it.
1925 #print "skip<$line_nr_next>\n";
1927 }
1929 # Find the real next line.
1935 }
1940 # Ignore goto labels.
1943 # Ignore functions being called
1948 # declarations always start with types
1949 } 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) {
1954 # definitions in global scope can only start with types
1957 }
1959 # any (foo ... *) is a pointer cast, and foo is a type
1962 }
1964 # Check for any sort of function declaration.
1965 # int foo(something bar, other baz);
1966 # void (*store_gdt)(x86_descr_ptr *);
1967 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
1975 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
1978 }
1979 }
1980 }
1982 }
1984 #
1985 # Checks which may be anchored in the context.
1986 #
1988 # Check for switch () and associated case and default
1989 # statements should be at the same indent.
2003 }
2004 }
2008 }
2009 }
2011 # if/while/etc brace do not go on next line, unless defining a do while loop,
2012 # or if that brace on the next line is for something else
2021 }
2032 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2035 }
2037 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2038 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2044 }
2048 {
2054 }
2055 }
2056 }
2058 # Check relative indent for conditionals and blocks.
2059 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2067 # Make sure we remove the line prefixes as we have
2068 # none on the first line, and are going to readd them
2069 # where necessary.
2072 # Find out how long the conditional actually is.
2076 # We want to check the first line inside the block
2077 # starting at the end of the conditional, so remove:
2078 # 1) any blank line termination
2079 # 2) any opening brace { on end of the line
2080 # 3) any do (...) {
2087 }
2091 }
2093 # Also ignore a loop construct at the end of a
2094 # preprocessor statement.
2098 }
2105 # If we see an #else/#elif then the code
2106 # is not linear.
2109 }
2111 # Ignore:
2112 # 1) blank lines, they should be at 0,
2113 # 2) preprocessor lines, and
2114 # 3) labels.
2122 }
2123 }
2124 }
2129 # Check if either of these lines are modified, else
2130 # this is not this patch's fault.
2134 }
2137 }
2139 #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";
2144 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2145 }
2146 }
2148 # Track the 'values' across context and added lines.
2158 }
2161 #ignore lines not being added
2164 # TEST: allow direct testing of the type matcher.
2172 }
2174 }
2175 # TEST: allow direct testing of the attribute matcher.
2183 }
2185 }
2187 # check for initialisation to aggregates open brace on the next line
2192 }
2194 #
2195 # Checks which are anchored on the added line.
2196 #
2198 # check for malformed paths in #include statements (uses RAW line)
2205 }
2206 }
2208 # no C99 // comments
2212 }
2213 # Remove C99 comments.
2217 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2218 # the whole statement.
2219 #print "APW <$lines[$realline_next - 1]>\n";
2225 # Handle definitions which produce identifiers with
2226 # a prefix:
2227 # XXX(foo);
2228 # EXPORT_SYMBOL(something_foo);
2232 #print "FOO C name<$name>\n";
2243 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2247 }
2248 }
2253 #print "FOO B <$lines[$linenr - 1]>\n";
2255 }
2260 }
2262 # check for global initialisers.
2267 }
2268 # check for static initialisers.
2273 }
2275 # check for static const char * arrays.
2280 }
2282 # check for static char foo[] = "bar" declarations.
2287 }
2289 # check for declarations of struct pci_device_id
2293 }
2295 # check for new typedefs, only function parameters and sparse annotations
2296 # make sense.
2304 }
2306 # * goes on variable not on type
2307 # (char*[ const])
2309 #print "AA<$1>\n";
2312 # Should start with a space.
2314 # Should not end with a space.
2316 # '*'s should not have spaces between.
2318 }
2320 #print "from<$from> to<$to>\n";
2324 }
2325 }
2327 #print "BB<$1>\n";
2330 # Should start with a space.
2332 # Should not end with a space.
2334 # '*'s should not have spaces between.
2336 }
2337 # Modifiers should have spaces.
2340 #print "from<$from> to<$to> ident<$ident>\n";
2344 }
2345 }
2347 # # no BUG() or BUG_ON()
2348 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2349 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2350 # print "$herecurr";
2351 # $clean = 0;
2352 # }
2356 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2357 }
2359 # check for uses of printk_ratelimit
2363 }
2365 # printk should use KERN_* levels. Note that follow on printk's on the
2366 # same line do not need a level, so we use the current block context
2367 # to try and find and validate the current printk. In summary the current
2368 # printk includes all preceding printk's which have no newline on the end.
2369 # we assume the first bad printk is the one to report.
2373 #print "CHECK<$lines[$ln - 1]\n";
2374 # we have a preceding printk if it ends
2375 # with "\n" ignore it, else it is to blame
2379 }
2381 }
2382 }
2386 }
2387 }
2395 }
2400 }
2402 # function brace can't be on same line, except for #defines of do while,
2403 # or if closed on same line
2408 }
2410 # open braces for enum, union and struct go on the same line.
2415 }
2417 # missing space after union, struct or enum definition
2421 }
2423 # check for spacing round square brackets; allowed:
2424 # 1. with a type on the left -- int [] a;
2425 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2426 # 3. inside a curly brace -- = { [0...10] = 5 }
2434 }
2435 }
2437 # check for spaces between functions and their parentheses.
2443 # Ignore those directives where spaces _are_ permitted.
2449 {
2451 # cpp #define statements have non-optional spaces, ie
2452 # if there is a space between the name and the open
2453 # parenthesis it is simply not a parameter group.
2456 # cpp #elif statement condition may start with a (
2459 # If this whole things ends with a type its most
2460 # likely a typedef for a function.
2466 }
2467 }
2469 # check for whitespace before a non-naked semicolon
2473 }
2475 # Check operator spacing.
2478 <<=|>>=|<=|>=|==|!=|
2480 =>|->|<<|>>|<|>|=|!|~|
2492 # Pick up the preceding and succeeding characters.
2497 }
2520 }
2529 # Pull out the value of this operator.
2532 # Get the full operator variant.
2535 # Ignore operators passed as parameters.
2539 # # Ignore comments
2540 # } elsif ($op =~ /^$;+$/) {
2542 # ; should have either the end of line or a space or \ after it
2548 }
2550 # // is a comment
2553 # No spaces for:
2554 # ->
2555 # : when part of a bitfield
2560 }
2562 # , must have a space on the right.
2567 }
2569 # '*' as part of a type definition -- reported already.
2571 #warn "'*' is part of type\n";
2573 # unary operators should have a space before and
2574 # none after. May be left adjacent to another
2575 # unary operator, or a cast
2582 }
2584 # A unary '*' may be const
2589 }
2591 # unary ++ and unary -- are allowed no space on one side.
2596 }
2601 }
2605 }
2608 # << and >> may either have or not have spaces both sides
2614 {
2619 }
2621 # A colon needs no spaces before when it is
2622 # terminating a case value or a label.
2627 }
2629 # All the others need spaces both sides.
2633 # Ignore email addresses <foo@bar>
2638 {
2640 }
2642 # Ignore ?:
2646 }
2651 }
2652 }
2654 }
2655 }
2657 # check for multiple assignments
2661 }
2663 ## # check for multiple declarations, allowing for a function declaration
2664 ## # continuation.
2665 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
2666 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
2667 ##
2668 ## # Remove any bracketed sections to ensure we do not
2669 ## # falsly report the parameters of functions.
2670 ## my $ln = $line;
2671 ## while ($ln =~ s/\([^\(\)]*\)//g) {
2672 ## }
2673 ## if ($ln =~ /,/) {
2674 ## WARN("MULTIPLE_DECLARATION",
2675 ## "declaring multiple variables together should be avoided\n" . $herecurr);
2676 ## }
2677 ## }
2679 #need space before brace following if, while, etc
2684 }
2686 # closing brace should have a space following it when it has anything
2687 # on the line
2691 }
2693 # check spacing on square brackets
2697 }
2701 }
2703 # check spacing on parentheses
2708 }
2714 }
2716 #goto labels aren't indented, allow a single space however
2721 }
2723 # Return is not a function.
2728 # Flatten any parentheses
2736 }
2737 #print "value<$value>\n";
2745 }
2746 }
2747 # Return of what appears to be an errno should normally be -'ve
2753 }
2754 }
2756 # Need a space before open parenthesis after if, while etc
2759 }
2761 # Check for illegal assignment in if conditional -- and check for trailing
2762 # statements after the conditional.
2770 ##print "stat<$stat> stat_next<$stat_next>\n";
2773 # If the statement carries leading newlines,
2774 # then count those as offsets.
2782 }
2783 }
2791 }
2793 # Find out what is on the end of the line after the
2794 # conditional.
2800 {
2801 # Find out how long the conditional actually is.
2810 }
2814 }
2815 }
2817 # Check for bitwise tests written as boolean
2823 |
2828 {
2831 }
2833 # if and else should not have general statements after it
2840 }
2841 }
2842 # if should not continue a brace
2847 }
2848 # case and default should not have general statements after them
2854 {
2857 }
2859 # Check for }<nl>else {, these must be at the same
2860 # indent level to be relevant to each other.
2865 }
2871 # Find out what is on the end of the line after the
2872 # conditional.
2879 }
2880 }
2882 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
2883 # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
2884 # print "No studly caps, use _\n";
2885 # print "$herecurr";
2886 # $clean = 0;
2887 # }
2889 #no spaces allowed after \ in define
2893 }
2895 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
2902 {
2909 }
2910 }
2911 }
2913 # multi-statement macros should be enclosed in a do while loop, grab the
2914 # first statement and ensure its the whole macro if its not enclosed
2915 # in a known good container
2925 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
2926 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
2934 # Flatten any parentheses and braces
2938 {
2939 }
2941 # Flatten any obvious string concatentation.
2944 {
2945 }
2949 module_param_named|
2950 MODULE_PARAM_DESC|
2951 DECLARE_PER_CPU|
2952 DEFINE_PER_CPU|
2953 __typeof__\(|
2954 union|
2955 struct|
2959 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
2967 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
2972 {
2979 }
2987 }
2988 }
2989 }
2991 # do {} while (0) macro tests:
2992 # single-statement macros do not need to be enclosed in do while (0) loop,
2993 # macro should not end with a semicolon
3007 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3017 }
3023 }
3027 }
3028 }
3029 }
3031 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3032 # all assignments may have only one of the following with an assignment:
3033 # .
3034 # ALIGN(...)
3035 # VMLINUX_SYMBOL(...)
3039 }
3041 # check for redundant bracing round if etc
3045 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3046 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3056 # If the condition carries leading newlines, then count those as offsets.
3061 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3063 # We have looked at and allowed this specific line.
3073 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3075 #print "APW: ALLOWED: cond<$cond>\n";
3077 }
3079 #print "APW: ALLOWED: block<$block>\n";
3081 }
3083 #print "APW: ALLOWED: lines block<$block>\n";
3085 }
3087 }
3092 }
3100 }
3101 }
3102 }
3103 }
3108 # Check the pre-context.
3110 #print "APW: ALLOWED: pre<$1>\n";
3112 }
3117 # Check the condition.
3119 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3122 }
3124 #print "APW: ALLOWED: cond<$cond>\n";
3126 }
3128 #print "APW: ALLOWED: block<$block>\n";
3130 }
3132 #print "APW: ALLOWED: lines block<$block>\n";
3134 }
3135 # Check the post-context.
3140 }
3142 #print "APW: ALLOWED: chunk-1 block<$block>\n";
3144 }
3145 }
3152 }
3156 }
3157 }
3159 # don't include deprecated include files (uses RAW line)
3164 }
3165 }
3167 # don't use deprecated functions
3172 }
3173 }
3175 # no volatiles please
3179 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3180 }
3182 # warn about #if 0
3187 }
3189 # check for needless kfree() checks
3195 }
3196 }
3197 # check for needless usb_free_urb() checks
3203 }
3204 }
3206 # prefer usleep_range over udelay
3208 # ignore udelay's < 10, however
3212 }
3213 }
3215 # warn about unexpectedly long msleep's
3219 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3220 }
3221 }
3223 # warn about #ifdefs in C files
3224 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3225 # print "#ifdef in C files should be avoided\n";
3226 # print "$herecurr";
3227 # $clean = 0;
3228 # }
3230 # warn about spacing in #ifdefs
3234 }
3236 # check for spinlock_t definitions without a comment.
3243 }
3244 }
3245 # check for memory barriers without a comment.
3246 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3250 }
3251 }
3252 # check of hardware specific defines
3253 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
3256 }
3258 # Check that the storage class is at the beginning of a declaration
3262 }
3264 # check the location of the inline attribute, that it is between
3265 # storage class and type.
3270 }
3272 # Check for __inline__ and __inline, prefer inline
3276 }
3278 # Check for __attribute__ packed, prefer __packed
3282 }
3284 # Check for __attribute__ aligned, prefer __aligned
3288 }
3290 # Check for __attribute__ format(printf, prefer __printf
3293 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr);
3294 }
3296 # Check for __attribute__ format(scanf, prefer __scanf
3299 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr);
3300 }
3302 # check for sizeof(&)
3306 }
3308 # check for sizeof without parenthesis
3312 }
3314 # check for line continuations in quoted strings with odd counts of "
3318 }
3320 # Check for misused memsets
3335 }
3336 }
3338 # typecasts on min/max could be min_t/max_t
3356 }
3359 }
3360 }
3362 # check usleep_range arguments
3370 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
3374 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
3375 }
3376 }
3378 # check for new externs in .c files.
3381 {
3388 }
3391 {
3394 }
3399 }
3403 {
3406 }
3408 # checks for new __setup's
3415 }
3416 }
3418 # check for pointless casting of kmalloc return
3421 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
3422 }
3424 # check for multiple semicolons
3428 }
3430 # check for gcc specific __FUNCTION__
3434 }
3436 # check for use of yield()
3440 }
3442 # check for semaphores initialized locked
3446 }
3448 # recommend kstrto* over simple_strto* and strict_strto*
3452 }
3454 # check for __initcall(), use device_initcall() explicitly please
3458 }
3460 # check for various ops structs, ensure they are const.
3462 address_space_operations|
3463 backlight_ops|
3464 block_device_operations|
3465 dentry_operations|
3466 dev_pm_ops|
3467 dma_map_ops|
3468 extent_io_ops|
3469 file_lock_operations|
3470 file_operations|
3471 hv_ops|
3472 ide_dma_ops|
3473 intel_dvo_dev_ops|
3474 item_operations|
3475 iwl_ops|
3476 kgdb_arch|
3477 kgdb_io|
3478 kset_uevent_ops|
3479 lock_manager_operations|
3480 microcode_ops|
3481 mtrr_ops|
3482 neigh_ops|
3483 nlmsvc_binding|
3484 pci_raw_ops|
3485 pipe_buf_operations|
3486 platform_hibernation_ops|
3487 platform_suspend_ops|
3488 proto_ops|
3489 rpc_pipe_ops|
3490 seq_operations|
3491 snd_ac97_build_ops|
3492 soc_pcmcia_socket_ops|
3493 stacktrace_ops|
3494 sysfs_ops|
3495 tty_operations|
3496 usb_mon_operations|
3503 }
3505 # use of NR_CPUS is usually wrong
3506 # ignore definitions of NR_CPUS and usage to define arrays as likely right
3513 {
3515 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
3516 }
3518 # check for %L{u,d,i} in strings
3527 }
3528 }
3530 # whine mightly about in_atomic
3538 }
3539 }
3541 # check for lockdep_set_novalidate_class
3549 }
3550 }
3555 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
3556 }
3557 }
3559 # If we have no input at all, then there is nothing to report on
3560 # so just keep quiet.
3563 }
3565 # In mailback mode only produce a report in the negative, for
3566 # things that appear to be patches.
3569 }
3571 # This is not a patch, and we are are in 'no-patch' mode so
3572 # just keep quiet.
3575 }
3580 }
3584 }
3593 }
3600 }
3602 # If there were whitespace errors which cleanpatch can fix
3603 # then suggest that.
3608 }
3609 }
3615 }
3617 }
3621 }
3626 If any of these errors are false positives, please report
3628 EOM
3629 }
3632 }