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
16 use Getopt::Long qw(:config no_auto_abbrev);
42 my $configuration_file = ".checkpatch.conf";
43 my $max_line_length = 80;
44 my $ignore_perl_version = 0;
45 my $minimum_perl_version = 5.10.0;
51 Usage: $P [OPTION]... [FILE]...
56 --no-tree run without a kernel tree
57 --no-signoff do not check for 'Signed-off-by' line
58 --patch treat FILE as patchfile (default)
59 --emacs emacs compile window format
60 --terse one line per report
61 -f, --file treat FILE as regular source file
62 --subjective, --strict enable more subjective tests
63 --types TYPE(,TYPE2...) show only these comma separated message types
64 --ignore TYPE(,TYPE2...) ignore various comma separated message types
65 --max-line-length=n set the maximum line length, if exceeded, warn
66 --show-types show the message "types" in the output
67 --root=PATH PATH to the kernel tree root
68 --no-summary suppress the per-file summary
69 --mailback only produce a report in case of warnings/errors
70 --summary-file include the filename in summary
71 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
72 'values', 'possible', 'type', and 'attr' (default
74 --test-only=WORD report only warnings/errors containing WORD
76 --fix EXPERIMENTAL - may create horrible results
77 If correctable single-line errors exist, create
78 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
79 with potential errors corrected to the preferred
81 --fix-inplace EXPERIMENTAL - may create horrible results
82 Is the same as --fix, but overwrites the input
83 file. It's your fault if there's no backup or git
84 --ignore-perl-version override checking of perl version. expect
86 -h, --help, --version display this help and exit
88 When FILE is - read standard input.
94 my $conf = which_conf($configuration_file);
97 open(my $conffile, '<', "$conf")
98 or warn "$P: Can't find a readable $configuration_file file $!\n";
100 while (<$conffile>) {
103 $line =~ s/\s*\n?$//g;
107 next if ($line =~ m/^\s*#/);
108 next if ($line =~ m/^\s*$/);
110 my @words = split(" ", $line);
111 foreach my $word (@words) {
112 last if ($word =~ m/^#/);
113 push (@conf_args, $word);
117 unshift(@ARGV, @conf_args) if @conf_args;
121 'q|quiet+' => \$quiet,
123 'signoff!' => \$chk_signoff,
124 'patch!' => \$chk_patch,
128 'subjective!' => \$check,
129 'strict!' => \$check,
130 'ignore=s' => \@ignore,
132 'show-types!' => \$show_types,
133 'max-line-length=i' => \$max_line_length,
135 'summary!' => \$summary,
136 'mailback!' => \$mailback,
137 'summary-file!' => \$summary_file,
139 'fix-inplace!' => \$fix_inplace,
140 'ignore-perl-version!' => \$ignore_perl_version,
141 'debug=s' => \%debug,
142 'test-only=s' => \$tst_only,
149 $fix = 1 if ($fix_inplace);
150 $check_orig = $check;
154 if ($^V && $^V lt $minimum_perl_version) {
155 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
156 if (!$ignore_perl_version) {
162 print "$P: no input files\n";
166 sub hash_save_array_words {
167 my ($hashRef, $arrayRef) = @_;
169 my @array = split(/,/, join(',', @$arrayRef));
170 foreach my $word (@array) {
171 $word =~ s/\s*\n?$//g;
174 $word =~ tr/[a-z]/[A-Z]/;
176 next if ($word =~ m/^\s*#/);
177 next if ($word =~ m/^\s*$/);
183 sub hash_show_words {
184 my ($hashRef, $prefix) = @_;
186 if ($quiet == 0 && keys %$hashRef) {
187 print "NOTE: $prefix message types:";
188 foreach my $word (sort keys %$hashRef) {
195 hash_save_array_words(\%ignore_type, \@ignore);
196 hash_save_array_words(\%use_type, \@use);
199 my $dbg_possible = 0;
202 for my $key (keys %debug) {
204 eval "\${dbg_$key} = '$debug{$key}';";
208 my $rpt_cleaners = 0;
217 if (!top_of_kernel_tree($root)) {
218 die "$P: $root: --root does not point at a valid tree\n";
221 if (top_of_kernel_tree('.')) {
223 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
224 top_of_kernel_tree($1)) {
229 if (!defined $root) {
230 print "Must be run from the top-level dir. of a kernel tree\n";
235 my $emitted_corrupt = 0;
238 [A-Za-z_][A-Za-z\d_]*
239 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
241 our $Storage = qr{extern|static|asmlinkage};
253 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
254 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
255 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
256 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
257 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
259 # Notes to $Attribute:
260 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
280 ____cacheline_aligned|
281 ____cacheline_aligned_in_smp|
282 ____cacheline_internodealigned_in_smp|
286 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
287 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
288 our $Lval = qr{$Ident(?:$Member)*};
290 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
291 our $Binary = qr{(?i)0b[01]+$Int_type?};
292 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
293 our $Int = qr{[0-9]+$Int_type?};
294 our $Octal = qr{0[0-7]+$Int_type?};
295 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
296 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
297 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
298 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
299 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
300 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
301 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
302 our $Arithmetic = qr{\+|-|\*|\/|%};
306 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
309 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
312 our $NonptrTypeMisordered;
313 our $NonptrTypeWithAttr;
317 our $DeclareMisordered;
319 our $NON_ASCII_UTF8 = qr{
320 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
321 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
322 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
323 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
324 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
325 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
326 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
330 [\x09\x0A\x0D\x20-\x7E] # ASCII
334 our $typeTypedefs = qr{(?x:
335 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
339 our $logFunctions = qr{(?x:
340 printk(?:_ratelimited|_once|)|
341 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
342 WARN(?:_RATELIMIT|_ONCE|)|
345 seq_vprintf|seq_printf|seq_puts
348 our $signature_tags = qr{(?xi:
359 our @typeListMisordered = (
360 qr{char\s+(?:un)?signed},
361 qr{int\s+(?:(?:un)?signed\s+)?short\s},
362 qr{int\s+short(?:\s+(?:un)?signed)},
363 qr{short\s+int(?:\s+(?:un)?signed)},
364 qr{(?:un)?signed\s+int\s+short},
365 qr{short\s+(?:un)?signed},
366 qr{long\s+int\s+(?:un)?signed},
367 qr{int\s+long\s+(?:un)?signed},
368 qr{long\s+(?:un)?signed\s+int},
369 qr{int\s+(?:un)?signed\s+long},
370 qr{int\s+(?:un)?signed},
371 qr{int\s+long\s+long\s+(?:un)?signed},
372 qr{long\s+long\s+int\s+(?:un)?signed},
373 qr{long\s+long\s+(?:un)?signed\s+int},
374 qr{long\s+long\s+(?:un)?signed},
375 qr{long\s+(?:un)?signed},
380 qr{(?:(?:un)?signed\s+)?char},
381 qr{(?:(?:un)?signed\s+)?short\s+int},
382 qr{(?:(?:un)?signed\s+)?short},
383 qr{(?:(?:un)?signed\s+)?int},
384 qr{(?:(?:un)?signed\s+)?long\s+int},
385 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
386 qr{(?:(?:un)?signed\s+)?long\s+long},
387 qr{(?:(?:un)?signed\s+)?long},
396 qr{${Ident}_handler},
397 qr{${Ident}_handler_fn},
400 our @typeListWithAttr = (
402 qr{struct\s+$InitAttribute\s+$Ident},
403 qr{union\s+$InitAttribute\s+$Ident},
406 our @modifierList = (
410 our @mode_permission_funcs = (
412 ["module_param_(?:array|named|string)", 4],
413 ["module_param_array_named", 5],
414 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
415 ["proc_create(?:_data|)", 2],
416 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
419 #Create a search pattern for all these functions to speed up a loop below
420 our $mode_perms_search = "";
421 foreach my $entry (@mode_permission_funcs) {
422 $mode_perms_search .= '|' if ($mode_perms_search ne "");
423 $mode_perms_search .= $entry->[0];
426 our $allowed_asm_includes = qr{(?x:
432 # memory.h: ARM has a custom one
435 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
436 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
437 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
438 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
439 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
441 (?:$Modifier\s+|const\s+)*
443 (?:typeof|__typeof__)\s*\([^\)]*\)|
447 (?:\s+$Modifier|\s+const)*
449 $NonptrTypeMisordered = qr{
450 (?:$Modifier\s+|const\s+)*
454 (?:\s+$Modifier|\s+const)*
456 $NonptrTypeWithAttr = qr{
457 (?:$Modifier\s+|const\s+)*
459 (?:typeof|__typeof__)\s*\([^\)]*\)|
463 (?:\s+$Modifier|\s+const)*
467 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
468 (?:\s+$Inline|\s+$Modifier)*
470 $TypeMisordered = qr{
471 $NonptrTypeMisordered
472 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
473 (?:\s+$Inline|\s+$Modifier)*
475 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
476 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
480 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
482 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
483 # requires at least perl version v5.10.0
484 # Any use must be runtime checked with $^V
486 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
487 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
488 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
490 our $declaration_macros = qr{(?x:
491 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,2}\s*\(|
492 (?:$Storage\s+)?LIST_HEAD\s*\(|
493 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
498 return "" if (!defined($string));
500 while ($string =~ /^\s*\(.*\)\s*$/) {
501 $string =~ s@^\s*\(\s*@@;
502 $string =~ s@\s*\)\s*$@@;
505 $string =~ s@\s+@ @g;
510 sub seed_camelcase_file {
513 return if (!(-f $file));
517 open(my $include_file, '<', "$file")
518 or warn "$P: Can't read '$file' $!\n";
519 my $text = <$include_file>;
520 close($include_file);
522 my @lines = split('\n', $text);
524 foreach my $line (@lines) {
525 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
526 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
528 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
530 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
536 my $camelcase_seeded = 0;
537 sub seed_camelcase_includes {
538 return if ($camelcase_seeded);
541 my $camelcase_cache = "";
542 my @include_files = ();
544 $camelcase_seeded = 1;
547 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
548 chomp $git_last_include_commit;
549 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
551 my $last_mod_date = 0;
552 $files = `find $root/include -name "*.h"`;
553 @include_files = split('\n', $files);
554 foreach my $file (@include_files) {
555 my $date = POSIX::strftime("%Y%m%d%H%M",
556 localtime((stat $file)[9]));
557 $last_mod_date = $date if ($last_mod_date < $date);
559 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
562 if ($camelcase_cache ne "" && -f $camelcase_cache) {
563 open(my $camelcase_file, '<', "$camelcase_cache")
564 or warn "$P: Can't read '$camelcase_cache' $!\n";
565 while (<$camelcase_file>) {
569 close($camelcase_file);
575 $files = `git ls-files "include/*.h"`;
576 @include_files = split('\n', $files);
579 foreach my $file (@include_files) {
580 seed_camelcase_file($file);
583 if ($camelcase_cache ne "") {
584 unlink glob ".checkpatch-camelcase.*";
585 open(my $camelcase_file, '>', "$camelcase_cache")
586 or warn "$P: Can't write '$camelcase_cache' $!\n";
587 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
588 print $camelcase_file ("$_\n");
590 close($camelcase_file);
594 sub git_commit_info {
595 my ($commit, $id, $desc) = @_;
597 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
599 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
600 $output =~ s/^\s*//gm;
601 my @lines = split("\n", $output);
603 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
604 # Maybe one day convert this block of bash into something that returns
605 # all matching commit ids, but it's very slow...
607 # echo "checking commits $1..."
608 # git rev-list --remotes | grep -i "^$1" |
609 # while read line ; do
610 # git log --format='%H %s' -1 $line |
611 # echo "commit $(cut -c 1-12,41-)"
613 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
615 $id = substr($lines[0], 0, 12);
616 $desc = substr($lines[0], 41);
622 $chk_signoff = 0 if ($file);
627 my @fixed_inserted = ();
628 my @fixed_deleted = ();
632 for my $filename (@ARGV) {
635 open($FILE, '-|', "diff -u /dev/null $filename") ||
636 die "$P: $filename: diff failed - $!\n";
637 } elsif ($filename eq '-') {
638 open($FILE, '<&STDIN');
640 open($FILE, '<', "$filename") ||
641 die "$P: $filename: open failed - $!\n";
643 if ($filename eq '-') {
644 $vname = 'Your patch';
653 if (!process($filename)) {
659 @fixed_inserted = ();
666 sub top_of_kernel_tree {
670 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
671 "README", "Documentation", "arch", "include", "drivers",
672 "fs", "init", "ipc", "kernel", "lib", "scripts",
675 foreach my $check (@tree_check) {
676 if (! -e $root . '/' . $check) {
684 my ($formatted_email) = @_;
690 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
693 $comment = $3 if defined $3;
694 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
696 $comment = $2 if defined $2;
697 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
699 $comment = $2 if defined $2;
700 $formatted_email =~ s/$address.*$//;
701 $name = $formatted_email;
703 $name =~ s/^\"|\"$//g;
704 # If there's a name left after stripping spaces and
705 # leading quotes, and the address doesn't have both
706 # leading and trailing angle brackets, the address
708 # "joe smith joe@smith.com" bad
709 # "joe smith <joe@smith.com" bad
710 if ($name ne "" && $address !~ /^<[^>]+>$/) {
718 $name =~ s/^\"|\"$//g;
719 $address = trim($address);
720 $address =~ s/^\<|\>$//g;
722 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
723 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
727 return ($name, $address, $comment);
731 my ($name, $address) = @_;
736 $name =~ s/^\"|\"$//g;
737 $address = trim($address);
739 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
740 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
745 $formatted_email = "$address";
747 $formatted_email = "$name <$address>";
750 return $formatted_email;
756 foreach my $path (split(/:/, $ENV{PATH})) {
757 if (-e "$path/$bin") {
768 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
769 if (-e "$path/$conf") {
770 return "$path/$conf";
782 for my $c (split(//, $str)) {
786 for (; ($n % 8) != 0; $n++) {
798 (my $res = shift) =~ tr/\t/ /c;
805 # Drop the diff line leader and expand tabs
807 $line = expand_tabs($line);
809 # Pick the indent from the front of the line.
810 my ($white) = ($line =~ /^(\s*)/);
812 return (length($line), length($white));
815 my $sanitise_quote = '';
817 sub sanitise_line_reset {
818 my ($in_comment) = @_;
821 $sanitise_quote = '*/';
823 $sanitise_quote = '';
836 # Always copy over the diff marker.
837 $res = substr($line, 0, 1);
839 for ($off = 1; $off < length($line); $off++) {
840 $c = substr($line, $off, 1);
842 # Comments we are wacking completly including the begin
843 # and end, all to $;.
844 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
845 $sanitise_quote = '*/';
847 substr($res, $off, 2, "$;$;");
851 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
852 $sanitise_quote = '';
853 substr($res, $off, 2, "$;$;");
857 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
858 $sanitise_quote = '//';
860 substr($res, $off, 2, $sanitise_quote);
865 # A \ in a string means ignore the next character.
866 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
868 substr($res, $off, 2, 'XX');
873 if ($c eq "'" || $c eq '"') {
874 if ($sanitise_quote eq '') {
875 $sanitise_quote = $c;
877 substr($res, $off, 1, $c);
879 } elsif ($sanitise_quote eq $c) {
880 $sanitise_quote = '';
884 #print "c<$c> SQ<$sanitise_quote>\n";
885 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
886 substr($res, $off, 1, $;);
887 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
888 substr($res, $off, 1, $;);
889 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
890 substr($res, $off, 1, 'X');
892 substr($res, $off, 1, $c);
896 if ($sanitise_quote eq '//') {
897 $sanitise_quote = '';
900 # The pathname on a #include may be surrounded by '<' and '>'.
901 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
902 my $clean = 'X' x length($1);
903 $res =~ s@\<.*\>@<$clean>@;
905 # The whole of a #error is a string.
906 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
907 my $clean = 'X' x length($1);
908 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
914 sub get_quoted_string {
915 my ($line, $rawline) = @_;
917 return "" if ($line !~ m/(\"[X]+\")/g);
918 return substr($rawline, $-[0], $+[0] - $-[0]);
921 sub ctx_statement_block {
922 my ($linenr, $remain, $off) = @_;
923 my $line = $linenr - 1;
940 @stack = (['', 0]) if ($#stack == -1);
942 #warn "CSB: blk<$blk> remain<$remain>\n";
943 # If we are about to drop off the end, pull in more
946 for (; $remain > 0; $line++) {
947 last if (!defined $lines[$line]);
948 next if ($lines[$line] =~ /^-/);
951 $blk .= $lines[$line] . "\n";
956 # Bail if there is no further context.
957 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
961 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
967 $c = substr($blk, $off, 1);
968 $remainder = substr($blk, $off);
970 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
972 # Handle nested #if/#else.
973 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
974 push(@stack, [ $type, $level ]);
975 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
976 ($type, $level) = @{$stack[$#stack - 1]};
977 } elsif ($remainder =~ /^#\s*endif\b/) {
978 ($type, $level) = @{pop(@stack)};
981 # Statement ends at the ';' or a close '}' at the
983 if ($level == 0 && $c eq ';') {
987 # An else is really a conditional as long as its not else if
988 if ($level == 0 && $coff_set == 0 &&
989 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
990 $remainder =~ /^(else)(?:\s|{)/ &&
991 $remainder !~ /^else\s+if\b/) {
992 $coff = $off + length($1) - 1;
994 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
995 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
998 if (($type eq '' || $type eq '(') && $c eq '(') {
1002 if ($type eq '(' && $c eq ')') {
1004 $type = ($level != 0)? '(' : '';
1006 if ($level == 0 && $coff < $soff) {
1009 #warn "CSB: mark coff<$coff>\n";
1012 if (($type eq '' || $type eq '{') && $c eq '{') {
1016 if ($type eq '{' && $c eq '}') {
1018 $type = ($level != 0)? '{' : '';
1021 if (substr($blk, $off + 1, 1) eq ';') {
1027 # Preprocessor commands end at the newline unless escaped.
1028 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1036 # We are truly at the end, so shuffle to the next line.
1043 my $statement = substr($blk, $soff, $off - $soff + 1);
1044 my $condition = substr($blk, $soff, $coff - $soff + 1);
1046 #warn "STATEMENT<$statement>\n";
1047 #warn "CONDITION<$condition>\n";
1049 #print "coff<$coff> soff<$off> loff<$loff>\n";
1051 return ($statement, $condition,
1052 $line, $remain + 1, $off - $loff + 1, $level);
1055 sub statement_lines {
1058 # Strip the diff line prefixes and rip blank lines at start and end.
1059 $stmt =~ s/(^|\n)./$1/g;
1063 my @stmt_lines = ($stmt =~ /\n/g);
1065 return $#stmt_lines + 2;
1068 sub statement_rawlines {
1071 my @stmt_lines = ($stmt =~ /\n/g);
1073 return $#stmt_lines + 2;
1076 sub statement_block_size {
1079 $stmt =~ s/(^|\n)./$1/g;
1085 my @stmt_lines = ($stmt =~ /\n/g);
1086 my @stmt_statements = ($stmt =~ /;/g);
1088 my $stmt_lines = $#stmt_lines + 2;
1089 my $stmt_statements = $#stmt_statements + 1;
1091 if ($stmt_lines > $stmt_statements) {
1094 return $stmt_statements;
1098 sub ctx_statement_full {
1099 my ($linenr, $remain, $off) = @_;
1100 my ($statement, $condition, $level);
1104 # Grab the first conditional/block pair.
1105 ($statement, $condition, $linenr, $remain, $off, $level) =
1106 ctx_statement_block($linenr, $remain, $off);
1107 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1108 push(@chunks, [ $condition, $statement ]);
1109 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1110 return ($level, $linenr, @chunks);
1113 # Pull in the following conditional/block pairs and see if they
1114 # could continue the statement.
1116 ($statement, $condition, $linenr, $remain, $off, $level) =
1117 ctx_statement_block($linenr, $remain, $off);
1118 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1119 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1121 push(@chunks, [ $condition, $statement ]);
1124 return ($level, $linenr, @chunks);
1128 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1130 my $start = $linenr - 1;
1137 my @stack = ($level);
1138 for ($line = $start; $remain > 0; $line++) {
1139 next if ($rawlines[$line] =~ /^-/);
1142 $blk .= $rawlines[$line];
1144 # Handle nested #if/#else.
1145 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1146 push(@stack, $level);
1147 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1148 $level = $stack[$#stack - 1];
1149 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1150 $level = pop(@stack);
1153 foreach my $c (split(//, $lines[$line])) {
1154 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1160 if ($c eq $close && $level > 0) {
1162 last if ($level == 0);
1163 } elsif ($c eq $open) {
1168 if (!$outer || $level <= 1) {
1169 push(@res, $rawlines[$line]);
1172 last if ($level == 0);
1175 return ($level, @res);
1177 sub ctx_block_outer {
1178 my ($linenr, $remain) = @_;
1180 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1184 my ($linenr, $remain) = @_;
1186 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1190 my ($linenr, $remain, $off) = @_;
1192 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1195 sub ctx_block_level {
1196 my ($linenr, $remain) = @_;
1198 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1200 sub ctx_statement_level {
1201 my ($linenr, $remain, $off) = @_;
1203 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1206 sub ctx_locate_comment {
1207 my ($first_line, $end_line) = @_;
1209 # Catch a comment on the end of the line itself.
1210 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1211 return $current_comment if (defined $current_comment);
1213 # Look through the context and try and figure out if there is a
1216 $current_comment = '';
1217 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1218 my $line = $rawlines[$linenr - 1];
1220 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1223 if ($line =~ m@/\*@) {
1226 if (!$in_comment && $current_comment ne '') {
1227 $current_comment = '';
1229 $current_comment .= $line . "\n" if ($in_comment);
1230 if ($line =~ m@\*/@) {
1235 chomp($current_comment);
1236 return($current_comment);
1238 sub ctx_has_comment {
1239 my ($first_line, $end_line) = @_;
1240 my $cmt = ctx_locate_comment($first_line, $end_line);
1242 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1243 ##print "CMMT: $cmt\n";
1245 return ($cmt ne '');
1249 my ($linenr, $cnt) = @_;
1251 my $offset = $linenr - 1;
1256 $line = $rawlines[$offset++];
1257 next if (defined($line) && $line =~ /^-/);
1269 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1272 $coded = sprintf("^%c", unpack('C', $2) + 64);
1281 my $av_preprocessor = 0;
1286 sub annotate_reset {
1287 $av_preprocessor = 0;
1289 @av_paren_type = ('E');
1290 $av_pend_colon = 'O';
1293 sub annotate_values {
1294 my ($stream, $type) = @_;
1297 my $var = '_' x length($stream);
1300 print "$stream\n" if ($dbg_values > 1);
1302 while (length($cur)) {
1303 @av_paren_type = ('E') if ($#av_paren_type < 0);
1304 print " <" . join('', @av_paren_type) .
1305 "> <$type> <$av_pending>" if ($dbg_values > 1);
1306 if ($cur =~ /^(\s+)/o) {
1307 print "WS($1)\n" if ($dbg_values > 1);
1308 if ($1 =~ /\n/ && $av_preprocessor) {
1309 $type = pop(@av_paren_type);
1310 $av_preprocessor = 0;
1313 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1314 print "CAST($1)\n" if ($dbg_values > 1);
1315 push(@av_paren_type, $type);
1318 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1319 print "DECLARE($1)\n" if ($dbg_values > 1);
1322 } elsif ($cur =~ /^($Modifier)\s*/) {
1323 print "MODIFIER($1)\n" if ($dbg_values > 1);
1326 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1327 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1328 $av_preprocessor = 1;
1329 push(@av_paren_type, $type);
1335 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1336 print "UNDEF($1)\n" if ($dbg_values > 1);
1337 $av_preprocessor = 1;
1338 push(@av_paren_type, $type);
1340 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1341 print "PRE_START($1)\n" if ($dbg_values > 1);
1342 $av_preprocessor = 1;
1344 push(@av_paren_type, $type);
1345 push(@av_paren_type, $type);
1348 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1349 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1350 $av_preprocessor = 1;
1352 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1356 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1357 print "PRE_END($1)\n" if ($dbg_values > 1);
1359 $av_preprocessor = 1;
1361 # Assume all arms of the conditional end as this
1362 # one does, and continue as if the #endif was not here.
1363 pop(@av_paren_type);
1364 push(@av_paren_type, $type);
1367 } elsif ($cur =~ /^(\\\n)/o) {
1368 print "PRECONT($1)\n" if ($dbg_values > 1);
1370 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1371 print "ATTR($1)\n" if ($dbg_values > 1);
1372 $av_pending = $type;
1375 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1376 print "SIZEOF($1)\n" if ($dbg_values > 1);
1382 } elsif ($cur =~ /^(if|while|for)\b/o) {
1383 print "COND($1)\n" if ($dbg_values > 1);
1387 } elsif ($cur =~/^(case)/o) {
1388 print "CASE($1)\n" if ($dbg_values > 1);
1389 $av_pend_colon = 'C';
1392 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1393 print "KEYWORD($1)\n" if ($dbg_values > 1);
1396 } elsif ($cur =~ /^(\()/o) {
1397 print "PAREN('$1')\n" if ($dbg_values > 1);
1398 push(@av_paren_type, $av_pending);
1402 } elsif ($cur =~ /^(\))/o) {
1403 my $new_type = pop(@av_paren_type);
1404 if ($new_type ne '_') {
1406 print "PAREN('$1') -> $type\n"
1407 if ($dbg_values > 1);
1409 print "PAREN('$1')\n" if ($dbg_values > 1);
1412 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1413 print "FUNC($1)\n" if ($dbg_values > 1);
1417 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1418 if (defined $2 && $type eq 'C' || $type eq 'T') {
1419 $av_pend_colon = 'B';
1420 } elsif ($type eq 'E') {
1421 $av_pend_colon = 'L';
1423 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1426 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1427 print "IDENT($1)\n" if ($dbg_values > 1);
1430 } elsif ($cur =~ /^($Assignment)/o) {
1431 print "ASSIGN($1)\n" if ($dbg_values > 1);
1434 } elsif ($cur =~/^(;|{|})/) {
1435 print "END($1)\n" if ($dbg_values > 1);
1437 $av_pend_colon = 'O';
1439 } elsif ($cur =~/^(,)/) {
1440 print "COMMA($1)\n" if ($dbg_values > 1);
1443 } elsif ($cur =~ /^(\?)/o) {
1444 print "QUESTION($1)\n" if ($dbg_values > 1);
1447 } elsif ($cur =~ /^(:)/o) {
1448 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1450 substr($var, length($res), 1, $av_pend_colon);
1451 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1456 $av_pend_colon = 'O';
1458 } elsif ($cur =~ /^(\[)/o) {
1459 print "CLOSE($1)\n" if ($dbg_values > 1);
1462 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1465 print "OPV($1)\n" if ($dbg_values > 1);
1472 substr($var, length($res), 1, $variant);
1475 } elsif ($cur =~ /^($Operators)/o) {
1476 print "OP($1)\n" if ($dbg_values > 1);
1477 if ($1 ne '++' && $1 ne '--') {
1481 } elsif ($cur =~ /(^.)/o) {
1482 print "C($1)\n" if ($dbg_values > 1);
1485 $cur = substr($cur, length($1));
1486 $res .= $type x length($1);
1490 return ($res, $var);
1494 my ($possible, $line) = @_;
1495 my $notPermitted = qr{(?:
1512 ^(?:typedef|struct|enum)\b
1514 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1515 if ($possible !~ $notPermitted) {
1516 # Check for modifiers.
1517 $possible =~ s/\s*$Storage\s*//g;
1518 $possible =~ s/\s*$Sparse\s*//g;
1519 if ($possible =~ /^\s*$/) {
1521 } elsif ($possible =~ /\s/) {
1522 $possible =~ s/\s*$Type\s*//g;
1523 for my $modifier (split(' ', $possible)) {
1524 if ($modifier !~ $notPermitted) {
1525 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1526 push(@modifierList, $modifier);
1531 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1532 push(@typeList, $possible);
1536 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1545 return defined $use_type{$type} if (scalar keys %use_type > 0);
1547 return !defined $ignore_type{$type};
1551 my ($level, $type, $msg) = @_;
1553 if (!show_type($type) ||
1554 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1559 $line = "$prefix$level:$type: $msg\n";
1561 $line = "$prefix$level: $msg\n";
1563 $line = (split('\n', $line))[0] . "\n" if ($terse);
1565 push(our @report, $line);
1574 sub fixup_current_range {
1575 my ($lineRef, $offset, $length) = @_;
1577 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1580 my $no = $o + $offset;
1581 my $nl = $l + $length;
1582 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1586 sub fix_inserted_deleted_lines {
1587 my ($linesRef, $insertedRef, $deletedRef) = @_;
1589 my $range_last_linenr = 0;
1590 my $delta_offset = 0;
1595 my $next_insert = 0;
1596 my $next_delete = 0;
1600 my $inserted = @{$insertedRef}[$next_insert++];
1601 my $deleted = @{$deletedRef}[$next_delete++];
1603 foreach my $old_line (@{$linesRef}) {
1605 my $line = $old_line; #don't modify the array
1606 if ($line =~ /^(?:\+\+\+\|\-\-\-)\s+\S+/) { #new filename
1608 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1609 $range_last_linenr = $new_linenr;
1610 fixup_current_range(\$line, $delta_offset, 0);
1613 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1614 $deleted = @{$deletedRef}[$next_delete++];
1616 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1619 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1620 push(@lines, ${$inserted}{'LINE'});
1621 $inserted = @{$insertedRef}[$next_insert++];
1623 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1627 push(@lines, $line);
1637 sub fix_insert_line {
1638 my ($linenr, $line) = @_;
1644 push(@fixed_inserted, $inserted);
1647 sub fix_delete_line {
1648 my ($linenr, $line) = @_;
1655 push(@fixed_deleted, $deleted);
1659 my ($type, $msg) = @_;
1661 if (report("ERROR", $type, $msg)) {
1669 my ($type, $msg) = @_;
1671 if (report("WARNING", $type, $msg)) {
1679 my ($type, $msg) = @_;
1681 if ($check && report("CHECK", $type, $msg)) {
1689 sub check_absolute_file {
1690 my ($absolute, $herecurr) = @_;
1691 my $file = $absolute;
1693 ##print "absolute<$absolute>\n";
1695 # See if any suffix of this path is a path within the tree.
1696 while ($file =~ s@^[^/]*/@@) {
1697 if (-f "$root/$file") {
1698 ##print "file<$file>\n";
1706 # It is, so see if the prefix is acceptable.
1707 my $prefix = $absolute;
1708 substr($prefix, -length($file)) = '';
1710 ##print "prefix<$prefix>\n";
1711 if ($prefix ne ".../") {
1712 WARN("USE_RELATIVE_PATH",
1713 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1720 $string =~ s/^\s+|\s+$//g;
1728 $string =~ s/^\s+//;
1736 $string =~ s/\s+$//;
1741 sub string_find_replace {
1742 my ($string, $find, $replace) = @_;
1744 $string =~ s/$find/$replace/g;
1752 my $source_indent = 8;
1753 my $max_spaces_before_tab = $source_indent - 1;
1754 my $spaces_to_tab = " " x $source_indent;
1756 #convert leading spaces to tabs
1757 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1758 #Remove spaces before a tab
1759 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1764 sub pos_last_openparen {
1769 my $opens = $line =~ tr/\(/\(/;
1770 my $closes = $line =~ tr/\)/\)/;
1772 my $last_openparen = 0;
1774 if (($opens == 0) || ($closes >= $opens)) {
1778 my $len = length($line);
1780 for ($pos = 0; $pos < $len; $pos++) {
1781 my $string = substr($line, $pos);
1782 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1783 $pos += length($1) - 1;
1784 } elsif (substr($line, $pos, 1) eq '(') {
1785 $last_openparen = $pos;
1786 } elsif (index($string, '(') == -1) {
1791 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
1795 my $filename = shift;
1801 my $stashrawline="";
1812 my $in_header_lines = $file ? 0 : 1;
1813 my $in_commit_log = 0; #Scanning lines before patch
1814 my $reported_maintainer_file = 0;
1815 my $non_utf8_charset = 0;
1817 my $last_blank_line = 0;
1825 # Trace the real file/line as we go.
1831 my $comment_edge = 0;
1835 my $prev_values = 'E';
1838 my %suppress_ifbraces;
1839 my %suppress_whiletrailers;
1840 my %suppress_export;
1841 my $suppress_statement = 0;
1843 my %signatures = ();
1845 # Pre-scan the patch sanitizing the lines.
1846 # Pre-scan the patch looking for any __setup documentation.
1848 my @setup_docs = ();
1851 my $camelcase_file_seeded = 0;
1853 sanitise_line_reset();
1855 foreach my $rawline (@rawlines) {
1859 push(@fixed, $rawline) if ($fix);
1861 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1863 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1868 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1877 # Guestimate if this is a continuing comment. Run
1878 # the context looking for a comment "edge". If this
1879 # edge is a close comment then we must be in a comment
1883 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1884 next if (defined $rawlines[$ln - 1] &&
1885 $rawlines[$ln - 1] =~ /^-/);
1887 #print "RAW<$rawlines[$ln - 1]>\n";
1888 last if (!defined $rawlines[$ln - 1]);
1889 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1890 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1895 if (defined $edge && $edge eq '*/') {
1899 # Guestimate if this is a continuing comment. If this
1900 # is the start of a diff block and this line starts
1901 # ' *' then it is very likely a comment.
1902 if (!defined $edge &&
1903 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1908 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1909 sanitise_line_reset($in_comment);
1911 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1912 # Standardise the strings and chars within the input to
1913 # simplify matching -- only bother with positive lines.
1914 $line = sanitise_line($rawline);
1916 push(@lines, $line);
1919 $realcnt-- if ($line =~ /^(?:\+| |$)/);
1924 #print "==>$rawline\n";
1925 #print "-->$line\n";
1927 if ($setup_docs && $line =~ /^\+/) {
1928 push(@setup_docs, $line);
1937 foreach my $line (@lines) {
1940 my $sline = $line; #copy of $line
1941 $sline =~ s/$;/ /g; #with comments as spaces
1943 my $rawline = $rawlines[$linenr - 1];
1945 #extract the line range in the file after the patch is applied
1946 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1948 $first_line = $linenr + 1;
1958 %suppress_ifbraces = ();
1959 %suppress_whiletrailers = ();
1960 %suppress_export = ();
1961 $suppress_statement = 0;
1964 # track the line number as we move through the hunk, note that
1965 # new versions of GNU diff omit the leading space on completely
1966 # blank context lines so we need to count that too.
1967 } elsif ($line =~ /^( |\+|$)/) {
1969 $realcnt-- if ($realcnt != 0);
1971 # Measure the line length and indent.
1972 ($length, $indent) = line_stats($rawline);
1974 # Track the previous line.
1975 ($prevline, $stashline) = ($stashline, $line);
1976 ($previndent, $stashindent) = ($stashindent, $indent);
1977 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1979 #warn "line<$line>\n";
1981 } elsif ($realcnt == 1) {
1985 my $hunk_line = ($realcnt != 0);
1987 #make up the handle for any error we report on this line
1988 $prefix = "$filename:$realline: " if ($emacs && $file);
1989 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1991 $here = "#$linenr: " if (!$file);
1992 $here = "#$realline: " if ($file);
1995 # extract the filename as it passes
1996 if ($line =~ /^diff --git.*?(\S+)$/) {
1998 $realfile =~ s@^([^/]*)/@@ if (!$file);
2001 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2003 $realfile =~ s@^([^/]*)/@@ if (!$file);
2007 if (!$file && $tree && $p1_prefix ne '' &&
2008 -e "$root/$p1_prefix") {
2009 WARN("PATCH_PREFIX",
2010 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2013 if ($realfile =~ m@^include/asm/@) {
2014 ERROR("MODIFIED_INCLUDE_ASM",
2015 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2021 if ($realfile =~ m@^(drivers/net/|net/)@) {
2024 $check = $check_orig;
2029 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2031 my $hereline = "$here\n$rawline\n";
2032 my $herecurr = "$here\n$rawline\n";
2033 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2035 $cnt_lines++ if ($realcnt != 0);
2037 # Check for incorrect file permissions
2038 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2039 my $permhere = $here . "FILE: $realfile\n";
2040 if ($realfile !~ m@scripts/@ &&
2041 $realfile !~ /\.(py|pl|awk|sh)$/) {
2042 ERROR("EXECUTE_PERMISSIONS",
2043 "do not set execute permissions for source files\n" . $permhere);
2047 # Check the patch for a signoff:
2048 if ($line =~ /^\s*signed-off-by:/i) {
2053 # Check signature styles
2054 if (!$in_header_lines &&
2055 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2056 my $space_before = $1;
2058 my $space_after = $3;
2060 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2062 if ($sign_off !~ /$signature_tags/) {
2063 WARN("BAD_SIGN_OFF",
2064 "Non-standard signature: $sign_off\n" . $herecurr);
2066 if (defined $space_before && $space_before ne "") {
2067 if (WARN("BAD_SIGN_OFF",
2068 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2070 $fixed[$fixlinenr] =
2071 "$ucfirst_sign_off $email";
2074 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2075 if (WARN("BAD_SIGN_OFF",
2076 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2078 $fixed[$fixlinenr] =
2079 "$ucfirst_sign_off $email";
2083 if (!defined $space_after || $space_after ne " ") {
2084 if (WARN("BAD_SIGN_OFF",
2085 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2087 $fixed[$fixlinenr] =
2088 "$ucfirst_sign_off $email";
2092 my ($email_name, $email_address, $comment) = parse_email($email);
2093 my $suggested_email = format_email(($email_name, $email_address));
2094 if ($suggested_email eq "") {
2095 ERROR("BAD_SIGN_OFF",
2096 "Unrecognized email address: '$email'\n" . $herecurr);
2098 my $dequoted = $suggested_email;
2099 $dequoted =~ s/^"//;
2100 $dequoted =~ s/" </ </;
2101 # Don't force email to have quotes
2102 # Allow just an angle bracketed address
2103 if ("$dequoted$comment" ne $email &&
2104 "<$email_address>$comment" ne $email &&
2105 "$suggested_email$comment" ne $email) {
2106 WARN("BAD_SIGN_OFF",
2107 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2111 # Check for duplicate signatures
2112 my $sig_nospace = $line;
2113 $sig_nospace =~ s/\s//g;
2114 $sig_nospace = lc($sig_nospace);
2115 if (defined $signatures{$sig_nospace}) {
2116 WARN("BAD_SIGN_OFF",
2117 "Duplicate signature\n" . $herecurr);
2119 $signatures{$sig_nospace} = 1;
2123 # Check for old stable address
2124 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2125 ERROR("STABLE_ADDRESS",
2126 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2129 # Check for unwanted Gerrit info
2130 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2131 ERROR("GERRIT_CHANGE_ID",
2132 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2135 # Check for improperly formed commit descriptions
2136 if ($in_commit_log &&
2137 $line =~ /\bcommit\s+[0-9a-f]{5,}/i &&
2138 !($line =~ /\b[Cc]ommit [0-9a-f]{12,40} \("/ ||
2139 ($line =~ /\b[Cc]ommit [0-9a-f]{12,40}\s*$/ &&
2140 defined $rawlines[$linenr] &&
2141 $rawlines[$linenr] =~ /^\s*\("/))) {
2142 $line =~ /\b(c)ommit\s+([0-9a-f]{5,})/i;
2144 my $orig_commit = lc($2);
2145 my $id = '01234567890ab';
2146 my $desc = 'commit description';
2147 ($id, $desc) = git_commit_info($orig_commit, $id, $desc);
2148 ERROR("GIT_COMMIT_ID",
2149 "Please use 12 or more chars for the git commit ID like: '${init_char}ommit $id (\"$desc\")'\n" . $herecurr);
2152 # Check for added, moved or deleted files
2153 if (!$reported_maintainer_file && !$in_commit_log &&
2154 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2155 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2156 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2157 (defined($1) || defined($2))))) {
2158 $reported_maintainer_file = 1;
2159 WARN("FILE_PATH_CHANGES",
2160 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2163 # Check for wrappage within a valid hunk of the file
2164 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2165 ERROR("CORRUPTED_PATCH",
2166 "patch seems to be corrupt (line wrapped?)\n" .
2167 $herecurr) if (!$emitted_corrupt++);
2170 # Check for absolute kernel paths.
2172 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2175 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2176 check_absolute_file($1, $herecurr)) {
2179 check_absolute_file($file, $herecurr);
2184 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2185 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2186 $rawline !~ m/^$UTF8*$/) {
2187 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2189 my $blank = copy_spacing($rawline);
2190 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2191 my $hereptr = "$hereline$ptr\n";
2194 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2197 # Check if it's the start of a commit log
2198 # (not a header line and we haven't seen the patch filename)
2199 if ($in_header_lines && $realfile =~ /^$/ &&
2200 !($rawline =~ /^\s+\S/ ||
2201 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2202 $in_header_lines = 0;
2206 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2207 # declined it, i.e defined some charset where it is missing.
2208 if ($in_header_lines &&
2209 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2211 $non_utf8_charset = 1;
2214 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2215 $rawline =~ /$NON_ASCII_UTF8/) {
2216 WARN("UTF8_BEFORE_PATCH",
2217 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2220 # ignore non-hunk lines and lines being removed
2221 next if (!$hunk_line || $line =~ /^-/);
2223 #trailing whitespace
2224 if ($line =~ /^\+.*\015/) {
2225 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2226 if (ERROR("DOS_LINE_ENDINGS",
2227 "DOS line endings\n" . $herevet) &&
2229 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2231 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2232 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2233 if (ERROR("TRAILING_WHITESPACE",
2234 "trailing whitespace\n" . $herevet) &&
2236 $fixed[$fixlinenr] =~ s/\s+$//;
2242 # Check for FSF mailing addresses.
2243 if ($rawline =~ /\bwrite to the Free/i ||
2244 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2245 $rawline =~ /\b51\s+Franklin\s+St/i) {
2246 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2247 my $msg_type = \&ERROR;
2248 $msg_type = \&CHK if ($file);
2249 &{$msg_type}("FSF_MAILING_ADDRESS",
2250 "Do not include the paragraph about writing to the Free Software Foundation's mailing address from the sample GPL notice. The FSF has changed addresses in the past, and may do so again. Linux already includes a copy of the GPL.\n" . $herevet)
2253 # check for Kconfig help text having a real description
2254 # Only applies when adding the entry originally, after that we do not have
2255 # sufficient context to determine whether it is indeed long enough.
2256 if ($realfile =~ /Kconfig/ &&
2257 $line =~ /^\+\s*config\s+/) {
2260 my $ln = $linenr + 1;
2264 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2265 $f = $lines[$ln - 1];
2266 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2267 $is_end = $lines[$ln - 1] =~ /^\+/;
2269 next if ($f =~ /^-/);
2270 last if (!$file && $f =~ /^\@\@/);
2272 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2274 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2281 next if ($f =~ /^$/);
2282 if ($f =~ /^\s*config\s/) {
2288 WARN("CONFIG_DESCRIPTION",
2289 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
2290 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2293 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2294 if ($realfile =~ /Kconfig/ &&
2295 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2296 WARN("CONFIG_EXPERIMENTAL",
2297 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2300 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2301 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2304 'EXTRA_AFLAGS' => 'asflags-y',
2305 'EXTRA_CFLAGS' => 'ccflags-y',
2306 'EXTRA_CPPFLAGS' => 'cppflags-y',
2307 'EXTRA_LDFLAGS' => 'ldflags-y',
2310 WARN("DEPRECATED_VARIABLE",
2311 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2314 # check for DT compatible documentation
2315 if (defined $root &&
2316 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2317 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2319 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2321 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2322 my $vp_file = $dt_path . "vendor-prefixes.txt";
2324 foreach my $compat (@compats) {
2325 my $compat2 = $compat;
2326 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2327 my $compat3 = $compat;
2328 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2329 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2331 WARN("UNDOCUMENTED_DT_STRING",
2332 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2335 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2337 `grep -Eq "^$vendor\\b" $vp_file`;
2339 WARN("UNDOCUMENTED_DT_STRING",
2340 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2345 # check we are in a valid source file if not then ignore this hunk
2346 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
2349 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2350 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2351 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2352 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
2353 $length > $max_line_length)
2356 "line over $max_line_length characters\n" . $herecurr);
2359 # Check for user-visible strings broken across lines, which breaks the ability
2360 # to grep for the string. Make exceptions when the previous string ends in a
2361 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2362 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
2363 if ($line =~ /^\+\s*"/ &&
2364 $prevline =~ /"\s*$/ &&
2365 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
2366 WARN("SPLIT_STRING",
2367 "quoted string split across lines\n" . $hereprev);
2370 # check for missing a space in a string concatination
2371 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
2372 WARN('MISSING_SPACE',
2373 "break quoted strings at a space character\n" . $hereprev);
2376 # check for spaces before a quoted newline
2377 if ($rawline =~ /^.*\".*\s\\n/) {
2378 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2379 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2381 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2386 # check for adding lines without a newline.
2387 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2388 WARN("MISSING_EOF_NEWLINE",
2389 "adding a line without newline at end of file\n" . $herecurr);
2392 # Blackfin: use hi/lo macros
2393 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2394 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2395 my $herevet = "$here\n" . cat_vet($line) . "\n";
2397 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2399 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2400 my $herevet = "$here\n" . cat_vet($line) . "\n";
2402 "use the HI() macro, not (... >> 16)\n" . $herevet);
2406 # check we are in a valid source file C or perl if not then ignore this hunk
2407 next if ($realfile !~ /\.(h|c|pl)$/);
2409 # at the beginning of a line any tabs must come first and anything
2410 # more than 8 must use tabs.
2411 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2412 $rawline =~ /^\+\s* \s*/) {
2413 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2415 if (ERROR("CODE_INDENT",
2416 "code indent should use tabs where possible\n" . $herevet) &&
2418 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2422 # check for space before tabs.
2423 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2424 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2425 if (WARN("SPACE_BEFORE_TAB",
2426 "please, no space before tabs\n" . $herevet) &&
2428 while ($fixed[$fixlinenr] =~
2429 s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2430 while ($fixed[$fixlinenr] =~
2431 s/(^\+.*) +\t/$1\t/) {}
2435 # check for && or || at the start of a line
2436 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2437 CHK("LOGICAL_CONTINUATIONS",
2438 "Logical continuations should be on the previous line\n" . $hereprev);
2441 # check multi-line statement indentation matches previous line
2442 if ($^V && $^V ge 5.10.0 &&
2443 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2444 $prevline =~ /^\+(\t*)(.*)$/;
2448 my $pos = pos_last_openparen($rest);
2450 $line =~ /^(\+| )([ \t]*)/;
2453 my $goodtabindent = $oldindent .
2456 my $goodspaceindent = $oldindent . " " x $pos;
2458 if ($newindent ne $goodtabindent &&
2459 $newindent ne $goodspaceindent) {
2461 if (CHK("PARENTHESIS_ALIGNMENT",
2462 "Alignment should match open parenthesis\n" . $hereprev) &&
2463 $fix && $line =~ /^\+/) {
2464 $fixed[$fixlinenr] =~
2465 s/^\+[ \t]*/\+$goodtabindent/;
2471 if ($line =~ /^\+.*\(\s*$Type\s*\)[ \t]+(?!$Assignment|$Arithmetic|{)/) {
2473 "No space is necessary after a cast\n" . $herecurr) &&
2475 $fixed[$fixlinenr] =~
2476 s/(\(\s*$Type\s*\))[ \t]+/$1/;
2480 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2481 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2482 $rawline =~ /^\+[ \t]*\*/ &&
2484 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2485 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2488 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2489 $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /*
2490 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
2491 $rawline =~ /^\+/ && #line is new
2492 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2493 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2494 "networking block comments start with * on subsequent lines\n" . $hereprev);
2497 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2498 $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2499 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2500 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2501 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
2502 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2503 "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2506 # check for missing blank lines after struct/union declarations
2507 # with exceptions for various attributes and macros
2508 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2510 !($line =~ /^\+\s*$/ ||
2511 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2512 $line =~ /^\+\s*MODULE_/i ||
2513 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2514 $line =~ /^\+[a-z_]*init/ ||
2515 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2516 $line =~ /^\+\s*DECLARE/ ||
2517 $line =~ /^\+\s*__setup/)) {
2518 if (CHK("LINE_SPACING",
2519 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2521 fix_insert_line($fixlinenr, "\+");
2525 # check for multiple consecutive blank lines
2526 if ($prevline =~ /^[\+ ]\s*$/ &&
2527 $line =~ /^\+\s*$/ &&
2528 $last_blank_line != ($linenr - 1)) {
2529 if (CHK("LINE_SPACING",
2530 "Please don't use multiple blank lines\n" . $hereprev) &&
2532 fix_delete_line($fixlinenr, $rawline);
2535 $last_blank_line = $linenr;
2538 # check for missing blank lines after declarations
2539 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2540 # actual declarations
2541 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2542 # function pointer declarations
2543 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2544 # foo bar; where foo is some local typedef or #define
2545 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2546 # known declaration macros
2547 $prevline =~ /^\+\s+$declaration_macros/) &&
2548 # for "else if" which can look like "$Ident $Ident"
2549 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2550 # other possible extensions of declaration lines
2551 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2552 # not starting a section or a macro "\" extended line
2553 $prevline =~ /(?:\{\s*|\\)$/) &&
2554 # looks like a declaration
2555 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2556 # function pointer declarations
2557 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2558 # foo bar; where foo is some local typedef or #define
2559 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2560 # known declaration macros
2561 $sline =~ /^\+\s+$declaration_macros/ ||
2562 # start of struct or union or enum
2563 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2564 # start or end of block or continuation of declaration
2565 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2566 # bitfield continuation
2567 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2568 # other possible extensions of declaration lines
2569 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2570 # indentation of previous and current line are the same
2571 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2572 if (WARN("LINE_SPACING",
2573 "Missing a blank line after declarations\n" . $hereprev) &&
2575 fix_insert_line($fixlinenr, "\+");
2579 # check for spaces at the beginning of a line.
2581 # 1) within comments
2582 # 2) indented preprocessor commands
2584 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
2585 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2586 if (WARN("LEADING_SPACE",
2587 "please, no spaces at the start of a line\n" . $herevet) &&
2589 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2593 # check we are in a valid C source file if not then ignore this hunk
2594 next if ($realfile !~ /\.(h|c)$/);
2596 # check indentation of any line with a bare else
2597 # if the previous line is a break or return and is indented 1 tab more...
2598 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2599 my $tabs = length($1) + 1;
2600 if ($prevline =~ /^\+\t{$tabs,$tabs}(?:break|return)\b/) {
2601 WARN("UNNECESSARY_ELSE",
2602 "else is not generally useful after a break or return\n" . $hereprev);
2606 # check indentation of a line with a break;
2607 # if the previous line is a goto or return and is indented the same # of tabs
2608 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2610 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2611 WARN("UNNECESSARY_BREAK",
2612 "break is not useful after a goto or return\n" . $hereprev);
2616 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2617 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2618 WARN("CONFIG_EXPERIMENTAL",
2619 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2622 # check for RCS/CVS revision markers
2623 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2625 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2628 # Blackfin: don't use __builtin_bfin_[cs]sync
2629 if ($line =~ /__builtin_bfin_csync/) {
2630 my $herevet = "$here\n" . cat_vet($line) . "\n";
2632 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2634 if ($line =~ /__builtin_bfin_ssync/) {
2635 my $herevet = "$here\n" . cat_vet($line) . "\n";
2637 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2640 # check for old HOTPLUG __dev<foo> section markings
2641 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2642 WARN("HOTPLUG_SECTION",
2643 "Using $1 is unnecessary\n" . $herecurr);
2646 # Check for potential 'bare' types
2647 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2649 #print "LINE<$line>\n";
2650 if ($linenr >= $suppress_statement &&
2651 $realcnt && $sline =~ /.\s*\S/) {
2652 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2653 ctx_statement_block($linenr, $realcnt, 0);
2654 $stat =~ s/\n./\n /g;
2655 $cond =~ s/\n./\n /g;
2657 #print "linenr<$linenr> <$stat>\n";
2658 # If this statement has no statement boundaries within
2659 # it there is no point in retrying a statement scan
2660 # until we hit end of it.
2661 my $frag = $stat; $frag =~ s/;+\s*$//;
2662 if ($frag !~ /(?:{|;)/) {
2663 #print "skip<$line_nr_next>\n";
2664 $suppress_statement = $line_nr_next;
2667 # Find the real next line.
2668 $realline_next = $line_nr_next;
2669 if (defined $realline_next &&
2670 (!defined $lines[$realline_next - 1] ||
2671 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2678 # Ignore goto labels.
2679 if ($s =~ /$Ident:\*$/s) {
2681 # Ignore functions being called
2682 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2684 } elsif ($s =~ /^.\s*else\b/s) {
2686 # declarations always start with types
2687 } 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) {
2690 possible($type, "A:" . $s);
2692 # definitions in global scope can only start with types
2693 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2694 possible($1, "B:" . $s);
2697 # any (foo ... *) is a pointer cast, and foo is a type
2698 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2699 possible($1, "C:" . $s);
2702 # Check for any sort of function declaration.
2703 # int foo(something bar, other baz);
2704 # void (*store_gdt)(x86_descr_ptr *);
2705 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2706 my ($name_len) = length($1);
2709 substr($ctx, 0, $name_len + 1, '');
2710 $ctx =~ s/\)[^\)]*$//;
2712 for my $arg (split(/\s*,\s*/, $ctx)) {
2713 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2715 possible($1, "D:" . $s);
2723 # Checks which may be anchored in the context.
2726 # Check for switch () and associated case and default
2727 # statements should be at the same indent.
2728 if ($line=~/\bswitch\s*\(.*\)/) {
2731 my @ctx = ctx_block_outer($linenr, $realcnt);
2733 for my $ctx (@ctx) {
2734 my ($clen, $cindent) = line_stats($ctx);
2735 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2736 $indent != $cindent) {
2737 $err .= "$sep$ctx\n";
2744 ERROR("SWITCH_CASE_INDENT_LEVEL",
2745 "switch and case should be at the same indent\n$hereline$err");
2749 # if/while/etc brace do not go on next line, unless defining a do while loop,
2750 # or if that brace on the next line is for something else
2751 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2752 my $pre_ctx = "$1$2";
2754 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2756 if ($line =~ /^\+\t{6,}/) {
2757 WARN("DEEP_INDENTATION",
2758 "Too many leading tabs - consider code refactoring\n" . $herecurr);
2761 my $ctx_cnt = $realcnt - $#ctx - 1;
2762 my $ctx = join("\n", @ctx);
2764 my $ctx_ln = $linenr;
2765 my $ctx_skip = $realcnt;
2767 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2768 defined $lines[$ctx_ln - 1] &&
2769 $lines[$ctx_ln - 1] =~ /^-/)) {
2770 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2771 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2775 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2776 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2778 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2780 "that open brace { should be on the previous line\n" .
2781 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2783 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2784 $ctx =~ /\)\s*\;\s*$/ &&
2785 defined $lines[$ctx_ln - 1])
2787 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2788 if ($nindent > $indent) {
2789 WARN("TRAILING_SEMICOLON",
2790 "trailing semicolon indicates no statements, indent implies otherwise\n" .
2791 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2796 # Check relative indent for conditionals and blocks.
2797 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2798 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2799 ctx_statement_block($linenr, $realcnt, 0)
2800 if (!defined $stat);
2801 my ($s, $c) = ($stat, $cond);
2803 substr($s, 0, length($c), '');
2805 # Make sure we remove the line prefixes as we have
2806 # none on the first line, and are going to readd them
2810 # Find out how long the conditional actually is.
2811 my @newlines = ($c =~ /\n/gs);
2812 my $cond_lines = 1 + $#newlines;
2814 # We want to check the first line inside the block
2815 # starting at the end of the conditional, so remove:
2816 # 1) any blank line termination
2817 # 2) any opening brace { on end of the line
2819 my $continuation = 0;
2821 $s =~ s/^.*\bdo\b//;
2823 if ($s =~ s/^\s*\\//) {
2826 if ($s =~ s/^\s*?\n//) {
2831 # Also ignore a loop construct at the end of a
2832 # preprocessor statement.
2833 if (($prevline =~ /^.\s*#\s*define\s/ ||
2834 $prevline =~ /\\\s*$/) && $continuation == 0) {
2840 while ($cond_ptr != $cond_lines) {
2841 $cond_ptr = $cond_lines;
2843 # If we see an #else/#elif then the code
2845 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2850 # 1) blank lines, they should be at 0,
2851 # 2) preprocessor lines, and
2853 if ($continuation ||
2855 $s =~ /^\s*#\s*?/ ||
2856 $s =~ /^\s*$Ident\s*:/) {
2857 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2858 if ($s =~ s/^.*?\n//) {
2864 my (undef, $sindent) = line_stats("+" . $s);
2865 my $stat_real = raw_line($linenr, $cond_lines);
2867 # Check if either of these lines are modified, else
2868 # this is not this patch's fault.
2869 if (!defined($stat_real) ||
2870 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2873 if (defined($stat_real) && $cond_lines > 1) {
2874 $stat_real = "[...]\n$stat_real";
2877 #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";
2879 if ($check && (($sindent % 8) != 0 ||
2880 ($sindent <= $indent && $s ne ''))) {
2881 WARN("SUSPECT_CODE_INDENT",
2882 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2886 # Track the 'values' across context and added lines.
2887 my $opline = $line; $opline =~ s/^./ /;
2888 my ($curr_values, $curr_vars) =
2889 annotate_values($opline . "\n", $prev_values);
2890 $curr_values = $prev_values . $curr_values;
2892 my $outline = $opline; $outline =~ s/\t/ /g;
2893 print "$linenr > .$outline\n";
2894 print "$linenr > $curr_values\n";
2895 print "$linenr > $curr_vars\n";
2897 $prev_values = substr($curr_values, -1);
2899 #ignore lines not being added
2900 next if ($line =~ /^[^\+]/);
2902 # TEST: allow direct testing of the type matcher.
2904 if ($line =~ /^.\s*$Declare\s*$/) {
2906 "TEST: is type\n" . $herecurr);
2907 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2908 ERROR("TEST_NOT_TYPE",
2909 "TEST: is not type ($1 is)\n". $herecurr);
2913 # TEST: allow direct testing of the attribute matcher.
2915 if ($line =~ /^.\s*$Modifier\s*$/) {
2917 "TEST: is attr\n" . $herecurr);
2918 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2919 ERROR("TEST_NOT_ATTR",
2920 "TEST: is not attr ($1 is)\n". $herecurr);
2925 # check for initialisation to aggregates open brace on the next line
2926 if ($line =~ /^.\s*{/ &&
2927 $prevline =~ /(?:^|[^=])=\s*$/) {
2928 if (ERROR("OPEN_BRACE",
2929 "that open brace { should be on the previous line\n" . $hereprev) &&
2930 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
2931 fix_delete_line($fixlinenr - 1, $prevrawline);
2932 fix_delete_line($fixlinenr, $rawline);
2933 my $fixedline = $prevrawline;
2934 $fixedline =~ s/\s*=\s*$/ = {/;
2935 fix_insert_line($fixlinenr, $fixedline);
2937 $fixedline =~ s/^(.\s*){\s*/$1/;
2938 fix_insert_line($fixlinenr, $fixedline);
2943 # Checks which are anchored on the added line.
2946 # check for malformed paths in #include statements (uses RAW line)
2947 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2949 if ($path =~ m{//}) {
2950 ERROR("MALFORMED_INCLUDE",
2951 "malformed #include filename\n" . $herecurr);
2953 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2954 ERROR("UAPI_INCLUDE",
2955 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
2959 # no C99 // comments
2960 if ($line =~ m{//}) {
2961 if (ERROR("C99_COMMENTS",
2962 "do not use C99 // comments\n" . $herecurr) &&
2964 my $line = $fixed[$fixlinenr];
2965 if ($line =~ /\/\/(.*)$/) {
2966 my $comment = trim($1);
2967 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
2971 # Remove C99 comments.
2973 $opline =~ s@//.*@@;
2975 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2976 # the whole statement.
2977 #print "APW <$lines[$realline_next - 1]>\n";
2978 if (defined $realline_next &&
2979 exists $lines[$realline_next - 1] &&
2980 !defined $suppress_export{$realline_next} &&
2981 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2982 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2983 # Handle definitions which produce identifiers with
2986 # EXPORT_SYMBOL(something_foo);
2988 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
2989 $name =~ /^${Ident}_$2/) {
2990 #print "FOO C name<$name>\n";
2991 $suppress_export{$realline_next} = 1;
2993 } elsif ($stat !~ /(?:
2995 ^.DEFINE_$Ident\(\Q$name\E\)|
2996 ^.DECLARE_$Ident\(\Q$name\E\)|
2997 ^.LIST_HEAD\(\Q$name\E\)|
2998 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2999 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3001 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3002 $suppress_export{$realline_next} = 2;
3004 $suppress_export{$realline_next} = 1;
3007 if (!defined $suppress_export{$linenr} &&
3008 $prevline =~ /^.\s*$/ &&
3009 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3010 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3011 #print "FOO B <$lines[$linenr - 1]>\n";
3012 $suppress_export{$linenr} = 2;
3014 if (defined $suppress_export{$linenr} &&
3015 $suppress_export{$linenr} == 2) {
3016 WARN("EXPORT_SYMBOL",
3017 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3020 # check for global initialisers.
3021 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
3022 if (ERROR("GLOBAL_INITIALISERS",
3023 "do not initialise globals to 0 or NULL\n" .
3026 $fixed[$fixlinenr] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
3029 # check for static initialisers.
3030 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
3031 if (ERROR("INITIALISED_STATIC",
3032 "do not initialise statics to 0 or NULL\n" .
3035 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
3039 # check for misordered declarations of char/short/int/long with signed/unsigned
3040 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3042 WARN("MISORDERED_TYPE",
3043 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3046 # check for static const char * arrays.
3047 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3048 WARN("STATIC_CONST_CHAR_ARRAY",
3049 "static const char * array should probably be static const char * const\n" .
3053 # check for static char foo[] = "bar" declarations.
3054 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3055 WARN("STATIC_CONST_CHAR_ARRAY",
3056 "static char array declaration should probably be static const char\n" .
3060 # check for non-global char *foo[] = {"bar", ...} declarations.
3061 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3062 WARN("STATIC_CONST_CHAR_ARRAY",
3063 "char * array declaration might be better as static const\n" .
3067 # check for function declarations without arguments like "int foo()"
3068 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3069 if (ERROR("FUNCTION_WITHOUT_ARGS",
3070 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3072 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3076 # check for uses of DEFINE_PCI_DEVICE_TABLE
3077 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3078 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3079 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3081 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3085 # check for new typedefs, only function parameters and sparse annotations
3087 if ($line =~ /\btypedef\s/ &&
3088 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3089 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3090 $line !~ /\b$typeTypedefs\b/ &&
3091 $line !~ /\b__bitwise(?:__|)\b/) {
3092 WARN("NEW_TYPEDEFS",
3093 "do not add new typedefs\n" . $herecurr);
3096 # * goes on variable not on type
3098 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3100 my ($ident, $from, $to) = ($1, $2, $2);
3102 # Should start with a space.
3103 $to =~ s/^(\S)/ $1/;
3104 # Should not end with a space.
3106 # '*'s should not have spaces between.
3107 while ($to =~ s/\*\s+\*/\*\*/) {
3110 ## print "1: from<$from> to<$to> ident<$ident>\n";
3112 if (ERROR("POINTER_LOCATION",
3113 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3115 my $sub_from = $ident;
3116 my $sub_to = $ident;
3117 $sub_to =~ s/\Q$from\E/$to/;
3118 $fixed[$fixlinenr] =~
3119 s@\Q$sub_from\E@$sub_to@;
3123 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3125 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3127 # Should start with a space.
3128 $to =~ s/^(\S)/ $1/;
3129 # Should not end with a space.
3131 # '*'s should not have spaces between.
3132 while ($to =~ s/\*\s+\*/\*\*/) {
3134 # Modifiers should have spaces.
3135 $to =~ s/(\b$Modifier$)/$1 /;
3137 ## print "2: from<$from> to<$to> ident<$ident>\n";
3138 if ($from ne $to && $ident !~ /^$Modifier$/) {
3139 if (ERROR("POINTER_LOCATION",
3140 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3143 my $sub_from = $match;
3144 my $sub_to = $match;
3145 $sub_to =~ s/\Q$from\E/$to/;
3146 $fixed[$fixlinenr] =~
3147 s@\Q$sub_from\E@$sub_to@;
3152 # # no BUG() or BUG_ON()
3153 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
3154 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
3155 # print "$herecurr";
3159 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3160 WARN("LINUX_VERSION_CODE",
3161 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3164 # check for uses of printk_ratelimit
3165 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3166 WARN("PRINTK_RATELIMITED",
3167 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3170 # printk should use KERN_* levels. Note that follow on printk's on the
3171 # same line do not need a level, so we use the current block context
3172 # to try and find and validate the current printk. In summary the current
3173 # printk includes all preceding printk's which have no newline on the end.
3174 # we assume the first bad printk is the one to report.
3175 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3177 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3178 #print "CHECK<$lines[$ln - 1]\n";
3179 # we have a preceding printk if it ends
3180 # with "\n" ignore it, else it is to blame
3181 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3182 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3189 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3190 "printk() should include KERN_ facility level\n" . $herecurr);
3194 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3196 my $level = lc($orig);
3197 $level = "warn" if ($level eq "warning");
3198 my $level2 = $level;
3199 $level2 = "dbg" if ($level eq "debug");
3200 WARN("PREFER_PR_LEVEL",
3201 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3204 if ($line =~ /\bpr_warning\s*\(/) {
3205 if (WARN("PREFER_PR_LEVEL",
3206 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3208 $fixed[$fixlinenr] =~
3209 s/\bpr_warning\b/pr_warn/;
3213 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3215 my $level = lc($orig);
3216 $level = "warn" if ($level eq "warning");
3217 $level = "dbg" if ($level eq "debug");
3218 WARN("PREFER_DEV_LEVEL",
3219 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3222 # function brace can't be on same line, except for #defines of do while,
3223 # or if closed on same line
3224 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3225 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
3226 if (ERROR("OPEN_BRACE",
3227 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3229 fix_delete_line($fixlinenr, $rawline);
3230 my $fixed_line = $rawline;
3231 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3234 fix_insert_line($fixlinenr, ltrim($line1));
3235 fix_insert_line($fixlinenr, "\+{");
3236 if ($line2 !~ /^\s*$/) {
3237 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3242 # open braces for enum, union and struct go on the same line.
3243 if ($line =~ /^.\s*{/ &&
3244 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3245 if (ERROR("OPEN_BRACE",
3246 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3247 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3248 fix_delete_line($fixlinenr - 1, $prevrawline);
3249 fix_delete_line($fixlinenr, $rawline);
3250 my $fixedline = rtrim($prevrawline) . " {";
3251 fix_insert_line($fixlinenr, $fixedline);
3252 $fixedline = $rawline;
3253 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3254 if ($fixedline !~ /^\+\s*$/) {
3255 fix_insert_line($fixlinenr, $fixedline);
3260 # missing space after union, struct or enum definition
3261 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3263 "missing space after $1 definition\n" . $herecurr) &&
3265 $fixed[$fixlinenr] =~
3266 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3270 # Function pointer declarations
3271 # check spacing between type, funcptr, and args
3272 # canonical declaration is "type (*funcptr)(args...)"
3273 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3275 my $pre_pointer_space = $2;
3276 my $post_pointer_space = $3;
3278 my $post_funcname_space = $5;
3279 my $pre_args_space = $6;
3281 # the $Declare variable will capture all spaces after the type
3282 # so check it for a missing trailing missing space but pointer return types
3283 # don't need a space so don't warn for those.
3284 my $post_declare_space = "";
3285 if ($declare =~ /(\s+)$/) {
3286 $post_declare_space = $1;
3287 $declare = rtrim($declare);
3289 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3291 "missing space after return type\n" . $herecurr);
3292 $post_declare_space = " ";
3295 # unnecessary space "type (*funcptr)(args...)"
3296 # This test is not currently implemented because these declarations are
3298 # int foo(int bar, ...)
3299 # and this is form shouldn't/doesn't generate a checkpatch warning.
3301 # elsif ($declare =~ /\s{2,}$/) {
3303 # "Multiple spaces after return type\n" . $herecurr);
3306 # unnecessary space "type ( *funcptr)(args...)"
3307 if (defined $pre_pointer_space &&
3308 $pre_pointer_space =~ /^\s/) {
3310 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3313 # unnecessary space "type (* funcptr)(args...)"
3314 if (defined $post_pointer_space &&
3315 $post_pointer_space =~ /^\s/) {
3317 "Unnecessary space before function pointer name\n" . $herecurr);
3320 # unnecessary space "type (*funcptr )(args...)"
3321 if (defined $post_funcname_space &&
3322 $post_funcname_space =~ /^\s/) {
3324 "Unnecessary space after function pointer name\n" . $herecurr);
3327 # unnecessary space "type (*funcptr) (args...)"
3328 if (defined $pre_args_space &&
3329 $pre_args_space =~ /^\s/) {
3331 "Unnecessary space before function pointer arguments\n" . $herecurr);
3334 if (show_type("SPACING") && $fix) {
3335 $fixed[$fixlinenr] =~
3336 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3340 # check for spacing round square brackets; allowed:
3341 # 1. with a type on the left -- int [] a;
3342 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3343 # 3. inside a curly brace -- = { [0...10] = 5 }
3344 while ($line =~ /(.*?\s)\[/g) {
3345 my ($where, $prefix) = ($-[1], $1);
3346 if ($prefix !~ /$Type\s+$/ &&
3347 ($where != 0 || $prefix !~ /^.\s+$/) &&
3348 $prefix !~ /[{,]\s+$/) {
3349 if (ERROR("BRACKET_SPACE",
3350 "space prohibited before open square bracket '['\n" . $herecurr) &&
3352 $fixed[$fixlinenr] =~
3353 s/^(\+.*?)\s+\[/$1\[/;
3358 # check for spaces between functions and their parentheses.
3359 while ($line =~ /($Ident)\s+\(/g) {
3361 my $ctx_before = substr($line, 0, $-[1]);
3362 my $ctx = "$ctx_before$name";
3364 # Ignore those directives where spaces _are_ permitted.
3366 if|for|while|switch|return|case|
3367 volatile|__volatile__|
3368 __attribute__|format|__extension__|
3371 # cpp #define statements have non-optional spaces, ie
3372 # if there is a space between the name and the open
3373 # parenthesis it is simply not a parameter group.
3374 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3376 # cpp #elif statement condition may start with a (
3377 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3379 # If this whole things ends with a type its most
3380 # likely a typedef for a function.
3381 } elsif ($ctx =~ /$Type$/) {
3385 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3387 $fixed[$fixlinenr] =~
3388 s/\b$name\s+\(/$name\(/;
3393 # Check operator spacing.
3394 if (!($line=~/\#\s*include/)) {
3395 my $fixed_line = "";
3399 <<=|>>=|<=|>=|==|!=|
3400 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3401 =>|->|<<|>>|<|>|=|!|~|
3402 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3405 my @elements = split(/($ops|;)/, $opline);
3407 ## print("element count: <" . $#elements . ">\n");
3408 ## foreach my $el (@elements) {
3409 ## print("el: <$el>\n");
3412 my @fix_elements = ();
3415 foreach my $el (@elements) {
3416 push(@fix_elements, substr($rawline, $off, length($el)));
3417 $off += length($el);
3422 my $blank = copy_spacing($opline);
3423 my $last_after = -1;
3425 for (my $n = 0; $n < $#elements; $n += 2) {
3427 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3429 ## print("n: <$n> good: <$good>\n");
3431 $off += length($elements[$n]);
3433 # Pick up the preceding and succeeding characters.
3434 my $ca = substr($opline, 0, $off);
3436 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3437 $cc = substr($opline, $off + length($elements[$n + 1]));
3439 my $cb = "$ca$;$cc";
3442 $a = 'V' if ($elements[$n] ne '');
3443 $a = 'W' if ($elements[$n] =~ /\s$/);
3444 $a = 'C' if ($elements[$n] =~ /$;$/);
3445 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3446 $a = 'O' if ($elements[$n] eq '');
3447 $a = 'E' if ($ca =~ /^\s*$/);
3449 my $op = $elements[$n + 1];
3452 if (defined $elements[$n + 2]) {
3453 $c = 'V' if ($elements[$n + 2] ne '');
3454 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3455 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3456 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3457 $c = 'O' if ($elements[$n + 2] eq '');
3458 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3463 my $ctx = "${a}x${c}";
3465 my $at = "(ctx:$ctx)";
3467 my $ptr = substr($blank, 0, $off) . "^";
3468 my $hereptr = "$hereline$ptr\n";
3470 # Pull out the value of this operator.
3471 my $op_type = substr($curr_values, $off + 1, 1);
3473 # Get the full operator variant.
3474 my $opv = $op . substr($curr_vars, $off, 1);
3476 # Ignore operators passed as parameters.
3477 if ($op_type ne 'V' &&
3478 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3481 # } elsif ($op =~ /^$;+$/) {
3483 # ; should have either the end of line or a space or \ after it
3484 } elsif ($op eq ';') {
3485 if ($ctx !~ /.x[WEBC]/ &&
3486 $cc !~ /^\\/ && $cc !~ /^;/) {
3487 if (ERROR("SPACING",
3488 "space required after that '$op' $at\n" . $hereptr)) {
3489 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3495 } elsif ($op eq '//') {
3497 # : when part of a bitfield
3498 } elsif ($opv eq ':B') {
3499 # skip the bitfield test for now
3503 } elsif ($op eq '->') {
3504 if ($ctx =~ /Wx.|.xW/) {
3505 if (ERROR("SPACING",
3506 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3507 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3508 if (defined $fix_elements[$n + 2]) {
3509 $fix_elements[$n + 2] =~ s/^\s+//;
3515 # , must have a space on the right.
3516 } elsif ($op eq ',') {
3517 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3518 if (ERROR("SPACING",
3519 "space required after that '$op' $at\n" . $hereptr)) {
3520 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3526 # '*' as part of a type definition -- reported already.
3527 } elsif ($opv eq '*_') {
3528 #warn "'*' is part of type\n";
3530 # unary operators should have a space before and
3531 # none after. May be left adjacent to another
3532 # unary operator, or a cast
3533 } elsif ($op eq '!' || $op eq '~' ||
3534 $opv eq '*U' || $opv eq '-U' ||
3535 $opv eq '&U' || $opv eq '&&U') {
3536 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3537 if (ERROR("SPACING",
3538 "space required before that '$op' $at\n" . $hereptr)) {
3539 if ($n != $last_after + 2) {
3540 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3545 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3546 # A unary '*' may be const
3548 } elsif ($ctx =~ /.xW/) {
3549 if (ERROR("SPACING",
3550 "space prohibited after that '$op' $at\n" . $hereptr)) {
3551 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3552 if (defined $fix_elements[$n + 2]) {
3553 $fix_elements[$n + 2] =~ s/^\s+//;
3559 # unary ++ and unary -- are allowed no space on one side.
3560 } elsif ($op eq '++' or $op eq '--') {
3561 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3562 if (ERROR("SPACING",
3563 "space required one side of that '$op' $at\n" . $hereptr)) {
3564 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3568 if ($ctx =~ /Wx[BE]/ ||
3569 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3570 if (ERROR("SPACING",
3571 "space prohibited before that '$op' $at\n" . $hereptr)) {
3572 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3576 if ($ctx =~ /ExW/) {
3577 if (ERROR("SPACING",
3578 "space prohibited after that '$op' $at\n" . $hereptr)) {
3579 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3580 if (defined $fix_elements[$n + 2]) {
3581 $fix_elements[$n + 2] =~ s/^\s+//;
3587 # << and >> may either have or not have spaces both sides
3588 } elsif ($op eq '<<' or $op eq '>>' or
3589 $op eq '&' or $op eq '^' or $op eq '|' or
3590 $op eq '+' or $op eq '-' or
3591 $op eq '*' or $op eq '/' or
3594 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3595 if (ERROR("SPACING",
3596 "need consistent spacing around '$op' $at\n" . $hereptr)) {
3597 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3598 if (defined $fix_elements[$n + 2]) {
3599 $fix_elements[$n + 2] =~ s/^\s+//;
3605 # A colon needs no spaces before when it is
3606 # terminating a case value or a label.
3607 } elsif ($opv eq ':C' || $opv eq ':L') {
3608 if ($ctx =~ /Wx./) {
3609 if (ERROR("SPACING",
3610 "space prohibited before that '$op' $at\n" . $hereptr)) {
3611 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3616 # All the others need spaces both sides.
3617 } elsif ($ctx !~ /[EWC]x[CWE]/) {
3620 # Ignore email addresses <foo@bar>
3622 $cc =~ /^\S+\@\S+>/) ||
3624 $ca =~ /<\S+\@\S+$/))
3629 # messages are ERROR, but ?: are CHK
3631 my $msg_type = \&ERROR;
3632 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3634 if (&{$msg_type}("SPACING",
3635 "spaces required around that '$op' $at\n" . $hereptr)) {
3636 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3637 if (defined $fix_elements[$n + 2]) {
3638 $fix_elements[$n + 2] =~ s/^\s+//;
3644 $off += length($elements[$n + 1]);
3646 ## print("n: <$n> GOOD: <$good>\n");
3648 $fixed_line = $fixed_line . $good;
3651 if (($#elements % 2) == 0) {
3652 $fixed_line = $fixed_line . $fix_elements[$#elements];
3655 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
3656 $fixed[$fixlinenr] = $fixed_line;
3662 # check for whitespace before a non-naked semicolon
3663 if ($line =~ /^\+.*\S\s+;\s*$/) {
3665 "space prohibited before semicolon\n" . $herecurr) &&
3667 1 while $fixed[$fixlinenr] =~
3668 s/^(\+.*\S)\s+;/$1;/;
3672 # check for multiple assignments
3673 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3674 CHK("MULTIPLE_ASSIGNMENTS",
3675 "multiple assignments should be avoided\n" . $herecurr);
3678 ## # check for multiple declarations, allowing for a function declaration
3680 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3681 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3683 ## # Remove any bracketed sections to ensure we do not
3684 ## # falsly report the parameters of functions.
3686 ## while ($ln =~ s/\([^\(\)]*\)//g) {
3688 ## if ($ln =~ /,/) {
3689 ## WARN("MULTIPLE_DECLARATION",
3690 ## "declaring multiple variables together should be avoided\n" . $herecurr);
3694 #need space before brace following if, while, etc
3695 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3697 if (ERROR("SPACING",
3698 "space required before the open brace '{'\n" . $herecurr) &&
3700 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
3704 ## # check for blank lines before declarations
3705 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3706 ## $prevrawline =~ /^.\s*$/) {
3708 ## "No blank lines before declarations\n" . $hereprev);
3712 # closing brace should have a space following it when it has anything
3714 if ($line =~ /}(?!(?:,|;|\)))\S/) {
3715 if (ERROR("SPACING",
3716 "space required after that close brace '}'\n" . $herecurr) &&
3718 $fixed[$fixlinenr] =~
3719 s/}((?!(?:,|;|\)))\S)/} $1/;
3723 # check spacing on square brackets
3724 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3725 if (ERROR("SPACING",
3726 "space prohibited after that open square bracket '['\n" . $herecurr) &&
3728 $fixed[$fixlinenr] =~
3732 if ($line =~ /\s\]/) {
3733 if (ERROR("SPACING",
3734 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3736 $fixed[$fixlinenr] =~
3741 # check spacing on parentheses
3742 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3743 $line !~ /for\s*\(\s+;/) {
3744 if (ERROR("SPACING",
3745 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3747 $fixed[$fixlinenr] =~
3751 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3752 $line !~ /for\s*\(.*;\s+\)/ &&
3753 $line !~ /:\s+\)/) {
3754 if (ERROR("SPACING",
3755 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3757 $fixed[$fixlinenr] =~
3762 # check unnecessary parentheses around addressof/dereference single $Lvals
3763 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
3765 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
3766 CHK("UNNECESSARY_PARENTHESES",
3767 "Unnecessary parentheses around $1\n" . $herecurr);
3770 #goto labels aren't indented, allow a single space however
3771 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3772 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3773 if (WARN("INDENTED_LABEL",
3774 "labels should not be indented\n" . $herecurr) &&
3776 $fixed[$fixlinenr] =~
3781 # return is not a function
3782 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
3784 if ($^V && $^V ge 5.10.0 &&
3785 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
3787 $value = deparenthesize($value);
3788 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
3789 ERROR("RETURN_PARENTHESES",
3790 "return is not a function, parentheses are not required\n" . $herecurr);
3792 } elsif ($spacing !~ /\s+/) {
3794 "space required before the open parenthesis '('\n" . $herecurr);
3798 # unnecessary return in a void function
3799 # at end-of-function, with the previous line a single leading tab, then return;
3800 # and the line before that not a goto label target like "out:"
3801 if ($sline =~ /^[ \+]}\s*$/ &&
3802 $prevline =~ /^\+\treturn\s*;\s*$/ &&
3804 $lines[$linenr - 3] =~ /^[ +]/ &&
3805 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
3807 "void function return statements are not generally useful\n" . $hereprev);
3810 # if statements using unnecessary parentheses - ie: if ((foo == bar))
3811 if ($^V && $^V ge 5.10.0 &&
3812 $line =~ /\bif\s*((?:\(\s*){2,})/) {
3813 my $openparens = $1;
3814 my $count = $openparens =~ tr@\(@\(@;
3816 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3817 my $comp = $4; #Not $1 because of $LvalOrFunc
3818 $msg = " - maybe == should be = ?" if ($comp eq "==");
3819 WARN("UNNECESSARY_PARENTHESES",
3820 "Unnecessary parentheses$msg\n" . $herecurr);
3824 # Return of what appears to be an errno should normally be -'ve
3825 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3827 if ($name ne 'EOF' && $name ne 'ERROR') {
3828 WARN("USE_NEGATIVE_ERRNO",
3829 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3833 # Need a space before open parenthesis after if, while etc
3834 if ($line =~ /\b(if|while|for|switch)\(/) {
3835 if (ERROR("SPACING",
3836 "space required before the open parenthesis '('\n" . $herecurr) &&
3838 $fixed[$fixlinenr] =~
3839 s/\b(if|while|for|switch)\(/$1 \(/;
3843 # Check for illegal assignment in if conditional -- and check for trailing
3844 # statements after the conditional.
3845 if ($line =~ /do\s*(?!{)/) {
3846 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3847 ctx_statement_block($linenr, $realcnt, 0)
3848 if (!defined $stat);
3849 my ($stat_next) = ctx_statement_block($line_nr_next,
3850 $remain_next, $off_next);
3851 $stat_next =~ s/\n./\n /g;
3852 ##print "stat<$stat> stat_next<$stat_next>\n";
3854 if ($stat_next =~ /^\s*while\b/) {
3855 # If the statement carries leading newlines,
3856 # then count those as offsets.
3858 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3860 statement_rawlines($whitespace) - 1;
3862 $suppress_whiletrailers{$line_nr_next +
3866 if (!defined $suppress_whiletrailers{$linenr} &&
3867 defined($stat) && defined($cond) &&
3868 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3869 my ($s, $c) = ($stat, $cond);
3871 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3872 ERROR("ASSIGN_IN_IF",
3873 "do not use assignment in if condition\n" . $herecurr);
3876 # Find out what is on the end of the line after the
3878 substr($s, 0, length($c), '');
3880 $s =~ s/$;//g; # Remove any comments
3881 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3882 $c !~ /}\s*while\s*/)
3884 # Find out how long the conditional actually is.
3885 my @newlines = ($c =~ /\n/gs);
3886 my $cond_lines = 1 + $#newlines;
3889 $stat_real = raw_line($linenr, $cond_lines)
3890 . "\n" if ($cond_lines);
3891 if (defined($stat_real) && $cond_lines > 1) {
3892 $stat_real = "[...]\n$stat_real";
3895 ERROR("TRAILING_STATEMENTS",
3896 "trailing statements should be on next line\n" . $herecurr . $stat_real);
3900 # Check for bitwise tests written as boolean
3912 WARN("HEXADECIMAL_BOOLEAN_TEST",
3913 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3916 # if and else should not have general statements after it
3917 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3919 $s =~ s/$;//g; # Remove any comments
3920 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3921 ERROR("TRAILING_STATEMENTS",
3922 "trailing statements should be on next line\n" . $herecurr);
3925 # if should not continue a brace
3926 if ($line =~ /}\s*if\b/) {
3927 ERROR("TRAILING_STATEMENTS",
3928 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
3931 # case and default should not have general statements after them
3932 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3934 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3938 ERROR("TRAILING_STATEMENTS",
3939 "trailing statements should be on next line\n" . $herecurr);
3942 # Check for }<nl>else {, these must be at the same
3943 # indent level to be relevant to each other.
3944 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
3945 $previndent == $indent) {
3946 if (ERROR("ELSE_AFTER_BRACE",
3947 "else should follow close brace '}'\n" . $hereprev) &&
3948 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3949 fix_delete_line($fixlinenr - 1, $prevrawline);
3950 fix_delete_line($fixlinenr, $rawline);
3951 my $fixedline = $prevrawline;
3952 $fixedline =~ s/}\s*$//;
3953 if ($fixedline !~ /^\+\s*$/) {
3954 fix_insert_line($fixlinenr, $fixedline);
3956 $fixedline = $rawline;
3957 $fixedline =~ s/^(.\s*)else/$1} else/;
3958 fix_insert_line($fixlinenr, $fixedline);
3962 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
3963 $previndent == $indent) {
3964 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3966 # Find out what is on the end of the line after the
3968 substr($s, 0, length($c), '');
3971 if ($s =~ /^\s*;/) {
3972 if (ERROR("WHILE_AFTER_BRACE",
3973 "while should follow close brace '}'\n" . $hereprev) &&
3974 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3975 fix_delete_line($fixlinenr - 1, $prevrawline);
3976 fix_delete_line($fixlinenr, $rawline);
3977 my $fixedline = $prevrawline;
3978 my $trailing = $rawline;
3979 $trailing =~ s/^\+//;
3980 $trailing = trim($trailing);
3981 $fixedline =~ s/}\s*$/} $trailing/;
3982 fix_insert_line($fixlinenr, $fixedline);
3987 #Specific variable tests
3988 while ($line =~ m{($Constant|$Lval)}g) {
3991 #gcc binary extension
3992 if ($var =~ /^$Binary$/) {
3993 if (WARN("GCC_BINARY_CONSTANT",
3994 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3996 my $hexval = sprintf("0x%x", oct($var));
3997 $fixed[$fixlinenr] =~
3998 s/\b$var\b/$hexval/;
4003 if ($var !~ /^$Constant$/ &&
4004 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4005 #Ignore Page<foo> variants
4006 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4007 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4008 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
4009 while ($var =~ m{($Ident)}g) {
4011 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4013 seed_camelcase_includes();
4014 if (!$file && !$camelcase_file_seeded) {
4015 seed_camelcase_file($realfile);
4016 $camelcase_file_seeded = 1;
4019 if (!defined $camelcase{$word}) {
4020 $camelcase{$word} = 1;
4022 "Avoid CamelCase: <$word>\n" . $herecurr);
4028 #no spaces allowed after \ in define
4029 if ($line =~ /\#\s*define.*\\\s+$/) {
4030 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4031 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4033 $fixed[$fixlinenr] =~ s/\s+$//;
4037 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
4038 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4040 my $checkfile = "include/linux/$file";
4041 if (-f "$root/$checkfile" &&
4042 $realfile ne $checkfile &&
4043 $1 !~ /$allowed_asm_includes/)
4045 if ($realfile =~ m{^arch/}) {
4046 CHK("ARCH_INCLUDE_LINUX",
4047 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4049 WARN("INCLUDE_LINUX",
4050 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4055 # multi-statement macros should be enclosed in a do while loop, grab the
4056 # first statement and ensure its the whole macro if its not enclosed
4057 # in a known good container
4058 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4059 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4062 my ($off, $dstat, $dcond, $rest);
4064 ($dstat, $dcond, $ln, $cnt, $off) =
4065 ctx_statement_block($linenr, $realcnt, 0);
4067 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4068 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4070 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4072 $dstat =~ s/\\\n.//g;
4073 $dstat =~ s/^\s*//s;
4074 $dstat =~ s/\s*$//s;
4076 # Flatten any parentheses and braces
4077 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4078 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4079 $dstat =~ s/\[[^\[\]]*\]/1/)
4083 # Flatten any obvious string concatentation.
4084 while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
4085 $dstat =~ s/$Ident\s*("X*")/$1/)
4089 my $exceptions = qr{
4101 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4103 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4104 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4105 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4106 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4107 $dstat !~ /$exceptions/ &&
4108 $dstat !~ /^\.$Ident\s*=/ && # .foo =
4109 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4110 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4111 $dstat !~ /^for\s*$Constant$/ && # for (...)
4112 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4113 $dstat !~ /^do\s*{/ && # do {...
4114 $dstat !~ /^\({/ && # ({...
4115 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4118 my $herectx = $here . "\n";
4119 my $cnt = statement_rawlines($ctx);
4121 for (my $n = 0; $n < $cnt; $n++) {
4122 $herectx .= raw_line($linenr, $n) . "\n";
4125 if ($dstat =~ /;/) {
4126 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4127 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4129 ERROR("COMPLEX_MACRO",
4130 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4134 # check for line continuations outside of #defines, preprocessor #, and asm
4137 if ($prevline !~ /^..*\\$/ &&
4138 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4139 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
4140 $line =~ /^\+.*\\$/) {
4141 WARN("LINE_CONTINUATIONS",
4142 "Avoid unnecessary line continuations\n" . $herecurr);
4146 # do {} while (0) macro tests:
4147 # single-statement macros do not need to be enclosed in do while (0) loop,
4148 # macro should not end with a semicolon
4149 if ($^V && $^V ge 5.10.0 &&
4150 $realfile !~ m@/vmlinux.lds.h$@ &&
4151 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4154 my ($off, $dstat, $dcond, $rest);
4156 ($dstat, $dcond, $ln, $cnt, $off) =
4157 ctx_statement_block($linenr, $realcnt, 0);
4160 $dstat =~ s/\\\n.//g;
4162 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4167 my $cnt = statement_rawlines($ctx);
4168 my $herectx = $here . "\n";
4170 for (my $n = 0; $n < $cnt; $n++) {
4171 $herectx .= raw_line($linenr, $n) . "\n";
4174 if (($stmts =~ tr/;/;/) == 1 &&
4175 $stmts !~ /^\s*(if|while|for|switch)\b/) {
4176 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4177 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4179 if (defined $semis && $semis ne "") {
4180 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4181 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4183 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4185 my $cnt = statement_rawlines($ctx);
4186 my $herectx = $here . "\n";
4188 for (my $n = 0; $n < $cnt; $n++) {
4189 $herectx .= raw_line($linenr, $n) . "\n";
4192 WARN("TRAILING_SEMICOLON",
4193 "macros should not use a trailing semicolon\n" . "$herectx");
4197 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4198 # all assignments may have only one of the following with an assignment:
4201 # VMLINUX_SYMBOL(...)
4202 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4203 WARN("MISSING_VMLINUX_SYMBOL",
4204 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4207 # check for redundant bracing round if etc
4208 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4209 my ($level, $endln, @chunks) =
4210 ctx_statement_full($linenr, $realcnt, 1);
4211 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4212 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4213 if ($#chunks > 0 && $level == 0) {
4217 my $herectx = $here . "\n";
4218 my $ln = $linenr - 1;
4219 for my $chunk (@chunks) {
4220 my ($cond, $block) = @{$chunk};
4222 # If the condition carries leading newlines, then count those as offsets.
4223 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4224 my $offset = statement_rawlines($whitespace) - 1;
4226 $allowed[$allow] = 0;
4227 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4229 # We have looked at and allowed this specific line.
4230 $suppress_ifbraces{$ln + $offset} = 1;
4232 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4233 $ln += statement_rawlines($block) - 1;
4235 substr($block, 0, length($cond), '');
4237 $seen++ if ($block =~ /^\s*{/);
4239 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4240 if (statement_lines($cond) > 1) {
4241 #print "APW: ALLOWED: cond<$cond>\n";
4242 $allowed[$allow] = 1;
4244 if ($block =~/\b(?:if|for|while)\b/) {
4245 #print "APW: ALLOWED: block<$block>\n";
4246 $allowed[$allow] = 1;
4248 if (statement_block_size($block) > 1) {
4249 #print "APW: ALLOWED: lines block<$block>\n";
4250 $allowed[$allow] = 1;
4255 my $sum_allowed = 0;
4256 foreach (@allowed) {
4259 if ($sum_allowed == 0) {
4261 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4262 } elsif ($sum_allowed != $allow &&
4265 "braces {} should be used on all arms of this statement\n" . $herectx);
4270 if (!defined $suppress_ifbraces{$linenr - 1} &&
4271 $line =~ /\b(if|while|for|else)\b/) {
4274 # Check the pre-context.
4275 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4276 #print "APW: ALLOWED: pre<$1>\n";
4280 my ($level, $endln, @chunks) =
4281 ctx_statement_full($linenr, $realcnt, $-[0]);
4283 # Check the condition.
4284 my ($cond, $block) = @{$chunks[0]};
4285 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4286 if (defined $cond) {
4287 substr($block, 0, length($cond), '');
4289 if (statement_lines($cond) > 1) {
4290 #print "APW: ALLOWED: cond<$cond>\n";
4293 if ($block =~/\b(?:if|for|while)\b/) {
4294 #print "APW: ALLOWED: block<$block>\n";
4297 if (statement_block_size($block) > 1) {
4298 #print "APW: ALLOWED: lines block<$block>\n";
4301 # Check the post-context.
4302 if (defined $chunks[1]) {
4303 my ($cond, $block) = @{$chunks[1]};
4304 if (defined $cond) {
4305 substr($block, 0, length($cond), '');
4307 if ($block =~ /^\s*\{/) {
4308 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4312 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4313 my $herectx = $here . "\n";
4314 my $cnt = statement_rawlines($block);
4316 for (my $n = 0; $n < $cnt; $n++) {
4317 $herectx .= raw_line($linenr, $n) . "\n";
4321 "braces {} are not necessary for single statement blocks\n" . $herectx);
4325 # check for unnecessary blank lines around braces
4326 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4328 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
4330 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4332 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
4335 # no volatiles please
4336 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4337 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4339 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4343 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
4344 CHK("REDUNDANT_CODE",
4345 "if this code is redundant consider removing it\n" .
4349 # check for needless "if (<foo>) fn(<foo>)" uses
4350 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4351 my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
4352 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
4354 "$1(NULL) is safe this check is probably not required\n" . $hereprev);
4358 # check for unnecessary "Out of Memory" messages
4359 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4360 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4361 (defined $1 || defined $3) &&
4364 my $testline = $lines[$linenr - 3];
4366 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4367 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4369 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4371 "Possible unnecessary 'out of memory' message\n" . $hereprev);
4375 # check for bad placement of section $InitAttribute (e.g.: __initdata)
4376 if ($line =~ /(\b$InitAttribute\b)/) {
4378 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4381 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4382 ERROR("MISPLACED_INIT",
4383 "$attr should be placed after $var\n" . $herecurr)) ||
4384 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4385 WARN("MISPLACED_INIT",
4386 "$attr should be placed after $var\n" . $herecurr))) &&
4388 $fixed[$fixlinenr] =~ 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;
4393 # check for $InitAttributeData (ie: __initdata) with const
4394 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
4396 $attr =~ /($InitAttributePrefix)(.*)/;
4397 my $attr_prefix = $1;
4399 if (ERROR("INIT_ATTRIBUTE",
4400 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
4402 $fixed[$fixlinenr] =~
4403 s/$InitAttributeData/${attr_prefix}initconst/;
4407 # check for $InitAttributeConst (ie: __initconst) without const
4408 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
4410 if (ERROR("INIT_ATTRIBUTE",
4411 "Use of $attr requires a separate use of const\n" . $herecurr) &&
4413 my $lead = $fixed[$fixlinenr] =~
4414 /(^\+\s*(?:static\s+))/;
4416 $lead = "$lead " if ($lead !~ /^\+$/);
4417 $lead = "${lead}const ";
4418 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
4422 # don't use __constant_<foo> functions outside of include/uapi/
4423 if ($realfile !~ m@^include/uapi/@ &&
4424 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
4425 my $constant_func = $1;
4426 my $func = $constant_func;
4427 $func =~ s/^__constant_//;
4428 if (WARN("CONSTANT_CONVERSION",
4429 "$constant_func should be $func\n" . $herecurr) &&
4431 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
4435 # prefer usleep_range over udelay
4436 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
4438 # ignore udelay's < 10, however
4439 if (! ($delay < 10) ) {
4441 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4443 if ($delay > 2000) {
4445 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
4449 # warn about unexpectedly long msleep's
4450 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
4453 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
4457 # check for comparisons of jiffies
4458 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
4459 WARN("JIFFIES_COMPARISON",
4460 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4463 # check for comparisons of get_jiffies_64()
4464 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4465 WARN("JIFFIES_COMPARISON",
4466 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4469 # warn about #ifdefs in C files
4470 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4471 # print "#ifdef in C files should be avoided\n";
4472 # print "$herecurr";
4476 # warn about spacing in #ifdefs
4477 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4478 if (ERROR("SPACING",
4479 "exactly one space required after that #$1\n" . $herecurr) &&
4481 $fixed[$fixlinenr] =~
4482 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4487 # check for spinlock_t definitions without a comment.
4488 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4489 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4491 if (!ctx_has_comment($first_line, $linenr)) {
4492 CHK("UNCOMMENTED_DEFINITION",
4493 "$1 definition without comment\n" . $herecurr);
4496 # check for memory barriers without a comment.
4497 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4498 if (!ctx_has_comment($first_line, $linenr)) {
4499 WARN("MEMORY_BARRIER",
4500 "memory barrier without comment\n" . $herecurr);
4503 # check of hardware specific defines
4504 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4506 "architecture specific defines should be avoided\n" . $herecurr);
4509 # Check that the storage class is at the beginning of a declaration
4510 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4511 WARN("STORAGE_CLASS",
4512 "storage class should be at the beginning of the declaration\n" . $herecurr)
4515 # check the location of the inline attribute, that it is between
4516 # storage class and type.
4517 if ($line =~ /\b$Type\s+$Inline\b/ ||
4518 $line =~ /\b$Inline\s+$Storage\b/) {
4519 ERROR("INLINE_LOCATION",
4520 "inline keyword should sit between storage class and type\n" . $herecurr);
4523 # Check for __inline__ and __inline, prefer inline
4524 if ($realfile !~ m@\binclude/uapi/@ &&
4525 $line =~ /\b(__inline__|__inline)\b/) {
4527 "plain inline is preferred over $1\n" . $herecurr) &&
4529 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
4534 # Check for __attribute__ packed, prefer __packed
4535 if ($realfile !~ m@\binclude/uapi/@ &&
4536 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4537 WARN("PREFER_PACKED",
4538 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4541 # Check for __attribute__ aligned, prefer __aligned
4542 if ($realfile !~ m@\binclude/uapi/@ &&
4543 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4544 WARN("PREFER_ALIGNED",
4545 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4548 # Check for __attribute__ format(printf, prefer __printf
4549 if ($realfile !~ m@\binclude/uapi/@ &&
4550 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4551 if (WARN("PREFER_PRINTF",
4552 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4554 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4559 # Check for __attribute__ format(scanf, prefer __scanf
4560 if ($realfile !~ m@\binclude/uapi/@ &&
4561 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4562 if (WARN("PREFER_SCANF",
4563 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4565 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4569 # check for sizeof(&)
4570 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4571 WARN("SIZEOF_ADDRESS",
4572 "sizeof(& should be avoided\n" . $herecurr);
4575 # check for sizeof without parenthesis
4576 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4577 if (WARN("SIZEOF_PARENTHESIS",
4578 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4580 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4584 # check for line continuations in quoted strings with odd counts of "
4585 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4586 WARN("LINE_CONTINUATIONS",
4587 "Avoid line continuations in quoted strings\n" . $herecurr);
4590 # check for struct spinlock declarations
4591 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4592 WARN("USE_SPINLOCK_T",
4593 "struct spinlock should be spinlock_t\n" . $herecurr);
4596 # check for seq_printf uses that could be seq_puts
4597 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4598 my $fmt = get_quoted_string($line, $rawline);
4599 if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4600 if (WARN("PREFER_SEQ_PUTS",
4601 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4603 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
4608 # Check for misused memsets
4609 if ($^V && $^V ge 5.10.0 &&
4611 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4617 if ($ms_size =~ /^(0x|)0$/i) {
4619 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4620 } elsif ($ms_size =~ /^(0x|)1$/i) {
4622 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4626 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4627 if ($^V && $^V ge 5.10.0 &&
4628 $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4629 if (WARN("PREFER_ETHER_ADDR_COPY",
4630 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4632 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4636 # typecasts on min/max could be min_t/max_t
4637 if ($^V && $^V ge 5.10.0 &&
4639 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4640 if (defined $2 || defined $7) {
4642 my $cast1 = deparenthesize($2);
4644 my $cast2 = deparenthesize($7);
4648 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4649 $cast = "$cast1 or $cast2";
4650 } elsif ($cast1 ne "") {
4656 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4660 # check usleep_range arguments
4661 if ($^V && $^V ge 5.10.0 &&
4663 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4667 WARN("USLEEP_RANGE",
4668 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4669 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4671 WARN("USLEEP_RANGE",
4672 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4676 # check for naked sscanf
4677 if ($^V && $^V ge 5.10.0 &&
4679 $line =~ /\bsscanf\b/ &&
4680 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4681 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4682 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4683 my $lc = $stat =~ tr@\n@@;
4684 $lc = $lc + $linenr;
4685 my $stat_real = raw_line($linenr, 0);
4686 for (my $count = $linenr + 1; $count <= $lc; $count++) {
4687 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4689 WARN("NAKED_SSCANF",
4690 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4693 # check for simple sscanf that should be kstrto<foo>
4694 if ($^V && $^V ge 5.10.0 &&
4696 $line =~ /\bsscanf\b/) {
4697 my $lc = $stat =~ tr@\n@@;
4698 $lc = $lc + $linenr;
4699 my $stat_real = raw_line($linenr, 0);
4700 for (my $count = $linenr + 1; $count <= $lc; $count++) {
4701 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4703 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
4705 my $count = $format =~ tr@%@%@;
4707 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
4708 WARN("SSCANF_TO_KSTRTO",
4709 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
4714 # check for new externs in .h files.
4715 if ($realfile =~ /\.h$/ &&
4716 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4717 if (CHK("AVOID_EXTERNS",
4718 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4720 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4724 # check for new externs in .c files.
4725 if ($realfile =~ /\.c$/ && defined $stat &&
4726 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4728 my $function_name = $1;
4729 my $paren_space = $2;
4732 if (defined $cond) {
4733 substr($s, 0, length($cond), '');
4735 if ($s =~ /^\s*;/ &&
4736 $function_name ne 'uninitialized_var')
4738 WARN("AVOID_EXTERNS",
4739 "externs should be avoided in .c files\n" . $herecurr);
4742 if ($paren_space =~ /\n/) {
4743 WARN("FUNCTION_ARGUMENTS",
4744 "arguments for function declarations should follow identifier\n" . $herecurr);
4747 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4748 $stat =~ /^.\s*extern\s+/)
4750 WARN("AVOID_EXTERNS",
4751 "externs should be avoided in .c files\n" . $herecurr);
4754 # checks for new __setup's
4755 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4758 if (!grep(/$name/, @setup_docs)) {
4759 CHK("UNDOCUMENTED_SETUP",
4760 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4764 # check for pointless casting of kmalloc return
4765 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4766 WARN("UNNECESSARY_CASTS",
4767 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4771 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4772 if ($^V && $^V ge 5.10.0 &&
4773 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4774 CHK("ALLOC_SIZEOF_STRUCT",
4775 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4778 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
4779 if ($^V && $^V ge 5.10.0 &&
4780 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
4784 my $newfunc = "kmalloc_array";
4785 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
4788 if ($a1 =~ /^sizeof\s*\S/) {
4792 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
4793 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
4794 if (WARN("ALLOC_WITH_MULTIPLY",
4795 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
4797 $fixed[$fixlinenr] =~ s/\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)/$1 . ' = ' . "$newfunc(" . trim($r1) . ', ' . trim($r2)/e;
4803 # check for krealloc arg reuse
4804 if ($^V && $^V ge 5.10.0 &&
4805 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4806 WARN("KREALLOC_ARG_REUSE",
4807 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4810 # check for alloc argument mismatch
4811 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4812 WARN("ALLOC_ARRAY_ARGS",
4813 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4816 # check for multiple semicolons
4817 if ($line =~ /;\s*;\s*$/) {
4818 if (WARN("ONE_SEMICOLON",
4819 "Statements terminations use 1 semicolon\n" . $herecurr) &&
4821 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
4825 # check for case / default statements not preceded by break/fallthrough/switch
4826 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4828 my $has_statement = 0;
4830 my $prevline = $linenr;
4831 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
4833 my $rline = $rawlines[$prevline - 1];
4834 my $fline = $lines[$prevline - 1];
4835 last if ($fline =~ /^\@\@/);
4836 next if ($fline =~ /^\-/);
4837 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4838 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4839 next if ($fline =~ /^.[\s$;]*$/);
4842 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4844 if (!$has_break && $has_statement) {
4845 WARN("MISSING_BREAK",
4846 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4850 # check for switch/default statements without a break;
4851 if ($^V && $^V ge 5.10.0 &&
4853 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4855 my $herectx = $here . "\n";
4856 my $cnt = statement_rawlines($stat);
4857 for (my $n = 0; $n < $cnt; $n++) {
4858 $herectx .= raw_line($linenr, $n) . "\n";
4860 WARN("DEFAULT_NO_BREAK",
4861 "switch default: should use break\n" . $herectx);
4864 # check for gcc specific __FUNCTION__
4865 if ($line =~ /\b__FUNCTION__\b/) {
4866 if (WARN("USE_FUNC",
4867 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
4869 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
4873 # check for use of yield()
4874 if ($line =~ /\byield\s*\(\s*\)/) {
4876 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
4879 # check for comparisons against true and false
4880 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4888 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4890 my $type = lc($otype);
4891 if ($type =~ /^(?:true|false)$/) {
4892 if (("$test" eq "==" && "$type" eq "true") ||
4893 ("$test" eq "!=" && "$type" eq "false")) {
4897 CHK("BOOL_COMPARISON",
4898 "Using comparison to $otype is error prone\n" . $herecurr);
4900 ## maybe suggesting a correct construct would better
4901 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4906 # check for semaphores initialized locked
4907 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4908 WARN("CONSIDER_COMPLETION",
4909 "consider using a completion\n" . $herecurr);
4912 # recommend kstrto* over simple_strto* and strict_strto*
4913 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
4914 WARN("CONSIDER_KSTRTO",
4915 "$1 is obsolete, use k$3 instead\n" . $herecurr);
4918 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
4919 if ($line =~ /^.\s*__initcall\s*\(/) {
4920 WARN("USE_DEVICE_INITCALL",
4921 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
4924 # check for various ops structs, ensure they are const.
4925 my $struct_ops = qr{acpi_dock_ops|
4926 address_space_operations|
4928 block_device_operations|
4933 file_lock_operations|
4943 lock_manager_operations|
4949 pipe_buf_operations|
4950 platform_hibernation_ops|
4951 platform_suspend_ops|
4956 soc_pcmcia_socket_ops|
4962 if ($line !~ /\bconst\b/ &&
4963 $line =~ /\bstruct\s+($struct_ops)\b/) {
4964 WARN("CONST_STRUCT",
4965 "struct $1 should normally be const\n" .
4969 # use of NR_CPUS is usually wrong
4970 # ignore definitions of NR_CPUS and usage to define arrays as likely right
4971 if ($line =~ /\bNR_CPUS\b/ &&
4972 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4973 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4974 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4975 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4976 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4979 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4982 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4983 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4984 ERROR("DEFINE_ARCH_HAS",
4985 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4988 # check for %L{u,d,i} in strings
4990 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4991 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4992 $string =~ s/%%/__/g;
4993 if ($string =~ /(?<!%)%L[udi]/) {
4995 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
5000 # whine mightly about in_atomic
5001 if ($line =~ /\bin_atomic\s*\(/) {
5002 if ($realfile =~ m@^drivers/@) {
5004 "do not use in_atomic in drivers\n" . $herecurr);
5005 } elsif ($realfile !~ m@^kernel/@) {
5007 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5011 # check for lockdep_set_novalidate_class
5012 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5013 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5014 if ($realfile !~ m@^kernel/lockdep@ &&
5015 $realfile !~ m@^include/linux/lockdep@ &&
5016 $realfile !~ m@^drivers/base/core@) {
5018 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5022 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
5023 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
5024 WARN("EXPORTED_WORLD_WRITABLE",
5025 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5028 # Mode permission misuses where it seems decimal should be octal
5029 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5030 if ($^V && $^V ge 5.10.0 &&
5031 $line =~ /$mode_perms_search/) {
5032 foreach my $entry (@mode_permission_funcs) {
5033 my $func = $entry->[0];
5034 my $arg_pos = $entry->[1];
5039 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5041 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5042 if ($line =~ /$test/) {
5044 $val = $6 if ($skip_args ne "");
5046 if ($val !~ /^0$/ &&
5047 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5048 length($val) ne 4)) {
5049 ERROR("NON_OCTAL_PERMISSIONS",
5050 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
5057 # If we have no input at all, then there is nothing to report on
5058 # so just keep quiet.
5059 if ($#rawlines == -1) {
5063 # In mailback mode only produce a report in the negative, for
5064 # things that appear to be patches.
5065 if ($mailback && ($clean == 1 || !$is_patch)) {
5069 # This is not a patch, and we are are in 'no-patch' mode so
5071 if (!$chk_patch && !$is_patch) {
5076 ERROR("NOT_UNIFIED_DIFF",
5077 "Does not appear to be a unified-diff format patch\n");
5079 if ($is_patch && $chk_signoff && $signoff == 0) {
5080 ERROR("MISSING_SIGN_OFF",
5081 "Missing Signed-off-by: line(s)\n");
5084 print report_dump();
5085 if ($summary && !($clean == 1 && $quiet == 1)) {
5086 print "$filename " if ($summary_file);
5087 print "total: $cnt_error errors, $cnt_warn warnings, " .
5088 (($check)? "$cnt_chk checks, " : "") .
5089 "$cnt_lines lines checked\n";
5090 print "\n" if ($quiet == 0);
5095 if ($^V lt 5.10.0) {
5096 print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
5097 print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
5100 # If there were whitespace errors which cleanpatch can fix
5101 # then suggest that.
5102 if ($rpt_cleaners) {
5103 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
5104 print " scripts/cleanfile\n\n";
5109 hash_show_words(\%use_type, "Used");
5110 hash_show_words(\%ignore_type, "Ignored");
5112 if ($clean == 0 && $fix &&
5113 ("@rawlines" ne "@fixed" ||
5114 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
5115 my $newfile = $filename;
5116 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
5120 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5122 open($f, '>', $newfile)
5123 or die "$P: Can't open $newfile for write\n";
5124 foreach my $fixed_line (@fixed) {
5127 if ($linecount > 3) {
5128 $fixed_line =~ s/^\+//;
5129 print $f $fixed_line . "\n";
5132 print $f $fixed_line . "\n";
5139 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5141 Do _NOT_ trust the results written to this file.
5142 Do _NOT_ submit these changes without inspecting them for correctness.
5144 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5145 No warranties, expressed or implied...
5151 if ($clean == 1 && $quiet == 0) {
5152 print "$vname has no obvious style problems and is ready for submission.\n"
5154 if ($clean == 0 && $quiet == 0) {
5156 $vname has style problems, please review.
5158 If any of these errors are false positives, please report
5159 them to the maintainer, see CHECKPATCH in MAINTAINERS.