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
12 use Term::ANSIColor qw(:constants);
15 my $D = dirname(abs_path($P));
19 use Getopt::Long qw(:config no_auto_abbrev);
46 my $configuration_file = ".checkpatch.conf";
47 my $max_line_length = 80;
48 my $ignore_perl_version = 0;
49 my $minimum_perl_version = 5.10.0;
50 my $min_conf_desc_length = 4;
51 my $spelling_file = "$D/spelling.txt";
53 my $codespellfile = "/usr/share/codespell/dictionary.txt";
60 Usage: $P [OPTION]... [FILE]...
65 --no-tree run without a kernel tree
66 --no-signoff do not check for 'Signed-off-by' line
67 --patch treat FILE as patchfile (default)
68 --emacs emacs compile window format
69 --terse one line per report
70 --showfile emit diffed file position, not input file position
71 -f, --file treat FILE as regular source file
72 --subjective, --strict enable more subjective tests
73 --types TYPE(,TYPE2...) show only these comma separated message types
74 --ignore TYPE(,TYPE2...) ignore various comma separated message types
75 --max-line-length=n set the maximum line length, if exceeded, warn
76 --min-conf-desc-length=n set the min description length, if shorter, warn
77 --show-types show the message "types" in the output
78 --root=PATH PATH to the kernel tree root
79 --no-summary suppress the per-file summary
80 --mailback only produce a report in case of warnings/errors
81 --summary-file include the filename in summary
82 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
83 'values', 'possible', 'type', and 'attr' (default
85 --test-only=WORD report only warnings/errors containing WORD
87 --fix EXPERIMENTAL - may create horrible results
88 If correctable single-line errors exist, create
89 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
90 with potential errors corrected to the preferred
92 --fix-inplace EXPERIMENTAL - may create horrible results
93 Is the same as --fix, but overwrites the input
94 file. It's your fault if there's no backup or git
95 --ignore-perl-version override checking of perl version. expect
97 --codespell Use the codespell dictionary for spelling/typos
98 (default:/usr/share/codespell/dictionary.txt)
99 --codespellfile Use this codespell dictionary
100 --color Use colors when output is STDOUT (default: on)
101 -h, --help, --version display this help and exit
103 When FILE is - read standard input.
109 my $conf = which_conf($configuration_file);
112 open(my $conffile, '<', "$conf")
113 or warn "$P: Can't find a readable $configuration_file file $!\n";
115 while (<$conffile>) {
118 $line =~ s/\s*\n?$//g;
122 next if ($line =~ m/^\s*#/);
123 next if ($line =~ m/^\s*$/);
125 my @words = split(" ", $line);
126 foreach my $word (@words) {
127 last if ($word =~ m/^#/);
128 push (@conf_args, $word);
132 unshift(@ARGV, @conf_args) if @conf_args;
136 'q|quiet+' => \$quiet,
138 'signoff!' => \$chk_signoff,
139 'patch!' => \$chk_patch,
142 'showfile!' => \$showfile,
144 'subjective!' => \$check,
145 'strict!' => \$check,
146 'ignore=s' => \@ignore,
148 'show-types!' => \$show_types,
149 'max-line-length=i' => \$max_line_length,
150 'min-conf-desc-length=i' => \$min_conf_desc_length,
152 'summary!' => \$summary,
153 'mailback!' => \$mailback,
154 'summary-file!' => \$summary_file,
156 'fix-inplace!' => \$fix_inplace,
157 'ignore-perl-version!' => \$ignore_perl_version,
158 'debug=s' => \%debug,
159 'test-only=s' => \$tst_only,
160 'codespell!' => \$codespell,
161 'codespellfile=s' => \$codespellfile,
169 $fix = 1 if ($fix_inplace);
170 $check_orig = $check;
174 if ($^V && $^V lt $minimum_perl_version) {
175 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
176 if (!$ignore_perl_version) {
182 print "$P: no input files\n";
186 sub hash_save_array_words {
187 my ($hashRef, $arrayRef) = @_;
189 my @array = split(/,/, join(',', @$arrayRef));
190 foreach my $word (@array) {
191 $word =~ s/\s*\n?$//g;
194 $word =~ tr/[a-z]/[A-Z]/;
196 next if ($word =~ m/^\s*#/);
197 next if ($word =~ m/^\s*$/);
203 sub hash_show_words {
204 my ($hashRef, $prefix) = @_;
206 if (keys %$hashRef) {
207 print "\nNOTE: $prefix message types:";
208 foreach my $word (sort keys %$hashRef) {
215 hash_save_array_words(\%ignore_type, \@ignore);
216 hash_save_array_words(\%use_type, \@use);
219 my $dbg_possible = 0;
222 for my $key (keys %debug) {
224 eval "\${dbg_$key} = '$debug{$key}';";
228 my $rpt_cleaners = 0;
237 if (!top_of_kernel_tree($root)) {
238 die "$P: $root: --root does not point at a valid tree\n";
241 if (top_of_kernel_tree('.')) {
243 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
244 top_of_kernel_tree($1)) {
249 if (!defined $root) {
250 print "Must be run from the top-level dir. of a kernel tree\n";
255 my $emitted_corrupt = 0;
258 [A-Za-z_][A-Za-z\d_]*
259 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
261 our $Storage = qr{extern|static|asmlinkage};
274 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
275 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
276 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
277 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
278 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
280 # Notes to $Attribute:
281 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
302 ____cacheline_aligned|
303 ____cacheline_aligned_in_smp|
304 ____cacheline_internodealigned_in_smp|
308 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
309 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
310 our $Lval = qr{$Ident(?:$Member)*};
312 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
313 our $Binary = qr{(?i)0b[01]+$Int_type?};
314 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
315 our $Int = qr{[0-9]+$Int_type?};
316 our $Octal = qr{0[0-7]+$Int_type?};
317 our $String = qr{"[X\t]*"};
318 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
319 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
320 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
321 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
322 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
323 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
324 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
325 our $Arithmetic = qr{\+|-|\*|\/|%};
329 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
332 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
336 our $NonptrTypeMisordered;
337 our $NonptrTypeWithAttr;
341 our $DeclareMisordered;
343 our $NON_ASCII_UTF8 = qr{
344 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
345 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
346 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
347 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
348 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
349 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
350 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
354 [\x09\x0A\x0D\x20-\x7E] # ASCII
358 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
359 our $typeOtherOSTypedefs = qr{(?x:
360 u_(?:char|short|int|long) | # bsd
361 u(?:nchar|short|int|long) # sysv
363 our $typeKernelTypedefs = qr{(?x:
364 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
367 our $typeTypedefs = qr{(?x:
369 $typeOtherOSTypedefs\b|
370 $typeKernelTypedefs\b
373 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
375 our $logFunctions = qr{(?x:
376 printk(?:_ratelimited|_once|)|
377 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
378 WARN(?:_RATELIMIT|_ONCE|)|
381 seq_vprintf|seq_printf|seq_puts
384 our $signature_tags = qr{(?xi:
395 our @typeListMisordered = (
396 qr{char\s+(?:un)?signed},
397 qr{int\s+(?:(?:un)?signed\s+)?short\s},
398 qr{int\s+short(?:\s+(?:un)?signed)},
399 qr{short\s+int(?:\s+(?:un)?signed)},
400 qr{(?:un)?signed\s+int\s+short},
401 qr{short\s+(?:un)?signed},
402 qr{long\s+int\s+(?:un)?signed},
403 qr{int\s+long\s+(?:un)?signed},
404 qr{long\s+(?:un)?signed\s+int},
405 qr{int\s+(?:un)?signed\s+long},
406 qr{int\s+(?:un)?signed},
407 qr{int\s+long\s+long\s+(?:un)?signed},
408 qr{long\s+long\s+int\s+(?:un)?signed},
409 qr{long\s+long\s+(?:un)?signed\s+int},
410 qr{long\s+long\s+(?:un)?signed},
411 qr{long\s+(?:un)?signed},
416 qr{(?:(?:un)?signed\s+)?char},
417 qr{(?:(?:un)?signed\s+)?short\s+int},
418 qr{(?:(?:un)?signed\s+)?short},
419 qr{(?:(?:un)?signed\s+)?int},
420 qr{(?:(?:un)?signed\s+)?long\s+int},
421 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
422 qr{(?:(?:un)?signed\s+)?long\s+long},
423 qr{(?:(?:un)?signed\s+)?long},
432 qr{${Ident}_handler},
433 qr{${Ident}_handler_fn},
436 our @typeListFile = ();
437 our @typeListWithAttr = (
439 qr{struct\s+$InitAttribute\s+$Ident},
440 qr{union\s+$InitAttribute\s+$Ident},
443 our @modifierList = (
446 our @modifierListFile = ();
448 our @mode_permission_funcs = (
450 ["module_param_(?:array|named|string)", 4],
451 ["module_param_array_named", 5],
452 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
453 ["proc_create(?:_data|)", 2],
454 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
457 #Create a search pattern for all these functions to speed up a loop below
458 our $mode_perms_search = "";
459 foreach my $entry (@mode_permission_funcs) {
460 $mode_perms_search .= '|' if ($mode_perms_search ne "");
461 $mode_perms_search .= $entry->[0];
464 our $mode_perms_world_writable = qr{
472 our $allowed_asm_includes = qr{(?x:
478 # memory.h: ARM has a custom one
480 # Load common spelling mistakes and build regular expression list.
484 if (open(my $spelling, '<', $spelling_file)) {
485 while (<$spelling>) {
488 $line =~ s/\s*\n?$//g;
491 next if ($line =~ m/^\s*#/);
492 next if ($line =~ m/^\s*$/);
494 my ($suspect, $fix) = split(/\|\|/, $line);
496 $spelling_fix{$suspect} = $fix;
500 warn "No typos will be found - file '$spelling_file': $!\n";
504 if (open(my $spelling, '<', $codespellfile)) {
505 while (<$spelling>) {
508 $line =~ s/\s*\n?$//g;
511 next if ($line =~ m/^\s*#/);
512 next if ($line =~ m/^\s*$/);
513 next if ($line =~ m/, disabled/i);
517 my ($suspect, $fix) = split(/->/, $line);
519 $spelling_fix{$suspect} = $fix;
523 warn "No codespell typos will be found - file '$codespellfile': $!\n";
527 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
530 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
531 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
532 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
533 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
534 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
540 (?:$Modifier\s+|const\s+)*
542 (?:typeof|__typeof__)\s*\([^\)]*\)|
546 (?:\s+$Modifier|\s+const)*
548 $NonptrTypeMisordered = qr{
549 (?:$Modifier\s+|const\s+)*
553 (?:\s+$Modifier|\s+const)*
555 $NonptrTypeWithAttr = qr{
556 (?:$Modifier\s+|const\s+)*
558 (?:typeof|__typeof__)\s*\([^\)]*\)|
562 (?:\s+$Modifier|\s+const)*
566 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
567 (?:\s+$Inline|\s+$Modifier)*
569 $TypeMisordered = qr{
570 $NonptrTypeMisordered
571 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
572 (?:\s+$Inline|\s+$Modifier)*
574 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
575 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
579 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
581 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
582 # requires at least perl version v5.10.0
583 # Any use must be runtime checked with $^V
585 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
586 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
587 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
589 our $declaration_macros = qr{(?x:
590 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
591 (?:$Storage\s+)?LIST_HEAD\s*\(|
592 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
597 return "" if (!defined($string));
599 while ($string =~ /^\s*\(.*\)\s*$/) {
600 $string =~ s@^\s*\(\s*@@;
601 $string =~ s@\s*\)\s*$@@;
604 $string =~ s@\s+@ @g;
609 sub seed_camelcase_file {
612 return if (!(-f $file));
616 open(my $include_file, '<', "$file")
617 or warn "$P: Can't read '$file' $!\n";
618 my $text = <$include_file>;
619 close($include_file);
621 my @lines = split('\n', $text);
623 foreach my $line (@lines) {
624 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
625 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
627 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
629 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
635 my $camelcase_seeded = 0;
636 sub seed_camelcase_includes {
637 return if ($camelcase_seeded);
640 my $camelcase_cache = "";
641 my @include_files = ();
643 $camelcase_seeded = 1;
646 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
647 chomp $git_last_include_commit;
648 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
650 my $last_mod_date = 0;
651 $files = `find $root/include -name "*.h"`;
652 @include_files = split('\n', $files);
653 foreach my $file (@include_files) {
654 my $date = POSIX::strftime("%Y%m%d%H%M",
655 localtime((stat $file)[9]));
656 $last_mod_date = $date if ($last_mod_date < $date);
658 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
661 if ($camelcase_cache ne "" && -f $camelcase_cache) {
662 open(my $camelcase_file, '<', "$camelcase_cache")
663 or warn "$P: Can't read '$camelcase_cache' $!\n";
664 while (<$camelcase_file>) {
668 close($camelcase_file);
674 $files = `git ls-files "include/*.h"`;
675 @include_files = split('\n', $files);
678 foreach my $file (@include_files) {
679 seed_camelcase_file($file);
682 if ($camelcase_cache ne "") {
683 unlink glob ".checkpatch-camelcase.*";
684 open(my $camelcase_file, '>', "$camelcase_cache")
685 or warn "$P: Can't write '$camelcase_cache' $!\n";
686 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
687 print $camelcase_file ("$_\n");
689 close($camelcase_file);
693 sub git_commit_info {
694 my ($commit, $id, $desc) = @_;
696 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
698 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
699 $output =~ s/^\s*//gm;
700 my @lines = split("\n", $output);
702 return ($id, $desc) if ($#lines < 0);
704 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
705 # Maybe one day convert this block of bash into something that returns
706 # all matching commit ids, but it's very slow...
708 # echo "checking commits $1..."
709 # git rev-list --remotes | grep -i "^$1" |
710 # while read line ; do
711 # git log --format='%H %s' -1 $line |
712 # echo "commit $(cut -c 1-12,41-)"
714 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
716 $id = substr($lines[0], 0, 12);
717 $desc = substr($lines[0], 41);
723 $chk_signoff = 0 if ($file);
728 my @fixed_inserted = ();
729 my @fixed_deleted = ();
733 for my $filename (@ARGV) {
736 open($FILE, '-|', "diff -u /dev/null $filename") ||
737 die "$P: $filename: diff failed - $!\n";
738 } elsif ($filename eq '-') {
739 open($FILE, '<&STDIN');
741 open($FILE, '<', "$filename") ||
742 die "$P: $filename: open failed - $!\n";
744 if ($filename eq '-') {
745 $vname = 'Your patch';
755 if ($#ARGV > 0 && $quiet == 0) {
756 print '-' x length($vname) . "\n";
758 print '-' x length($vname) . "\n";
761 if (!process($filename)) {
767 @fixed_inserted = ();
770 @modifierListFile = ();
776 hash_show_words(\%use_type, "Used");
777 hash_show_words(\%ignore_type, "Ignored");
782 NOTE: perl $^V is not modern enough to detect all possible issues.
783 An upgrade to at least perl v5.10.0 is suggested.
789 NOTE: If any of the errors are false positives, please report
790 them to the maintainer, see CHECKPATCH in MAINTAINERS.
797 sub top_of_kernel_tree {
801 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
802 "README", "Documentation", "arch", "include", "drivers",
803 "fs", "init", "ipc", "kernel", "lib", "scripts",
806 foreach my $check (@tree_check) {
807 if (! -e $root . '/' . $check) {
815 my ($formatted_email) = @_;
821 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
824 $comment = $3 if defined $3;
825 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
827 $comment = $2 if defined $2;
828 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
830 $comment = $2 if defined $2;
831 $formatted_email =~ s/$address.*$//;
832 $name = $formatted_email;
834 $name =~ s/^\"|\"$//g;
835 # If there's a name left after stripping spaces and
836 # leading quotes, and the address doesn't have both
837 # leading and trailing angle brackets, the address
839 # "joe smith joe@smith.com" bad
840 # "joe smith <joe@smith.com" bad
841 if ($name ne "" && $address !~ /^<[^>]+>$/) {
849 $name =~ s/^\"|\"$//g;
850 $address = trim($address);
851 $address =~ s/^\<|\>$//g;
853 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
854 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
858 return ($name, $address, $comment);
862 my ($name, $address) = @_;
867 $name =~ s/^\"|\"$//g;
868 $address = trim($address);
870 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
871 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
876 $formatted_email = "$address";
878 $formatted_email = "$name <$address>";
881 return $formatted_email;
887 foreach my $path (split(/:/, $ENV{PATH})) {
888 if (-e "$path/$bin") {
899 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
900 if (-e "$path/$conf") {
901 return "$path/$conf";
913 for my $c (split(//, $str)) {
917 for (; ($n % 8) != 0; $n++) {
929 (my $res = shift) =~ tr/\t/ /c;
936 # Drop the diff line leader and expand tabs
938 $line = expand_tabs($line);
940 # Pick the indent from the front of the line.
941 my ($white) = ($line =~ /^(\s*)/);
943 return (length($line), length($white));
946 my $sanitise_quote = '';
948 sub sanitise_line_reset {
949 my ($in_comment) = @_;
952 $sanitise_quote = '*/';
954 $sanitise_quote = '';
967 # Always copy over the diff marker.
968 $res = substr($line, 0, 1);
970 for ($off = 1; $off < length($line); $off++) {
971 $c = substr($line, $off, 1);
973 # Comments we are wacking completly including the begin
974 # and end, all to $;.
975 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
976 $sanitise_quote = '*/';
978 substr($res, $off, 2, "$;$;");
982 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
983 $sanitise_quote = '';
984 substr($res, $off, 2, "$;$;");
988 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
989 $sanitise_quote = '//';
991 substr($res, $off, 2, $sanitise_quote);
996 # A \ in a string means ignore the next character.
997 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
999 substr($res, $off, 2, 'XX');
1004 if ($c eq "'" || $c eq '"') {
1005 if ($sanitise_quote eq '') {
1006 $sanitise_quote = $c;
1008 substr($res, $off, 1, $c);
1010 } elsif ($sanitise_quote eq $c) {
1011 $sanitise_quote = '';
1015 #print "c<$c> SQ<$sanitise_quote>\n";
1016 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1017 substr($res, $off, 1, $;);
1018 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1019 substr($res, $off, 1, $;);
1020 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1021 substr($res, $off, 1, 'X');
1023 substr($res, $off, 1, $c);
1027 if ($sanitise_quote eq '//') {
1028 $sanitise_quote = '';
1031 # The pathname on a #include may be surrounded by '<' and '>'.
1032 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1033 my $clean = 'X' x length($1);
1034 $res =~ s@\<.*\>@<$clean>@;
1036 # The whole of a #error is a string.
1037 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1038 my $clean = 'X' x length($1);
1039 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1045 sub get_quoted_string {
1046 my ($line, $rawline) = @_;
1048 return "" if ($line !~ m/($String)/g);
1049 return substr($rawline, $-[0], $+[0] - $-[0]);
1052 sub ctx_statement_block {
1053 my ($linenr, $remain, $off) = @_;
1054 my $line = $linenr - 1;
1057 my $coff = $off - 1;
1071 @stack = (['', 0]) if ($#stack == -1);
1073 #warn "CSB: blk<$blk> remain<$remain>\n";
1074 # If we are about to drop off the end, pull in more
1077 for (; $remain > 0; $line++) {
1078 last if (!defined $lines[$line]);
1079 next if ($lines[$line] =~ /^-/);
1082 $blk .= $lines[$line] . "\n";
1083 $len = length($blk);
1087 # Bail if there is no further context.
1088 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1092 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1098 $c = substr($blk, $off, 1);
1099 $remainder = substr($blk, $off);
1101 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1103 # Handle nested #if/#else.
1104 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1105 push(@stack, [ $type, $level ]);
1106 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1107 ($type, $level) = @{$stack[$#stack - 1]};
1108 } elsif ($remainder =~ /^#\s*endif\b/) {
1109 ($type, $level) = @{pop(@stack)};
1112 # Statement ends at the ';' or a close '}' at the
1114 if ($level == 0 && $c eq ';') {
1118 # An else is really a conditional as long as its not else if
1119 if ($level == 0 && $coff_set == 0 &&
1120 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1121 $remainder =~ /^(else)(?:\s|{)/ &&
1122 $remainder !~ /^else\s+if\b/) {
1123 $coff = $off + length($1) - 1;
1125 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1126 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1129 if (($type eq '' || $type eq '(') && $c eq '(') {
1133 if ($type eq '(' && $c eq ')') {
1135 $type = ($level != 0)? '(' : '';
1137 if ($level == 0 && $coff < $soff) {
1140 #warn "CSB: mark coff<$coff>\n";
1143 if (($type eq '' || $type eq '{') && $c eq '{') {
1147 if ($type eq '{' && $c eq '}') {
1149 $type = ($level != 0)? '{' : '';
1152 if (substr($blk, $off + 1, 1) eq ';') {
1158 # Preprocessor commands end at the newline unless escaped.
1159 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1167 # We are truly at the end, so shuffle to the next line.
1174 my $statement = substr($blk, $soff, $off - $soff + 1);
1175 my $condition = substr($blk, $soff, $coff - $soff + 1);
1177 #warn "STATEMENT<$statement>\n";
1178 #warn "CONDITION<$condition>\n";
1180 #print "coff<$coff> soff<$off> loff<$loff>\n";
1182 return ($statement, $condition,
1183 $line, $remain + 1, $off - $loff + 1, $level);
1186 sub statement_lines {
1189 # Strip the diff line prefixes and rip blank lines at start and end.
1190 $stmt =~ s/(^|\n)./$1/g;
1194 my @stmt_lines = ($stmt =~ /\n/g);
1196 return $#stmt_lines + 2;
1199 sub statement_rawlines {
1202 my @stmt_lines = ($stmt =~ /\n/g);
1204 return $#stmt_lines + 2;
1207 sub statement_block_size {
1210 $stmt =~ s/(^|\n)./$1/g;
1216 my @stmt_lines = ($stmt =~ /\n/g);
1217 my @stmt_statements = ($stmt =~ /;/g);
1219 my $stmt_lines = $#stmt_lines + 2;
1220 my $stmt_statements = $#stmt_statements + 1;
1222 if ($stmt_lines > $stmt_statements) {
1225 return $stmt_statements;
1229 sub ctx_statement_full {
1230 my ($linenr, $remain, $off) = @_;
1231 my ($statement, $condition, $level);
1235 # Grab the first conditional/block pair.
1236 ($statement, $condition, $linenr, $remain, $off, $level) =
1237 ctx_statement_block($linenr, $remain, $off);
1238 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1239 push(@chunks, [ $condition, $statement ]);
1240 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1241 return ($level, $linenr, @chunks);
1244 # Pull in the following conditional/block pairs and see if they
1245 # could continue the statement.
1247 ($statement, $condition, $linenr, $remain, $off, $level) =
1248 ctx_statement_block($linenr, $remain, $off);
1249 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1250 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1252 push(@chunks, [ $condition, $statement ]);
1255 return ($level, $linenr, @chunks);
1259 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1261 my $start = $linenr - 1;
1268 my @stack = ($level);
1269 for ($line = $start; $remain > 0; $line++) {
1270 next if ($rawlines[$line] =~ /^-/);
1273 $blk .= $rawlines[$line];
1275 # Handle nested #if/#else.
1276 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1277 push(@stack, $level);
1278 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1279 $level = $stack[$#stack - 1];
1280 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1281 $level = pop(@stack);
1284 foreach my $c (split(//, $lines[$line])) {
1285 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1291 if ($c eq $close && $level > 0) {
1293 last if ($level == 0);
1294 } elsif ($c eq $open) {
1299 if (!$outer || $level <= 1) {
1300 push(@res, $rawlines[$line]);
1303 last if ($level == 0);
1306 return ($level, @res);
1308 sub ctx_block_outer {
1309 my ($linenr, $remain) = @_;
1311 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1315 my ($linenr, $remain) = @_;
1317 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1321 my ($linenr, $remain, $off) = @_;
1323 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1326 sub ctx_block_level {
1327 my ($linenr, $remain) = @_;
1329 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1331 sub ctx_statement_level {
1332 my ($linenr, $remain, $off) = @_;
1334 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1337 sub ctx_locate_comment {
1338 my ($first_line, $end_line) = @_;
1340 # Catch a comment on the end of the line itself.
1341 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1342 return $current_comment if (defined $current_comment);
1344 # Look through the context and try and figure out if there is a
1347 $current_comment = '';
1348 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1349 my $line = $rawlines[$linenr - 1];
1351 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1354 if ($line =~ m@/\*@) {
1357 if (!$in_comment && $current_comment ne '') {
1358 $current_comment = '';
1360 $current_comment .= $line . "\n" if ($in_comment);
1361 if ($line =~ m@\*/@) {
1366 chomp($current_comment);
1367 return($current_comment);
1369 sub ctx_has_comment {
1370 my ($first_line, $end_line) = @_;
1371 my $cmt = ctx_locate_comment($first_line, $end_line);
1373 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1374 ##print "CMMT: $cmt\n";
1376 return ($cmt ne '');
1380 my ($linenr, $cnt) = @_;
1382 my $offset = $linenr - 1;
1387 $line = $rawlines[$offset++];
1388 next if (defined($line) && $line =~ /^-/);
1400 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1403 $coded = sprintf("^%c", unpack('C', $2) + 64);
1412 my $av_preprocessor = 0;
1417 sub annotate_reset {
1418 $av_preprocessor = 0;
1420 @av_paren_type = ('E');
1421 $av_pend_colon = 'O';
1424 sub annotate_values {
1425 my ($stream, $type) = @_;
1428 my $var = '_' x length($stream);
1431 print "$stream\n" if ($dbg_values > 1);
1433 while (length($cur)) {
1434 @av_paren_type = ('E') if ($#av_paren_type < 0);
1435 print " <" . join('', @av_paren_type) .
1436 "> <$type> <$av_pending>" if ($dbg_values > 1);
1437 if ($cur =~ /^(\s+)/o) {
1438 print "WS($1)\n" if ($dbg_values > 1);
1439 if ($1 =~ /\n/ && $av_preprocessor) {
1440 $type = pop(@av_paren_type);
1441 $av_preprocessor = 0;
1444 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1445 print "CAST($1)\n" if ($dbg_values > 1);
1446 push(@av_paren_type, $type);
1449 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1450 print "DECLARE($1)\n" if ($dbg_values > 1);
1453 } elsif ($cur =~ /^($Modifier)\s*/) {
1454 print "MODIFIER($1)\n" if ($dbg_values > 1);
1457 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1458 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1459 $av_preprocessor = 1;
1460 push(@av_paren_type, $type);
1466 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1467 print "UNDEF($1)\n" if ($dbg_values > 1);
1468 $av_preprocessor = 1;
1469 push(@av_paren_type, $type);
1471 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1472 print "PRE_START($1)\n" if ($dbg_values > 1);
1473 $av_preprocessor = 1;
1475 push(@av_paren_type, $type);
1476 push(@av_paren_type, $type);
1479 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1480 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1481 $av_preprocessor = 1;
1483 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1487 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1488 print "PRE_END($1)\n" if ($dbg_values > 1);
1490 $av_preprocessor = 1;
1492 # Assume all arms of the conditional end as this
1493 # one does, and continue as if the #endif was not here.
1494 pop(@av_paren_type);
1495 push(@av_paren_type, $type);
1498 } elsif ($cur =~ /^(\\\n)/o) {
1499 print "PRECONT($1)\n" if ($dbg_values > 1);
1501 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1502 print "ATTR($1)\n" if ($dbg_values > 1);
1503 $av_pending = $type;
1506 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1507 print "SIZEOF($1)\n" if ($dbg_values > 1);
1513 } elsif ($cur =~ /^(if|while|for)\b/o) {
1514 print "COND($1)\n" if ($dbg_values > 1);
1518 } elsif ($cur =~/^(case)/o) {
1519 print "CASE($1)\n" if ($dbg_values > 1);
1520 $av_pend_colon = 'C';
1523 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1524 print "KEYWORD($1)\n" if ($dbg_values > 1);
1527 } elsif ($cur =~ /^(\()/o) {
1528 print "PAREN('$1')\n" if ($dbg_values > 1);
1529 push(@av_paren_type, $av_pending);
1533 } elsif ($cur =~ /^(\))/o) {
1534 my $new_type = pop(@av_paren_type);
1535 if ($new_type ne '_') {
1537 print "PAREN('$1') -> $type\n"
1538 if ($dbg_values > 1);
1540 print "PAREN('$1')\n" if ($dbg_values > 1);
1543 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1544 print "FUNC($1)\n" if ($dbg_values > 1);
1548 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1549 if (defined $2 && $type eq 'C' || $type eq 'T') {
1550 $av_pend_colon = 'B';
1551 } elsif ($type eq 'E') {
1552 $av_pend_colon = 'L';
1554 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1557 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1558 print "IDENT($1)\n" if ($dbg_values > 1);
1561 } elsif ($cur =~ /^($Assignment)/o) {
1562 print "ASSIGN($1)\n" if ($dbg_values > 1);
1565 } elsif ($cur =~/^(;|{|})/) {
1566 print "END($1)\n" if ($dbg_values > 1);
1568 $av_pend_colon = 'O';
1570 } elsif ($cur =~/^(,)/) {
1571 print "COMMA($1)\n" if ($dbg_values > 1);
1574 } elsif ($cur =~ /^(\?)/o) {
1575 print "QUESTION($1)\n" if ($dbg_values > 1);
1578 } elsif ($cur =~ /^(:)/o) {
1579 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1581 substr($var, length($res), 1, $av_pend_colon);
1582 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1587 $av_pend_colon = 'O';
1589 } elsif ($cur =~ /^(\[)/o) {
1590 print "CLOSE($1)\n" if ($dbg_values > 1);
1593 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1596 print "OPV($1)\n" if ($dbg_values > 1);
1603 substr($var, length($res), 1, $variant);
1606 } elsif ($cur =~ /^($Operators)/o) {
1607 print "OP($1)\n" if ($dbg_values > 1);
1608 if ($1 ne '++' && $1 ne '--') {
1612 } elsif ($cur =~ /(^.)/o) {
1613 print "C($1)\n" if ($dbg_values > 1);
1616 $cur = substr($cur, length($1));
1617 $res .= $type x length($1);
1621 return ($res, $var);
1625 my ($possible, $line) = @_;
1626 my $notPermitted = qr{(?:
1643 ^(?:typedef|struct|enum)\b
1645 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1646 if ($possible !~ $notPermitted) {
1647 # Check for modifiers.
1648 $possible =~ s/\s*$Storage\s*//g;
1649 $possible =~ s/\s*$Sparse\s*//g;
1650 if ($possible =~ /^\s*$/) {
1652 } elsif ($possible =~ /\s/) {
1653 $possible =~ s/\s*$Type\s*//g;
1654 for my $modifier (split(' ', $possible)) {
1655 if ($modifier !~ $notPermitted) {
1656 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1657 push(@modifierListFile, $modifier);
1662 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1663 push(@typeListFile, $possible);
1667 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1676 return defined $use_type{$type} if (scalar keys %use_type > 0);
1678 return !defined $ignore_type{$type};
1682 my ($level, $type, $msg) = @_;
1684 if (!show_type($type) ||
1685 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1689 if (-t STDOUT && $color) {
1690 if ($level eq 'ERROR') {
1692 } elsif ($level eq 'WARNING') {
1698 $output .= $prefix . $level . ':';
1700 $output .= BLUE if (-t STDOUT && $color);
1701 $output .= "$type:";
1703 $output .= RESET if (-t STDOUT && $color);
1704 $output .= ' ' . $msg . "\n";
1707 my @lines = split("\n", $output, -1);
1708 splice(@lines, 1, 1);
1709 $output = join("\n", @lines);
1711 $output = (split('\n', $output))[0] . "\n" if ($terse);
1713 push(our @report, $output);
1722 sub fixup_current_range {
1723 my ($lineRef, $offset, $length) = @_;
1725 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1728 my $no = $o + $offset;
1729 my $nl = $l + $length;
1730 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1734 sub fix_inserted_deleted_lines {
1735 my ($linesRef, $insertedRef, $deletedRef) = @_;
1737 my $range_last_linenr = 0;
1738 my $delta_offset = 0;
1743 my $next_insert = 0;
1744 my $next_delete = 0;
1748 my $inserted = @{$insertedRef}[$next_insert++];
1749 my $deleted = @{$deletedRef}[$next_delete++];
1751 foreach my $old_line (@{$linesRef}) {
1753 my $line = $old_line; #don't modify the array
1754 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
1756 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1757 $range_last_linenr = $new_linenr;
1758 fixup_current_range(\$line, $delta_offset, 0);
1761 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1762 $deleted = @{$deletedRef}[$next_delete++];
1764 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1767 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1768 push(@lines, ${$inserted}{'LINE'});
1769 $inserted = @{$insertedRef}[$next_insert++];
1771 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1775 push(@lines, $line);
1785 sub fix_insert_line {
1786 my ($linenr, $line) = @_;
1792 push(@fixed_inserted, $inserted);
1795 sub fix_delete_line {
1796 my ($linenr, $line) = @_;
1803 push(@fixed_deleted, $deleted);
1807 my ($type, $msg) = @_;
1809 if (report("ERROR", $type, $msg)) {
1817 my ($type, $msg) = @_;
1819 if (report("WARNING", $type, $msg)) {
1827 my ($type, $msg) = @_;
1829 if ($check && report("CHECK", $type, $msg)) {
1837 sub check_absolute_file {
1838 my ($absolute, $herecurr) = @_;
1839 my $file = $absolute;
1841 ##print "absolute<$absolute>\n";
1843 # See if any suffix of this path is a path within the tree.
1844 while ($file =~ s@^[^/]*/@@) {
1845 if (-f "$root/$file") {
1846 ##print "file<$file>\n";
1854 # It is, so see if the prefix is acceptable.
1855 my $prefix = $absolute;
1856 substr($prefix, -length($file)) = '';
1858 ##print "prefix<$prefix>\n";
1859 if ($prefix ne ".../") {
1860 WARN("USE_RELATIVE_PATH",
1861 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1868 $string =~ s/^\s+|\s+$//g;
1876 $string =~ s/^\s+//;
1884 $string =~ s/\s+$//;
1889 sub string_find_replace {
1890 my ($string, $find, $replace) = @_;
1892 $string =~ s/$find/$replace/g;
1900 my $source_indent = 8;
1901 my $max_spaces_before_tab = $source_indent - 1;
1902 my $spaces_to_tab = " " x $source_indent;
1904 #convert leading spaces to tabs
1905 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1906 #Remove spaces before a tab
1907 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1912 sub pos_last_openparen {
1917 my $opens = $line =~ tr/\(/\(/;
1918 my $closes = $line =~ tr/\)/\)/;
1920 my $last_openparen = 0;
1922 if (($opens == 0) || ($closes >= $opens)) {
1926 my $len = length($line);
1928 for ($pos = 0; $pos < $len; $pos++) {
1929 my $string = substr($line, $pos);
1930 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1931 $pos += length($1) - 1;
1932 } elsif (substr($line, $pos, 1) eq '(') {
1933 $last_openparen = $pos;
1934 } elsif (index($string, '(') == -1) {
1939 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
1943 my $filename = shift;
1949 my $stashrawline="";
1959 my $in_header_lines = $file ? 0 : 1;
1960 my $in_commit_log = 0; #Scanning lines before patch
1961 my $commit_log_possible_stack_dump = 0;
1962 my $commit_log_long_line = 0;
1963 my $commit_log_has_diff = 0;
1964 my $reported_maintainer_file = 0;
1965 my $non_utf8_charset = 0;
1967 my $last_blank_line = 0;
1968 my $last_coalesced_string_linenr = -1;
1976 # Trace the real file/line as we go.
1982 my $comment_edge = 0;
1986 my $prev_values = 'E';
1989 my %suppress_ifbraces;
1990 my %suppress_whiletrailers;
1991 my %suppress_export;
1992 my $suppress_statement = 0;
1994 my %signatures = ();
1996 # Pre-scan the patch sanitizing the lines.
1997 # Pre-scan the patch looking for any __setup documentation.
1999 my @setup_docs = ();
2002 my $camelcase_file_seeded = 0;
2004 sanitise_line_reset();
2006 foreach my $rawline (@rawlines) {
2010 push(@fixed, $rawline) if ($fix);
2012 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2014 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
2019 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2028 # Guestimate if this is a continuing comment. Run
2029 # the context looking for a comment "edge". If this
2030 # edge is a close comment then we must be in a comment
2034 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2035 next if (defined $rawlines[$ln - 1] &&
2036 $rawlines[$ln - 1] =~ /^-/);
2038 #print "RAW<$rawlines[$ln - 1]>\n";
2039 last if (!defined $rawlines[$ln - 1]);
2040 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2041 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2046 if (defined $edge && $edge eq '*/') {
2050 # Guestimate if this is a continuing comment. If this
2051 # is the start of a diff block and this line starts
2052 # ' *' then it is very likely a comment.
2053 if (!defined $edge &&
2054 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2059 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2060 sanitise_line_reset($in_comment);
2062 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2063 # Standardise the strings and chars within the input to
2064 # simplify matching -- only bother with positive lines.
2065 $line = sanitise_line($rawline);
2067 push(@lines, $line);
2070 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2075 #print "==>$rawline\n";
2076 #print "-->$line\n";
2078 if ($setup_docs && $line =~ /^\+/) {
2079 push(@setup_docs, $line);
2088 foreach my $line (@lines) {
2091 my $sline = $line; #copy of $line
2092 $sline =~ s/$;/ /g; #with comments as spaces
2094 my $rawline = $rawlines[$linenr - 1];
2096 #extract the line range in the file after the patch is applied
2097 if (!$in_commit_log &&
2098 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2100 $first_line = $linenr + 1;
2110 %suppress_ifbraces = ();
2111 %suppress_whiletrailers = ();
2112 %suppress_export = ();
2113 $suppress_statement = 0;
2116 # track the line number as we move through the hunk, note that
2117 # new versions of GNU diff omit the leading space on completely
2118 # blank context lines so we need to count that too.
2119 } elsif ($line =~ /^( |\+|$)/) {
2121 $realcnt-- if ($realcnt != 0);
2123 # Measure the line length and indent.
2124 ($length, $indent) = line_stats($rawline);
2126 # Track the previous line.
2127 ($prevline, $stashline) = ($stashline, $line);
2128 ($previndent, $stashindent) = ($stashindent, $indent);
2129 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2131 #warn "line<$line>\n";
2133 } elsif ($realcnt == 1) {
2137 my $hunk_line = ($realcnt != 0);
2139 $here = "#$linenr: " if (!$file);
2140 $here = "#$realline: " if ($file);
2143 # extract the filename as it passes
2144 if ($line =~ /^diff --git.*?(\S+)$/) {
2146 $realfile =~ s@^([^/]*)/@@ if (!$file);
2149 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2151 $realfile =~ s@^([^/]*)/@@ if (!$file);
2155 if (!$file && $tree && $p1_prefix ne '' &&
2156 -e "$root/$p1_prefix") {
2157 WARN("PATCH_PREFIX",
2158 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2161 if ($realfile =~ m@^include/asm/@) {
2162 ERROR("MODIFIED_INCLUDE_ASM",
2163 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2168 #make up the handle for any error we report on this line
2170 $prefix = "$realfile:$realline: "
2173 $prefix = "$filename:$realline: ";
2175 $prefix = "$filename:$linenr: ";
2180 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2183 $check = $check_orig;
2188 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2190 my $hereline = "$here\n$rawline\n";
2191 my $herecurr = "$here\n$rawline\n";
2192 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2194 $cnt_lines++ if ($realcnt != 0);
2196 # Check if the commit log has what seems like a diff which can confuse patch
2197 if ($in_commit_log && !$commit_log_has_diff &&
2198 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2199 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2200 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2201 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2202 ERROR("DIFF_IN_COMMIT_MSG",
2203 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2204 $commit_log_has_diff = 1;
2207 # Check for incorrect file permissions
2208 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2209 my $permhere = $here . "FILE: $realfile\n";
2210 if ($realfile !~ m@scripts/@ &&
2211 $realfile !~ /\.(py|pl|awk|sh)$/) {
2212 ERROR("EXECUTE_PERMISSIONS",
2213 "do not set execute permissions for source files\n" . $permhere);
2217 # Check the patch for a signoff:
2218 if ($line =~ /^\s*signed-off-by:/i) {
2223 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2224 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2225 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2226 $reported_maintainer_file = 1;
2229 # Check signature styles
2230 if (!$in_header_lines &&
2231 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2232 my $space_before = $1;
2234 my $space_after = $3;
2236 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2238 if ($sign_off !~ /$signature_tags/) {
2239 WARN("BAD_SIGN_OFF",
2240 "Non-standard signature: $sign_off\n" . $herecurr);
2242 if (defined $space_before && $space_before ne "") {
2243 if (WARN("BAD_SIGN_OFF",
2244 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2246 $fixed[$fixlinenr] =
2247 "$ucfirst_sign_off $email";
2250 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2251 if (WARN("BAD_SIGN_OFF",
2252 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2254 $fixed[$fixlinenr] =
2255 "$ucfirst_sign_off $email";
2259 if (!defined $space_after || $space_after ne " ") {
2260 if (WARN("BAD_SIGN_OFF",
2261 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2263 $fixed[$fixlinenr] =
2264 "$ucfirst_sign_off $email";
2268 my ($email_name, $email_address, $comment) = parse_email($email);
2269 my $suggested_email = format_email(($email_name, $email_address));
2270 if ($suggested_email eq "") {
2271 ERROR("BAD_SIGN_OFF",
2272 "Unrecognized email address: '$email'\n" . $herecurr);
2274 my $dequoted = $suggested_email;
2275 $dequoted =~ s/^"//;
2276 $dequoted =~ s/" </ </;
2277 # Don't force email to have quotes
2278 # Allow just an angle bracketed address
2279 if ("$dequoted$comment" ne $email &&
2280 "<$email_address>$comment" ne $email &&
2281 "$suggested_email$comment" ne $email) {
2282 WARN("BAD_SIGN_OFF",
2283 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2287 # Check for duplicate signatures
2288 my $sig_nospace = $line;
2289 $sig_nospace =~ s/\s//g;
2290 $sig_nospace = lc($sig_nospace);
2291 if (defined $signatures{$sig_nospace}) {
2292 WARN("BAD_SIGN_OFF",
2293 "Duplicate signature\n" . $herecurr);
2295 $signatures{$sig_nospace} = 1;
2299 # Check email subject for common tools that don't need to be mentioned
2300 if ($in_header_lines &&
2301 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2302 WARN("EMAIL_SUBJECT",
2303 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2306 # Check for old stable address
2307 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2308 ERROR("STABLE_ADDRESS",
2309 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2312 # Check for unwanted Gerrit info
2313 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2314 ERROR("GERRIT_CHANGE_ID",
2315 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2318 # Check if the commit log is in a possible stack dump
2319 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2320 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2321 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2323 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2324 # stack dump address
2325 $commit_log_possible_stack_dump = 1;
2328 # Check for line lengths > 75 in commit log, warn once
2329 if ($in_commit_log && !$commit_log_long_line &&
2330 length($line) > 75 &&
2331 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2332 # file delta changes
2333 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2335 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2336 # A Fixes: or Link: line
2337 $commit_log_possible_stack_dump)) {
2338 WARN("COMMIT_LOG_LONG_LINE",
2339 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2340 $commit_log_long_line = 1;
2343 # Reset possible stack dump if a blank line is found
2344 if ($in_commit_log && $commit_log_possible_stack_dump &&
2346 $commit_log_possible_stack_dump = 0;
2349 # Check for git id commit length and improperly formed commit descriptions
2350 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2351 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
2352 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2353 ($line =~ /\b[0-9a-f]{12,40}\b/i &&
2354 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2355 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2356 my $init_char = "c";
2357 my $orig_commit = "";
2364 my $id = '0123456789ab';
2365 my $orig_desc = "commit description";
2366 my $description = "";
2368 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2370 $orig_commit = lc($2);
2371 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2372 $orig_commit = lc($1);
2375 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2376 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2377 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2378 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2379 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2382 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2383 defined $rawlines[$linenr] &&
2384 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2387 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2388 defined $rawlines[$linenr] &&
2389 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2390 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2392 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2393 $orig_desc .= " " . $1;
2397 ($id, $description) = git_commit_info($orig_commit,
2400 if ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens) {
2401 ERROR("GIT_COMMIT_ID",
2402 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2406 # Check for added, moved or deleted files
2407 if (!$reported_maintainer_file && !$in_commit_log &&
2408 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2409 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2410 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2411 (defined($1) || defined($2))))) {
2412 $reported_maintainer_file = 1;
2413 WARN("FILE_PATH_CHANGES",
2414 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2417 # Check for wrappage within a valid hunk of the file
2418 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2419 ERROR("CORRUPTED_PATCH",
2420 "patch seems to be corrupt (line wrapped?)\n" .
2421 $herecurr) if (!$emitted_corrupt++);
2424 # Check for absolute kernel paths.
2426 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2429 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2430 check_absolute_file($1, $herecurr)) {
2433 check_absolute_file($file, $herecurr);
2438 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2439 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2440 $rawline !~ m/^$UTF8*$/) {
2441 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2443 my $blank = copy_spacing($rawline);
2444 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2445 my $hereptr = "$hereline$ptr\n";
2448 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2451 # Check if it's the start of a commit log
2452 # (not a header line and we haven't seen the patch filename)
2453 if ($in_header_lines && $realfile =~ /^$/ &&
2454 !($rawline =~ /^\s+\S/ ||
2455 $rawline =~ /^(commit\b|from\b|[\w-]+:).*$/i)) {
2456 $in_header_lines = 0;
2460 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2461 # declined it, i.e defined some charset where it is missing.
2462 if ($in_header_lines &&
2463 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2465 $non_utf8_charset = 1;
2468 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2469 $rawline =~ /$NON_ASCII_UTF8/) {
2470 WARN("UTF8_BEFORE_PATCH",
2471 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2474 # Check for various typo / spelling mistakes
2475 if (defined($misspellings) &&
2476 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2477 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2479 my $typo_fix = $spelling_fix{lc($typo)};
2480 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2481 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2482 my $msg_type = \&WARN;
2483 $msg_type = \&CHK if ($file);
2484 if (&{$msg_type}("TYPO_SPELLING",
2485 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2487 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2492 # ignore non-hunk lines and lines being removed
2493 next if (!$hunk_line || $line =~ /^-/);
2495 #trailing whitespace
2496 if ($line =~ /^\+.*\015/) {
2497 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2498 if (ERROR("DOS_LINE_ENDINGS",
2499 "DOS line endings\n" . $herevet) &&
2501 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2503 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2504 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2505 if (ERROR("TRAILING_WHITESPACE",
2506 "trailing whitespace\n" . $herevet) &&
2508 $fixed[$fixlinenr] =~ s/\s+$//;
2514 # Check for FSF mailing addresses.
2515 if ($rawline =~ /\bwrite to the Free/i ||
2516 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2517 $rawline =~ /\b51\s+Franklin\s+St/i) {
2518 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2519 my $msg_type = \&ERROR;
2520 $msg_type = \&CHK if ($file);
2521 &{$msg_type}("FSF_MAILING_ADDRESS",
2522 "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)
2525 # check for Kconfig help text having a real description
2526 # Only applies when adding the entry originally, after that we do not have
2527 # sufficient context to determine whether it is indeed long enough.
2528 if ($realfile =~ /Kconfig/ &&
2529 $line =~ /^\+\s*config\s+/) {
2532 my $ln = $linenr + 1;
2536 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2537 $f = $lines[$ln - 1];
2538 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2539 $is_end = $lines[$ln - 1] =~ /^\+/;
2541 next if ($f =~ /^-/);
2542 last if (!$file && $f =~ /^\@\@/);
2544 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2546 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2553 next if ($f =~ /^$/);
2554 if ($f =~ /^\s*config\s/) {
2560 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2561 WARN("CONFIG_DESCRIPTION",
2562 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2564 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2567 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2568 if ($realfile =~ /Kconfig/ &&
2569 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2570 WARN("CONFIG_EXPERIMENTAL",
2571 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2574 # discourage the use of boolean for type definition attributes of Kconfig options
2575 if ($realfile =~ /Kconfig/ &&
2576 $line =~ /^\+\s*\bboolean\b/) {
2577 WARN("CONFIG_TYPE_BOOLEAN",
2578 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2581 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2582 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2585 'EXTRA_AFLAGS' => 'asflags-y',
2586 'EXTRA_CFLAGS' => 'ccflags-y',
2587 'EXTRA_CPPFLAGS' => 'cppflags-y',
2588 'EXTRA_LDFLAGS' => 'ldflags-y',
2591 WARN("DEPRECATED_VARIABLE",
2592 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2595 # check for DT compatible documentation
2596 if (defined $root &&
2597 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2598 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2600 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2602 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2603 my $vp_file = $dt_path . "vendor-prefixes.txt";
2605 foreach my $compat (@compats) {
2606 my $compat2 = $compat;
2607 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2608 my $compat3 = $compat;
2609 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2610 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2612 WARN("UNDOCUMENTED_DT_STRING",
2613 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2616 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2618 `grep -Eq "^$vendor\\b" $vp_file`;
2620 WARN("UNDOCUMENTED_DT_STRING",
2621 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2626 # check we are in a valid source file if not then ignore this hunk
2627 next if ($realfile !~ /\.(h|c|s|S|pl|sh|dtsi|dts)$/);
2629 # line length limit (with some exclusions)
2631 # There are a few types of lines that may extend beyond $max_line_length:
2632 # logging functions like pr_info that end in a string
2633 # lines with a single string
2634 # #defines that are a single string
2636 # There are 3 different line length message types:
2637 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2638 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2639 # LONG_LINE all other lines longer than $max_line_length
2641 # if LONG_LINE is ignored, the other 2 types are also ignored
2644 if ($line =~ /^\+/ && $length > $max_line_length) {
2645 my $msg_type = "LONG_LINE";
2647 # Check the allowed long line types first
2649 # logging functions that end in a string that starts
2650 # before $max_line_length
2651 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2652 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2655 # lines with only strings (w/ possible termination)
2656 # #defines with only strings
2657 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2658 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2661 # Otherwise set the alternate message types
2663 # a comment starts before $max_line_length
2664 } elsif ($line =~ /($;[\s$;]*)$/ &&
2665 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2666 $msg_type = "LONG_LINE_COMMENT"
2668 # a quoted string starts before $max_line_length
2669 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2670 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2671 $msg_type = "LONG_LINE_STRING"
2674 if ($msg_type ne "" &&
2675 (show_type("LONG_LINE") || show_type($msg_type))) {
2677 "line over $max_line_length characters\n" . $herecurr);
2681 # check for adding lines without a newline.
2682 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2683 WARN("MISSING_EOF_NEWLINE",
2684 "adding a line without newline at end of file\n" . $herecurr);
2687 # Blackfin: use hi/lo macros
2688 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2689 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2690 my $herevet = "$here\n" . cat_vet($line) . "\n";
2692 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2694 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2695 my $herevet = "$here\n" . cat_vet($line) . "\n";
2697 "use the HI() macro, not (... >> 16)\n" . $herevet);
2701 # check we are in a valid source file C or perl if not then ignore this hunk
2702 next if ($realfile !~ /\.(h|c|pl|dtsi|dts)$/);
2704 # at the beginning of a line any tabs must come first and anything
2705 # more than 8 must use tabs.
2706 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2707 $rawline =~ /^\+\s* \s*/) {
2708 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2710 if (ERROR("CODE_INDENT",
2711 "code indent should use tabs where possible\n" . $herevet) &&
2713 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2717 # check for space before tabs.
2718 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2719 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2720 if (WARN("SPACE_BEFORE_TAB",
2721 "please, no space before tabs\n" . $herevet) &&
2723 while ($fixed[$fixlinenr] =~
2724 s/(^\+.*) {8,8}\t/$1\t\t/) {}
2725 while ($fixed[$fixlinenr] =~
2726 s/(^\+.*) +\t/$1\t/) {}
2730 # check for && or || at the start of a line
2731 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2732 CHK("LOGICAL_CONTINUATIONS",
2733 "Logical continuations should be on the previous line\n" . $hereprev);
2736 # check multi-line statement indentation matches previous line
2737 if ($^V && $^V ge 5.10.0 &&
2738 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|$Ident\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
2739 $prevline =~ /^\+(\t*)(.*)$/;
2743 my $pos = pos_last_openparen($rest);
2745 $line =~ /^(\+| )([ \t]*)/;
2748 my $goodtabindent = $oldindent .
2751 my $goodspaceindent = $oldindent . " " x $pos;
2753 if ($newindent ne $goodtabindent &&
2754 $newindent ne $goodspaceindent) {
2756 if (CHK("PARENTHESIS_ALIGNMENT",
2757 "Alignment should match open parenthesis\n" . $hereprev) &&
2758 $fix && $line =~ /^\+/) {
2759 $fixed[$fixlinenr] =~
2760 s/^\+[ \t]*/\+$goodtabindent/;
2766 # check for space after cast like "(int) foo" or "(struct foo) bar"
2767 # avoid checking a few false positives:
2768 # "sizeof(<type>)" or "__alignof__(<type>)"
2769 # function pointer declarations like "(*foo)(int) = bar;"
2770 # structure definitions like "(struct foo) { 0 };"
2771 # multiline macros that define functions
2772 # known attributes or the __attribute__ keyword
2773 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
2774 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
2776 "No space is necessary after a cast\n" . $herecurr) &&
2778 $fixed[$fixlinenr] =~
2779 s/(\(\s*$Type\s*\))[ \t]+/$1/;
2783 # Block comment styles
2784 # Networking with an initial /*
2785 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2786 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2787 $rawline =~ /^\+[ \t]*\*/ &&
2789 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2790 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2793 # Block comments use * on subsequent lines
2794 if ($prevline =~ /$;[ \t]*$/ && #ends in comment
2795 $prevrawline =~ /^\+.*?\/\*/ && #starting /*
2796 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
2797 $rawline =~ /^\+/ && #line is new
2798 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2799 WARN("BLOCK_COMMENT_STYLE",
2800 "Block comments use * on subsequent lines\n" . $hereprev);
2803 # Block comments use */ on trailing lines
2804 if ($rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2805 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2806 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2807 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
2808 WARN("BLOCK_COMMENT_STYLE",
2809 "Block comments use a trailing */ on a separate line\n" . $herecurr);
2812 # check for missing blank lines after struct/union declarations
2813 # with exceptions for various attributes and macros
2814 if ($prevline =~ /^[\+ ]};?\s*$/ &&
2816 !($line =~ /^\+\s*$/ ||
2817 $line =~ /^\+\s*EXPORT_SYMBOL/ ||
2818 $line =~ /^\+\s*MODULE_/i ||
2819 $line =~ /^\+\s*\#\s*(?:end|elif|else)/ ||
2820 $line =~ /^\+[a-z_]*init/ ||
2821 $line =~ /^\+\s*(?:static\s+)?[A-Z_]*ATTR/ ||
2822 $line =~ /^\+\s*DECLARE/ ||
2823 $line =~ /^\+\s*__setup/)) {
2824 if (CHK("LINE_SPACING",
2825 "Please use a blank line after function/struct/union/enum declarations\n" . $hereprev) &&
2827 fix_insert_line($fixlinenr, "\+");
2831 # check for multiple consecutive blank lines
2832 if ($prevline =~ /^[\+ ]\s*$/ &&
2833 $line =~ /^\+\s*$/ &&
2834 $last_blank_line != ($linenr - 1)) {
2835 if (CHK("LINE_SPACING",
2836 "Please don't use multiple blank lines\n" . $hereprev) &&
2838 fix_delete_line($fixlinenr, $rawline);
2841 $last_blank_line = $linenr;
2844 # check for missing blank lines after declarations
2845 if ($sline =~ /^\+\s+\S/ && #Not at char 1
2846 # actual declarations
2847 ($prevline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2848 # function pointer declarations
2849 $prevline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2850 # foo bar; where foo is some local typedef or #define
2851 $prevline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2852 # known declaration macros
2853 $prevline =~ /^\+\s+$declaration_macros/) &&
2854 # for "else if" which can look like "$Ident $Ident"
2855 !($prevline =~ /^\+\s+$c90_Keywords\b/ ||
2856 # other possible extensions of declaration lines
2857 $prevline =~ /(?:$Compare|$Assignment|$Operators)\s*$/ ||
2858 # not starting a section or a macro "\" extended line
2859 $prevline =~ /(?:\{\s*|\\)$/) &&
2860 # looks like a declaration
2861 !($sline =~ /^\+\s+$Declare\s*$Ident\s*[=,;:\[]/ ||
2862 # function pointer declarations
2863 $sline =~ /^\+\s+$Declare\s*\(\s*\*\s*$Ident\s*\)\s*[=,;:\[\(]/ ||
2864 # foo bar; where foo is some local typedef or #define
2865 $sline =~ /^\+\s+$Ident(?:\s+|\s*\*\s*)$Ident\s*[=,;\[]/ ||
2866 # known declaration macros
2867 $sline =~ /^\+\s+$declaration_macros/ ||
2868 # start of struct or union or enum
2869 $sline =~ /^\+\s+(?:union|struct|enum|typedef)\b/ ||
2870 # start or end of block or continuation of declaration
2871 $sline =~ /^\+\s+(?:$|[\{\}\.\#\"\?\:\(\[])/ ||
2872 # bitfield continuation
2873 $sline =~ /^\+\s+$Ident\s*:\s*\d+\s*[,;]/ ||
2874 # other possible extensions of declaration lines
2875 $sline =~ /^\+\s+\(?\s*(?:$Compare|$Assignment|$Operators)/) &&
2876 # indentation of previous and current line are the same
2877 (($prevline =~ /\+(\s+)\S/) && $sline =~ /^\+$1\S/)) {
2878 if (WARN("LINE_SPACING",
2879 "Missing a blank line after declarations\n" . $hereprev) &&
2881 fix_insert_line($fixlinenr, "\+");
2885 # check for spaces at the beginning of a line.
2887 # 1) within comments
2888 # 2) indented preprocessor commands
2890 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
2891 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2892 if (WARN("LEADING_SPACE",
2893 "please, no spaces at the start of a line\n" . $herevet) &&
2895 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2899 # check we are in a valid C source file if not then ignore this hunk
2900 next if ($realfile !~ /\.(h|c)$/);
2902 # check indentation of any line with a bare else
2903 # (but not if it is a multiple line "if (foo) return bar; else return baz;")
2904 # if the previous line is a break or return and is indented 1 tab more...
2905 if ($sline =~ /^\+([\t]+)(?:}[ \t]*)?else(?:[ \t]*{)?\s*$/) {
2906 my $tabs = length($1) + 1;
2907 if ($prevline =~ /^\+\t{$tabs,$tabs}break\b/ ||
2908 ($prevline =~ /^\+\t{$tabs,$tabs}return\b/ &&
2909 defined $lines[$linenr] &&
2910 $lines[$linenr] !~ /^[ \+]\t{$tabs,$tabs}return/)) {
2911 WARN("UNNECESSARY_ELSE",
2912 "else is not generally useful after a break or return\n" . $hereprev);
2916 # check indentation of a line with a break;
2917 # if the previous line is a goto or return and is indented the same # of tabs
2918 if ($sline =~ /^\+([\t]+)break\s*;\s*$/) {
2920 if ($prevline =~ /^\+$tabs(?:goto|return)\b/) {
2921 WARN("UNNECESSARY_BREAK",
2922 "break is not useful after a goto or return\n" . $hereprev);
2926 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2927 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2928 WARN("CONFIG_EXPERIMENTAL",
2929 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2932 # check for RCS/CVS revision markers
2933 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2935 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2938 # Blackfin: don't use __builtin_bfin_[cs]sync
2939 if ($line =~ /__builtin_bfin_csync/) {
2940 my $herevet = "$here\n" . cat_vet($line) . "\n";
2942 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2944 if ($line =~ /__builtin_bfin_ssync/) {
2945 my $herevet = "$here\n" . cat_vet($line) . "\n";
2947 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2950 # check for old HOTPLUG __dev<foo> section markings
2951 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2952 WARN("HOTPLUG_SECTION",
2953 "Using $1 is unnecessary\n" . $herecurr);
2956 # Check for potential 'bare' types
2957 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2959 #print "LINE<$line>\n";
2960 if ($linenr >= $suppress_statement &&
2961 $realcnt && $sline =~ /.\s*\S/) {
2962 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2963 ctx_statement_block($linenr, $realcnt, 0);
2964 $stat =~ s/\n./\n /g;
2965 $cond =~ s/\n./\n /g;
2967 #print "linenr<$linenr> <$stat>\n";
2968 # If this statement has no statement boundaries within
2969 # it there is no point in retrying a statement scan
2970 # until we hit end of it.
2971 my $frag = $stat; $frag =~ s/;+\s*$//;
2972 if ($frag !~ /(?:{|;)/) {
2973 #print "skip<$line_nr_next>\n";
2974 $suppress_statement = $line_nr_next;
2977 # Find the real next line.
2978 $realline_next = $line_nr_next;
2979 if (defined $realline_next &&
2980 (!defined $lines[$realline_next - 1] ||
2981 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2988 # Ignore goto labels.
2989 if ($s =~ /$Ident:\*$/s) {
2991 # Ignore functions being called
2992 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2994 } elsif ($s =~ /^.\s*else\b/s) {
2996 # declarations always start with types
2997 } 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) {
3000 possible($type, "A:" . $s);
3002 # definitions in global scope can only start with types
3003 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
3004 possible($1, "B:" . $s);
3007 # any (foo ... *) is a pointer cast, and foo is a type
3008 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
3009 possible($1, "C:" . $s);
3012 # Check for any sort of function declaration.
3013 # int foo(something bar, other baz);
3014 # void (*store_gdt)(x86_descr_ptr *);
3015 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
3016 my ($name_len) = length($1);
3019 substr($ctx, 0, $name_len + 1, '');
3020 $ctx =~ s/\)[^\)]*$//;
3022 for my $arg (split(/\s*,\s*/, $ctx)) {
3023 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
3025 possible($1, "D:" . $s);
3033 # Checks which may be anchored in the context.
3036 # Check for switch () and associated case and default
3037 # statements should be at the same indent.
3038 if ($line=~/\bswitch\s*\(.*\)/) {
3041 my @ctx = ctx_block_outer($linenr, $realcnt);
3043 for my $ctx (@ctx) {
3044 my ($clen, $cindent) = line_stats($ctx);
3045 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
3046 $indent != $cindent) {
3047 $err .= "$sep$ctx\n";
3054 ERROR("SWITCH_CASE_INDENT_LEVEL",
3055 "switch and case should be at the same indent\n$hereline$err");
3059 # if/while/etc brace do not go on next line, unless defining a do while loop,
3060 # or if that brace on the next line is for something else
3061 if ($line =~ /(.*)\b((?:if|while|for|switch|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
3062 my $pre_ctx = "$1$2";
3064 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
3066 if ($line =~ /^\+\t{6,}/) {
3067 WARN("DEEP_INDENTATION",
3068 "Too many leading tabs - consider code refactoring\n" . $herecurr);
3071 my $ctx_cnt = $realcnt - $#ctx - 1;
3072 my $ctx = join("\n", @ctx);
3074 my $ctx_ln = $linenr;
3075 my $ctx_skip = $realcnt;
3077 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
3078 defined $lines[$ctx_ln - 1] &&
3079 $lines[$ctx_ln - 1] =~ /^-/)) {
3080 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
3081 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
3085 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
3086 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
3088 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln - 1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
3090 "that open brace { should be on the previous line\n" .
3091 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3093 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
3094 $ctx =~ /\)\s*\;\s*$/ &&
3095 defined $lines[$ctx_ln - 1])
3097 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
3098 if ($nindent > $indent) {
3099 WARN("TRAILING_SEMICOLON",
3100 "trailing semicolon indicates no statements, indent implies otherwise\n" .
3101 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
3106 # Check relative indent for conditionals and blocks.
3107 if ($line =~ /\b(?:(?:if|while|for|(?:[a-z_]+|)for_each[a-z_]+)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
3108 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3109 ctx_statement_block($linenr, $realcnt, 0)
3110 if (!defined $stat);
3111 my ($s, $c) = ($stat, $cond);
3113 substr($s, 0, length($c), '');
3115 # remove inline comments
3119 # Find out how long the conditional actually is.
3120 my @newlines = ($c =~ /\n/gs);
3121 my $cond_lines = 1 + $#newlines;
3123 # Make sure we remove the line prefixes as we have
3124 # none on the first line, and are going to readd them
3127 while ($s =~ /\n\s+\\\n/) {
3128 $cond_lines += $s =~ s/\n\s+\\\n/\n/g;
3131 # We want to check the first line inside the block
3132 # starting at the end of the conditional, so remove:
3133 # 1) any blank line termination
3134 # 2) any opening brace { on end of the line
3136 my $continuation = 0;
3138 $s =~ s/^.*\bdo\b//;
3140 if ($s =~ s/^\s*\\//) {
3143 if ($s =~ s/^\s*?\n//) {
3148 # Also ignore a loop construct at the end of a
3149 # preprocessor statement.
3150 if (($prevline =~ /^.\s*#\s*define\s/ ||
3151 $prevline =~ /\\\s*$/) && $continuation == 0) {
3157 while ($cond_ptr != $cond_lines) {
3158 $cond_ptr = $cond_lines;
3160 # If we see an #else/#elif then the code
3162 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
3167 # 1) blank lines, they should be at 0,
3168 # 2) preprocessor lines, and
3170 if ($continuation ||
3172 $s =~ /^\s*#\s*?/ ||
3173 $s =~ /^\s*$Ident\s*:/) {
3174 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
3175 if ($s =~ s/^.*?\n//) {
3181 my (undef, $sindent) = line_stats("+" . $s);
3182 my $stat_real = raw_line($linenr, $cond_lines);
3184 # Check if either of these lines are modified, else
3185 # this is not this patch's fault.
3186 if (!defined($stat_real) ||
3187 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
3190 if (defined($stat_real) && $cond_lines > 1) {
3191 $stat_real = "[...]\n$stat_real";
3194 #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";
3196 if ($check && $s ne '' &&
3197 (($sindent % 8) != 0 ||
3198 ($sindent < $indent) ||
3199 ($sindent > $indent + 8))) {
3200 WARN("SUSPECT_CODE_INDENT",
3201 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
3205 # Track the 'values' across context and added lines.
3206 my $opline = $line; $opline =~ s/^./ /;
3207 my ($curr_values, $curr_vars) =
3208 annotate_values($opline . "\n", $prev_values);
3209 $curr_values = $prev_values . $curr_values;
3211 my $outline = $opline; $outline =~ s/\t/ /g;
3212 print "$linenr > .$outline\n";
3213 print "$linenr > $curr_values\n";
3214 print "$linenr > $curr_vars\n";
3216 $prev_values = substr($curr_values, -1);
3218 #ignore lines not being added
3219 next if ($line =~ /^[^\+]/);
3221 # TEST: allow direct testing of the type matcher.
3223 if ($line =~ /^.\s*$Declare\s*$/) {
3225 "TEST: is type\n" . $herecurr);
3226 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
3227 ERROR("TEST_NOT_TYPE",
3228 "TEST: is not type ($1 is)\n". $herecurr);
3232 # TEST: allow direct testing of the attribute matcher.
3234 if ($line =~ /^.\s*$Modifier\s*$/) {
3236 "TEST: is attr\n" . $herecurr);
3237 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
3238 ERROR("TEST_NOT_ATTR",
3239 "TEST: is not attr ($1 is)\n". $herecurr);
3244 # check for initialisation to aggregates open brace on the next line
3245 if ($line =~ /^.\s*{/ &&
3246 $prevline =~ /(?:^|[^=])=\s*$/) {
3247 if (ERROR("OPEN_BRACE",
3248 "that open brace { should be on the previous line\n" . $hereprev) &&
3249 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3250 fix_delete_line($fixlinenr - 1, $prevrawline);
3251 fix_delete_line($fixlinenr, $rawline);
3252 my $fixedline = $prevrawline;
3253 $fixedline =~ s/\s*=\s*$/ = {/;
3254 fix_insert_line($fixlinenr, $fixedline);
3256 $fixedline =~ s/^(.\s*){\s*/$1/;
3257 fix_insert_line($fixlinenr, $fixedline);
3262 # Checks which are anchored on the added line.
3265 # check for malformed paths in #include statements (uses RAW line)
3266 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
3268 if ($path =~ m{//}) {
3269 ERROR("MALFORMED_INCLUDE",
3270 "malformed #include filename\n" . $herecurr);
3272 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
3273 ERROR("UAPI_INCLUDE",
3274 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
3278 # no C99 // comments
3279 if ($line =~ m{//}) {
3280 if (ERROR("C99_COMMENTS",
3281 "do not use C99 // comments\n" . $herecurr) &&
3283 my $line = $fixed[$fixlinenr];
3284 if ($line =~ /\/\/(.*)$/) {
3285 my $comment = trim($1);
3286 $fixed[$fixlinenr] =~ s@\/\/(.*)$@/\* $comment \*/@;
3290 # Remove C99 comments.
3292 $opline =~ s@//.*@@;
3294 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
3295 # the whole statement.
3296 #print "APW <$lines[$realline_next - 1]>\n";
3297 if (defined $realline_next &&
3298 exists $lines[$realline_next - 1] &&
3299 !defined $suppress_export{$realline_next} &&
3300 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3301 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3302 # Handle definitions which produce identifiers with
3305 # EXPORT_SYMBOL(something_foo);
3307 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
3308 $name =~ /^${Ident}_$2/) {
3309 #print "FOO C name<$name>\n";
3310 $suppress_export{$realline_next} = 1;
3312 } elsif ($stat !~ /(?:
3314 ^.DEFINE_$Ident\(\Q$name\E\)|
3315 ^.DECLARE_$Ident\(\Q$name\E\)|
3316 ^.LIST_HEAD\(\Q$name\E\)|
3317 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
3318 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
3320 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
3321 $suppress_export{$realline_next} = 2;
3323 $suppress_export{$realline_next} = 1;
3326 if (!defined $suppress_export{$linenr} &&
3327 $prevline =~ /^.\s*$/ &&
3328 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
3329 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
3330 #print "FOO B <$lines[$linenr - 1]>\n";
3331 $suppress_export{$linenr} = 2;
3333 if (defined $suppress_export{$linenr} &&
3334 $suppress_export{$linenr} == 2) {
3335 WARN("EXPORT_SYMBOL",
3336 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
3339 # check for global initialisers.
3340 if ($line =~ /^\+$Type\s*$Ident(?:\s+$Modifier)*\s*=\s*($zero_initializer)\s*;/) {
3341 if (ERROR("GLOBAL_INITIALISERS",
3342 "do not initialise globals to $1\n" . $herecurr) &&
3344 $fixed[$fixlinenr] =~ s/(^.$Type\s*$Ident(?:\s+$Modifier)*)\s*=\s*$zero_initializer\s*;/$1;/;
3347 # check for static initialisers.
3348 if ($line =~ /^\+.*\bstatic\s.*=\s*($zero_initializer)\s*;/) {
3349 if (ERROR("INITIALISED_STATIC",
3350 "do not initialise statics to $1\n" .
3353 $fixed[$fixlinenr] =~ s/(\bstatic\s.*?)\s*=\s*$zero_initializer\s*;/$1;/;
3357 # check for misordered declarations of char/short/int/long with signed/unsigned
3358 while ($sline =~ m{(\b$TypeMisordered\b)}g) {
3360 WARN("MISORDERED_TYPE",
3361 "type '$tmp' should be specified in [[un]signed] [short|int|long|long long] order\n" . $herecurr);
3364 # check for static const char * arrays.
3365 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
3366 WARN("STATIC_CONST_CHAR_ARRAY",
3367 "static const char * array should probably be static const char * const\n" .
3371 # check for static char foo[] = "bar" declarations.
3372 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
3373 WARN("STATIC_CONST_CHAR_ARRAY",
3374 "static char array declaration should probably be static const char\n" .
3378 # check for const <foo> const where <foo> is not a pointer or array type
3379 if ($sline =~ /\bconst\s+($BasicType)\s+const\b/) {
3381 if ($sline =~ /\bconst\s+\Q$found\E\s+const\b\s*\*/) {
3383 "'const $found const *' should probably be 'const $found * const'\n" . $herecurr);
3384 } elsif ($sline !~ /\bconst\s+\Q$found\E\s+const\s+\w+\s*\[/) {
3386 "'const $found const' should probably be 'const $found'\n" . $herecurr);
3390 # check for non-global char *foo[] = {"bar", ...} declarations.
3391 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
3392 WARN("STATIC_CONST_CHAR_ARRAY",
3393 "char * array declaration might be better as static const\n" .
3397 # check for sizeof(foo)/sizeof(foo[0]) that could be ARRAY_SIZE(foo)
3398 if ($line =~ m@\bsizeof\s*\(\s*($Lval)\s*\)@) {
3400 if ($line =~ m@\b(sizeof\s*\(\s*\Q$array\E\s*\)\s*/\s*sizeof\s*\(\s*\Q$array\E\s*\[\s*0\s*\]\s*\))@) {
3402 if (WARN("ARRAY_SIZE",
3403 "Prefer ARRAY_SIZE($array)\n" . $herecurr) &&
3405 $fixed[$fixlinenr] =~ s/\Q$array_div\E/ARRAY_SIZE($array)/;
3410 # check for function declarations without arguments like "int foo()"
3411 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
3412 if (ERROR("FUNCTION_WITHOUT_ARGS",
3413 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
3415 $fixed[$fixlinenr] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
3419 # check for uses of DEFINE_PCI_DEVICE_TABLE
3420 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
3421 if (WARN("DEFINE_PCI_DEVICE_TABLE",
3422 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
3424 $fixed[$fixlinenr] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
3428 # check for new typedefs, only function parameters and sparse annotations
3430 if ($line =~ /\btypedef\s/ &&
3431 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
3432 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
3433 $line !~ /\b$typeTypedefs\b/ &&
3434 $line !~ /\b__bitwise(?:__|)\b/) {
3435 WARN("NEW_TYPEDEFS",
3436 "do not add new typedefs\n" . $herecurr);
3439 # * goes on variable not on type
3441 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
3443 my ($ident, $from, $to) = ($1, $2, $2);
3445 # Should start with a space.
3446 $to =~ s/^(\S)/ $1/;
3447 # Should not end with a space.
3449 # '*'s should not have spaces between.
3450 while ($to =~ s/\*\s+\*/\*\*/) {
3453 ## print "1: from<$from> to<$to> ident<$ident>\n";
3455 if (ERROR("POINTER_LOCATION",
3456 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
3458 my $sub_from = $ident;
3459 my $sub_to = $ident;
3460 $sub_to =~ s/\Q$from\E/$to/;
3461 $fixed[$fixlinenr] =~
3462 s@\Q$sub_from\E@$sub_to@;
3466 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
3468 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
3470 # Should start with a space.
3471 $to =~ s/^(\S)/ $1/;
3472 # Should not end with a space.
3474 # '*'s should not have spaces between.
3475 while ($to =~ s/\*\s+\*/\*\*/) {
3477 # Modifiers should have spaces.
3478 $to =~ s/(\b$Modifier$)/$1 /;
3480 ## print "2: from<$from> to<$to> ident<$ident>\n";
3481 if ($from ne $to && $ident !~ /^$Modifier$/) {
3482 if (ERROR("POINTER_LOCATION",
3483 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
3486 my $sub_from = $match;
3487 my $sub_to = $match;
3488 $sub_to =~ s/\Q$from\E/$to/;
3489 $fixed[$fixlinenr] =~
3490 s@\Q$sub_from\E@$sub_to@;
3495 # avoid BUG() or BUG_ON()
3496 if ($line =~ /\b(?:BUG|BUG_ON)\b/) {
3497 my $msg_type = \&WARN;
3498 $msg_type = \&CHK if ($file);
3499 &{$msg_type}("AVOID_BUG",
3500 "Avoid crashing the kernel - try using WARN_ON & recovery code rather than BUG() or BUG_ON()\n" . $herecurr);
3503 # avoid LINUX_VERSION_CODE
3504 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
3505 WARN("LINUX_VERSION_CODE",
3506 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
3509 # check for uses of printk_ratelimit
3510 if ($line =~ /\bprintk_ratelimit\s*\(/) {
3511 WARN("PRINTK_RATELIMITED",
3512 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
3515 # printk should use KERN_* levels. Note that follow on printk's on the
3516 # same line do not need a level, so we use the current block context
3517 # to try and find and validate the current printk. In summary the current
3518 # printk includes all preceding printk's which have no newline on the end.
3519 # we assume the first bad printk is the one to report.
3520 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
3522 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
3523 #print "CHECK<$lines[$ln - 1]\n";
3524 # we have a preceding printk if it ends
3525 # with "\n" ignore it, else it is to blame
3526 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
3527 if ($rawlines[$ln - 1] !~ m{\\n"}) {
3534 WARN("PRINTK_WITHOUT_KERN_LEVEL",
3535 "printk() should include KERN_ facility level\n" . $herecurr);
3539 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
3541 my $level = lc($orig);
3542 $level = "warn" if ($level eq "warning");
3543 my $level2 = $level;
3544 $level2 = "dbg" if ($level eq "debug");
3545 WARN("PREFER_PR_LEVEL",
3546 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
3549 if ($line =~ /\bpr_warning\s*\(/) {
3550 if (WARN("PREFER_PR_LEVEL",
3551 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
3553 $fixed[$fixlinenr] =~
3554 s/\bpr_warning\b/pr_warn/;
3558 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
3560 my $level = lc($orig);
3561 $level = "warn" if ($level eq "warning");
3562 $level = "dbg" if ($level eq "debug");
3563 WARN("PREFER_DEV_LEVEL",
3564 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
3567 # ENOSYS means "bad syscall nr" and nothing else. This will have a small
3568 # number of false positives, but assembly files are not checked, so at
3569 # least the arch entry code will not trigger this warning.
3570 if ($line =~ /\bENOSYS\b/) {
3572 "ENOSYS means 'invalid syscall nr' and nothing else\n" . $herecurr);
3575 # function brace can't be on same line, except for #defines of do while,
3576 # or if closed on same line
3577 if (($line=~/$Type\s*$Ident\(.*\).*\s*{/) and
3578 !($line=~/\#\s*define.*do\s\{/) and !($line=~/}/)) {
3579 if (ERROR("OPEN_BRACE",
3580 "open brace '{' following function declarations go on the next line\n" . $herecurr) &&
3582 fix_delete_line($fixlinenr, $rawline);
3583 my $fixed_line = $rawline;
3584 $fixed_line =~ /(^..*$Type\s*$Ident\(.*\)\s*){(.*)$/;
3587 fix_insert_line($fixlinenr, ltrim($line1));
3588 fix_insert_line($fixlinenr, "\+{");
3589 if ($line2 !~ /^\s*$/) {
3590 fix_insert_line($fixlinenr, "\+\t" . trim($line2));
3595 # open braces for enum, union and struct go on the same line.
3596 if ($line =~ /^.\s*{/ &&
3597 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
3598 if (ERROR("OPEN_BRACE",
3599 "open brace '{' following $1 go on the same line\n" . $hereprev) &&
3600 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
3601 fix_delete_line($fixlinenr - 1, $prevrawline);
3602 fix_delete_line($fixlinenr, $rawline);
3603 my $fixedline = rtrim($prevrawline) . " {";
3604 fix_insert_line($fixlinenr, $fixedline);
3605 $fixedline = $rawline;
3606 $fixedline =~ s/^(.\s*){\s*/$1\t/;
3607 if ($fixedline !~ /^\+\s*$/) {
3608 fix_insert_line($fixlinenr, $fixedline);
3613 # missing space after union, struct or enum definition
3614 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
3616 "missing space after $1 definition\n" . $herecurr) &&
3618 $fixed[$fixlinenr] =~
3619 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
3623 # Function pointer declarations
3624 # check spacing between type, funcptr, and args
3625 # canonical declaration is "type (*funcptr)(args...)"
3626 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
3628 my $pre_pointer_space = $2;
3629 my $post_pointer_space = $3;
3631 my $post_funcname_space = $5;
3632 my $pre_args_space = $6;
3634 # the $Declare variable will capture all spaces after the type
3635 # so check it for a missing trailing missing space but pointer return types
3636 # don't need a space so don't warn for those.
3637 my $post_declare_space = "";
3638 if ($declare =~ /(\s+)$/) {
3639 $post_declare_space = $1;
3640 $declare = rtrim($declare);
3642 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
3644 "missing space after return type\n" . $herecurr);
3645 $post_declare_space = " ";
3648 # unnecessary space "type (*funcptr)(args...)"
3649 # This test is not currently implemented because these declarations are
3651 # int foo(int bar, ...)
3652 # and this is form shouldn't/doesn't generate a checkpatch warning.
3654 # elsif ($declare =~ /\s{2,}$/) {
3656 # "Multiple spaces after return type\n" . $herecurr);
3659 # unnecessary space "type ( *funcptr)(args...)"
3660 if (defined $pre_pointer_space &&
3661 $pre_pointer_space =~ /^\s/) {
3663 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
3666 # unnecessary space "type (* funcptr)(args...)"
3667 if (defined $post_pointer_space &&
3668 $post_pointer_space =~ /^\s/) {
3670 "Unnecessary space before function pointer name\n" . $herecurr);
3673 # unnecessary space "type (*funcptr )(args...)"
3674 if (defined $post_funcname_space &&
3675 $post_funcname_space =~ /^\s/) {
3677 "Unnecessary space after function pointer name\n" . $herecurr);
3680 # unnecessary space "type (*funcptr) (args...)"
3681 if (defined $pre_args_space &&
3682 $pre_args_space =~ /^\s/) {
3684 "Unnecessary space before function pointer arguments\n" . $herecurr);
3687 if (show_type("SPACING") && $fix) {
3688 $fixed[$fixlinenr] =~
3689 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
3693 # check for spacing round square brackets; allowed:
3694 # 1. with a type on the left -- int [] a;
3695 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
3696 # 3. inside a curly brace -- = { [0...10] = 5 }
3697 while ($line =~ /(.*?\s)\[/g) {
3698 my ($where, $prefix) = ($-[1], $1);
3699 if ($prefix !~ /$Type\s+$/ &&
3700 ($where != 0 || $prefix !~ /^.\s+$/) &&
3701 $prefix !~ /[{,]\s+$/) {
3702 if (ERROR("BRACKET_SPACE",
3703 "space prohibited before open square bracket '['\n" . $herecurr) &&
3705 $fixed[$fixlinenr] =~
3706 s/^(\+.*?)\s+\[/$1\[/;
3711 # check for spaces between functions and their parentheses.
3712 while ($line =~ /($Ident)\s+\(/g) {
3714 my $ctx_before = substr($line, 0, $-[1]);
3715 my $ctx = "$ctx_before$name";
3717 # Ignore those directives where spaces _are_ permitted.
3719 if|for|while|switch|return|case|
3720 volatile|__volatile__|
3721 __attribute__|format|__extension__|
3724 # cpp #define statements have non-optional spaces, ie
3725 # if there is a space between the name and the open
3726 # parenthesis it is simply not a parameter group.
3727 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
3729 # cpp #elif statement condition may start with a (
3730 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
3732 # If this whole things ends with a type its most
3733 # likely a typedef for a function.
3734 } elsif ($ctx =~ /$Type$/) {
3738 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
3740 $fixed[$fixlinenr] =~
3741 s/\b$name\s+\(/$name\(/;
3746 # Check operator spacing.
3747 if (!($line=~/\#\s*include/)) {
3748 my $fixed_line = "";
3752 <<=|>>=|<=|>=|==|!=|
3753 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3754 =>|->|<<|>>|<|>|=|!|~|
3755 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3758 my @elements = split(/($ops|;)/, $opline);
3760 ## print("element count: <" . $#elements . ">\n");
3761 ## foreach my $el (@elements) {
3762 ## print("el: <$el>\n");
3765 my @fix_elements = ();
3768 foreach my $el (@elements) {
3769 push(@fix_elements, substr($rawline, $off, length($el)));
3770 $off += length($el);
3775 my $blank = copy_spacing($opline);
3776 my $last_after = -1;
3778 for (my $n = 0; $n < $#elements; $n += 2) {
3780 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3782 ## print("n: <$n> good: <$good>\n");
3784 $off += length($elements[$n]);
3786 # Pick up the preceding and succeeding characters.
3787 my $ca = substr($opline, 0, $off);
3789 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3790 $cc = substr($opline, $off + length($elements[$n + 1]));
3792 my $cb = "$ca$;$cc";
3795 $a = 'V' if ($elements[$n] ne '');
3796 $a = 'W' if ($elements[$n] =~ /\s$/);
3797 $a = 'C' if ($elements[$n] =~ /$;$/);
3798 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3799 $a = 'O' if ($elements[$n] eq '');
3800 $a = 'E' if ($ca =~ /^\s*$/);
3802 my $op = $elements[$n + 1];
3805 if (defined $elements[$n + 2]) {
3806 $c = 'V' if ($elements[$n + 2] ne '');
3807 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3808 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3809 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3810 $c = 'O' if ($elements[$n + 2] eq '');
3811 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3816 my $ctx = "${a}x${c}";
3818 my $at = "(ctx:$ctx)";
3820 my $ptr = substr($blank, 0, $off) . "^";
3821 my $hereptr = "$hereline$ptr\n";
3823 # Pull out the value of this operator.
3824 my $op_type = substr($curr_values, $off + 1, 1);
3826 # Get the full operator variant.
3827 my $opv = $op . substr($curr_vars, $off, 1);
3829 # Ignore operators passed as parameters.
3830 if ($op_type ne 'V' &&
3831 $ca =~ /\s$/ && $cc =~ /^\s*[,\)]/) {
3834 # } elsif ($op =~ /^$;+$/) {
3836 # ; should have either the end of line or a space or \ after it
3837 } elsif ($op eq ';') {
3838 if ($ctx !~ /.x[WEBC]/ &&
3839 $cc !~ /^\\/ && $cc !~ /^;/) {
3840 if (ERROR("SPACING",
3841 "space required after that '$op' $at\n" . $hereptr)) {
3842 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3848 } elsif ($op eq '//') {
3850 # : when part of a bitfield
3851 } elsif ($opv eq ':B') {
3852 # skip the bitfield test for now
3856 } elsif ($op eq '->') {
3857 if ($ctx =~ /Wx.|.xW/) {
3858 if (ERROR("SPACING",
3859 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3860 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3861 if (defined $fix_elements[$n + 2]) {
3862 $fix_elements[$n + 2] =~ s/^\s+//;
3868 # , must not have a space before and must have a space on the right.
3869 } elsif ($op eq ',') {
3870 my $rtrim_before = 0;
3871 my $space_after = 0;
3872 if ($ctx =~ /Wx./) {
3873 if (ERROR("SPACING",
3874 "space prohibited before that '$op' $at\n" . $hereptr)) {
3879 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3880 if (ERROR("SPACING",
3881 "space required after that '$op' $at\n" . $hereptr)) {
3887 if ($rtrim_before || $space_after) {
3888 if ($rtrim_before) {
3889 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3891 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3898 # '*' as part of a type definition -- reported already.
3899 } elsif ($opv eq '*_') {
3900 #warn "'*' is part of type\n";
3902 # unary operators should have a space before and
3903 # none after. May be left adjacent to another
3904 # unary operator, or a cast
3905 } elsif ($op eq '!' || $op eq '~' ||
3906 $opv eq '*U' || $opv eq '-U' ||
3907 $opv eq '&U' || $opv eq '&&U') {
3908 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3909 if (ERROR("SPACING",
3910 "space required before that '$op' $at\n" . $hereptr)) {
3911 if ($n != $last_after + 2) {
3912 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3917 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3918 # A unary '*' may be const
3920 } elsif ($ctx =~ /.xW/) {
3921 if (ERROR("SPACING",
3922 "space prohibited after that '$op' $at\n" . $hereptr)) {
3923 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3924 if (defined $fix_elements[$n + 2]) {
3925 $fix_elements[$n + 2] =~ s/^\s+//;
3931 # unary ++ and unary -- are allowed no space on one side.
3932 } elsif ($op eq '++' or $op eq '--') {
3933 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3934 if (ERROR("SPACING",
3935 "space required one side of that '$op' $at\n" . $hereptr)) {
3936 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3940 if ($ctx =~ /Wx[BE]/ ||
3941 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3942 if (ERROR("SPACING",
3943 "space prohibited before that '$op' $at\n" . $hereptr)) {
3944 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3948 if ($ctx =~ /ExW/) {
3949 if (ERROR("SPACING",
3950 "space prohibited after that '$op' $at\n" . $hereptr)) {
3951 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3952 if (defined $fix_elements[$n + 2]) {
3953 $fix_elements[$n + 2] =~ s/^\s+//;
3959 # << and >> may either have or not have spaces both sides
3960 } elsif ($op eq '<<' or $op eq '>>' or
3961 $op eq '&' or $op eq '^' or $op eq '|' or
3962 $op eq '+' or $op eq '-' or
3963 $op eq '*' or $op eq '/' or
3967 if (defined $fix_elements[$n + 2] && $ctx !~ /[EW]x[EW]/) {
3969 "spaces preferred around that '$op' $at\n" . $hereptr)) {
3970 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3971 $fix_elements[$n + 2] =~ s/^\s+//;
3974 } elsif (!defined $fix_elements[$n + 2] && $ctx !~ /Wx[OE]/) {
3976 "space preferred before that '$op' $at\n" . $hereptr)) {
3977 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]);
3981 } elsif ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3982 if (ERROR("SPACING",
3983 "need consistent spacing around '$op' $at\n" . $hereptr)) {
3984 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3985 if (defined $fix_elements[$n + 2]) {
3986 $fix_elements[$n + 2] =~ s/^\s+//;
3992 # A colon needs no spaces before when it is
3993 # terminating a case value or a label.
3994 } elsif ($opv eq ':C' || $opv eq ':L') {
3995 if ($ctx =~ /Wx./) {
3996 if (ERROR("SPACING",
3997 "space prohibited before that '$op' $at\n" . $hereptr)) {
3998 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
4003 # All the others need spaces both sides.
4004 } elsif ($ctx !~ /[EWC]x[CWE]/) {
4007 # Ignore email addresses <foo@bar>
4009 $cc =~ /^\S+\@\S+>/) ||
4011 $ca =~ /<\S+\@\S+$/))
4016 # for asm volatile statements
4017 # ignore a colon with another
4018 # colon immediately before or after
4020 ($ca =~ /:$/ || $cc =~ /^:/)) {
4024 # messages are ERROR, but ?: are CHK
4026 my $msg_type = \&ERROR;
4027 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
4029 if (&{$msg_type}("SPACING",
4030 "spaces required around that '$op' $at\n" . $hereptr)) {
4031 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
4032 if (defined $fix_elements[$n + 2]) {
4033 $fix_elements[$n + 2] =~ s/^\s+//;
4039 $off += length($elements[$n + 1]);
4041 ## print("n: <$n> GOOD: <$good>\n");
4043 $fixed_line = $fixed_line . $good;
4046 if (($#elements % 2) == 0) {
4047 $fixed_line = $fixed_line . $fix_elements[$#elements];
4050 if ($fix && $line_fixed && $fixed_line ne $fixed[$fixlinenr]) {
4051 $fixed[$fixlinenr] = $fixed_line;
4057 # check for whitespace before a non-naked semicolon
4058 if ($line =~ /^\+.*\S\s+;\s*$/) {
4060 "space prohibited before semicolon\n" . $herecurr) &&
4062 1 while $fixed[$fixlinenr] =~
4063 s/^(\+.*\S)\s+;/$1;/;
4067 # check for multiple assignments
4068 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
4069 CHK("MULTIPLE_ASSIGNMENTS",
4070 "multiple assignments should be avoided\n" . $herecurr);
4073 ## # check for multiple declarations, allowing for a function declaration
4075 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
4076 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
4078 ## # Remove any bracketed sections to ensure we do not
4079 ## # falsly report the parameters of functions.
4081 ## while ($ln =~ s/\([^\(\)]*\)//g) {
4083 ## if ($ln =~ /,/) {
4084 ## WARN("MULTIPLE_DECLARATION",
4085 ## "declaring multiple variables together should be avoided\n" . $herecurr);
4089 #need space before brace following if, while, etc
4090 if (($line =~ /\(.*\)\{/ && $line !~ /\($Type\){/) ||
4092 if (ERROR("SPACING",
4093 "space required before the open brace '{'\n" . $herecurr) &&
4095 $fixed[$fixlinenr] =~ s/^(\+.*(?:do|\))){/$1 {/;
4099 ## # check for blank lines before declarations
4100 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
4101 ## $prevrawline =~ /^.\s*$/) {
4103 ## "No blank lines before declarations\n" . $hereprev);
4107 # closing brace should have a space following it when it has anything
4109 if ($line =~ /}(?!(?:,|;|\)))\S/) {
4110 if (ERROR("SPACING",
4111 "space required after that close brace '}'\n" . $herecurr) &&
4113 $fixed[$fixlinenr] =~
4114 s/}((?!(?:,|;|\)))\S)/} $1/;
4118 # check spacing on square brackets
4119 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
4120 if (ERROR("SPACING",
4121 "space prohibited after that open square bracket '['\n" . $herecurr) &&
4123 $fixed[$fixlinenr] =~
4127 if ($line =~ /\s\]/) {
4128 if (ERROR("SPACING",
4129 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
4131 $fixed[$fixlinenr] =~
4136 # check spacing on parentheses
4137 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
4138 $line !~ /for\s*\(\s+;/) {
4139 if (ERROR("SPACING",
4140 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
4142 $fixed[$fixlinenr] =~
4146 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
4147 $line !~ /for\s*\(.*;\s+\)/ &&
4148 $line !~ /:\s+\)/) {
4149 if (ERROR("SPACING",
4150 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
4152 $fixed[$fixlinenr] =~
4157 # check unnecessary parentheses around addressof/dereference single $Lvals
4158 # ie: &(foo->bar) should be &foo->bar and *(foo->bar) should be *foo->bar
4160 while ($line =~ /(?:[^&]&\s*|\*)\(\s*($Ident\s*(?:$Member\s*)+)\s*\)/g) {
4162 if (CHK("UNNECESSARY_PARENTHESES",
4163 "Unnecessary parentheses around $var\n" . $herecurr) &&
4165 $fixed[$fixlinenr] =~ s/\(\s*\Q$var\E\s*\)/$var/;
4169 # check for unnecessary parentheses around function pointer uses
4170 # ie: (foo->bar)(); should be foo->bar();
4171 # but not "if (foo->bar) (" to avoid some false positives
4172 if ($line =~ /(\bif\s*|)(\(\s*$Ident\s*(?:$Member\s*)+\))[ \t]*\(/ && $1 !~ /^if/) {
4174 if (CHK("UNNECESSARY_PARENTHESES",
4175 "Unnecessary parentheses around function pointer $var\n" . $herecurr) &&
4177 my $var2 = deparenthesize($var);
4179 $fixed[$fixlinenr] =~ s/\Q$var\E/$var2/;
4183 #goto labels aren't indented, allow a single space however
4184 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
4185 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
4186 if (WARN("INDENTED_LABEL",
4187 "labels should not be indented\n" . $herecurr) &&
4189 $fixed[$fixlinenr] =~
4194 # return is not a function
4195 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
4197 if ($^V && $^V ge 5.10.0 &&
4198 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
4200 $value = deparenthesize($value);
4201 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
4202 ERROR("RETURN_PARENTHESES",
4203 "return is not a function, parentheses are not required\n" . $herecurr);
4205 } elsif ($spacing !~ /\s+/) {
4207 "space required before the open parenthesis '('\n" . $herecurr);
4211 # unnecessary return in a void function
4212 # at end-of-function, with the previous line a single leading tab, then return;
4213 # and the line before that not a goto label target like "out:"
4214 if ($sline =~ /^[ \+]}\s*$/ &&
4215 $prevline =~ /^\+\treturn\s*;\s*$/ &&
4217 $lines[$linenr - 3] =~ /^[ +]/ &&
4218 $lines[$linenr - 3] !~ /^[ +]\s*$Ident\s*:/) {
4220 "void function return statements are not generally useful\n" . $hereprev);
4223 # if statements using unnecessary parentheses - ie: if ((foo == bar))
4224 if ($^V && $^V ge 5.10.0 &&
4225 $line =~ /\bif\s*((?:\(\s*){2,})/) {
4226 my $openparens = $1;
4227 my $count = $openparens =~ tr@\(@\(@;
4229 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
4230 my $comp = $4; #Not $1 because of $LvalOrFunc
4231 $msg = " - maybe == should be = ?" if ($comp eq "==");
4232 WARN("UNNECESSARY_PARENTHESES",
4233 "Unnecessary parentheses$msg\n" . $herecurr);
4237 # comparisons with a constant or upper case identifier on the left
4238 # avoid cases like "foo + BAR < baz"
4239 # only fix matches surrounded by parentheses to avoid incorrect
4240 # conversions like "FOO < baz() + 5" being "misfixed" to "baz() > FOO + 5"
4241 if ($^V && $^V ge 5.10.0 &&
4242 $line =~ /^\+(.*)\b($Constant|[A-Z_][A-Z0-9_]*)\s*($Compare)\s*($LvalOrFunc)/) {
4247 my $newcomp = $comp;
4248 if ($lead !~ /$Operators\s*$/ &&
4249 $to !~ /^(?:Constant|[A-Z_][A-Z0-9_]*)$/ &&
4250 WARN("CONSTANT_COMPARISON",
4251 "Comparisons should place the constant on the right side of the test\n" . $herecurr) &&
4255 } elsif ($comp eq "<=") {
4257 } elsif ($comp eq ">") {
4259 } elsif ($comp eq ">=") {
4262 $fixed[$fixlinenr] =~ s/\(\s*\Q$const\E\s*$Compare\s*\Q$to\E\s*\)/($to $newcomp $const)/;
4266 # Return of what appears to be an errno should normally be negative
4267 if ($sline =~ /\breturn(?:\s*\(+\s*|\s+)(E[A-Z]+)(?:\s*\)+\s*|\s*)[;:,]/) {
4269 if ($name ne 'EOF' && $name ne 'ERROR') {
4270 WARN("USE_NEGATIVE_ERRNO",
4271 "return of an errno should typically be negative (ie: return -$1)\n" . $herecurr);
4275 # Need a space before open parenthesis after if, while etc
4276 if ($line =~ /\b(if|while|for|switch)\(/) {
4277 if (ERROR("SPACING",
4278 "space required before the open parenthesis '('\n" . $herecurr) &&
4280 $fixed[$fixlinenr] =~
4281 s/\b(if|while|for|switch)\(/$1 \(/;
4285 # Check for illegal assignment in if conditional -- and check for trailing
4286 # statements after the conditional.
4287 if ($line =~ /do\s*(?!{)/) {
4288 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
4289 ctx_statement_block($linenr, $realcnt, 0)
4290 if (!defined $stat);
4291 my ($stat_next) = ctx_statement_block($line_nr_next,
4292 $remain_next, $off_next);
4293 $stat_next =~ s/\n./\n /g;
4294 ##print "stat<$stat> stat_next<$stat_next>\n";
4296 if ($stat_next =~ /^\s*while\b/) {
4297 # If the statement carries leading newlines,
4298 # then count those as offsets.
4300 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
4302 statement_rawlines($whitespace) - 1;
4304 $suppress_whiletrailers{$line_nr_next +
4308 if (!defined $suppress_whiletrailers{$linenr} &&
4309 defined($stat) && defined($cond) &&
4310 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
4311 my ($s, $c) = ($stat, $cond);
4313 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
4314 ERROR("ASSIGN_IN_IF",
4315 "do not use assignment in if condition\n" . $herecurr);
4318 # Find out what is on the end of the line after the
4320 substr($s, 0, length($c), '');
4322 $s =~ s/$;//g; # Remove any comments
4323 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
4324 $c !~ /}\s*while\s*/)
4326 # Find out how long the conditional actually is.
4327 my @newlines = ($c =~ /\n/gs);
4328 my $cond_lines = 1 + $#newlines;
4331 $stat_real = raw_line($linenr, $cond_lines)
4332 . "\n" if ($cond_lines);
4333 if (defined($stat_real) && $cond_lines > 1) {
4334 $stat_real = "[...]\n$stat_real";
4337 ERROR("TRAILING_STATEMENTS",
4338 "trailing statements should be on next line\n" . $herecurr . $stat_real);
4342 # Check for bitwise tests written as boolean
4354 WARN("HEXADECIMAL_BOOLEAN_TEST",
4355 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
4358 # if and else should not have general statements after it
4359 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
4361 $s =~ s/$;//g; # Remove any comments
4362 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
4363 ERROR("TRAILING_STATEMENTS",
4364 "trailing statements should be on next line\n" . $herecurr);
4367 # if should not continue a brace
4368 if ($line =~ /}\s*if\b/) {
4369 ERROR("TRAILING_STATEMENTS",
4370 "trailing statements should be on next line (or did you mean 'else if'?)\n" .
4373 # case and default should not have general statements after them
4374 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
4376 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
4380 ERROR("TRAILING_STATEMENTS",
4381 "trailing statements should be on next line\n" . $herecurr);
4384 # Check for }<nl>else {, these must be at the same
4385 # indent level to be relevant to each other.
4386 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ &&
4387 $previndent == $indent) {
4388 if (ERROR("ELSE_AFTER_BRACE",
4389 "else should follow close brace '}'\n" . $hereprev) &&
4390 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4391 fix_delete_line($fixlinenr - 1, $prevrawline);
4392 fix_delete_line($fixlinenr, $rawline);
4393 my $fixedline = $prevrawline;
4394 $fixedline =~ s/}\s*$//;
4395 if ($fixedline !~ /^\+\s*$/) {
4396 fix_insert_line($fixlinenr, $fixedline);
4398 $fixedline = $rawline;
4399 $fixedline =~ s/^(.\s*)else/$1} else/;
4400 fix_insert_line($fixlinenr, $fixedline);
4404 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ &&
4405 $previndent == $indent) {
4406 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
4408 # Find out what is on the end of the line after the
4410 substr($s, 0, length($c), '');
4413 if ($s =~ /^\s*;/) {
4414 if (ERROR("WHILE_AFTER_BRACE",
4415 "while should follow close brace '}'\n" . $hereprev) &&
4416 $fix && $prevline =~ /^\+/ && $line =~ /^\+/) {
4417 fix_delete_line($fixlinenr - 1, $prevrawline);
4418 fix_delete_line($fixlinenr, $rawline);
4419 my $fixedline = $prevrawline;
4420 my $trailing = $rawline;
4421 $trailing =~ s/^\+//;
4422 $trailing = trim($trailing);
4423 $fixedline =~ s/}\s*$/} $trailing/;
4424 fix_insert_line($fixlinenr, $fixedline);
4429 #Specific variable tests
4430 while ($line =~ m{($Constant|$Lval)}g) {
4433 #gcc binary extension
4434 if ($var =~ /^$Binary$/) {
4435 if (WARN("GCC_BINARY_CONSTANT",
4436 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
4438 my $hexval = sprintf("0x%x", oct($var));
4439 $fixed[$fixlinenr] =~
4440 s/\b$var\b/$hexval/;
4445 if ($var !~ /^$Constant$/ &&
4446 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
4447 #Ignore Page<foo> variants
4448 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
4449 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
4450 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/ &&
4451 #Ignore some three character SI units explicitly, like MiB and KHz
4452 $var !~ /^(?:[a-z_]*?)_?(?:[KMGT]iB|[KMGT]?Hz)(?:_[a-z_]+)?$/) {
4453 while ($var =~ m{($Ident)}g) {
4455 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
4457 seed_camelcase_includes();
4458 if (!$file && !$camelcase_file_seeded) {
4459 seed_camelcase_file($realfile);
4460 $camelcase_file_seeded = 1;
4463 if (!defined $camelcase{$word}) {
4464 $camelcase{$word} = 1;
4466 "Avoid CamelCase: <$word>\n" . $herecurr);
4472 #no spaces allowed after \ in define
4473 if ($line =~ /\#\s*define.*\\\s+$/) {
4474 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
4475 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
4477 $fixed[$fixlinenr] =~ s/\s+$//;
4481 # warn if <asm/foo.h> is #included and <linux/foo.h> is available and includes
4482 # itself <asm/foo.h> (uses RAW line)
4483 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
4485 my $checkfile = "include/linux/$file";
4486 if (-f "$root/$checkfile" &&
4487 $realfile ne $checkfile &&
4488 $1 !~ /$allowed_asm_includes/)
4490 my $asminclude = `grep -Ec "#include\\s+<asm/$file>" $root/$checkfile`;
4491 if ($asminclude > 0) {
4492 if ($realfile =~ m{^arch/}) {
4493 CHK("ARCH_INCLUDE_LINUX",
4494 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4496 WARN("INCLUDE_LINUX",
4497 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
4503 # multi-statement macros should be enclosed in a do while loop, grab the
4504 # first statement and ensure its the whole macro if its not enclosed
4505 # in a known good container
4506 if ($realfile !~ m@/vmlinux.lds.h$@ &&
4507 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
4510 my ($off, $dstat, $dcond, $rest);
4512 my $has_flow_statement = 0;
4513 my $has_arg_concat = 0;
4514 ($dstat, $dcond, $ln, $cnt, $off) =
4515 ctx_statement_block($linenr, $realcnt, 0);
4517 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
4518 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
4520 $has_flow_statement = 1 if ($ctx =~ /\b(goto|return)\b/);
4521 $has_arg_concat = 1 if ($ctx =~ /\#\#/);
4523 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
4525 $dstat =~ s/\\\n.//g;
4526 $dstat =~ s/^\s*//s;
4527 $dstat =~ s/\s*$//s;
4529 # Flatten any parentheses and braces
4530 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
4531 $dstat =~ s/\{[^\{\}]*\}/1/ ||
4532 $dstat =~ s/\[[^\[\]]*\]/1/)
4536 # Flatten any obvious string concatentation.
4537 while ($dstat =~ s/($String)\s*$Ident/$1/ ||
4538 $dstat =~ s/$Ident\s*($String)/$1/)
4542 my $exceptions = qr{
4554 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
4556 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
4557 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
4558 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
4559 $dstat !~ /^'X'$/ && $dstat !~ /^'XX'$/ && # character constants
4560 $dstat !~ /$exceptions/ &&
4561 $dstat !~ /^\.$Ident\s*=/ && # .foo =
4562 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
4563 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
4564 $dstat !~ /^for\s*$Constant$/ && # for (...)
4565 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
4566 $dstat !~ /^do\s*{/ && # do {...
4567 $dstat !~ /^\(\{/ && # ({...
4568 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
4571 my $herectx = $here . "\n";
4572 my $cnt = statement_rawlines($ctx);
4574 for (my $n = 0; $n < $cnt; $n++) {
4575 $herectx .= raw_line($linenr, $n) . "\n";
4578 if ($dstat =~ /;/) {
4579 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
4580 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
4582 ERROR("COMPLEX_MACRO",
4583 "Macros with complex values should be enclosed in parentheses\n" . "$herectx");
4587 # check for macros with flow control, but without ## concatenation
4588 # ## concatenation is commonly a macro that defines a function so ignore those
4589 if ($has_flow_statement && !$has_arg_concat) {
4590 my $herectx = $here . "\n";
4591 my $cnt = statement_rawlines($ctx);
4593 for (my $n = 0; $n < $cnt; $n++) {
4594 $herectx .= raw_line($linenr, $n) . "\n";
4596 WARN("MACRO_WITH_FLOW_CONTROL",
4597 "Macros with flow control statements should be avoided\n" . "$herectx");
4600 # check for line continuations outside of #defines, preprocessor #, and asm
4603 if ($prevline !~ /^..*\\$/ &&
4604 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
4605 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
4606 $line =~ /^\+.*\\$/) {
4607 WARN("LINE_CONTINUATIONS",
4608 "Avoid unnecessary line continuations\n" . $herecurr);
4612 # do {} while (0) macro tests:
4613 # single-statement macros do not need to be enclosed in do while (0) loop,
4614 # macro should not end with a semicolon
4615 if ($^V && $^V ge 5.10.0 &&
4616 $realfile !~ m@/vmlinux.lds.h$@ &&
4617 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
4620 my ($off, $dstat, $dcond, $rest);
4622 ($dstat, $dcond, $ln, $cnt, $off) =
4623 ctx_statement_block($linenr, $realcnt, 0);
4626 $dstat =~ s/\\\n.//g;
4629 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
4634 my $cnt = statement_rawlines($ctx);
4635 my $herectx = $here . "\n";
4637 for (my $n = 0; $n < $cnt; $n++) {
4638 $herectx .= raw_line($linenr, $n) . "\n";
4641 if (($stmts =~ tr/;/;/) == 1 &&
4642 $stmts !~ /^\s*(if|while|for|switch)\b/) {
4643 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
4644 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
4646 if (defined $semis && $semis ne "") {
4647 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
4648 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
4650 } elsif ($dstat =~ /^\+\s*#\s*define\s+$Ident.*;\s*$/) {
4652 my $cnt = statement_rawlines($ctx);
4653 my $herectx = $here . "\n";
4655 for (my $n = 0; $n < $cnt; $n++) {
4656 $herectx .= raw_line($linenr, $n) . "\n";
4659 WARN("TRAILING_SEMICOLON",
4660 "macros should not use a trailing semicolon\n" . "$herectx");
4664 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
4665 # all assignments may have only one of the following with an assignment:
4668 # VMLINUX_SYMBOL(...)
4669 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
4670 WARN("MISSING_VMLINUX_SYMBOL",
4671 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
4674 # check for redundant bracing round if etc
4675 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
4676 my ($level, $endln, @chunks) =
4677 ctx_statement_full($linenr, $realcnt, 1);
4678 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
4679 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
4680 if ($#chunks > 0 && $level == 0) {
4684 my $herectx = $here . "\n";
4685 my $ln = $linenr - 1;
4686 for my $chunk (@chunks) {
4687 my ($cond, $block) = @{$chunk};
4689 # If the condition carries leading newlines, then count those as offsets.
4690 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
4691 my $offset = statement_rawlines($whitespace) - 1;
4693 $allowed[$allow] = 0;
4694 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
4696 # We have looked at and allowed this specific line.
4697 $suppress_ifbraces{$ln + $offset} = 1;
4699 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
4700 $ln += statement_rawlines($block) - 1;
4702 substr($block, 0, length($cond), '');
4704 $seen++ if ($block =~ /^\s*{/);
4706 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
4707 if (statement_lines($cond) > 1) {
4708 #print "APW: ALLOWED: cond<$cond>\n";
4709 $allowed[$allow] = 1;
4711 if ($block =~/\b(?:if|for|while)\b/) {
4712 #print "APW: ALLOWED: block<$block>\n";
4713 $allowed[$allow] = 1;
4715 if (statement_block_size($block) > 1) {
4716 #print "APW: ALLOWED: lines block<$block>\n";
4717 $allowed[$allow] = 1;
4722 my $sum_allowed = 0;
4723 foreach (@allowed) {
4726 if ($sum_allowed == 0) {
4728 "braces {} are not necessary for any arm of this statement\n" . $herectx);
4729 } elsif ($sum_allowed != $allow &&
4732 "braces {} should be used on all arms of this statement\n" . $herectx);
4737 if (!defined $suppress_ifbraces{$linenr - 1} &&
4738 $line =~ /\b(if|while|for|else)\b/) {
4741 # Check the pre-context.
4742 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
4743 #print "APW: ALLOWED: pre<$1>\n";
4747 my ($level, $endln, @chunks) =
4748 ctx_statement_full($linenr, $realcnt, $-[0]);
4750 # Check the condition.
4751 my ($cond, $block) = @{$chunks[0]};
4752 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
4753 if (defined $cond) {
4754 substr($block, 0, length($cond), '');
4756 if (statement_lines($cond) > 1) {
4757 #print "APW: ALLOWED: cond<$cond>\n";
4760 if ($block =~/\b(?:if|for|while)\b/) {
4761 #print "APW: ALLOWED: block<$block>\n";
4764 if (statement_block_size($block) > 1) {
4765 #print "APW: ALLOWED: lines block<$block>\n";
4768 # Check the post-context.
4769 if (defined $chunks[1]) {
4770 my ($cond, $block) = @{$chunks[1]};
4771 if (defined $cond) {
4772 substr($block, 0, length($cond), '');
4774 if ($block =~ /^\s*\{/) {
4775 #print "APW: ALLOWED: chunk-1 block<$block>\n";
4779 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
4780 my $herectx = $here . "\n";
4781 my $cnt = statement_rawlines($block);
4783 for (my $n = 0; $n < $cnt; $n++) {
4784 $herectx .= raw_line($linenr, $n) . "\n";
4788 "braces {} are not necessary for single statement blocks\n" . $herectx);
4792 # check for unnecessary blank lines around braces
4793 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
4795 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev) &&
4796 $fix && $prevrawline =~ /^\+/) {
4797 fix_delete_line($fixlinenr - 1, $prevrawline);
4800 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
4802 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev) &&
4804 fix_delete_line($fixlinenr, $rawline);
4808 # no volatiles please
4809 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
4810 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
4812 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
4815 # Check for user-visible strings broken across lines, which breaks the ability
4816 # to grep for the string. Make exceptions when the previous string ends in a
4817 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
4818 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
4819 if ($line =~ /^\+\s*$String/ &&
4820 $prevline =~ /"\s*$/ &&
4821 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
4822 if (WARN("SPLIT_STRING",
4823 "quoted string split across lines\n" . $hereprev) &&
4825 $prevrawline =~ /^\+.*"\s*$/ &&
4826 $last_coalesced_string_linenr != $linenr - 1) {
4827 my $extracted_string = get_quoted_string($line, $rawline);
4828 my $comma_close = "";
4829 if ($rawline =~ /\Q$extracted_string\E(\s*\)\s*;\s*$|\s*,\s*)/) {
4833 fix_delete_line($fixlinenr - 1, $prevrawline);
4834 fix_delete_line($fixlinenr, $rawline);
4835 my $fixedline = $prevrawline;
4836 $fixedline =~ s/"\s*$//;
4837 $fixedline .= substr($extracted_string, 1) . trim($comma_close);
4838 fix_insert_line($fixlinenr - 1, $fixedline);
4839 $fixedline = $rawline;
4840 $fixedline =~ s/\Q$extracted_string\E\Q$comma_close\E//;
4841 if ($fixedline !~ /\+\s*$/) {
4842 fix_insert_line($fixlinenr, $fixedline);
4844 $last_coalesced_string_linenr = $linenr;
4848 # check for missing a space in a string concatenation
4849 if ($prevrawline =~ /[^\\]\w"$/ && $rawline =~ /^\+[\t ]+"\w/) {
4850 WARN('MISSING_SPACE',
4851 "break quoted strings at a space character\n" . $hereprev);
4854 # check for spaces before a quoted newline
4855 if ($rawline =~ /^.*\".*\s\\n/) {
4856 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
4857 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
4859 $fixed[$fixlinenr] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
4864 # concatenated string without spaces between elements
4865 if ($line =~ /$String[A-Z_]/ || $line =~ /[A-Za-z0-9_]$String/) {
4866 CHK("CONCATENATED_STRING",
4867 "Concatenated strings should use spaces between elements\n" . $herecurr);
4870 # uncoalesced string fragments
4871 if ($line =~ /$String\s*"/) {
4872 WARN("STRING_FRAGMENTS",
4873 "Consecutive strings are generally better as a single string\n" . $herecurr);
4876 # check for %L{u,d,i} and 0x%[udi] in strings
4878 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4879 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4880 $string =~ s/%%/__/g;
4881 if ($string =~ /(?<!%)%[\*\d\.\$]*L[udi]/) {
4883 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4886 if ($string =~ /0x%[\*\d\.\$\Llzth]*[udi]/) {
4887 ERROR("PRINTF_0xDECIMAL",
4888 "Prefixing 0x with decimal output is defective\n" . $herecurr);
4892 # check for line continuations in quoted strings with odd counts of "
4893 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4894 WARN("LINE_CONTINUATIONS",
4895 "Avoid line continuations in quoted strings\n" . $herecurr);
4899 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
4900 CHK("REDUNDANT_CODE",
4901 "if this code is redundant consider removing it\n" .
4905 # check for needless "if (<foo>) fn(<foo>)" uses
4906 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
4907 my $tested = quotemeta($1);
4908 my $expr = '\s*\(\s*' . $tested . '\s*\)\s*;';
4909 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?|(?:kmem_cache|mempool|dma_pool)_destroy)$expr/) {
4911 if (WARN('NEEDLESS_IF',
4912 "$func(NULL) is safe and this check is probably not required\n" . $hereprev) &&
4915 my $leading_tabs = "";
4916 my $new_leading_tabs = "";
4917 if ($lines[$linenr - 2] =~ /^\+(\t*)if\s*\(\s*$tested\s*\)\s*$/) {
4922 if ($lines[$linenr - 1] =~ /^\+(\t+)$func\s*\(\s*$tested\s*\)\s*;\s*$/) {
4923 $new_leading_tabs = $1;
4924 if (length($leading_tabs) + 1 ne length($new_leading_tabs)) {
4931 fix_delete_line($fixlinenr - 1, $prevrawline);
4932 $fixed[$fixlinenr] =~ s/^\+$new_leading_tabs/\+$leading_tabs/;
4938 # check for unnecessary "Out of Memory" messages
4939 if ($line =~ /^\+.*\b$logFunctions\s*\(/ &&
4940 $prevline =~ /^[ \+]\s*if\s*\(\s*(\!\s*|NULL\s*==\s*)?($Lval)(\s*==\s*NULL\s*)?\s*\)/ &&
4941 (defined $1 || defined $3) &&
4944 my $testline = $lines[$linenr - 3];
4946 my ($s, $c) = ctx_statement_block($linenr - 3, $realcnt, 0);
4947 # print("line: <$line>\nprevline: <$prevline>\ns: <$s>\nc: <$c>\n\n\n");
4949 if ($c =~ /(?:^|\n)[ \+]\s*(?:$Type\s*)?\Q$testval\E\s*=\s*(?:\([^\)]*\)\s*)?\s*(?:devm_)?(?:[kv][czm]alloc(?:_node|_array)?\b|kstrdup|(?:dev_)?alloc_skb)/) {
4951 "Possible unnecessary 'out of memory' message\n" . $hereprev);
4955 # check for logging functions with KERN_<LEVEL>
4956 if ($line !~ /printk(?:_ratelimited|_once)?\s*\(/ &&
4957 $line =~ /\b$logFunctions\s*\(.*\b(KERN_[A-Z]+)\b/) {
4959 if (WARN("UNNECESSARY_KERN_LEVEL",
4960 "Possible unnecessary $level\n" . $herecurr) &&
4962 $fixed[$fixlinenr] =~ s/\s*$level\s*//;
4966 # check for mask then right shift without a parentheses
4967 if ($^V && $^V ge 5.10.0 &&
4968 $line =~ /$LvalOrFunc\s*\&\s*($LvalOrFunc)\s*>>/ &&
4969 $4 !~ /^\&/) { # $LvalOrFunc may be &foo, ignore if so
4970 WARN("MASK_THEN_SHIFT",
4971 "Possible precedence defect with mask then right shift - may need parentheses\n" . $herecurr);
4974 # check for pointer comparisons to NULL
4975 if ($^V && $^V ge 5.10.0) {
4976 while ($line =~ /\b$LvalOrFunc\s*(==|\!=)\s*NULL\b/g) {
4979 $equal = "" if ($4 eq "!=");
4980 if (CHK("COMPARISON_TO_NULL",
4981 "Comparison to NULL could be written \"${equal}${val}\"\n" . $herecurr) &&
4983 $fixed[$fixlinenr] =~ s/\b\Q$val\E\s*(?:==|\!=)\s*NULL\b/$equal$val/;
4988 # check for bad placement of section $InitAttribute (e.g.: __initdata)
4989 if ($line =~ /(\b$InitAttribute\b)/) {
4991 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
4994 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
4995 ERROR("MISPLACED_INIT",
4996 "$attr should be placed after $var\n" . $herecurr)) ||
4997 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
4998 WARN("MISPLACED_INIT",
4999 "$attr should be placed after $var\n" . $herecurr))) &&
5001 $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;
5006 # check for $InitAttributeData (ie: __initdata) with const
5007 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
5009 $attr =~ /($InitAttributePrefix)(.*)/;
5010 my $attr_prefix = $1;
5012 if (ERROR("INIT_ATTRIBUTE",
5013 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
5015 $fixed[$fixlinenr] =~
5016 s/$InitAttributeData/${attr_prefix}initconst/;
5020 # check for $InitAttributeConst (ie: __initconst) without const
5021 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
5023 if (ERROR("INIT_ATTRIBUTE",
5024 "Use of $attr requires a separate use of const\n" . $herecurr) &&
5026 my $lead = $fixed[$fixlinenr] =~
5027 /(^\+\s*(?:static\s+))/;
5029 $lead = "$lead " if ($lead !~ /^\+$/);
5030 $lead = "${lead}const ";
5031 $fixed[$fixlinenr] =~ s/(^\+\s*(?:static\s+))/$lead/;
5035 # check for __read_mostly with const non-pointer (should just be const)
5036 if ($line =~ /\b__read_mostly\b/ &&
5037 $line =~ /($Type)\s*$Ident/ && $1 !~ /\*\s*$/ && $1 =~ /\bconst\b/) {
5038 if (ERROR("CONST_READ_MOSTLY",
5039 "Invalid use of __read_mostly with const type\n" . $herecurr) &&
5041 $fixed[$fixlinenr] =~ s/\s+__read_mostly\b//;
5045 # don't use __constant_<foo> functions outside of include/uapi/
5046 if ($realfile !~ m@^include/uapi/@ &&
5047 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
5048 my $constant_func = $1;
5049 my $func = $constant_func;
5050 $func =~ s/^__constant_//;
5051 if (WARN("CONSTANT_CONVERSION",
5052 "$constant_func should be $func\n" . $herecurr) &&
5054 $fixed[$fixlinenr] =~ s/\b$constant_func\b/$func/g;
5058 # prefer usleep_range over udelay
5059 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
5061 # ignore udelay's < 10, however
5062 if (! ($delay < 10) ) {
5064 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5066 if ($delay > 2000) {
5068 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
5072 # warn about unexpectedly long msleep's
5073 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
5076 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
5080 # check for comparisons of jiffies
5081 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
5082 WARN("JIFFIES_COMPARISON",
5083 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
5086 # check for comparisons of get_jiffies_64()
5087 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
5088 WARN("JIFFIES_COMPARISON",
5089 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
5092 # warn about #ifdefs in C files
5093 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
5094 # print "#ifdef in C files should be avoided\n";
5095 # print "$herecurr";
5099 # warn about spacing in #ifdefs
5100 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
5101 if (ERROR("SPACING",
5102 "exactly one space required after that #$1\n" . $herecurr) &&
5104 $fixed[$fixlinenr] =~
5105 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
5110 # check for spinlock_t definitions without a comment.
5111 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
5112 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
5114 if (!ctx_has_comment($first_line, $linenr)) {
5115 CHK("UNCOMMENTED_DEFINITION",
5116 "$1 definition without comment\n" . $herecurr);
5119 # check for memory barriers without a comment.
5120 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
5121 if (!ctx_has_comment($first_line, $linenr)) {
5122 WARN("MEMORY_BARRIER",
5123 "memory barrier without comment\n" . $herecurr);
5127 # check for waitqueue_active without a comment.
5128 if ($line =~ /\bwaitqueue_active\s*\(/) {
5129 if (!ctx_has_comment($first_line, $linenr)) {
5130 WARN("WAITQUEUE_ACTIVE",
5131 "waitqueue_active without comment\n" . $herecurr);
5135 # Check for expedited grace periods that interrupt non-idle non-nohz
5136 # online CPUs. These expedited can therefore degrade real-time response
5137 # if used carelessly, and should be avoided where not absolutely
5138 # needed. It is always OK to use synchronize_rcu_expedited() and
5139 # synchronize_sched_expedited() at boot time (before real-time applications
5140 # start) and in error situations where real-time response is compromised in
5141 # any case. Note that synchronize_srcu_expedited() does -not- interrupt
5142 # other CPUs, so don't warn on uses of synchronize_srcu_expedited().
5143 # Of course, nothing comes for free, and srcu_read_lock() and
5144 # srcu_read_unlock() do contain full memory barriers in payment for
5145 # synchronize_srcu_expedited() non-interruption properties.
5146 if ($line =~ /\b(synchronize_rcu_expedited|synchronize_sched_expedited)\(/) {
5147 WARN("EXPEDITED_RCU_GRACE_PERIOD",
5148 "expedited RCU grace periods should be avoided where they can degrade real-time response\n" . $herecurr);
5152 # check of hardware specific defines
5153 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
5155 "architecture specific defines should be avoided\n" . $herecurr);
5158 # Check that the storage class is at the beginning of a declaration
5159 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
5160 WARN("STORAGE_CLASS",
5161 "storage class should be at the beginning of the declaration\n" . $herecurr)
5164 # check the location of the inline attribute, that it is between
5165 # storage class and type.
5166 if ($line =~ /\b$Type\s+$Inline\b/ ||
5167 $line =~ /\b$Inline\s+$Storage\b/) {
5168 ERROR("INLINE_LOCATION",
5169 "inline keyword should sit between storage class and type\n" . $herecurr);
5172 # Check for __inline__ and __inline, prefer inline
5173 if ($realfile !~ m@\binclude/uapi/@ &&
5174 $line =~ /\b(__inline__|__inline)\b/) {
5176 "plain inline is preferred over $1\n" . $herecurr) &&
5178 $fixed[$fixlinenr] =~ s/\b(__inline__|__inline)\b/inline/;
5183 # Check for __attribute__ packed, prefer __packed
5184 if ($realfile !~ m@\binclude/uapi/@ &&
5185 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
5186 WARN("PREFER_PACKED",
5187 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
5190 # Check for __attribute__ aligned, prefer __aligned
5191 if ($realfile !~ m@\binclude/uapi/@ &&
5192 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
5193 WARN("PREFER_ALIGNED",
5194 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
5197 # Check for __attribute__ format(printf, prefer __printf
5198 if ($realfile !~ m@\binclude/uapi/@ &&
5199 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
5200 if (WARN("PREFER_PRINTF",
5201 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
5203 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
5208 # Check for __attribute__ format(scanf, prefer __scanf
5209 if ($realfile !~ m@\binclude/uapi/@ &&
5210 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
5211 if (WARN("PREFER_SCANF",
5212 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
5214 $fixed[$fixlinenr] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
5218 # Check for __attribute__ weak, or __weak declarations (may have link issues)
5219 if ($^V && $^V ge 5.10.0 &&
5220 $line =~ /(?:$Declare|$DeclareMisordered)\s*$Ident\s*$balanced_parens\s*(?:$Attribute)?\s*;/ &&
5221 ($line =~ /\b__attribute__\s*\(\s*\(.*\bweak\b/ ||
5222 $line =~ /\b__weak\b/)) {
5223 ERROR("WEAK_DECLARATION",
5224 "Using weak declarations can have unintended link defects\n" . $herecurr);
5227 # check for c99 types like uint8_t used outside of uapi/
5228 if ($realfile !~ m@\binclude/uapi/@ &&
5229 $line =~ /\b($Declare)\s*$Ident\s*[=;,\[]/) {
5231 if ($type =~ /\b($typeC99Typedefs)\b/) {
5233 my $kernel_type = 'u';
5234 $kernel_type = 's' if ($type =~ /^_*[si]/);
5237 if (CHK("PREFER_KERNEL_TYPES",
5238 "Prefer kernel type '$kernel_type' over '$type'\n" . $herecurr) &&
5240 $fixed[$fixlinenr] =~ s/\b$type\b/$kernel_type/;
5245 # check for sizeof(&)
5246 if ($line =~ /\bsizeof\s*\(\s*\&/) {
5247 WARN("SIZEOF_ADDRESS",
5248 "sizeof(& should be avoided\n" . $herecurr);
5251 # check for sizeof without parenthesis
5252 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
5253 if (WARN("SIZEOF_PARENTHESIS",
5254 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
5256 $fixed[$fixlinenr] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
5260 # check for struct spinlock declarations
5261 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
5262 WARN("USE_SPINLOCK_T",
5263 "struct spinlock should be spinlock_t\n" . $herecurr);
5266 # check for seq_printf uses that could be seq_puts
5267 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
5268 my $fmt = get_quoted_string($line, $rawline);
5271 if (WARN("PREFER_SEQ_PUTS",
5272 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
5274 $fixed[$fixlinenr] =~ s/\bseq_printf\b/seq_puts/;
5279 # Check for misused memsets
5280 if ($^V && $^V ge 5.10.0 &&
5282 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/) {
5288 if ($ms_size =~ /^(0x|)0$/i) {
5290 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
5291 } elsif ($ms_size =~ /^(0x|)1$/i) {
5293 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
5297 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
5298 if ($^V && $^V ge 5.10.0 &&
5300 $stat =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5301 if (WARN("PREFER_ETHER_ADDR_COPY",
5302 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . "$here\n$stat\n") &&
5304 $fixed[$fixlinenr] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
5308 # Check for memcmp(foo, bar, ETH_ALEN) that could be ether_addr_equal*(foo, bar)
5309 if ($^V && $^V ge 5.10.0 &&
5311 $stat =~ /^\+(?:.*?)\bmemcmp\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5312 WARN("PREFER_ETHER_ADDR_EQUAL",
5313 "Prefer ether_addr_equal() or ether_addr_equal_unaligned() over memcmp()\n" . "$here\n$stat\n")
5316 # check for memset(foo, 0x0, ETH_ALEN) that could be eth_zero_addr
5317 # check for memset(foo, 0xFF, ETH_ALEN) that could be eth_broadcast_addr
5318 if ($^V && $^V ge 5.10.0 &&
5320 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/) {
5324 if ($ms_val =~ /^(?:0x|)0+$/i) {
5325 if (WARN("PREFER_ETH_ZERO_ADDR",
5326 "Prefer eth_zero_addr over memset()\n" . "$here\n$stat\n") &&
5328 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_zero_addr($2)/;
5330 } elsif ($ms_val =~ /^(?:0xff|255)$/i) {
5331 if (WARN("PREFER_ETH_BROADCAST_ADDR",
5332 "Prefer eth_broadcast_addr() over memset()\n" . "$here\n$stat\n") &&
5334 $fixed[$fixlinenr] =~ s/\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*,\s*ETH_ALEN\s*\)/eth_broadcast_addr($2)/;
5339 # typecasts on min/max could be min_t/max_t
5340 if ($^V && $^V ge 5.10.0 &&
5342 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
5343 if (defined $2 || defined $7) {
5345 my $cast1 = deparenthesize($2);
5347 my $cast2 = deparenthesize($7);
5351 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
5352 $cast = "$cast1 or $cast2";
5353 } elsif ($cast1 ne "") {
5359 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
5363 # check usleep_range arguments
5364 if ($^V && $^V ge 5.10.0 &&
5366 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
5370 WARN("USLEEP_RANGE",
5371 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5372 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
5374 WARN("USLEEP_RANGE",
5375 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
5379 # check for naked sscanf
5380 if ($^V && $^V ge 5.10.0 &&
5382 $line =~ /\bsscanf\b/ &&
5383 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
5384 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
5385 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
5386 my $lc = $stat =~ tr@\n@@;
5387 $lc = $lc + $linenr;
5388 my $stat_real = raw_line($linenr, 0);
5389 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5390 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5392 WARN("NAKED_SSCANF",
5393 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
5396 # check for simple sscanf that should be kstrto<foo>
5397 if ($^V && $^V ge 5.10.0 &&
5399 $line =~ /\bsscanf\b/) {
5400 my $lc = $stat =~ tr@\n@@;
5401 $lc = $lc + $linenr;
5402 my $stat_real = raw_line($linenr, 0);
5403 for (my $count = $linenr + 1; $count <= $lc; $count++) {
5404 $stat_real = $stat_real . "\n" . raw_line($count, 0);
5406 if ($stat_real =~ /\bsscanf\b\s*\(\s*$FuncArg\s*,\s*("[^"]+")/) {
5408 my $count = $format =~ tr@%@%@;
5410 $format =~ /^"\%(?i:ll[udxi]|[udxi]ll|ll|[hl]h?[udxi]|[udxi][hl]h?|[hl]h?|[udxi])"$/) {
5411 WARN("SSCANF_TO_KSTRTO",
5412 "Prefer kstrto<type> to single variable sscanf\n" . "$here\n$stat_real\n");
5417 # check for new externs in .h files.
5418 if ($realfile =~ /\.h$/ &&
5419 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
5420 if (CHK("AVOID_EXTERNS",
5421 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
5423 $fixed[$fixlinenr] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
5427 # check for new externs in .c files.
5428 if ($realfile =~ /\.c$/ && defined $stat &&
5429 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
5431 my $function_name = $1;
5432 my $paren_space = $2;
5435 if (defined $cond) {
5436 substr($s, 0, length($cond), '');
5438 if ($s =~ /^\s*;/ &&
5439 $function_name ne 'uninitialized_var')
5441 WARN("AVOID_EXTERNS",
5442 "externs should be avoided in .c files\n" . $herecurr);
5445 if ($paren_space =~ /\n/) {
5446 WARN("FUNCTION_ARGUMENTS",
5447 "arguments for function declarations should follow identifier\n" . $herecurr);
5450 } elsif ($realfile =~ /\.c$/ && defined $stat &&
5451 $stat =~ /^.\s*extern\s+/)
5453 WARN("AVOID_EXTERNS",
5454 "externs should be avoided in .c files\n" . $herecurr);
5457 # checks for new __setup's
5458 if ($rawline =~ /\b__setup\("([^"]*)"/) {
5461 if (!grep(/$name/, @setup_docs)) {
5462 CHK("UNDOCUMENTED_SETUP",
5463 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
5467 # check for pointless casting of kmalloc return
5468 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
5469 WARN("UNNECESSARY_CASTS",
5470 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
5474 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
5475 if ($^V && $^V ge 5.10.0 &&
5476 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
5477 CHK("ALLOC_SIZEOF_STRUCT",
5478 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
5481 # check for k[mz]alloc with multiplies that could be kmalloc_array/kcalloc
5482 if ($^V && $^V ge 5.10.0 &&
5483 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*(k[mz]alloc)\s*\(\s*($FuncArg)\s*\*\s*($FuncArg)\s*,/) {
5487 my $newfunc = "kmalloc_array";
5488 $newfunc = "kcalloc" if ($oldfunc eq "kzalloc");
5491 if ($a1 =~ /^sizeof\s*\S/) {
5495 if ($r1 !~ /^sizeof\b/ && $r2 =~ /^sizeof\s*\S/ &&
5496 !($r1 =~ /^$Constant$/ || $r1 =~ /^[A-Z_][A-Z0-9_]*$/)) {
5497 if (WARN("ALLOC_WITH_MULTIPLY",
5498 "Prefer $newfunc over $oldfunc with multiply\n" . $herecurr) &&
5500 $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;
5506 # check for krealloc arg reuse
5507 if ($^V && $^V ge 5.10.0 &&
5508 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
5509 WARN("KREALLOC_ARG_REUSE",
5510 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
5513 # check for alloc argument mismatch
5514 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
5515 WARN("ALLOC_ARRAY_ARGS",
5516 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
5519 # check for multiple semicolons
5520 if ($line =~ /;\s*;\s*$/) {
5521 if (WARN("ONE_SEMICOLON",
5522 "Statements terminations use 1 semicolon\n" . $herecurr) &&
5524 $fixed[$fixlinenr] =~ s/(\s*;\s*){2,}$/;/g;
5528 # check for #defines like: 1 << <digit> that could be BIT(digit)
5529 if ($line =~ /#\s*define\s+\w+\s+\(?\s*1\s*([ulUL]*)\s*\<\<\s*(?:\d+|$Ident)\s*\)?/) {
5531 $ull = "_ULL" if (defined($1) && $1 =~ /ll/i);
5532 if (CHK("BIT_MACRO",
5533 "Prefer using the BIT$ull macro\n" . $herecurr) &&
5535 $fixed[$fixlinenr] =~ s/\(?\s*1\s*[ulUL]*\s*<<\s*(\d+|$Ident)\s*\)?/BIT${ull}($1)/;
5539 # check for case / default statements not preceded by break/fallthrough/switch
5540 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
5542 my $has_statement = 0;
5544 my $prevline = $linenr;
5545 while ($prevline > 1 && ($file || $count < 3) && !$has_break) {
5547 my $rline = $rawlines[$prevline - 1];
5548 my $fline = $lines[$prevline - 1];
5549 last if ($fline =~ /^\@\@/);
5550 next if ($fline =~ /^\-/);
5551 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
5552 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
5553 next if ($fline =~ /^.[\s$;]*$/);
5556 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
5558 if (!$has_break && $has_statement) {
5559 WARN("MISSING_BREAK",
5560 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
5564 # check for switch/default statements without a break;
5565 if ($^V && $^V ge 5.10.0 &&
5567 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
5569 my $herectx = $here . "\n";
5570 my $cnt = statement_rawlines($stat);
5571 for (my $n = 0; $n < $cnt; $n++) {
5572 $herectx .= raw_line($linenr, $n) . "\n";
5574 WARN("DEFAULT_NO_BREAK",
5575 "switch default: should use break\n" . $herectx);
5578 # check for gcc specific __FUNCTION__
5579 if ($line =~ /\b__FUNCTION__\b/) {
5580 if (WARN("USE_FUNC",
5581 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
5583 $fixed[$fixlinenr] =~ s/\b__FUNCTION__\b/__func__/g;
5587 # check for uses of __DATE__, __TIME__, __TIMESTAMP__
5588 while ($line =~ /\b(__(?:DATE|TIME|TIMESTAMP)__)\b/g) {
5590 "Use of the '$1' macro makes the build non-deterministic\n" . $herecurr);
5593 # check for use of yield()
5594 if ($line =~ /\byield\s*\(\s*\)/) {
5596 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
5599 # check for comparisons against true and false
5600 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
5608 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
5610 my $type = lc($otype);
5611 if ($type =~ /^(?:true|false)$/) {
5612 if (("$test" eq "==" && "$type" eq "true") ||
5613 ("$test" eq "!=" && "$type" eq "false")) {
5617 CHK("BOOL_COMPARISON",
5618 "Using comparison to $otype is error prone\n" . $herecurr);
5620 ## maybe suggesting a correct construct would better
5621 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
5626 # check for semaphores initialized locked
5627 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
5628 WARN("CONSIDER_COMPLETION",
5629 "consider using a completion\n" . $herecurr);
5632 # recommend kstrto* over simple_strto* and strict_strto*
5633 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
5634 WARN("CONSIDER_KSTRTO",
5635 "$1 is obsolete, use k$3 instead\n" . $herecurr);
5638 # check for __initcall(), use device_initcall() explicitly or more appropriate function please
5639 if ($line =~ /^.\s*__initcall\s*\(/) {
5640 WARN("USE_DEVICE_INITCALL",
5641 "please use device_initcall() or more appropriate function instead of __initcall() (see include/linux/init.h)\n" . $herecurr);
5644 # check for various structs that are normally const (ops, kgdb, device_tree)
5645 my $const_structs = qr{
5647 address_space_operations|
5649 block_device_operations|
5654 file_lock_operations|
5664 lock_manager_operations|
5671 pipe_buf_operations|
5672 platform_hibernation_ops|
5673 platform_suspend_ops|
5678 soc_pcmcia_socket_ops|
5685 if ($line !~ /\bconst\b/ &&
5686 $line =~ /\bstruct\s+($const_structs)\b/) {
5687 WARN("CONST_STRUCT",
5688 "struct $1 should normally be const\n" .
5692 # use of NR_CPUS is usually wrong
5693 # ignore definitions of NR_CPUS and usage to define arrays as likely right
5694 if ($line =~ /\bNR_CPUS\b/ &&
5695 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
5696 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
5697 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
5698 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
5699 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
5702 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
5705 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
5706 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
5707 ERROR("DEFINE_ARCH_HAS",
5708 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
5711 # likely/unlikely comparisons similar to "(likely(foo) > 0)"
5712 if ($^V && $^V ge 5.10.0 &&
5713 $line =~ /\b((?:un)?likely)\s*\(\s*$FuncArg\s*\)\s*$Compare/) {
5714 WARN("LIKELY_MISUSE",
5715 "Using $1 should generally have parentheses around the comparison\n" . $herecurr);
5718 # whine mightly about in_atomic
5719 if ($line =~ /\bin_atomic\s*\(/) {
5720 if ($realfile =~ m@^drivers/@) {
5722 "do not use in_atomic in drivers\n" . $herecurr);
5723 } elsif ($realfile !~ m@^kernel/@) {
5725 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
5729 # check for lockdep_set_novalidate_class
5730 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
5731 $line =~ /__lockdep_no_validate__\s*\)/ ) {
5732 if ($realfile !~ m@^kernel/lockdep@ &&
5733 $realfile !~ m@^include/linux/lockdep@ &&
5734 $realfile !~ m@^drivers/base/core@) {
5736 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
5740 if ($line =~ /debugfs_create_\w+.*\b$mode_perms_world_writable\b/ ||
5741 $line =~ /DEVICE_ATTR.*\b$mode_perms_world_writable\b/) {
5742 WARN("EXPORTED_WORLD_WRITABLE",
5743 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5746 # Mode permission misuses where it seems decimal should be octal
5747 # This uses a shortcut match to avoid unnecessary uses of a slow foreach loop
5748 if ($^V && $^V ge 5.10.0 &&
5749 $line =~ /$mode_perms_search/) {
5750 foreach my $entry (@mode_permission_funcs) {
5751 my $func = $entry->[0];
5752 my $arg_pos = $entry->[1];
5757 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
5759 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
5760 if ($line =~ /$test/) {
5762 $val = $6 if ($skip_args ne "");
5764 if ($val !~ /^0$/ &&
5765 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
5766 length($val) ne 4)) {
5767 ERROR("NON_OCTAL_PERMISSIONS",
5768 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
5769 } elsif ($val =~ /^$Octal$/ && (oct($val) & 02)) {
5770 ERROR("EXPORTED_WORLD_WRITABLE",
5771 "Exporting writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
5777 # validate content of MODULE_LICENSE against list from include/linux/module.h
5778 if ($line =~ /\bMODULE_LICENSE\s*\(\s*($String)\s*\)/) {
5779 my $extracted_string = get_quoted_string($line, $rawline);
5780 my $valid_licenses = qr{
5783 GPL\ and\ additional\ rights|
5789 if ($extracted_string !~ /^"(?:$valid_licenses)"$/x) {
5790 WARN("MODULE_LICENSE",
5791 "unknown module license " . $extracted_string . "\n" . $herecurr);
5796 # If we have no input at all, then there is nothing to report on
5797 # so just keep quiet.
5798 if ($#rawlines == -1) {
5802 # In mailback mode only produce a report in the negative, for
5803 # things that appear to be patches.
5804 if ($mailback && ($clean == 1 || !$is_patch)) {
5808 # This is not a patch, and we are are in 'no-patch' mode so
5810 if (!$chk_patch && !$is_patch) {
5814 if (!$is_patch && $file !~ /cover-letter\.patch$/) {
5815 ERROR("NOT_UNIFIED_DIFF",
5816 "Does not appear to be a unified-diff format patch\n");
5818 if ($is_patch && $filename ne '-' && $chk_signoff && $signoff == 0) {
5819 ERROR("MISSING_SIGN_OFF",
5820 "Missing Signed-off-by: line(s)\n");
5823 print report_dump();
5824 if ($summary && !($clean == 1 && $quiet == 1)) {
5825 print "$filename " if ($summary_file);
5826 print "total: $cnt_error errors, $cnt_warn warnings, " .
5827 (($check)? "$cnt_chk checks, " : "") .
5828 "$cnt_lines lines checked\n";
5832 # If there were whitespace errors which cleanpatch can fix
5833 # then suggest that.
5834 if ($rpt_cleaners) {
5838 NOTE: Whitespace errors detected.
5839 You may wish to use scripts/cleanpatch or scripts/cleanfile
5844 if ($clean == 0 && $fix &&
5845 ("@rawlines" ne "@fixed" ||
5846 $#fixed_inserted >= 0 || $#fixed_deleted >= 0)) {
5847 my $newfile = $filename;
5848 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
5852 @fixed = fix_inserted_deleted_lines(\@fixed, \@fixed_inserted, \@fixed_deleted);
5854 open($f, '>', $newfile)
5855 or die "$P: Can't open $newfile for write\n";
5856 foreach my $fixed_line (@fixed) {
5859 if ($linecount > 3) {
5860 $fixed_line =~ s/^\+//;
5861 print $f $fixed_line . "\n";
5864 print $f $fixed_line . "\n";
5872 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
5874 Do _NOT_ trust the results written to this file.
5875 Do _NOT_ submit these changes without inspecting them for correctness.
5877 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
5878 No warranties, expressed or implied...
5886 print "$vname has no obvious style problems and is ready for submission.\n";
5888 print "$vname has style problems, please review.\n";