| blob | d8670810db65f664623a18f991a88a7a72a00d5b |
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
40 Options:
45 --emacs emacs compile window format
46 --terse one line per report
55 is all off)
57 literally
61 EOM
64 }
66 GetOptions(
94 }
101 ## no critic
104 }
111 }
117 }
124 }
125 }
130 }
131 }
141 __user|
142 __kernel|
143 __force|
144 __iomem|
145 __must_check|
146 __init_refok|
147 __kprobes|
148 __ref
151 # Notes to $Attribute:
152 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
154 const|
155 __percpu|
156 __nocast|
157 __safe|
158 __bitwise__|
159 __packed__|
160 __packed2__|
161 __naked|
162 __maybe_unused|
163 __always_unused|
164 __noreturn|
165 __used|
166 __cold|
167 __noclone|
168 __deprecated|
169 __read_mostly|
170 __kprobes|
172 ____cacheline_aligned|
173 ____cacheline_aligned_in_smp|
174 ____cacheline_internodealigned_in_smp|
175 __weak
186 <=|>=|==|!=|
187 =>|->|<<|>>|<|>|!|~|
208 atomic_t
209 )};
212 printk|
215 WARN|
216 panic
217 )};
238 );
241 );
244 irq|
245 memory
246 )};
247 # memory.h: ARM has a custom one
259 )
263 $NonptrType
268 }
269 build_types();
287 }
288 }
289 }
290 }
292 }
307 }
312 }
316 }
320 }
323 }
334 );
339 }
340 }
342 }
355 }
357 }
360 }
363 }
367 }
372 # Drop the diff line leader and expand tabs
376 # Pick the indent from the front of the line.
380 }
391 }
392 }
403 # Always copy over the diff marker.
409 # Comments we are wacking completly including the begin
410 # and end, all to $;.
417 }
423 }
430 }
432 # A \ in a string means ignore the next character.
438 }
439 # Regular quotes.
448 }
449 }
451 #print "c<$c> SQ<$sanitise_quote>\n";
460 }
461 }
465 }
467 # The pathname on a #include may be surrounded by '<' and '>'.
472 # The whole of a #error is a string.
476 }
479 }
502 #warn "CSB: blk<$blk> remain<$remain>\n";
503 # If we are about to drop off the end, pull in more
504 # context.
515 }
516 # Bail if there is no further context.
517 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
520 }
521 }
526 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
528 # Handle nested #if/#else.
535 }
537 # Statement ends at the ';' or a close '}' at the
538 # outermost level.
541 }
543 # An else is really a conditional as long as its not else if
550 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
551 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
552 }
557 }
565 #warn "CSB: mark coff<$coff>\n";
566 }
567 }
571 }
579 }
581 }
582 }
584 }
585 # We are truly at the end, so shuffle to the next line.
590 }
595 #warn "STATEMENT<$statement>\n";
596 #warn "CONDITION<$condition>\n";
598 #print "coff<$coff> soff<$off> loff<$loff>\n";
602 }
607 # Strip the diff line prefixes and rip blank lines at start and end.
615 }
623 }
644 }
645 }
653 # Grab the first conditional/block pair.
656 #print "F: c<$condition> s<$statement> remain<$remain>\n";
660 }
662 # Pull in the following conditional/block pairs and see if they
663 # could continue the statement.
667 #print "C: c<$condition> s<$statement> remain<$remain>\n";
669 #print "C: push\n";
671 }
674 }
693 # Handle nested #if/#else.
700 }
703 ##print "C<$c>L<$level><$open$close>O<$off>\n";
707 }
714 }
715 }
719 }
722 }
725 }
731 }
737 }
743 }
748 }
753 }
758 # Catch a comment on the end of the line itself.
762 # Look through the context and try and figure out if there is a
763 # comment.
768 #warn " $line\n";
771 }
774 }
777 }
781 }
782 }
786 }
791 ##print "LINE: $rawlines[$end_line - 1 ]\n";
792 ##print "CMMT: $cmt\n";
795 }
808 }
811 }
823 }
824 }
828 }
840 }
860 }
881 }
910 # Assume all arms of the conditional end as this
911 # one does, and continue as if the #endif was not here.
928 }
959 }
971 }
1004 }
1019 }
1028 }
1032 }
1036 }
1037 }
1040 }
1049 DEFINE_\S+
1050 )$|
1054 case|
1057 do
1063 # Check for modifiers.
1074 }
1075 }
1080 }
1081 build_types();
1084 }
1085 }
1092 }
1100 }
1103 }
1108 }
1109 }
1114 }
1115 }
1120 }
1121 }
1127 ##print "absolute<$absolute>\n";
1129 # See if any suffix of this path is a path within the tree.
1132 ##print "file<$file>\n";
1134 }
1135 }
1138 }
1140 # It is, so see if the prefix is acceptable.
1144 ##print "prefix<$prefix>\n";
1147 }
1148 }
1174 # Trace the real file/line as we go.
1186 # suppression flags
1191 # Pre-scan the patch sanitizing the lines.
1192 # Pre-scan the patch looking for any __setup documentation.
1193 #
1197 sanitise_line_reset();
1207 }
1208 #next;
1209 }
1216 }
1219 # Guestimate if this is a continuing comment. Run
1220 # the context looking for a comment "edge". If this
1221 # edge is a close comment then we must be in a comment
1222 # at context start.
1229 #print "RAW<$rawlines[$ln - 1]>\n";
1235 }
1236 }
1239 }
1241 # Guestimate if this is a continuing comment. If this
1242 # is the start of a diff block and this line starts
1243 # ' *' then it is very likely a comment.
1246 {
1248 }
1250 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1254 # Standardise the strings and chars within the input to
1255 # simplify matching -- only bother with positive lines.
1257 }
1264 }
1266 #print "==>$rawline\n";
1267 #print "-->$line\n";
1271 }
1272 }
1283 #extract the line range in the file after the patch is applied
1292 }
1293 annotate_reset();
1301 # track the line number as we move through the hunk, note that
1302 # new versions of GNU diff omit the leading space on completely
1303 # blank context lines so we need to count that too.
1308 # Measure the line length and indent.
1311 # Track the previous line.
1316 #warn "line<$line>\n";
1320 }
1324 #make up the handle for any error we report on this line
1331 # extract the filename as it passes
1344 }
1347 ERROR("do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1348 }
1350 }
1360 # Check for incorrect file permissions
1365 }
1366 }
1368 #check the patch for a signoff:
1370 # This is a signoff, if ugly, so do not double report.
1375 }
1379 }
1380 }
1382 # Check for wrappage within a valid hunk of the file
1386 }
1388 # Check for absolute kernel paths.
1395 #
1398 }
1399 }
1400 }
1402 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1412 }
1414 # ignore non-hunk lines and lines being removed
1417 #trailing whitespace
1426 }
1428 # check for Kconfig help text having a real description
1429 # Only applies when adding the entry originally, after that we do not have
1430 # sufficient context to determine whether it is indeed long enough.
1452 }
1454 }
1455 WARN("please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_end && $length < 4);
1456 #print "is_end<$is_end> length<$length>\n";
1457 }
1459 # check we are in a valid source file if not then ignore this hunk
1462 #80 column limit
1468 {
1470 }
1472 # check for spaces before a quoted newline
1475 }
1477 # check for adding lines without a newline.
1478 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
1480 }
1482 # Blackfin: use hi/lo macros
1487 }
1491 }
1492 }
1494 # check we are in a valid source file C or perl if not then ignore this hunk
1497 # at the beginning of a line any tabs must come first and anything
1498 # more than 8 must use tabs.
1504 }
1506 # check for space before tabs.
1510 }
1512 # check for spaces at the beginning of a line.
1513 # Exceptions:
1514 # 1) within comments
1515 # 2) indented preprocessor commands
1516 # 3) hanging labels
1520 }
1522 # check we are in a valid C source file if not then ignore this hunk
1525 # check for RCS/CVS revision markers
1528 }
1530 # Blackfin: don't use __builtin_bfin_[cs]sync
1534 }
1538 }
1540 # Check for potential 'bare' types
1549 # Find the real next line.
1555 }
1560 # Ignore goto labels.
1563 # Ignore functions being called
1568 # declarations always start with types
1569 } 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) {
1574 # definitions in global scope can only start with types
1577 }
1579 # any (foo ... *) is a pointer cast, and foo is a type
1582 }
1584 # Check for any sort of function declaration.
1585 # int foo(something bar, other baz);
1586 # void (*store_gdt)(x86_descr_ptr *);
1587 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
1595 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
1598 }
1599 }
1600 }
1602 }
1604 #
1605 # Checks which may be anchored in the context.
1606 #
1608 # Check for switch () and associated case and default
1609 # statements should be at the same indent.
1623 }
1624 }
1627 }
1628 }
1630 # if/while/etc brace do not go on next line, unless defining a do while loop,
1631 # or if that brace on the next line is for something else
1645 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
1648 }
1650 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
1651 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
1656 }
1660 {
1665 }
1666 }
1667 }
1669 # Check relative indent for conditionals and blocks.
1670 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
1675 # Make sure we remove the line prefixes as we have
1676 # none on the first line, and are going to readd them
1677 # where necessary.
1680 # Find out how long the conditional actually is.
1684 # We want to check the first line inside the block
1685 # starting at the end of the conditional, so remove:
1686 # 1) any blank line termination
1687 # 2) any opening brace { on end of the line
1688 # 3) any do (...) {
1695 }
1699 }
1701 # Also ignore a loop construct at the end of a
1702 # preprocessor statement.
1706 }
1713 # If we see an #else/#elif then the code
1714 # is not linear.
1717 }
1719 # Ignore:
1720 # 1) blank lines, they should be at 0,
1721 # 2) preprocessor lines, and
1722 # 3) labels.
1730 }
1731 }
1732 }
1737 # Check if either of these lines are modified, else
1738 # this is not this patch's fault.
1742 }
1745 }
1747 #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";
1751 WARN("suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
1752 }
1753 }
1755 # Track the 'values' across context and added lines.
1765 }
1768 #ignore lines not being added
1771 # TEST: allow direct testing of the type matcher.
1777 }
1779 }
1780 # TEST: allow direct testing of the attribute matcher.
1786 }
1788 }
1790 # check for initialisation to aggregates open brace on the next line
1794 }
1796 #
1797 # Checks which are anchored on the added line.
1798 #
1800 # check for malformed paths in #include statements (uses RAW line)
1806 }
1807 }
1809 # no C99 // comments
1812 }
1813 # Remove C99 comments.
1817 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
1818 # the whole statement.
1819 #print "APW <$lines[$realline_next - 1]>\n";
1825 # Handle definitions which produce identifiers with
1826 # a prefix:
1827 # XXX(foo);
1828 # EXPORT_SYMBOL(something_foo);
1832 #print "FOO C name<$name>\n";
1843 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
1847 }
1848 }
1853 #print "FOO B <$lines[$linenr - 1]>\n";
1855 }
1859 }
1861 # check for global initialisers.
1865 }
1866 # check for static initialisers.
1870 }
1872 # check for static const char * arrays.
1876 }
1878 # check for static char foo[] = "bar" declarations.
1882 }
1884 # check for declarations of struct pci_device_id
1887 }
1889 # check for new typedefs, only function parameters and sparse annotations
1890 # make sense.
1897 }
1899 # * goes on variable not on type
1900 # (char*[ const])
1904 # Should start with a space.
1906 # Should not end with a space.
1908 # '*'s should not have spaces between.
1910 }
1912 #print "from<$from> to<$to>\n";
1915 }
1919 # Should start with a space.
1921 # Should not end with a space.
1923 # '*'s should not have spaces between.
1925 }
1926 # Modifiers should have spaces.
1929 #print "from<$from> to<$to> ident<$ident>\n";
1932 }
1933 }
1935 # # no BUG() or BUG_ON()
1936 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
1937 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
1938 # print "$herecurr";
1939 # $clean = 0;
1940 # }
1943 WARN("LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
1944 }
1946 # printk should use KERN_* levels. Note that follow on printk's on the
1947 # same line do not need a level, so we use the current block context
1948 # to try and find and validate the current printk. In summary the current
1949 # printk includes all preceding printk's which have no newline on the end.
1950 # we assume the first bad printk is the one to report.
1954 #print "CHECK<$lines[$ln - 1]\n";
1955 # we have a preceding printk if it ends
1956 # with "\n" ignore it, else it is to blame
1960 }
1962 }
1963 }
1966 }
1967 }
1969 # function brace can't be on same line, except for #defines of do while,
1970 # or if closed on same line
1974 }
1976 # open braces for enum, union and struct go on the same line.
1980 }
1982 # missing space after union, struct or enum definition
1985 }
1987 # check for spacing round square brackets; allowed:
1988 # 1. with a type on the left -- int [] a;
1989 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
1990 # 3. inside a curly brace -- = { [0...10] = 5 }
1997 }
1998 }
2000 # check for spaces between functions and their parentheses.
2006 # Ignore those directives where spaces _are_ permitted.
2012 {
2014 # cpp #define statements have non-optional spaces, ie
2015 # if there is a space between the name and the open
2016 # parenthesis it is simply not a parameter group.
2019 # cpp #elif statement condition may start with a (
2022 # If this whole things ends with a type its most
2023 # likely a typedef for a function.
2028 }
2029 }
2030 # Check operator spacing.
2033 <<=|>>=|<=|>=|==|!=|
2035 =>|->|<<|>>|<|>|=|!|~|
2047 # Pick up the preceding and succeeding characters.
2052 }
2075 }
2084 # Pull out the value of this operator.
2087 # Get the full operator variant.
2090 # Ignore operators passed as parameters.
2094 # # Ignore comments
2095 # } elsif ($op =~ /^$;+$/) {
2097 # ; should have either the end of line or a space or \ after it
2102 }
2104 # // is a comment
2107 # No spaces for:
2108 # ->
2109 # : when part of a bitfield
2113 }
2115 # , must have a space on the right.
2119 }
2121 # '*' as part of a type definition -- reported already.
2123 #warn "'*' is part of type\n";
2125 # unary operators should have a space before and
2126 # none after. May be left adjacent to another
2127 # unary operator, or a cast
2133 }
2135 # A unary '*' may be const
2139 }
2141 # unary ++ and unary -- are allowed no space on one side.
2145 }
2149 }
2152 }
2155 # << and >> may either have or not have spaces both sides
2161 {
2165 }
2167 # A colon needs no spaces before when it is
2168 # terminating a case value or a label.
2172 }
2174 # All the others need spaces both sides.
2178 # Ignore email addresses <foo@bar>
2183 {
2185 }
2187 # Ignore ?:
2191 }
2195 }
2196 }
2198 }
2199 }
2201 # check for multiple assignments
2204 }
2206 ## # check for multiple declarations, allowing for a function declaration
2207 ## # continuation.
2208 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
2209 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
2210 ##
2211 ## # Remove any bracketed sections to ensure we do not
2212 ## # falsly report the parameters of functions.
2213 ## my $ln = $line;
2214 ## while ($ln =~ s/\([^\(\)]*\)//g) {
2215 ## }
2216 ## if ($ln =~ /,/) {
2217 ## WARN("declaring multiple variables together should be avoided\n" . $herecurr);
2218 ## }
2219 ## }
2221 #need space before brace following if, while, etc
2225 }
2227 # closing brace should have a space following it when it has anything
2228 # on the line
2231 }
2233 # check spacing on square brackets
2236 }
2239 }
2241 # check spacing on parentheses
2245 }
2250 }
2252 #goto labels aren't indented, allow a single space however
2256 }
2258 # Return is not a function.
2263 # Flatten any parentheses
2271 }
2272 #print "value<$value>\n";
2278 }
2279 }
2280 # Return of what appears to be an errno should normally be -'ve
2285 }
2286 }
2288 # Need a space before open parenthesis after if, while etc
2291 }
2293 # Check for illegal assignment in if conditional -- and check for trailing
2294 # statements after the conditional.
2299 ##print "stat<$stat> stat_next<$stat_next>\n";
2302 # If the statement carries leading newlines,
2303 # then count those as offsets.
2311 }
2312 }
2319 }
2321 # Find out what is on the end of the line after the
2322 # conditional.
2328 {
2329 # Find out how long the conditional actually is.
2338 }
2341 }
2342 }
2344 # Check for bitwise tests written as boolean
2350 |
2355 {
2357 }
2359 # if and else should not have general statements after it
2365 }
2366 }
2367 # if should not continue a brace
2371 }
2372 # case and default should not have general statements after them
2378 {
2380 }
2382 # Check for }<nl>else {, these must be at the same
2383 # indent level to be relevant to each other.
2387 }
2393 # Find out what is on the end of the line after the
2394 # conditional.
2400 }
2401 }
2403 #studly caps, commented out until figure out how to distinguish between use of existing and adding new
2404 # if (($line=~/[\w_][a-z\d]+[A-Z]/) and !($line=~/print/)) {
2405 # print "No studly caps, use _\n";
2406 # print "$herecurr";
2407 # $clean = 0;
2408 # }
2410 #no spaces allowed after \ in define
2413 }
2415 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
2422 {
2427 }
2428 }
2429 }
2431 # multi-statement macros should be enclosed in a do while loop, grab the
2432 # first statement and ensure its the whole macro if its not enclosed
2433 # in a known good container
2443 # Find the end of the macro and limit our statement
2444 # search to that.
2447 {
2451 }
2456 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
2457 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
2459 # Extract the remainder of the define (if any) and
2460 # rip off surrounding spaces, and trailing \'s.
2463 #print "ADDING cnt<$cnt> $off <" . substr($lines[$ln - 1], $off) . "> rest<$rest>\n";
2467 }
2470 }
2475 # Clean up the original statement.
2480 }
2486 # Flatten any parentheses and braces
2490 {
2491 }
2495 module_param_named|
2496 MODULE_PARAM_DESC|
2497 DECLARE_PER_CPU|
2498 DEFINE_PER_CPU|
2499 __typeof__\(|
2500 union|
2501 struct|
2505 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
2509 {
2510 ERROR("Macros with multiple statements should be enclosed in a do - while loop\n" . "$here\n$ctx\n");
2511 }
2519 {
2521 }
2522 }
2523 }
2525 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
2526 # all assignments may have only one of the following with an assignment:
2527 # .
2528 # ALIGN(...)
2529 # VMLINUX_SYMBOL(...)
2532 }
2534 # check for redundant bracing round if etc
2538 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
2539 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
2548 # If the condition carries leading newlines, then count those as offsets.
2552 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
2554 # We have looked at and allowed this specific line.
2564 #print "cond<$cond> block<$block> allowed<$allowed>\n";
2566 #print "APW: ALLOWED: cond<$cond>\n";
2568 }
2570 #print "APW: ALLOWED: block<$block>\n";
2572 }
2574 #print "APW: ALLOWED: lines block<$block>\n";
2576 }
2577 }
2580 }
2581 }
2582 }
2587 # Check the pre-context.
2589 #print "APW: ALLOWED: pre<$1>\n";
2591 }
2596 # Check the condition.
2598 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
2601 }
2603 #print "APW: ALLOWED: cond<$cond>\n";
2605 }
2607 #print "APW: ALLOWED: block<$block>\n";
2609 }
2611 #print "APW: ALLOWED: lines block<$block>\n";
2613 }
2614 # Check the post-context.
2619 }
2621 #print "APW: ALLOWED: chunk-1 block<$block>\n";
2623 }
2624 }
2631 }
2634 }
2635 }
2637 # don't include deprecated include files (uses RAW line)
2641 }
2642 }
2644 # don't use deprecated functions
2648 }
2649 }
2651 # no volatiles please
2654 WARN("Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
2655 }
2657 # warn about #if 0
2661 }
2663 # check for needless kfree() checks
2668 }
2669 }
2670 # check for needless usb_free_urb() checks
2675 }
2676 }
2678 # prefer usleep_range over udelay
2680 # ignore udelay's < 10, however
2682 CHK("usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $line);
2683 }
2684 }
2686 # warn about unexpectedly long msleep's
2689 WARN("msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $line);
2690 }
2691 }
2693 # warn about #ifdefs in C files
2694 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
2695 # print "#ifdef in C files should be avoided\n";
2696 # print "$herecurr";
2697 # $clean = 0;
2698 # }
2700 # warn about spacing in #ifdefs
2703 }
2705 # check for spinlock_t definitions without a comment.
2711 }
2712 }
2713 # check for memory barriers without a comment.
2714 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
2717 }
2718 }
2719 # check of hardware specific defines
2720 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
2722 }
2724 # Check that the storage class is at the beginning of a declaration
2727 }
2729 # check the location of the inline attribute, that it is between
2730 # storage class and type.
2734 }
2736 # Check for __inline__ and __inline, prefer inline
2739 }
2741 # Check for __attribute__ packed, prefer __packed
2744 }
2746 # check for sizeof(&)
2749 }
2751 # check for new externs in .c files.
2754 {
2761 }
2764 {
2766 }
2770 }
2774 {
2776 }
2778 # checks for new __setup's
2783 CHK("__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
2784 }
2785 }
2787 # check for pointless casting of kmalloc return
2789 WARN("unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
2790 }
2792 # check for multiple semicolons
2795 }
2797 # check for gcc specific __FUNCTION__
2800 }
2802 # check for semaphores initialized locked
2806 }
2807 # recommend kstrto* over simple_strto*
2810 }
2811 # check for __initcall(), use device_initcall() explicitly please
2814 }
2815 # check for various ops structs, ensure they are const.
2817 address_space_operations|
2818 backlight_ops|
2819 block_device_operations|
2820 dentry_operations|
2821 dev_pm_ops|
2822 dma_map_ops|
2823 extent_io_ops|
2824 file_lock_operations|
2825 file_operations|
2826 hv_ops|
2827 ide_dma_ops|
2828 intel_dvo_dev_ops|
2829 item_operations|
2830 iwl_ops|
2831 kgdb_arch|
2832 kgdb_io|
2833 kset_uevent_ops|
2834 lock_manager_operations|
2835 microcode_ops|
2836 mtrr_ops|
2837 neigh_ops|
2838 nlmsvc_binding|
2839 pci_raw_ops|
2840 pipe_buf_operations|
2841 platform_hibernation_ops|
2842 platform_suspend_ops|
2843 proto_ops|
2844 rpc_pipe_ops|
2845 seq_operations|
2846 snd_ac97_build_ops|
2847 soc_pcmcia_socket_ops|
2848 stacktrace_ops|
2849 sysfs_ops|
2850 tty_operations|
2851 usb_mon_operations|
2857 }
2859 # use of NR_CPUS is usually wrong
2860 # ignore definitions of NR_CPUS and usage to define arrays as likely right
2867 {
2868 WARN("usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
2869 }
2871 # check for %L{u,d,i} in strings
2879 }
2880 }
2882 # whine mightly about in_atomic
2888 }
2889 }
2891 # check for lockdep_set_novalidate_class
2898 }
2899 }
2903 WARN("Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
2904 }
2906 # Check for memset with swapped arguments
2909 }
2910 }
2912 # If we have no input at all, then there is nothing to report on
2913 # so just keep quiet.
2916 }
2918 # In mailback mode only produce a report in the negative, for
2919 # things that appear to be patches.
2922 }
2924 # This is not a patch, and we are are in 'no-patch' mode so
2925 # just keep quiet.
2928 }
2932 }
2935 }
2944 }
2947 # If there were whitespace errors which cleanpatch can fix
2948 # then suggest that.
2953 }
2954 }
2958 }
2963 }
2966 }