| blob | 6afcd1239ca5652e9f857e564fdd70bf46d531f1 |
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
47 Options:
52 --emacs emacs compile window format
53 --terse one line per report
65 is all off)
67 literally
70 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
71 with potential errors corrected to the preferred
72 checkpatch style
76 EOM
79 }
101 }
102 }
105 }
107 GetOptions(
138 }
151 }
158 ## no critic
161 }
168 }
174 }
181 }
182 }
187 }
188 }
198 __user|
199 __kernel|
200 __force|
201 __iomem|
202 __must_check|
203 __init_refok|
204 __kprobes|
205 __ref|
206 __rcu
209 # Notes to $Attribute:
210 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
212 const|
213 __percpu|
214 __nocast|
215 __safe|
216 __bitwise__|
217 __packed__|
218 __packed2__|
219 __naked|
220 __maybe_unused|
221 __always_unused|
222 __noreturn|
223 __used|
224 __cold|
225 __noclone|
226 __deprecated|
227 __read_mostly|
228 __kprobes|
230 ____cacheline_aligned|
231 ____cacheline_aligned_in_smp|
232 ____cacheline_internodealigned_in_smp|
233 __weak
253 <=|>=|==|!=|
254 =>|->|<<|>>|<|>|!|~|
279 atomic_t
280 )};
284 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
286 panic|
288 )};
297 To:|
298 Cc:
299 )};
320 );
323 );
326 irq|
327 memory
328 )};
329 # memory.h: ARM has a custom one
341 )
345 $NonptrType
350 }
351 build_types();
355 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
356 # requires at least perl version v5.10.0
357 # Any use must be runtime checked with $^V
370 }
390 }
393 }
394 }
395 }
414 }
418 }
422 }
426 }
435 }
437 }
438 }
456 }
461 }
465 }
469 }
473 }
484 );
489 }
490 }
492 }
515 # If there's a name left after stripping spaces and
516 # leading quotes, and the address doesn't have both
517 # leading and trailing angle brackets, the address
518 # is invalid. ie:
519 # "joe smith joe@smith.com" bad
520 # "joe smith <joe@smith.com" bad
525 }
526 }
536 }
539 }
553 }
559 }
562 }
570 }
571 }
574 }
587 }
589 }
592 }
595 }
599 }
604 # Drop the diff line leader and expand tabs
608 # Pick the indent from the front of the line.
612 }
623 }
624 }
635 # Always copy over the diff marker.
641 # Comments we are wacking completly including the begin
642 # and end, all to $;.
649 }
655 }
662 }
664 # A \ in a string means ignore the next character.
670 }
671 # Regular quotes.
680 }
681 }
683 #print "c<$c> SQ<$sanitise_quote>\n";
692 }
693 }
697 }
699 # The pathname on a #include may be surrounded by '<' and '>'.
704 # The whole of a #error is a string.
708 }
711 }
718 }
741 #warn "CSB: blk<$blk> remain<$remain>\n";
742 # If we are about to drop off the end, pull in more
743 # context.
754 }
755 # Bail if there is no further context.
756 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
759 }
763 }
764 }
769 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
771 # Handle nested #if/#else.
778 }
780 # Statement ends at the ';' or a close '}' at the
781 # outermost level.
784 }
786 # An else is really a conditional as long as its not else if
793 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
794 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
795 }
800 }
808 #warn "CSB: mark coff<$coff>\n";
809 }
810 }
814 }
822 }
824 }
825 }
826 # Preprocessor commands end at the newline unless escaped.
832 }
834 }
835 # We are truly at the end, so shuffle to the next line.
840 }
845 #warn "STATEMENT<$statement>\n";
846 #warn "CONDITION<$condition>\n";
848 #print "coff<$coff> soff<$off> loff<$loff>\n";
852 }
857 # Strip the diff line prefixes and rip blank lines at start and end.
865 }
873 }
894 }
895 }
903 # Grab the first conditional/block pair.
906 #print "F: c<$condition> s<$statement> remain<$remain>\n";
910 }
912 # Pull in the following conditional/block pairs and see if they
913 # could continue the statement.
917 #print "C: c<$condition> s<$statement> remain<$remain>\n";
919 #print "C: push\n";
921 }
924 }
943 # Handle nested #if/#else.
950 }
953 ##print "C<$c>L<$level><$open$close>O<$off>\n";
957 }
964 }
965 }
969 }
972 }
975 }
981 }
987 }
993 }
998 }
1003 }
1008 # Catch a comment on the end of the line itself.
1012 # Look through the context and try and figure out if there is a
1013 # comment.
1018 #warn " $line\n";
1021 }
1024 }
1027 }
1031 }
1032 }
1036 }
1041 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1042 ##print "CMMT: $cmt\n";
1045 }
1058 }
1061 }
1073 }
1074 }
1078 }
1090 }
1110 }
1131 }
1160 # Assume all arms of the conditional end as this
1161 # one does, and continue as if the #endif was not here.
1178 }
1209 }
1221 }
1254 }
1269 }
1278 }
1282 }
1286 }
1287 }
1290 }
1299 DEFINE_\S+
1300 )$|
1304 case|
1308 \#|
1309 \#\#|
1315 # Check for modifiers.
1326 }
1327 }
1332 }
1333 build_types();
1336 }
1337 }
1343 }
1349 }
1355 }
1361 }
1364 }
1371 }
1373 }
1379 }
1381 }
1387 }
1389 }
1395 ##print "absolute<$absolute>\n";
1397 # See if any suffix of this path is a path within the tree.
1400 ##print "file<$file>\n";
1402 }
1403 }
1406 }
1408 # It is, so see if the prefix is acceptable.
1412 ##print "prefix<$prefix>\n";
1416 }
1417 }
1425 }
1434 #convert leading spaces to tabs
1436 #Remove spaces before a tab
1440 }
1454 }
1466 }
1467 }
1470 }
1501 # Trace the real file/line as we go.
1513 # suppression flags
1520 # Pre-scan the patch sanitizing the lines.
1521 # Pre-scan the patch looking for any __setup documentation.
1522 #
1526 sanitise_line_reset();
1538 }
1539 #next;
1540 }
1547 }
1550 # Guestimate if this is a continuing comment. Run
1551 # the context looking for a comment "edge". If this
1552 # edge is a close comment then we must be in a comment
1553 # at context start.
1560 #print "RAW<$rawlines[$ln - 1]>\n";
1566 }
1567 }
1570 }
1572 # Guestimate if this is a continuing comment. If this
1573 # is the start of a diff block and this line starts
1574 # ' *' then it is very likely a comment.
1577 {
1579 }
1581 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1585 # Standardise the strings and chars within the input to
1586 # simplify matching -- only bother with positive lines.
1588 }
1595 }
1597 #print "==>$rawline\n";
1598 #print "-->$line\n";
1602 }
1603 }
1614 #extract the line range in the file after the patch is applied
1623 }
1624 annotate_reset();
1633 # track the line number as we move through the hunk, note that
1634 # new versions of GNU diff omit the leading space on completely
1635 # blank context lines so we need to count that too.
1640 # Measure the line length and indent.
1643 # Track the previous line.
1648 #warn "line<$line>\n";
1652 }
1656 #make up the handle for any error we report on this line
1663 # extract the filename as it passes
1678 }
1682 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1683 }
1685 }
1695 # Check for incorrect file permissions
1702 }
1703 }
1705 # Check the patch for a signoff:
1709 }
1711 # Check signature styles
1723 }
1730 }
1731 }
1738 }
1740 }
1747 }
1748 }
1759 # Don't force email to have quotes
1760 # Allow just an angle bracketed address
1766 }
1767 }
1768 }
1770 # Check for wrappage within a valid hunk of the file
1775 }
1777 # Check for absolute kernel paths.
1784 #
1787 }
1788 }
1789 }
1791 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1802 }
1804 # Check if it's the start of a commit log
1805 # (not a header line and we haven't seen the patch filename)
1810 }
1812 # Check if there is UTF-8 in a commit log when a mail header has explicitly
1813 # declined it, i.e defined some charset where it is missing.
1818 }
1824 }
1826 # ignore non-hunk lines and lines being removed
1829 #trailing whitespace
1841 }
1844 }
1846 # check for Kconfig help text having a real description
1847 # Only applies when adding the entry originally, after that we do not have
1848 # sufficient context to determine whether it is indeed long enough.
1868 }
1877 }
1879 }
1881 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
1882 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
1883 }
1885 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
1889 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
1890 }
1900 };
1903 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
1904 }
1906 # check we are in a valid source file if not then ignore this hunk
1909 #line length limit
1912 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
1915 {
1918 }
1920 # Check for user-visible strings broken across lines, which breaks the ability
1921 # to grep for the string. Limited to strings used as parameters (those
1922 # following an open parenthesis), which almost completely eliminates false
1923 # positives, as well as warning only once per parameter rather than once per
1924 # line of the string. Make an exception when the previous string ends in a
1925 # newline (multiple lines in one string constant) or \n\t (common in inline
1926 # assembly to indent the instruction on the following line).
1933 }
1935 # check for spaces before a quoted newline
1941 }
1943 }
1945 # check for adding lines without a newline.
1946 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1949 }
1951 # Blackfin: use hi/lo macros
1957 }
1962 }
1963 }
1965 # check we are in a valid source file C or perl if not then ignore this hunk
1968 # at the beginning of a line any tabs must come first and anything
1969 # more than 8 must use tabs.
1978 }
1979 }
1981 # check for space before tabs.
1989 }
1990 }
1992 # check for && or || at the start of a line
1996 }
1998 # check multi-line statement indentation matches previous line
2023 }
2024 }
2025 }
2026 }
2034 }
2035 }
2042 }
2050 }
2059 }
2061 # check for spaces at the beginning of a line.
2062 # Exceptions:
2063 # 1) within comments
2064 # 2) indented preprocessor commands
2065 # 3) hanging labels
2072 }
2073 }
2075 # check we are in a valid C source file if not then ignore this hunk
2078 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2081 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2082 }
2084 # check for RCS/CVS revision markers
2088 }
2090 # Blackfin: don't use __builtin_bfin_[cs]sync
2095 }
2100 }
2102 # check for old HOTPLUG __dev<foo> section markings
2106 }
2108 # Check for potential 'bare' types
2111 #print "LINE<$line>\n";
2119 #print "linenr<$linenr> <$stat>\n";
2120 # If this statement has no statement boundaries within
2121 # it there is no point in retrying a statement scan
2122 # until we hit end of it.
2125 #print "skip<$line_nr_next>\n";
2127 }
2129 # Find the real next line.
2135 }
2140 # Ignore goto labels.
2143 # Ignore functions being called
2148 # declarations always start with types
2149 } 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) {
2154 # definitions in global scope can only start with types
2157 }
2159 # any (foo ... *) is a pointer cast, and foo is a type
2162 }
2164 # Check for any sort of function declaration.
2165 # int foo(something bar, other baz);
2166 # void (*store_gdt)(x86_descr_ptr *);
2167 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2175 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2178 }
2179 }
2180 }
2182 }
2184 #
2185 # Checks which may be anchored in the context.
2186 #
2188 # Check for switch () and associated case and default
2189 # statements should be at the same indent.
2203 }
2204 }
2208 }
2209 }
2211 # if/while/etc brace do not go on next line, unless defining a do while loop,
2212 # or if that brace on the next line is for something else
2221 }
2232 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2235 }
2237 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2238 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2244 }
2248 {
2254 }
2255 }
2256 }
2258 # Check relative indent for conditionals and blocks.
2259 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2267 # Make sure we remove the line prefixes as we have
2268 # none on the first line, and are going to readd them
2269 # where necessary.
2272 # Find out how long the conditional actually is.
2276 # We want to check the first line inside the block
2277 # starting at the end of the conditional, so remove:
2278 # 1) any blank line termination
2279 # 2) any opening brace { on end of the line
2280 # 3) any do (...) {
2287 }
2291 }
2293 # Also ignore a loop construct at the end of a
2294 # preprocessor statement.
2298 }
2305 # If we see an #else/#elif then the code
2306 # is not linear.
2309 }
2311 # Ignore:
2312 # 1) blank lines, they should be at 0,
2313 # 2) preprocessor lines, and
2314 # 3) labels.
2322 }
2323 }
2324 }
2329 # Check if either of these lines are modified, else
2330 # this is not this patch's fault.
2334 }
2337 }
2339 #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";
2344 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2345 }
2346 }
2348 # Track the 'values' across context and added lines.
2358 }
2361 #ignore lines not being added
2364 # TEST: allow direct testing of the type matcher.
2372 }
2374 }
2375 # TEST: allow direct testing of the attribute matcher.
2383 }
2385 }
2387 # check for initialisation to aggregates open brace on the next line
2392 }
2394 #
2395 # Checks which are anchored on the added line.
2396 #
2398 # check for malformed paths in #include statements (uses RAW line)
2404 }
2408 }
2409 }
2411 # no C99 // comments
2420 }
2421 }
2422 }
2423 # Remove C99 comments.
2427 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2428 # the whole statement.
2429 #print "APW <$lines[$realline_next - 1]>\n";
2435 # Handle definitions which produce identifiers with
2436 # a prefix:
2437 # XXX(foo);
2438 # EXPORT_SYMBOL(something_foo);
2442 #print "FOO C name<$name>\n";
2453 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2457 }
2458 }
2463 #print "FOO B <$lines[$linenr - 1]>\n";
2465 }
2470 }
2472 # check for global initialisers.
2477 }
2478 # check for static initialisers.
2483 }
2485 # check for static const char * arrays.
2490 }
2492 # check for static char foo[] = "bar" declarations.
2497 }
2499 # check for declarations of struct pci_device_id
2503 }
2505 # check for new typedefs, only function parameters and sparse annotations
2506 # make sense.
2514 }
2516 # * goes on variable not on type
2517 # (char*[ const])
2519 #print "AA<$1>\n";
2522 # Should start with a space.
2524 # Should not end with a space.
2526 # '*'s should not have spaces between.
2528 }
2530 ## print "1: from<$from> to<$to> ident<$ident>\n";
2540 }
2541 }
2542 }
2544 #print "BB<$1>\n";
2547 # Should start with a space.
2549 # Should not end with a space.
2551 # '*'s should not have spaces between.
2553 }
2554 # Modifiers should have spaces.
2557 ## print "2: from<$from> to<$to> ident<$ident>\n";
2568 }
2569 }
2570 }
2572 # # no BUG() or BUG_ON()
2573 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2574 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2575 # print "$herecurr";
2576 # $clean = 0;
2577 # }
2581 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2582 }
2584 # check for uses of printk_ratelimit
2588 }
2590 # printk should use KERN_* levels. Note that follow on printk's on the
2591 # same line do not need a level, so we use the current block context
2592 # to try and find and validate the current printk. In summary the current
2593 # printk includes all preceding printk's which have no newline on the end.
2594 # we assume the first bad printk is the one to report.
2598 #print "CHECK<$lines[$ln - 1]\n";
2599 # we have a preceding printk if it ends
2600 # with "\n" ignore it, else it is to blame
2604 }
2606 }
2607 }
2611 }
2612 }
2621 "Prefer netdev_$level2(netdev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
2622 }
2627 }
2636 }
2638 # function brace can't be on same line, except for #defines of do while,
2639 # or if closed on same line
2644 }
2646 # open braces for enum, union and struct go on the same line.
2651 }
2653 # missing space after union, struct or enum definition
2660 }
2661 }
2663 # check for spacing round square brackets; allowed:
2664 # 1. with a type on the left -- int [] a;
2665 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2666 # 3. inside a curly brace -- = { [0...10] = 5 }
2677 }
2678 }
2679 }
2681 # check for spaces between functions and their parentheses.
2687 # Ignore those directives where spaces _are_ permitted.
2693 {
2694 # cpp #define statements have non-optional spaces, ie
2695 # if there is a space between the name and the open
2696 # parenthesis it is simply not a parameter group.
2699 # cpp #elif statement condition may start with a (
2702 # If this whole things ends with a type its most
2703 # likely a typedef for a function.
2712 }
2713 }
2714 }
2716 # Check operator spacing.
2722 <<=|>>=|<=|>=|==|!=|
2724 =>|->|<<|>>|<|>|=|!|~|
2730 ## print("element count: <" . $#elements . ">\n");
2731 ## foreach my $el (@elements) {
2732 ## print("el: <$el>\n");
2733 ## }
2741 }
2751 ## print("n: <$n> good: <$good>\n");
2755 # Pick up the preceding and succeeding characters.
2760 }
2783 }
2792 # Pull out the value of this operator.
2795 # Get the full operator variant.
2798 # Ignore operators passed as parameters.
2802 # # Ignore comments
2803 # } elsif ($op =~ /^$;+$/) {
2805 # ; should have either the end of line or a space or \ after it
2813 }
2814 }
2816 # // is a comment
2819 # No spaces for:
2820 # ->
2821 # : when part of a bitfield
2830 }
2831 }
2832 }
2834 # , must have a space on the right.
2841 }
2842 }
2844 # '*' as part of a type definition -- reported already.
2846 #warn "'*' is part of type\n";
2848 # unary operators should have a space before and
2849 # none after. May be left adjacent to another
2850 # unary operator, or a cast
2859 }
2860 }
2862 # A unary '*' may be const
2872 }
2873 }
2874 }
2876 # unary ++ and unary -- are allowed no space on one side.
2884 }
2885 }
2893 }
2894 }
2903 }
2904 }
2905 }
2907 # << and >> may either have or not have spaces both sides
2913 {
2920 }
2921 }
2923 # A colon needs no spaces before when it is
2924 # terminating a case value or a label.
2931 }
2932 }
2934 # All the others need spaces both sides.
2938 # Ignore email addresses <foo@bar>
2943 {
2945 }
2947 # Ignore ?:
2951 }
2959 }
2960 }
2961 }
2964 ## print("n: <$n> GOOD: <$good>\n");
2967 }
2971 }
2975 }
2978 }
2980 # check for whitespace before a non-naked semicolon
2987 }
2988 }
2990 # check for multiple assignments
2994 }
2996 ## # check for multiple declarations, allowing for a function declaration
2997 ## # continuation.
2998 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
2999 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3000 ##
3001 ## # Remove any bracketed sections to ensure we do not
3002 ## # falsly report the parameters of functions.
3003 ## my $ln = $line;
3004 ## while ($ln =~ s/\([^\(\)]*\)//g) {
3005 ## }
3006 ## if ($ln =~ /,/) {
3007 ## WARN("MULTIPLE_DECLARATION",
3008 ## "declaring multiple variables together should be avoided\n" . $herecurr);
3009 ## }
3010 ## }
3012 #need space before brace following if, while, etc
3020 }
3021 }
3023 ## # check for blank lines before declarations
3024 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3025 ## $prevrawline =~ /^.\s*$/) {
3026 ## WARN("SPACING",
3027 ## "No blank lines before declarations\n" . $hereprev);
3028 ## }
3029 ##
3031 # closing brace should have a space following it when it has anything
3032 # on the line
3036 }
3038 # check spacing on square brackets
3045 }
3046 }
3053 }
3054 }
3056 # check spacing on parentheses
3064 }
3065 }
3074 }
3075 }
3077 #goto labels aren't indented, allow a single space however
3085 }
3086 }
3088 # Return is not a function.
3093 # Flatten any parentheses
3101 }
3102 #print "value<$value>\n";
3110 }
3111 }
3112 # Return of what appears to be an errno should normally be -'ve
3118 }
3119 }
3121 # Need a space before open parenthesis after if, while etc
3128 }
3129 }
3131 # Check for illegal assignment in if conditional -- and check for trailing
3132 # statements after the conditional.
3140 ##print "stat<$stat> stat_next<$stat_next>\n";
3143 # If the statement carries leading newlines,
3144 # then count those as offsets.
3152 }
3153 }
3161 }
3163 # Find out what is on the end of the line after the
3164 # conditional.
3170 {
3171 # Find out how long the conditional actually is.
3180 }
3184 }
3185 }
3187 # Check for bitwise tests written as boolean
3193 |
3198 {
3201 }
3203 # if and else should not have general statements after it
3210 }
3211 }
3212 # if should not continue a brace
3217 }
3218 # case and default should not have general statements after them
3224 {
3227 }
3229 # Check for }<nl>else {, these must be at the same
3230 # indent level to be relevant to each other.
3235 }
3241 # Find out what is on the end of the line after the
3242 # conditional.
3249 }
3250 }
3252 #Specific variable tests
3256 #gcc binary extension
3260 }
3262 #CamelCase
3265 #Ignore Page<foo> variants
3267 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3274 }
3275 }
3276 }
3278 #no spaces allowed after \ in define
3282 }
3284 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3291 {
3298 }
3299 }
3300 }
3302 # multi-statement macros should be enclosed in a do while loop, grab the
3303 # first statement and ensure its the whole macro if its not enclosed
3304 # in a known good container
3314 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3315 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3323 # Flatten any parentheses and braces
3327 {
3328 }
3330 # Flatten any obvious string concatentation.
3333 {
3334 }
3338 module_param_named|
3339 MODULE_PARM_DESC|
3340 DECLARE_PER_CPU|
3341 DEFINE_PER_CPU|
3342 __typeof__\(|
3343 union|
3344 struct|
3348 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3352 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3357 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
3362 {
3369 }
3377 }
3378 }
3380 # check for line continuations outside of #defines, preprocessor #, and asm
3389 }
3390 }
3392 # do {} while (0) macro tests:
3393 # single-statement macros do not need to be enclosed in do while (0) loop,
3394 # macro should not end with a semicolon
3408 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3418 }
3424 }
3428 }
3429 }
3430 }
3432 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3433 # all assignments may have only one of the following with an assignment:
3434 # .
3435 # ALIGN(...)
3436 # VMLINUX_SYMBOL(...)
3440 }
3442 # check for redundant bracing round if etc
3446 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3447 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3457 # If the condition carries leading newlines, then count those as offsets.
3462 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3464 # We have looked at and allowed this specific line.
3474 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3476 #print "APW: ALLOWED: cond<$cond>\n";
3478 }
3480 #print "APW: ALLOWED: block<$block>\n";
3482 }
3484 #print "APW: ALLOWED: lines block<$block>\n";
3486 }
3488 }
3493 }
3501 }
3502 }
3503 }
3504 }
3509 # Check the pre-context.
3511 #print "APW: ALLOWED: pre<$1>\n";
3513 }
3518 # Check the condition.
3520 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3523 }
3525 #print "APW: ALLOWED: cond<$cond>\n";
3527 }
3529 #print "APW: ALLOWED: block<$block>\n";
3531 }
3533 #print "APW: ALLOWED: lines block<$block>\n";
3535 }
3536 # Check the post-context.
3541 }
3543 #print "APW: ALLOWED: chunk-1 block<$block>\n";
3545 }
3546 }
3553 }
3557 }
3558 }
3560 # check for unnecessary blank lines around braces
3564 }
3568 }
3570 # no volatiles please
3574 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3575 }
3577 # warn about #if 0
3582 }
3584 # check for needless "if (<foo>) fn(<foo>)" uses
3590 }
3591 }
3593 # prefer usleep_range over udelay
3595 # ignore udelay's < 10, however
3599 }
3600 }
3602 # warn about unexpectedly long msleep's
3606 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3607 }
3608 }
3610 # check for comparisons of jiffies
3613 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
3614 }
3616 # check for comparisons of get_jiffies_64()
3619 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
3620 }
3622 # warn about #ifdefs in C files
3623 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3624 # print "#ifdef in C files should be avoided\n";
3625 # print "$herecurr";
3626 # $clean = 0;
3627 # }
3629 # warn about spacing in #ifdefs
3636 }
3638 }
3640 # check for spinlock_t definitions without a comment.
3647 }
3648 }
3649 # check for memory barriers without a comment.
3650 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3654 }
3655 }
3656 # check of hardware specific defines
3657 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
3660 }
3662 # Check that the storage class is at the beginning of a declaration
3666 }
3668 # check the location of the inline attribute, that it is between
3669 # storage class and type.
3674 }
3676 # Check for __inline__ and __inline, prefer inline
3680 }
3682 # Check for __attribute__ packed, prefer __packed
3686 }
3688 # Check for __attribute__ aligned, prefer __aligned
3692 }
3694 # Check for __attribute__ format(printf, prefer __printf
3697 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr);
3698 }
3700 # Check for __attribute__ format(scanf, prefer __scanf
3703 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr);
3704 }
3706 # check for sizeof(&)
3710 }
3712 # check for sizeof without parenthesis
3716 }
3718 # check for line continuations in quoted strings with odd counts of "
3722 }
3724 # check for struct spinlock declarations
3728 }
3730 # check for seq_printf uses that could be seq_puts
3736 }
3737 }
3739 # Check for misused memsets
3754 }
3755 }
3757 # typecasts on min/max could be min_t/max_t
3775 }
3778 }
3779 }
3781 # check usleep_range arguments
3789 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
3793 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
3794 }
3795 }
3797 # check for new externs in .c files.
3800 {
3807 }
3810 {
3813 }
3818 }
3822 {
3825 }
3827 # checks for new __setup's
3834 }
3835 }
3837 # check for pointless casting of kmalloc return
3840 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
3841 }
3843 # alloc style
3844 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
3846 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
3849 }
3851 # check for krealloc arg reuse
3856 }
3858 # check for alloc argument mismatch
3862 }
3864 # check for multiple semicolons
3868 }
3870 # check for switch/default statements without a break;
3879 }
3882 }
3884 # check for gcc specific __FUNCTION__
3888 }
3890 # check for use of yield()
3894 }
3896 # check for comparisons against true and false
3912 }
3917 ## maybe suggesting a correct construct would better
3918 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
3920 }
3921 }
3923 # check for semaphores initialized locked
3927 }
3929 # recommend kstrto* over simple_strto* and strict_strto*
3933 }
3935 # check for __initcall(), use device_initcall() explicitly please
3939 }
3941 # check for various ops structs, ensure they are const.
3943 address_space_operations|
3944 backlight_ops|
3945 block_device_operations|
3946 dentry_operations|
3947 dev_pm_ops|
3948 dma_map_ops|
3949 extent_io_ops|
3950 file_lock_operations|
3951 file_operations|
3952 hv_ops|
3953 ide_dma_ops|
3954 intel_dvo_dev_ops|
3955 item_operations|
3956 iwl_ops|
3957 kgdb_arch|
3958 kgdb_io|
3959 kset_uevent_ops|
3960 lock_manager_operations|
3961 microcode_ops|
3962 mtrr_ops|
3963 neigh_ops|
3964 nlmsvc_binding|
3965 pci_raw_ops|
3966 pipe_buf_operations|
3967 platform_hibernation_ops|
3968 platform_suspend_ops|
3969 proto_ops|
3970 rpc_pipe_ops|
3971 seq_operations|
3972 snd_ac97_build_ops|
3973 soc_pcmcia_socket_ops|
3974 stacktrace_ops|
3975 sysfs_ops|
3976 tty_operations|
3977 usb_mon_operations|
3984 }
3986 # use of NR_CPUS is usually wrong
3987 # ignore definitions of NR_CPUS and usage to define arrays as likely right
3994 {
3996 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
3997 }
3999 # check for %L{u,d,i} in strings
4008 }
4009 }
4011 # whine mightly about in_atomic
4019 }
4020 }
4022 # check for lockdep_set_novalidate_class
4030 }
4031 }
4036 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4037 }
4038 }
4040 # If we have no input at all, then there is nothing to report on
4041 # so just keep quiet.
4044 }
4046 # In mailback mode only produce a report in the negative, for
4047 # things that appear to be patches.
4050 }
4052 # This is not a patch, and we are are in 'no-patch' mode so
4053 # just keep quiet.
4056 }
4061 }
4065 }
4074 }
4081 }
4083 # If there were whitespace errors which cleanpatch can fix
4084 # then suggest that.
4089 }
4090 }
4096 }
4098 }
4113 }
4116 }
4117 }
4124 Do _NOT_ trust the results written to this file.
4127 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4130 EOM
4131 }
4132 }
4136 }
4141 If any of these errors are false positives, please report
4143 EOM
4144 }
4147 }