| blob | 66cad506b8a2a944f2873856ef0078445f673b8b |
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
52 Options:
57 --emacs emacs compile window format
58 --terse one line per report
71 is all off)
73 literally
76 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
77 with potential errors corrected to the preferred
78 checkpatch style
80 runtime errors.
84 EOM
87 }
109 }
110 }
113 }
115 GetOptions(
149 }
150 }
155 }
171 }
172 }
181 }
183 }
184 }
194 ## no critic
197 }
204 }
210 }
217 }
218 }
223 }
224 }
234 __user|
235 __kernel|
236 __force|
237 __iomem|
238 __must_check|
239 __init_refok|
240 __kprobes|
241 __ref|
242 __rcu
247 # Notes to $Attribute:
248 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
250 const|
251 __percpu|
252 __nocast|
253 __safe|
254 __bitwise__|
255 __packed__|
256 __packed2__|
257 __naked|
258 __maybe_unused|
259 __always_unused|
260 __noreturn|
261 __used|
262 __cold|
263 __noclone|
264 __deprecated|
265 __read_mostly|
266 __kprobes|
268 ____cacheline_aligned|
269 ____cacheline_aligned_in_smp|
270 ____cacheline_internodealigned_in_smp|
271 __weak
291 <=|>=|==|!=|
292 =>|->|<<|>>|<|>|!|~|
318 atomic_t
319 )};
323 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
325 panic|
327 )};
336 To:|
337 Cc:
338 )};
359 );
364 );
368 );
371 irq|
372 memory
373 )};
374 # memory.h: ARM has a custom one
387 )
396 )
400 $NonptrType
405 }
406 build_types();
410 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
411 # requires at least perl version v5.10.0
412 # Any use must be runtime checked with $^V
425 }
445 }
448 }
449 }
450 }
474 }
476 }
484 }
488 }
493 }
497 }
505 }
507 }
508 }
526 }
531 }
535 }
539 }
543 }
554 );
559 }
560 }
562 }
585 # If there's a name left after stripping spaces and
586 # leading quotes, and the address doesn't have both
587 # leading and trailing angle brackets, the address
588 # is invalid. ie:
589 # "joe smith joe@smith.com" bad
590 # "joe smith <joe@smith.com" bad
595 }
596 }
606 }
609 }
623 }
629 }
632 }
640 }
641 }
644 }
657 }
659 }
662 }
665 }
669 }
674 # Drop the diff line leader and expand tabs
678 # Pick the indent from the front of the line.
682 }
693 }
694 }
705 # Always copy over the diff marker.
711 # Comments we are wacking completly including the begin
712 # and end, all to $;.
719 }
725 }
732 }
734 # A \ in a string means ignore the next character.
740 }
741 # Regular quotes.
750 }
751 }
753 #print "c<$c> SQ<$sanitise_quote>\n";
762 }
763 }
767 }
769 # The pathname on a #include may be surrounded by '<' and '>'.
774 # The whole of a #error is a string.
778 }
781 }
788 }
811 #warn "CSB: blk<$blk> remain<$remain>\n";
812 # If we are about to drop off the end, pull in more
813 # context.
824 }
825 # Bail if there is no further context.
826 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
829 }
833 }
834 }
839 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
841 # Handle nested #if/#else.
848 }
850 # Statement ends at the ';' or a close '}' at the
851 # outermost level.
854 }
856 # An else is really a conditional as long as its not else if
863 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
864 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
865 }
870 }
878 #warn "CSB: mark coff<$coff>\n";
879 }
880 }
884 }
892 }
894 }
895 }
896 # Preprocessor commands end at the newline unless escaped.
902 }
904 }
905 # We are truly at the end, so shuffle to the next line.
910 }
915 #warn "STATEMENT<$statement>\n";
916 #warn "CONDITION<$condition>\n";
918 #print "coff<$coff> soff<$off> loff<$loff>\n";
922 }
927 # Strip the diff line prefixes and rip blank lines at start and end.
935 }
943 }
964 }
965 }
973 # Grab the first conditional/block pair.
976 #print "F: c<$condition> s<$statement> remain<$remain>\n";
980 }
982 # Pull in the following conditional/block pairs and see if they
983 # could continue the statement.
987 #print "C: c<$condition> s<$statement> remain<$remain>\n";
989 #print "C: push\n";
991 }
994 }
1013 # Handle nested #if/#else.
1020 }
1023 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1027 }
1034 }
1035 }
1039 }
1042 }
1045 }
1051 }
1057 }
1063 }
1068 }
1073 }
1078 # Catch a comment on the end of the line itself.
1082 # Look through the context and try and figure out if there is a
1083 # comment.
1088 #warn " $line\n";
1091 }
1094 }
1097 }
1101 }
1102 }
1106 }
1111 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1112 ##print "CMMT: $cmt\n";
1115 }
1128 }
1131 }
1143 }
1144 }
1148 }
1160 }
1180 }
1201 }
1230 # Assume all arms of the conditional end as this
1231 # one does, and continue as if the #endif was not here.
1248 }
1279 }
1291 }
1324 }
1339 }
1348 }
1352 }
1356 }
1357 }
1360 }
1369 DEFINE_\S+
1370 )$|
1374 case|
1378 \#|
1379 \#\#|
1385 # Check for modifiers.
1396 }
1397 }
1402 }
1403 build_types();
1406 }
1407 }
1415 }
1421 }
1427 }
1433 }
1436 }
1443 }
1445 }
1451 }
1453 }
1459 }
1461 }
1467 ##print "absolute<$absolute>\n";
1469 # See if any suffix of this path is a path within the tree.
1472 ##print "file<$file>\n";
1474 }
1475 }
1478 }
1480 # It is, so see if the prefix is acceptable.
1484 ##print "prefix<$prefix>\n";
1488 }
1489 }
1497 }
1505 }
1513 }
1522 #convert leading spaces to tabs
1524 #Remove spaces before a tab
1528 }
1542 }
1554 }
1555 }
1558 }
1589 # Trace the real file/line as we go.
1601 # suppression flags
1609 # Pre-scan the patch sanitizing the lines.
1610 # Pre-scan the patch looking for any __setup documentation.
1611 #
1615 sanitise_line_reset();
1627 }
1628 #next;
1629 }
1636 }
1639 # Guestimate if this is a continuing comment. Run
1640 # the context looking for a comment "edge". If this
1641 # edge is a close comment then we must be in a comment
1642 # at context start.
1649 #print "RAW<$rawlines[$ln - 1]>\n";
1655 }
1656 }
1659 }
1661 # Guestimate if this is a continuing comment. If this
1662 # is the start of a diff block and this line starts
1663 # ' *' then it is very likely a comment.
1666 {
1668 }
1670 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1674 # Standardise the strings and chars within the input to
1675 # simplify matching -- only bother with positive lines.
1677 }
1684 }
1686 #print "==>$rawline\n";
1687 #print "-->$line\n";
1691 }
1692 }
1705 #extract the line range in the file after the patch is applied
1714 }
1715 annotate_reset();
1724 # track the line number as we move through the hunk, note that
1725 # new versions of GNU diff omit the leading space on completely
1726 # blank context lines so we need to count that too.
1731 # Measure the line length and indent.
1734 # Track the previous line.
1739 #warn "line<$line>\n";
1743 }
1747 #make up the handle for any error we report on this line
1754 # extract the filename as it passes
1769 }
1773 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1774 }
1776 }
1786 # Check for incorrect file permissions
1793 }
1794 }
1796 # Check the patch for a signoff:
1800 }
1802 # Check signature styles
1814 }
1821 }
1822 }
1829 }
1831 }
1838 }
1839 }
1850 # Don't force email to have quotes
1851 # Allow just an angle bracketed address
1857 }
1858 }
1860 # Check for duplicate signatures
1869 }
1870 }
1872 # Check for wrappage within a valid hunk of the file
1877 }
1879 # Check for absolute kernel paths.
1886 #
1889 }
1890 }
1891 }
1893 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1904 }
1906 # Check if it's the start of a commit log
1907 # (not a header line and we haven't seen the patch filename)
1912 }
1914 # Check if there is UTF-8 in a commit log when a mail header has explicitly
1915 # declined it, i.e defined some charset where it is missing.
1920 }
1926 }
1928 # ignore non-hunk lines and lines being removed
1931 #trailing whitespace
1938 }
1945 }
1948 }
1950 # check for Kconfig help text having a real description
1951 # Only applies when adding the entry originally, after that we do not have
1952 # sufficient context to determine whether it is indeed long enough.
1972 }
1981 }
1983 }
1985 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
1986 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
1987 }
1989 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
1993 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
1994 }
2004 };
2007 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2008 }
2010 # check we are in a valid source file if not then ignore this hunk
2013 #line length limit
2016 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2019 {
2022 }
2024 # Check for user-visible strings broken across lines, which breaks the ability
2025 # to grep for the string. Limited to strings used as parameters (those
2026 # following an open parenthesis), which almost completely eliminates false
2027 # positives, as well as warning only once per parameter rather than once per
2028 # line of the string. Make an exception when the previous string ends in a
2029 # newline (multiple lines in one string constant) or \n\t (common in inline
2030 # assembly to indent the instruction on the following line).
2037 }
2039 # check for spaces before a quoted newline
2045 }
2047 }
2049 # check for adding lines without a newline.
2050 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2053 }
2055 # Blackfin: use hi/lo macros
2061 }
2066 }
2067 }
2069 # check we are in a valid source file C or perl if not then ignore this hunk
2072 # at the beginning of a line any tabs must come first and anything
2073 # more than 8 must use tabs.
2082 }
2083 }
2085 # check for space before tabs.
2093 }
2094 }
2096 # check for && or || at the start of a line
2100 }
2102 # check multi-line statement indentation matches previous line
2127 }
2128 }
2129 }
2130 }
2138 }
2139 }
2146 }
2155 }
2164 }
2166 # check for spaces at the beginning of a line.
2167 # Exceptions:
2168 # 1) within comments
2169 # 2) indented preprocessor commands
2170 # 3) hanging labels
2177 }
2178 }
2180 # check we are in a valid C source file if not then ignore this hunk
2183 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2186 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2187 }
2189 # check for RCS/CVS revision markers
2193 }
2195 # Blackfin: don't use __builtin_bfin_[cs]sync
2200 }
2205 }
2207 # check for old HOTPLUG __dev<foo> section markings
2211 }
2213 # Check for potential 'bare' types
2216 #print "LINE<$line>\n";
2224 #print "linenr<$linenr> <$stat>\n";
2225 # If this statement has no statement boundaries within
2226 # it there is no point in retrying a statement scan
2227 # until we hit end of it.
2230 #print "skip<$line_nr_next>\n";
2232 }
2234 # Find the real next line.
2240 }
2245 # Ignore goto labels.
2248 # Ignore functions being called
2253 # declarations always start with types
2254 } 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) {
2259 # definitions in global scope can only start with types
2262 }
2264 # any (foo ... *) is a pointer cast, and foo is a type
2267 }
2269 # Check for any sort of function declaration.
2270 # int foo(something bar, other baz);
2271 # void (*store_gdt)(x86_descr_ptr *);
2272 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2280 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2283 }
2284 }
2285 }
2287 }
2289 #
2290 # Checks which may be anchored in the context.
2291 #
2293 # Check for switch () and associated case and default
2294 # statements should be at the same indent.
2308 }
2309 }
2313 }
2314 }
2316 # if/while/etc brace do not go on next line, unless defining a do while loop,
2317 # or if that brace on the next line is for something else
2326 }
2337 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2340 }
2342 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2343 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2349 }
2353 {
2359 }
2360 }
2361 }
2363 # Check relative indent for conditionals and blocks.
2364 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2372 # Make sure we remove the line prefixes as we have
2373 # none on the first line, and are going to readd them
2374 # where necessary.
2377 # Find out how long the conditional actually is.
2381 # We want to check the first line inside the block
2382 # starting at the end of the conditional, so remove:
2383 # 1) any blank line termination
2384 # 2) any opening brace { on end of the line
2385 # 3) any do (...) {
2392 }
2396 }
2398 # Also ignore a loop construct at the end of a
2399 # preprocessor statement.
2403 }
2410 # If we see an #else/#elif then the code
2411 # is not linear.
2414 }
2416 # Ignore:
2417 # 1) blank lines, they should be at 0,
2418 # 2) preprocessor lines, and
2419 # 3) labels.
2427 }
2428 }
2429 }
2434 # Check if either of these lines are modified, else
2435 # this is not this patch's fault.
2439 }
2442 }
2444 #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";
2449 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2450 }
2451 }
2453 # Track the 'values' across context and added lines.
2463 }
2466 #ignore lines not being added
2469 # TEST: allow direct testing of the type matcher.
2477 }
2479 }
2480 # TEST: allow direct testing of the attribute matcher.
2488 }
2490 }
2492 # check for initialisation to aggregates open brace on the next line
2497 }
2499 #
2500 # Checks which are anchored on the added line.
2501 #
2503 # check for malformed paths in #include statements (uses RAW line)
2509 }
2513 }
2514 }
2516 # no C99 // comments
2525 }
2526 }
2527 }
2528 # Remove C99 comments.
2532 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2533 # the whole statement.
2534 #print "APW <$lines[$realline_next - 1]>\n";
2540 # Handle definitions which produce identifiers with
2541 # a prefix:
2542 # XXX(foo);
2543 # EXPORT_SYMBOL(something_foo);
2547 #print "FOO C name<$name>\n";
2558 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2562 }
2563 }
2568 #print "FOO B <$lines[$linenr - 1]>\n";
2570 }
2575 }
2577 # check for global initialisers.
2584 }
2585 }
2586 # check for static initialisers.
2593 }
2594 }
2596 # check for static const char * arrays.
2601 }
2603 # check for static char foo[] = "bar" declarations.
2608 }
2610 # check for declarations of struct pci_device_id
2614 }
2616 # check for new typedefs, only function parameters and sparse annotations
2617 # make sense.
2625 }
2627 # * goes on variable not on type
2628 # (char*[ const])
2630 #print "AA<$1>\n";
2633 # Should start with a space.
2635 # Should not end with a space.
2637 # '*'s should not have spaces between.
2639 }
2641 ## print "1: from<$from> to<$to> ident<$ident>\n";
2651 }
2652 }
2653 }
2655 #print "BB<$1>\n";
2658 # Should start with a space.
2660 # Should not end with a space.
2662 # '*'s should not have spaces between.
2664 }
2665 # Modifiers should have spaces.
2668 ## print "2: from<$from> to<$to> ident<$ident>\n";
2679 }
2680 }
2681 }
2683 # # no BUG() or BUG_ON()
2684 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2685 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2686 # print "$herecurr";
2687 # $clean = 0;
2688 # }
2692 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2693 }
2695 # check for uses of printk_ratelimit
2699 }
2701 # printk should use KERN_* levels. Note that follow on printk's on the
2702 # same line do not need a level, so we use the current block context
2703 # to try and find and validate the current printk. In summary the current
2704 # printk includes all preceding printk's which have no newline on the end.
2705 # we assume the first bad printk is the one to report.
2709 #print "CHECK<$lines[$ln - 1]\n";
2710 # we have a preceding printk if it ends
2711 # with "\n" ignore it, else it is to blame
2715 }
2717 }
2718 }
2722 }
2723 }
2732 "Prefer netdev_$level2(netdev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
2733 }
2741 }
2742 }
2751 }
2753 # function brace can't be on same line, except for #defines of do while,
2754 # or if closed on same line
2759 }
2761 # open braces for enum, union and struct go on the same line.
2766 }
2768 # missing space after union, struct or enum definition
2775 }
2776 }
2778 # check for spacing round square brackets; allowed:
2779 # 1. with a type on the left -- int [] a;
2780 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2781 # 3. inside a curly brace -- = { [0...10] = 5 }
2792 }
2793 }
2794 }
2796 # check for spaces between functions and their parentheses.
2802 # Ignore those directives where spaces _are_ permitted.
2808 {
2809 # cpp #define statements have non-optional spaces, ie
2810 # if there is a space between the name and the open
2811 # parenthesis it is simply not a parameter group.
2814 # cpp #elif statement condition may start with a (
2817 # If this whole things ends with a type its most
2818 # likely a typedef for a function.
2827 }
2828 }
2829 }
2831 # Check operator spacing.
2837 <<=|>>=|<=|>=|==|!=|
2839 =>|->|<<|>>|<|>|=|!|~|
2845 ## print("element count: <" . $#elements . ">\n");
2846 ## foreach my $el (@elements) {
2847 ## print("el: <$el>\n");
2848 ## }
2856 }
2867 ## print("n: <$n> good: <$good>\n");
2871 # Pick up the preceding and succeeding characters.
2876 }
2899 }
2908 # Pull out the value of this operator.
2911 # Get the full operator variant.
2914 # Ignore operators passed as parameters.
2918 # # Ignore comments
2919 # } elsif ($op =~ /^$;+$/) {
2921 # ; should have either the end of line or a space or \ after it
2929 }
2930 }
2932 # // is a comment
2935 # No spaces for:
2936 # ->
2937 # : when part of a bitfield
2945 }
2947 }
2948 }
2950 # , must have a space on the right.
2958 }
2959 }
2961 # '*' as part of a type definition -- reported already.
2963 #warn "'*' is part of type\n";
2965 # unary operators should have a space before and
2966 # none after. May be left adjacent to another
2967 # unary operator, or a cast
2977 }
2978 }
2979 }
2981 # A unary '*' may be const
2989 }
2991 }
2992 }
2994 # unary ++ and unary -- are allowed no space on one side.
3001 }
3002 }
3009 }
3010 }
3017 }
3019 }
3020 }
3022 # << and >> may either have or not have spaces both sides
3028 {
3035 }
3037 }
3038 }
3040 # A colon needs no spaces before when it is
3041 # terminating a case value or a label.
3048 }
3049 }
3051 # All the others need spaces both sides.
3055 # Ignore email addresses <foo@bar>
3060 {
3062 }
3064 # Ignore ?:
3068 }
3076 }
3078 }
3079 }
3080 }
3083 ## print("n: <$n> GOOD: <$good>\n");
3086 }
3090 }
3094 }
3097 }
3099 # check for whitespace before a non-naked semicolon
3106 }
3107 }
3109 # check for multiple assignments
3113 }
3115 ## # check for multiple declarations, allowing for a function declaration
3116 ## # continuation.
3117 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3118 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3119 ##
3120 ## # Remove any bracketed sections to ensure we do not
3121 ## # falsly report the parameters of functions.
3122 ## my $ln = $line;
3123 ## while ($ln =~ s/\([^\(\)]*\)//g) {
3124 ## }
3125 ## if ($ln =~ /,/) {
3126 ## WARN("MULTIPLE_DECLARATION",
3127 ## "declaring multiple variables together should be avoided\n" . $herecurr);
3128 ## }
3129 ## }
3131 #need space before brace following if, while, etc
3138 }
3139 }
3141 ## # check for blank lines before declarations
3142 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3143 ## $prevrawline =~ /^.\s*$/) {
3144 ## WARN("SPACING",
3145 ## "No blank lines before declarations\n" . $hereprev);
3146 ## }
3147 ##
3149 # closing brace should have a space following it when it has anything
3150 # on the line
3157 }
3158 }
3160 # check spacing on square brackets
3167 }
3168 }
3175 }
3176 }
3178 # check spacing on parentheses
3186 }
3187 }
3196 }
3197 }
3199 #goto labels aren't indented, allow a single space however
3207 }
3208 }
3210 # Return is not a function.
3215 # Flatten any parentheses
3223 }
3224 #print "value<$value>\n";
3232 }
3233 }
3234 # Return of what appears to be an errno should normally be -'ve
3240 }
3241 }
3243 # Need a space before open parenthesis after if, while etc
3250 }
3251 }
3253 # Check for illegal assignment in if conditional -- and check for trailing
3254 # statements after the conditional.
3262 ##print "stat<$stat> stat_next<$stat_next>\n";
3265 # If the statement carries leading newlines,
3266 # then count those as offsets.
3274 }
3275 }
3283 }
3285 # Find out what is on the end of the line after the
3286 # conditional.
3292 {
3293 # Find out how long the conditional actually is.
3302 }
3306 }
3307 }
3309 # Check for bitwise tests written as boolean
3315 |
3320 {
3323 }
3325 # if and else should not have general statements after it
3332 }
3333 }
3334 # if should not continue a brace
3339 }
3340 # case and default should not have general statements after them
3346 {
3349 }
3351 # Check for }<nl>else {, these must be at the same
3352 # indent level to be relevant to each other.
3357 }
3363 # Find out what is on the end of the line after the
3364 # conditional.
3371 }
3372 }
3374 #Specific variable tests
3378 #gcc binary extension
3386 }
3387 }
3389 #CamelCase
3392 #Ignore Page<foo> variants
3394 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3404 }
3405 }
3406 }
3407 }
3409 #no spaces allowed after \ in define
3415 }
3416 }
3418 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3425 {
3432 }
3433 }
3434 }
3436 # multi-statement macros should be enclosed in a do while loop, grab the
3437 # first statement and ensure its the whole macro if its not enclosed
3438 # in a known good container
3448 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3449 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3457 # Flatten any parentheses and braces
3461 {
3462 }
3464 # Flatten any obvious string concatentation.
3467 {
3468 }
3472 module_param_named|
3473 MODULE_PARM_DESC|
3474 DECLARE_PER_CPU|
3475 DEFINE_PER_CPU|
3476 __typeof__\(|
3477 union|
3478 struct|
3482 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3486 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3491 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
3497 {
3504 }
3512 }
3513 }
3515 # check for line continuations outside of #defines, preprocessor #, and asm
3524 }
3525 }
3527 # do {} while (0) macro tests:
3528 # single-statement macros do not need to be enclosed in do while (0) loop,
3529 # macro should not end with a semicolon
3543 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3553 }
3559 }
3563 }
3564 }
3565 }
3567 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3568 # all assignments may have only one of the following with an assignment:
3569 # .
3570 # ALIGN(...)
3571 # VMLINUX_SYMBOL(...)
3575 }
3577 # check for redundant bracing round if etc
3581 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3582 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3592 # If the condition carries leading newlines, then count those as offsets.
3597 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3599 # We have looked at and allowed this specific line.
3609 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3611 #print "APW: ALLOWED: cond<$cond>\n";
3613 }
3615 #print "APW: ALLOWED: block<$block>\n";
3617 }
3619 #print "APW: ALLOWED: lines block<$block>\n";
3621 }
3623 }
3628 }
3636 }
3637 }
3638 }
3639 }
3644 # Check the pre-context.
3646 #print "APW: ALLOWED: pre<$1>\n";
3648 }
3653 # Check the condition.
3655 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3658 }
3660 #print "APW: ALLOWED: cond<$cond>\n";
3662 }
3664 #print "APW: ALLOWED: block<$block>\n";
3666 }
3668 #print "APW: ALLOWED: lines block<$block>\n";
3670 }
3671 # Check the post-context.
3676 }
3678 #print "APW: ALLOWED: chunk-1 block<$block>\n";
3680 }
3681 }
3688 }
3692 }
3693 }
3695 # check for unnecessary blank lines around braces
3699 }
3703 }
3705 # no volatiles please
3709 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3710 }
3712 # warn about #if 0
3717 }
3719 # check for needless "if (<foo>) fn(<foo>)" uses
3725 }
3726 }
3734 }
3736 # check for bad placement of section $InitAttribute (e.g.: __initdata)
3739 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
3749 $fixed[$linenr - 1] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
3750 }
3751 }
3752 }
3754 # prefer usleep_range over udelay
3756 # ignore udelay's < 10, however
3760 }
3761 }
3763 # warn about unexpectedly long msleep's
3767 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
3768 }
3769 }
3771 # check for comparisons of jiffies
3774 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
3775 }
3777 # check for comparisons of get_jiffies_64()
3780 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
3781 }
3783 # warn about #ifdefs in C files
3784 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
3785 # print "#ifdef in C files should be avoided\n";
3786 # print "$herecurr";
3787 # $clean = 0;
3788 # }
3790 # warn about spacing in #ifdefs
3797 }
3799 }
3801 # check for spinlock_t definitions without a comment.
3808 }
3809 }
3810 # check for memory barriers without a comment.
3811 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
3815 }
3816 }
3817 # check of hardware specific defines
3818 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
3821 }
3823 # Check that the storage class is at the beginning of a declaration
3827 }
3829 # check the location of the inline attribute, that it is between
3830 # storage class and type.
3835 }
3837 # Check for __inline__ and __inline, prefer inline
3844 }
3845 }
3847 # Check for __attribute__ packed, prefer __packed
3851 }
3853 # Check for __attribute__ aligned, prefer __aligned
3857 }
3859 # Check for __attribute__ format(printf, prefer __printf
3862 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
3864 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
3866 }
3867 }
3869 # Check for __attribute__ format(scanf, prefer __scanf
3872 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
3874 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
3875 }
3876 }
3878 # check for sizeof(&)
3882 }
3884 # check for sizeof without parenthesis
3889 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
3890 }
3891 }
3893 # check for line continuations in quoted strings with odd counts of "
3897 }
3899 # check for struct spinlock declarations
3903 }
3905 # check for seq_printf uses that could be seq_puts
3913 }
3914 }
3915 }
3917 # Check for misused memsets
3932 }
3933 }
3935 # typecasts on min/max could be min_t/max_t
3953 }
3956 }
3957 }
3959 # check usleep_range arguments
3967 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
3971 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
3972 }
3973 }
3975 # check for new externs in .h files.
3982 }
3983 }
3985 # check for new externs in .c files.
3988 {
3995 }
3998 {
4001 }
4006 }
4010 {
4013 }
4015 # checks for new __setup's
4022 }
4023 }
4025 # check for pointless casting of kmalloc return
4028 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4029 }
4031 # alloc style
4032 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4034 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4037 }
4039 # check for krealloc arg reuse
4044 }
4046 # check for alloc argument mismatch
4050 }
4052 # check for multiple semicolons
4058 }
4059 }
4061 # check for switch/default statements without a break;
4070 }
4073 }
4075 # check for gcc specific __FUNCTION__
4081 }
4082 }
4084 # check for use of yield()
4088 }
4090 # check for comparisons against true and false
4106 }
4111 ## maybe suggesting a correct construct would better
4112 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4114 }
4115 }
4117 # check for semaphores initialized locked
4121 }
4123 # recommend kstrto* over simple_strto* and strict_strto*
4127 }
4129 # check for __initcall(), use device_initcall() explicitly please
4133 }
4135 # check for various ops structs, ensure they are const.
4137 address_space_operations|
4138 backlight_ops|
4139 block_device_operations|
4140 dentry_operations|
4141 dev_pm_ops|
4142 dma_map_ops|
4143 extent_io_ops|
4144 file_lock_operations|
4145 file_operations|
4146 hv_ops|
4147 ide_dma_ops|
4148 intel_dvo_dev_ops|
4149 item_operations|
4150 iwl_ops|
4151 kgdb_arch|
4152 kgdb_io|
4153 kset_uevent_ops|
4154 lock_manager_operations|
4155 microcode_ops|
4156 mtrr_ops|
4157 neigh_ops|
4158 nlmsvc_binding|
4159 pci_raw_ops|
4160 pipe_buf_operations|
4161 platform_hibernation_ops|
4162 platform_suspend_ops|
4163 proto_ops|
4164 rpc_pipe_ops|
4165 seq_operations|
4166 snd_ac97_build_ops|
4167 soc_pcmcia_socket_ops|
4168 stacktrace_ops|
4169 sysfs_ops|
4170 tty_operations|
4171 usb_mon_operations|
4178 }
4180 # use of NR_CPUS is usually wrong
4181 # ignore definitions of NR_CPUS and usage to define arrays as likely right
4188 {
4190 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4191 }
4193 # check for %L{u,d,i} in strings
4202 }
4203 }
4205 # whine mightly about in_atomic
4213 }
4214 }
4216 # check for lockdep_set_novalidate_class
4224 }
4225 }
4230 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4231 }
4232 }
4234 # If we have no input at all, then there is nothing to report on
4235 # so just keep quiet.
4238 }
4240 # In mailback mode only produce a report in the negative, for
4241 # things that appear to be patches.
4244 }
4246 # This is not a patch, and we are are in 'no-patch' mode so
4247 # just keep quiet.
4250 }
4255 }
4259 }
4268 }
4275 }
4277 # If there were whitespace errors which cleanpatch can fix
4278 # then suggest that.
4283 }
4284 }
4302 }
4305 }
4306 }
4313 Do _NOT_ trust the results written to this file.
4316 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4319 EOM
4320 }
4321 }
4325 }
4330 If any of these errors are false positives, please report
4332 EOM
4333 }
4336 }