| blob | de639eeeed506b76b54220e7e7f86ed879af02a1 |
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 }
1632 # Don't force email to have quotes
1633 # Allow just an angle bracketed address
1639 }
1640 }
1641 }
1643 # Check for wrappage within a valid hunk of the file
1648 }
1650 # Check for absolute kernel paths.
1657 #
1660 }
1661 }
1662 }
1664 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1675 }
1677 # Check if it's the start of a commit log
1678 # (not a header line and we haven't seen the patch filename)
1683 }
1685 # Still not yet in a patch, check for any UTF-8
1690 }
1692 # ignore non-hunk lines and lines being removed
1695 #trailing whitespace
1706 }
1708 # check for Kconfig help text having a real description
1709 # Only applies when adding the entry originally, after that we do not have
1710 # sufficient context to determine whether it is indeed long enough.
1730 }
1739 }
1741 }
1743 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
1744 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
1745 }
1755 };
1758 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
1759 }
1761 # check we are in a valid source file if not then ignore this hunk
1764 #80 column limit
1767 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
1770 {
1773 }
1775 # Check for user-visible strings broken across lines, which breaks the ability
1776 # to grep for the string. Limited to strings used as parameters (those
1777 # following an open parenthesis), which almost completely eliminates false
1778 # positives, as well as warning only once per parameter rather than once per
1779 # line of the string. Make an exception when the previous string ends in a
1780 # newline (multiple lines in one string constant) or \n\t (common in inline
1781 # assembly to indent the instruction on the following line).
1788 }
1790 # check for spaces before a quoted newline
1794 }
1796 # check for adding lines without a newline.
1797 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1800 }
1802 # Blackfin: use hi/lo macros
1808 }
1813 }
1814 }
1816 # check we are in a valid source file C or perl if not then ignore this hunk
1819 # at the beginning of a line any tabs must come first and anything
1820 # more than 8 must use tabs.
1827 }
1829 # check for space before tabs.
1834 }
1836 # check for && or || at the start of a line
1840 }
1842 # check multi-line statement indentation matches previous line
1863 }
1864 }
1865 }
1870 }
1876 }
1878 # check for spaces at the beginning of a line.
1879 # Exceptions:
1880 # 1) within comments
1881 # 2) indented preprocessor commands
1882 # 3) hanging labels
1887 }
1889 # check we are in a valid C source file if not then ignore this hunk
1892 # check for RCS/CVS revision markers
1896 }
1898 # Blackfin: don't use __builtin_bfin_[cs]sync
1903 }
1908 }
1910 # Check for potential 'bare' types
1913 #print "LINE<$line>\n";
1921 #print "linenr<$linenr> <$stat>\n";
1922 # If this statement has no statement boundaries within
1923 # it there is no point in retrying a statement scan
1924 # until we hit end of it.
1927 #print "skip<$line_nr_next>\n";
1929 }
1931 # Find the real next line.
1937 }
1942 # Ignore goto labels.
1945 # Ignore functions being called
1950 # declarations always start with types
1951 } 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) {
1956 # definitions in global scope can only start with types
1959 }
1961 # any (foo ... *) is a pointer cast, and foo is a type
1964 }
1966 # Check for any sort of function declaration.
1967 # int foo(something bar, other baz);
1968 # void (*store_gdt)(x86_descr_ptr *);
1969 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
1977 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
1980 }
1981 }
1982 }
1984 }
1986 #
1987 # Checks which may be anchored in the context.
1988 #
1990 # Check for switch () and associated case and default
1991 # statements should be at the same indent.
2005 }
2006 }
2010 }
2011 }
2013 # if/while/etc brace do not go on next line, unless defining a do while loop,
2014 # or if that brace on the next line is for something else
2023 }
2034 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2037 }
2039 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2040 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2046 }
2050 {
2056 }
2057 }
2058 }
2060 # Check relative indent for conditionals and blocks.
2061 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2069 # Make sure we remove the line prefixes as we have
2070 # none on the first line, and are going to readd them
2071 # where necessary.
2074 # Find out how long the conditional actually is.
2078 # We want to check the first line inside the block
2079 # starting at the end of the conditional, so remove:
2080 # 1) any blank line termination
2081 # 2) any opening brace { on end of the line
2082 # 3) any do (...) {
2089 }
2093 }
2095 # Also ignore a loop construct at the end of a
2096 # preprocessor statement.
2100 }
2107 # If we see an #else/#elif then the code
2108 # is not linear.
2111 }
2113 # Ignore:
2114 # 1) blank lines, they should be at 0,
2115 # 2) preprocessor lines, and
2116 # 3) labels.
2124 }
2125 }
2126 }
2131 # Check if either of these lines are modified, else
2132 # this is not this patch's fault.
2136 }
2139 }
2141 #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";
2146 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2147 }
2148 }
2150 # Track the 'values' across context and added lines.
2160 }
2163 #ignore lines not being added
2166 # TEST: allow direct testing of the type matcher.
2174 }
2176 }
2177 # TEST: allow direct testing of the attribute matcher.
2185 }
2187 }
2189 # check for initialisation to aggregates open brace on the next line
2194 }
2196 #
2197 # Checks which are anchored on the added line.
2198 #
2200 # check for malformed paths in #include statements (uses RAW line)
2207 }
2208 }
2210 # no C99 // comments
2214 }
2215 # Remove C99 comments.
2219 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2220 # the whole statement.
2221 #print "APW <$lines[$realline_next - 1]>\n";
2227 # Handle definitions which produce identifiers with
2228 # a prefix:
2229 # XXX(foo);
2230 # EXPORT_SYMBOL(something_foo);
2234 #print "FOO C name<$name>\n";
2245 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2249 }
2250 }
2255 #print "FOO B <$lines[$linenr - 1]>\n";
2257 }
2262 }
2264 # check for global initialisers.
2269 }
2270 # check for static initialisers.
2275 }
2277 # check for static const char * arrays.
2282 }
2284 # check for static char foo[] = "bar" declarations.
2289 }
2291 # check for declarations of struct pci_device_id
2295 }
2297 # check for new typedefs, only function parameters and sparse annotations
2298 # make sense.
2306 }
2308 # * goes on variable not on type
2309 # (char*[ const])
2311 #print "AA<$1>\n";
2314 # Should start with a space.
2316 # Should not end with a space.
2318 # '*'s should not have spaces between.
2320 }
2322 #print "from<$from> to<$to>\n";
2326 }
2327 }
2329 #print "BB<$1>\n";
2332 # Should start with a space.
2334 # Should not end with a space.
2336 # '*'s should not have spaces between.
2338 }
2339 # Modifiers should have spaces.
2342 #print "from<$from> to<$to> ident<$ident>\n";
2346 }
2347 }
2349 # # no BUG() or BUG_ON()
2350 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2351 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2352 # print "$herecurr";
2353 # $clean = 0;
2354 # }
2358 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2359 }
2361 # check for uses of printk_ratelimit
2365 }
2367 # printk should use KERN_* levels. Note that follow on printk's on the
2368 # same line do not need a level, so we use the current block context
2369 # to try and find and validate the current printk. In summary the current
2370 # printk includes all preceding printk's which have no newline on the end.
2371 # we assume the first bad printk is the one to report.
2375 #print "CHECK<$lines[$ln - 1]\n";
2376 # we have a preceding printk if it ends
2377 # with "\n" ignore it, else it is to blame
2381 }
2383 }
2384 }
2388 }
2389 }
2391 # function brace can't be on same line, except for #defines of do while,
2392 # or if closed on same line
2397 }
2399 # open braces for enum, union and struct go on the same line.
2404 }
2406 # missing space after union, struct or enum definition
2410 }
2412 # check for spacing round square brackets; allowed:
2413 # 1. with a type on the left -- int [] a;
2414 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2415 # 3. inside a curly brace -- = { [0...10] = 5 }
2423 }
2424 }
2426 # check for spaces between functions and their parentheses.
2432 # Ignore those directives where spaces _are_ permitted.
2438 {
2440 # cpp #define statements have non-optional spaces, ie
2441 # if there is a space between the name and the open
2442 # parenthesis it is simply not a parameter group.
2445 # cpp #elif statement condition may start with a (
2448 # If this whole things ends with a type its most
2449 # likely a typedef for a function.
2455 }
2456 }
2457 # Check operator spacing.
2460 <<=|>>=|<=|>=|==|!=|
2462 =>|->|<<|>>|<|>|=|!|~|
2474 # Pick up the preceding and succeeding characters.
2479 }
2502 }
2511 # Pull out the value of this operator.
2514 # Get the full operator variant.
2517 # Ignore operators passed as parameters.
2521 # # Ignore comments
2522 # } elsif ($op =~ /^$;+$/) {
2524 # ; should have either the end of line or a space or \ after it
2530 }
2532 # // is a comment
2535 # No spaces for:
2536 # ->
2537 # : when part of a bitfield
2542 }
2544 # , must have a space on the right.
2549 }
2551 # '*' as part of a type definition -- reported already.
2553 #warn "'*' is part of type\n";
2555 # unary operators should have a space before and
2556 # none after. May be left adjacent to another
2557 # unary operator, or a cast
2564 }
2566 # A unary '*' may be const
2571 }
2573 # unary ++ and unary -- are allowed no space on one side.
2578 }
2583 }
2587 }
2590 # << and >> may either have or not have spaces both sides
2596 {
2601 }
2603 # A colon needs no spaces before when it is
2604 # terminating a case value or a label.
2609 }
2611 # All the others need spaces both sides.
2615 # Ignore email addresses <foo@bar>
2620 {
2622 }
2624 # Ignore ?:
2628 }
2633 }
2634 }
2636 }
2637 }
2639 # check for multiple assignments
2643 }
2645 ## # check for multiple declarations, allowing for a function declaration
2646 ## # continuation.
2647 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
2648 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
2649 ##
2650 ## # Remove any bracketed sections to ensure we do not
2651 ## # falsly report the parameters of functions.
2652 ## my $ln = $line;
2653 ## while ($ln =~ s/\([^\(\)]*\)//g) {
2654 ## }
2655 ## if ($ln =~ /,/) {
2656 ## WARN("MULTIPLE_DECLARATION",
2657 ## "declaring multiple variables together should be avoided\n" . $herecurr);
2658 ## }
2659 ## }
2661 #need space before brace following if, while, etc
2666 }
2668 # closing brace should have a space following it when it has anything
2669 # on the line
2673 }
2675 # check spacing on square brackets
2679 }
2683 }
2685 # check spacing on parentheses
2690 }
2696 }
2698 #goto labels aren't indented, allow a single space however
2703 }
2705 # Return is not a function.
2710 # Flatten any parentheses
2718 }
2719 #print "value<$value>\n";
2727 }
2728 }
2729 # Return of what appears to be an errno should normally be -'ve
2735 }
2736 }
2738 # Need a space before open parenthesis after if, while etc
2741 }
2743 # Check for illegal assignment in if conditional -- and check for trailing
2744 # statements after the conditional.
2752 ##print "stat<$stat> stat_next<$stat_next>\n";
2755 # If the statement carries leading newlines,
2756 # then count those as offsets.
2764 }
2765 }
2773 }
2775 # Find out what is on the end of the line after the
2776 # conditional.
2782 {
2783 # Find out how long the conditional actually is.
2792 }
2796 }
2797 }
2799 # Check for bitwise tests written as boolean
2805 |
2810 {
2813 }
2815 # if and else should not have general statements after it
2822 }
2823 }
2824 # if should not continue a brace
2829 }
2830 # case and default should not have general statements after them
2836 {
2839 }
2841 # Check for }<nl>else {, these must be at the same
2842 # indent level to be relevant to each other.
2847 }
2853 # Find out what is on the end of the line after the
2854 # conditional.
2861 }
2862 }
2864 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
2865 # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
2866 # print "No studly caps, use _\n";
2867 # print "$herecurr";
2868 # $clean = 0;
2869 # }
2871 #no spaces allowed after \ in define
2875 }
2877 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
2884 {
2891 }
2892 }
2893 }
2895 # multi-statement macros should be enclosed in a do while loop, grab the
2896 # first statement and ensure its the whole macro if its not enclosed
2897 # in a known good container
2907 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
2908 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
2916 # Flatten any parentheses and braces
2920 {
2921 }
2923 # Flatten any obvious string concatentation.
2926 {
2927 }
2931 module_param_named|
2932 MODULE_PARAM_DESC|
2933 DECLARE_PER_CPU|
2934 DEFINE_PER_CPU|
2935 __typeof__\(|
2936 union|
2937 struct|
2941 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
2949 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
2954 {
2961 }
2969 }
2970 }
2971 }
2973 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
2974 # all assignments may have only one of the following with an assignment:
2975 # .
2976 # ALIGN(...)
2977 # VMLINUX_SYMBOL(...)
2981 }
2983 # check for redundant bracing round if etc
2987 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
2988 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
2998 # If the condition carries leading newlines, then count those as offsets.
3003 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3005 # We have looked at and allowed this specific line.
3015 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3017 #print "APW: ALLOWED: cond<$cond>\n";
3019 }
3021 #print "APW: ALLOWED: block<$block>\n";
3023 }
3025 #print "APW: ALLOWED: lines block<$block>\n";
3027 }
3029 }
3034 }
3042 }
3043 }
3044 }
3045 }
3050 # Check the pre-context.
3052 #print "APW: ALLOWED: pre<$1>\n";
3054 }
3059 # Check the condition.
3061 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3064 }
3066 #print "APW: ALLOWED: cond<$cond>\n";
3068 }
3070 #print "APW: ALLOWED: block<$block>\n";
3072 }
3074 #print "APW: ALLOWED: lines block<$block>\n";
3076 }
3077 # Check the post-context.
3082 }
3084 #print "APW: ALLOWED: chunk-1 block<$block>\n";
3086 }
3087 }
3094 }
3098 }
3099 }
3101 # don't include deprecated include files (uses RAW line)
3106 }
3107 }
3109 # don't use deprecated functions
3114 }
3115 }
3117 # no volatiles please
3121 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3122 }
3124 # warn about #if 0
3129 }
3131 # check for needless kfree() checks
3137 }
3138 }
3139 # check for needless usb_free_urb() checks
3145 }
3146 }
3148 # prefer usleep_range over udelay
3150 # ignore udelay's < 10, however
3154 }
3155 }
3157 # warn about unexpectedly long msleep's
3161 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3162 }
3163 }
3165 # warn about #ifdefs in C files
3166 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3167 # print "#ifdef in C files should be avoided\n";
3168 # print "$herecurr";
3169 # $clean = 0;
3170 # }
3172 # warn about spacing in #ifdefs
3176 }
3178 # check for spinlock_t definitions without a comment.
3185 }
3186 }
3187 # check for memory barriers without a comment.
3188 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3192 }
3193 }
3194 # check of hardware specific defines
3195 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
3198 }
3200 # Check that the storage class is at the beginning of a declaration
3204 }
3206 # check the location of the inline attribute, that it is between
3207 # storage class and type.
3212 }
3214 # Check for __inline__ and __inline, prefer inline
3218 }
3220 # Check for __attribute__ packed, prefer __packed
3224 }
3226 # Check for __attribute__ aligned, prefer __aligned
3230 }
3232 # Check for __attribute__ format(printf, prefer __printf
3235 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr);
3236 }
3238 # Check for __attribute__ format(scanf, prefer __scanf
3241 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr);
3242 }
3244 # check for sizeof(&)
3248 }
3250 # check for line continuations in quoted strings with odd counts of "
3254 }
3256 # Check for misused memsets
3271 }
3272 }
3274 # typecasts on min/max could be min_t/max_t
3292 }
3295 }
3296 }
3298 # check for new externs in .c files.
3301 {
3308 }
3311 {
3314 }
3319 }
3323 {
3326 }
3328 # checks for new __setup's
3335 }
3336 }
3338 # check for pointless casting of kmalloc return
3341 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
3342 }
3344 # check for multiple semicolons
3348 }
3350 # check for gcc specific __FUNCTION__
3354 }
3356 # check for use of yield()
3360 }
3362 # check for semaphores initialized locked
3366 }
3368 # recommend kstrto* over simple_strto* and strict_strto*
3372 }
3374 # check for __initcall(), use device_initcall() explicitly please
3378 }
3380 # check for various ops structs, ensure they are const.
3382 address_space_operations|
3383 backlight_ops|
3384 block_device_operations|
3385 dentry_operations|
3386 dev_pm_ops|
3387 dma_map_ops|
3388 extent_io_ops|
3389 file_lock_operations|
3390 file_operations|
3391 hv_ops|
3392 ide_dma_ops|
3393 intel_dvo_dev_ops|
3394 item_operations|
3395 iwl_ops|
3396 kgdb_arch|
3397 kgdb_io|
3398 kset_uevent_ops|
3399 lock_manager_operations|
3400 microcode_ops|
3401 mtrr_ops|
3402 neigh_ops|
3403 nlmsvc_binding|
3404 pci_raw_ops|
3405 pipe_buf_operations|
3406 platform_hibernation_ops|
3407 platform_suspend_ops|
3408 proto_ops|
3409 rpc_pipe_ops|
3410 seq_operations|
3411 snd_ac97_build_ops|
3412 soc_pcmcia_socket_ops|
3413 stacktrace_ops|
3414 sysfs_ops|
3415 tty_operations|
3416 usb_mon_operations|
3423 }
3425 # use of NR_CPUS is usually wrong
3426 # ignore definitions of NR_CPUS and usage to define arrays as likely right
3433 {
3435 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
3436 }
3438 # check for %L{u,d,i} in strings
3447 }
3448 }
3450 # whine mightly about in_atomic
3458 }
3459 }
3461 # check for lockdep_set_novalidate_class
3469 }
3470 }
3475 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
3476 }
3477 }
3479 # If we have no input at all, then there is nothing to report on
3480 # so just keep quiet.
3483 }
3485 # In mailback mode only produce a report in the negative, for
3486 # things that appear to be patches.
3489 }
3491 # This is not a patch, and we are are in 'no-patch' mode so
3492 # just keep quiet.
3495 }
3500 }
3504 }
3513 }
3520 }
3522 # If there were whitespace errors which cleanpatch can fix
3523 # then suggest that.
3528 }
3529 }
3535 }
3537 }
3541 }
3546 If any of these errors are false positives, please report
3548 EOM
3549 }
3552 }