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
8 # Based on linux/scripts/checkpatch.pl v4.12-11743-g96d0d83 with
9 # some additional Lustre-specific checks.
16 use Term::ANSIColor qw(:constants);
19 my $D = dirname(abs_path($P));
23 use Getopt::Long qw(:config no_auto_abbrev);
53 my $configuration_file = ".checkpatch.conf";
54 my $max_line_length = 80;
55 my $ignore_perl_version = 0;
56 my $minimum_perl_version = 5.10.0;
57 my $min_conf_desc_length = 4;
58 my $spelling_file = "$D/spelling.txt";
60 my $codespellfile = "/usr/share/codespell/dictionary.txt";
61 my $conststructsfile = "$D/const_structs.checkpatch";
62 my $typedefsfile = "";
64 my $allow_c99_comments = 1;
70 Usage: $P [OPTION]... [FILE]...
75 --no-tree run without a kernel tree
76 --no-signoff do not check for 'Signed-off-by' line
77 --patch treat FILE as patchfile (default)
78 --emacs emacs compile window format
79 --terse one line per report
80 --showfile emit diffed file position, not input file position
81 -g, --git treat FILE as a single commit or git revision range
82 single git commit with:
86 multiple git commits with:
90 git merges are ignored
91 -f, --file treat FILE as regular source file
92 --subjective, --strict enable more subjective tests
93 --list-types list the possible message types
94 --types TYPE(,TYPE2...) show only these comma separated message types
95 --ignore TYPE(,TYPE2...) ignore various comma separated message types
96 --show-types show the specific message type in the output
97 --max-line-length=n set the maximum line length, if exceeded, warn
98 --min-conf-desc-length=n set the min description length, if shorter, warn
99 --root=PATH PATH to the kernel tree root
100 --no-summary suppress the per-file summary
101 --mailback only produce a report in case of warnings/errors
102 --summary-file include the filename in summary
103 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
104 'values', 'possible', 'type', and 'attr' (default
106 --test-only=WORD report only warnings/errors containing WORD
108 --fix EXPERIMENTAL - may create horrible results
109 If correctable single-line errors exist, create
110 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
111 with potential errors corrected to the preferred
113 --fix-inplace EXPERIMENTAL - may create horrible results
114 Is the same as --fix, but overwrites the input
115 file. It's your fault if there's no backup or git
116 --ignore-perl-version override checking of perl version. expect
118 --codespell Use the codespell dictionary for spelling/typos
119 (default:/usr/share/codespell/dictionary.txt)
120 --codespellfile Use this codespell dictionary
121 --typedefsfile Read additional types from this file
122 --color[=WHEN] Use colors 'always', 'never', or only when output
123 is a terminal ('auto'). Default is 'auto'.
124 -h, --help, --version display this help and exit
126 When FILE is - read standard input.
134 return grep { !$seen{$_}++ } @_;
144 open(my $script, '<', abs_path($P)) or
145 die "$P: Can't read '$P' $!\n";
147 my $text = <$script>;
151 for ($text =~ /\b(?:(?:CHK|WARN|ERROR)\s*\(\s*"([^"]+)")/g) {
154 @types = sort(uniq(@types));
155 print("#\tMessage type\n\n");
156 foreach my $type (@types) {
157 print(++$count . "\t" . $type . "\n");
163 my $conf = which_conf($configuration_file);
166 open(my $conffile, '<', "$conf")
167 or warn "$P: Can't find a readable $configuration_file file $!\n";
169 while (<$conffile>) {
172 $line =~ s/\s*\n?$//g;
176 next if ($line =~ m/^\s*#/);
177 next if ($line =~ m/^\s*$/);
179 my @words = split(" ", $line);
180 foreach my $word (@words) {
181 last if ($word =~ m/^#/);
182 push (@conf_args, $word);
186 unshift(@ARGV, @conf_args) if @conf_args;
189 # Perl's Getopt::Long allows options to take optional arguments after a space.
190 # Prevent --color by itself from consuming other arguments
192 if ($_ eq "--color" || $_ eq "-color") {
193 $_ = "--color=$color";
198 'q|quiet+' => \$quiet,
200 'signoff!' => \$chk_signoff,
201 'patch!' => \$chk_patch,
204 'showfile!' => \$showfile,
207 'subjective!' => \$check,
208 'strict!' => \$check,
209 'ignore=s' => \@ignore,
211 'show-types!' => \$show_types,
212 'list-types!' => \$list_types,
213 'max-line-length=i' => \$max_line_length,
214 'min-conf-desc-length=i' => \$min_conf_desc_length,
216 'summary!' => \$summary,
217 'mailback!' => \$mailback,
218 'summary-file!' => \$summary_file,
220 'fix-inplace!' => \$fix_inplace,
221 'ignore-perl-version!' => \$ignore_perl_version,
222 'debug=s' => \%debug,
223 'test-only=s' => \$tst_only,
224 'codespell!' => \$codespell,
225 'codespellfile=s' => \$codespellfile,
226 'typedefsfile=s' => \$typedefsfile,
227 'color=s' => \$color,
228 'no-color' => \$color, #keep old behaviors of -nocolor
229 'nocolor' => \$color, #keep old behaviors of -nocolor
236 list_types(0) if ($list_types);
238 $fix = 1 if ($fix_inplace);
239 $check_orig = $check;
243 if ($^V && $^V lt $minimum_perl_version) {
244 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
245 if (!$ignore_perl_version) {
250 #if no filenames are given, push '-' to read patch from stdin
255 if ($color =~ /^[01]$/) {
257 } elsif ($color =~ /^always$/i) {
259 } elsif ($color =~ /^never$/i) {
261 } elsif ($color =~ /^auto$/i) {
262 $color = (-t STDOUT);
264 die "Invalid color mode: $color\n";
267 sub hash_save_array_words {
268 my ($hashRef, $arrayRef) = @_;
270 my @array = split(/,/, join(',', @$arrayRef));
271 foreach my $word (@array) {
272 $word =~ s/\s*\n?$//g;
275 $word =~ tr/[a-z]/[A-Z]/;
277 next if ($word =~ m/^\s*#/);
278 next if ($word =~ m/^\s*$/);
284 sub hash_show_words {
285 my ($hashRef, $prefix) = @_;
287 if (keys %$hashRef) {
288 print "\nNOTE: $prefix message types:";
289 foreach my $word (sort keys %$hashRef) {
296 hash_save_array_words(\%ignore_type, \@ignore);
297 hash_save_array_words(\%use_type, \@use);
300 my $dbg_possible = 0;
303 for my $key (keys %debug) {
305 eval "\${dbg_$key} = '$debug{$key}';";
309 my $rpt_cleaners = 0;
318 if (!top_of_kernel_tree($root)) {
319 die "$P: $root: --root does not point at a valid tree\n";
322 if (top_of_kernel_tree('.')) {
324 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
325 top_of_kernel_tree($1)) {
330 if (!defined $root) {
331 print "Must be run from the top-level dir. of a kernel tree\n";
336 my $emitted_corrupt = 0;
339 [A-Za-z_][A-Za-z\d_]*
340 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
342 our $Storage = qr{extern|static|asmlinkage};
355 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
356 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
357 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
358 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
359 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
361 # Notes to $Attribute:
362 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
383 ____cacheline_aligned|
384 ____cacheline_aligned_in_smp|
385 ____cacheline_internodealigned_in_smp|
389 our $Inline = qr{inline|__always_inline|noinline|__inline|__inline__};
390 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
391 our $Lval = qr{$Ident(?:$Member)*};
393 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
394 our $Binary = qr{(?i)0b[01]+$Int_type?};
395 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
396 our $Int = qr{[0-9]+$Int_type?};
397 our $Octal = qr{0[0-7]+$Int_type?};
398 our $String = qr{"[X\t]*"};
399 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
400 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
401 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
402 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
403 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
404 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
405 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
406 our $Arithmetic = qr{\+|-|\*|\/|%};
410 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
413 our $c90_Keywords = qr{do|for|while|if|else|return|goto|continue|switch|default|case|break}x;
417 our $NonptrTypeMisordered;
418 our $NonptrTypeWithAttr;
422 our $DeclareMisordered;
424 our $NON_ASCII_UTF8 = qr{
425 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
426 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
427 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
428 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
429 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
430 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
431 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
435 [\x09\x0A\x0D\x20-\x7E] # ASCII
439 our $typeC99Typedefs = qr{(?:__)?(?:[us]_?)?int_?(?:8|16|32|64)_t};
440 our $typeOtherOSTypedefs = qr{(?x:
441 u_(?:char|short|int|long) | # bsd
442 u(?:nchar|short|int|long) # sysv
444 our $typeKernelTypedefs = qr{(?x:
445 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
448 our $typeTypedefs = qr{(?x:
450 $typeOtherOSTypedefs\b|
451 $typeKernelTypedefs\b
454 our $zero_initializer = qr{(?:(?:0[xX])?0+$Int_type?|NULL|false)\b};
456 our $logFunctions = qr{(?x:
457 printk(?:_ratelimited|_once|_deferred_once|_deferred|)|
458 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
459 WARN(?:_RATELIMIT|_ONCE|)|
460 CDEBUG|CERROR|CL_LOCK_DEBUG|CWARN|DEBUG_REQ|LCONSOLE_[A-Z]*|
463 seq_vprintf|seq_printf|seq_puts
466 our $signature_tags = qr{(?xi:
477 our @typeListMisordered = (
478 qr{char\s+(?:un)?signed},
479 qr{int\s+(?:(?:un)?signed\s+)?short\s},
480 qr{int\s+short(?:\s+(?:un)?signed)},
481 qr{short\s+int(?:\s+(?:un)?signed)},
482 qr{(?:un)?signed\s+int\s+short},
483 qr{short\s+(?:un)?signed},
484 qr{long\s+int\s+(?:un)?signed},
485 qr{int\s+long\s+(?:un)?signed},
486 qr{long\s+(?:un)?signed\s+int},
487 qr{int\s+(?:un)?signed\s+long},
488 qr{int\s+(?:un)?signed},
489 qr{int\s+long\s+long\s+(?:un)?signed},
490 qr{long\s+long\s+int\s+(?:un)?signed},
491 qr{long\s+long\s+(?:un)?signed\s+int},
492 qr{long\s+long\s+(?:un)?signed},
493 qr{long\s+(?:un)?signed},
498 qr{(?:(?:un)?signed\s+)?char},
499 qr{(?:(?:un)?signed\s+)?short\s+int},
500 qr{(?:(?:un)?signed\s+)?short},
501 qr{(?:(?:un)?signed\s+)?int},
502 qr{(?:(?:un)?signed\s+)?long\s+int},
503 qr{(?:(?:un)?signed\s+)?long\s+long\s+int},
504 qr{(?:(?:un)?signed\s+)?long\s+long},
505 qr{(?:(?:un)?signed\s+)?long},
514 qr{${Ident}_handler},
515 qr{${Ident}_handler_fn},
519 our $C90_int_types = qr{(?x:
520 long\s+long\s+int\s+(?:un)?signed|
521 long\s+long\s+(?:un)?signed\s+int|
522 long\s+long\s+(?:un)?signed|
523 (?:(?:un)?signed\s+)?long\s+long\s+int|
524 (?:(?:un)?signed\s+)?long\s+long|
525 int\s+long\s+long\s+(?:un)?signed|
526 int\s+(?:(?:un)?signed\s+)?long\s+long|
528 long\s+int\s+(?:un)?signed|
529 long\s+(?:un)?signed\s+int|
530 long\s+(?:un)?signed|
531 (?:(?:un)?signed\s+)?long\s+int|
532 (?:(?:un)?signed\s+)?long|
533 int\s+long\s+(?:un)?signed|
534 int\s+(?:(?:un)?signed\s+)?long|
537 (?:(?:un)?signed\s+)?int
540 our @typeListFile = ();
541 our @typeListWithAttr = (
543 qr{struct\s+$InitAttribute\s+$Ident},
544 qr{union\s+$InitAttribute\s+$Ident},
547 our @modifierList = (
550 our @modifierListFile = ();
552 our @mode_permission_funcs = (
554 ["module_param_(?:array|named|string)", 4],
555 ["module_param_array_named", 5],
556 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
557 ["proc_create(?:_data|)", 2],
558 ["(?:CLASS|DEVICE|SENSOR|SENSOR_DEVICE|IIO_DEVICE)_ATTR", 2],
559 ["IIO_DEV_ATTR_[A-Z_]+", 1],
560 ["SENSOR_(?:DEVICE_|)ATTR_2", 2],
561 ["SENSOR_TEMPLATE(?:_2|)", 3],
565 #Create a search pattern for all these functions to speed up a loop below
566 our $mode_perms_search = "";
567 foreach my $entry (@mode_permission_funcs) {
568 $mode_perms_search .= '|' if ($mode_perms_search ne "");
569 $mode_perms_search .= $entry->[0];
572 our $mode_perms_world_writable = qr{
580 our %mode_permission_string_types = (
599 #Create a search pattern for all these strings to speed up a loop below
600 our $mode_perms_string_search = "";
601 foreach my $entry (keys %mode_permission_string_types) {
602 $mode_perms_string_search .= '|' if ($mode_perms_string_search ne "");
603 $mode_perms_string_search .= $entry;
606 our $allowed_asm_includes = qr{(?x:
612 # memory.h: ARM has a custom one
614 # Load common spelling mistakes and build regular expression list.
618 if (open(my $spelling, '<', $spelling_file)) {
619 while (<$spelling>) {
622 $line =~ s/\s*\n?$//g;
625 next if ($line =~ m/^\s*#/);
626 next if ($line =~ m/^\s*$/);
628 my ($suspect, $fix) = split(/\|\|/, $line);
630 $spelling_fix{$suspect} = $fix;
634 warn "No typos will be found - file '$spelling_file': $!\n";
638 if (open(my $spelling, '<', $codespellfile)) {
639 while (<$spelling>) {
642 $line =~ s/\s*\n?$//g;
645 next if ($line =~ m/^\s*#/);
646 next if ($line =~ m/^\s*$/);
647 next if ($line =~ m/, disabled/i);
651 my ($suspect, $fix) = split(/->/, $line);
653 $spelling_fix{$suspect} = $fix;
657 warn "No codespell typos will be found - file '$codespellfile': $!\n";
661 $misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
664 my ($wordsRef, $file) = @_;
666 if (open(my $words, '<', $file)) {
670 $line =~ s/\s*\n?$//g;
673 next if ($line =~ m/^\s*#/);
674 next if ($line =~ m/^\s*$/);
676 print("$file: '$line' invalid - ignored\n");
680 $$wordsRef .= '|' if ($$wordsRef ne "");
690 my $const_structs = "";
691 read_words(\$const_structs, $conststructsfile)
692 or warn "No structs that should be const will be found - file '$conststructsfile': $!\n";
694 my $typeOtherTypedefs = "";
695 if (length($typedefsfile)) {
696 read_words(\$typeOtherTypedefs, $typedefsfile)
697 or warn "No additional types will be considered - file '$typedefsfile': $!\n";
699 $typeTypedefs .= '|' . $typeOtherTypedefs if ($typeOtherTypedefs ne "");
702 my $mods = "(?x: \n" . join("|\n ", (@modifierList, @modifierListFile)) . "\n)";
703 my $all = "(?x: \n" . join("|\n ", (@typeList, @typeListFile)) . "\n)";
704 my $Misordered = "(?x: \n" . join("|\n ", @typeListMisordered) . "\n)";
705 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
706 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
712 (?:$Modifier\s+|const\s+)*
714 (?:typeof|__typeof__)\s*\([^\)]*\)|
718 (?:\s+$Modifier|\s+const)*
720 $NonptrTypeMisordered = qr{
721 (?:$Modifier\s+|const\s+)*
725 (?:\s+$Modifier|\s+const)*
727 $NonptrTypeWithAttr = qr{
728 (?:$Modifier\s+|const\s+)*
730 (?:typeof|__typeof__)\s*\([^\)]*\)|
734 (?:\s+$Modifier|\s+const)*
738 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
739 (?:\s+$Inline|\s+$Modifier)*
741 $TypeMisordered = qr{
742 $NonptrTypeMisordered
743 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*\s*(?:const\s*)?|\[\])+|(?:\s*\[\s*\])+)?
744 (?:\s+$Inline|\s+$Modifier)*
746 $Declare = qr{(?:$Storage\s+(?:$Inline\s+)?)?$Type};
747 $DeclareMisordered = qr{(?:$Storage\s+(?:$Inline\s+)?)?$TypeMisordered};
751 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
753 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
754 # requires at least perl version v5.10.0
755 # Any use must be runtime checked with $^V
757 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
758 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
759 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant|$String)};
761 our $declaration_macros = qr{(?x:
762 (?:$Storage\s+)?(?:[A-Z_][A-Z0-9]*_){0,2}(?:DEFINE|DECLARE)(?:_[A-Z0-9]+){1,6}\s*\(|
763 (?:$Storage\s+)?[HLP]?LIST_HEAD\s*\(|
764 (?:$Storage\s+)?${Type}\s+uninitialized_var\s*\(
769 return "" if (!defined($string));
771 while ($string =~ /^\s*\(.*\)\s*$/) {
772 $string =~ s@^\s*\(\s*@@;
773 $string =~ s@\s*\)\s*$@@;
776 $string =~ s@\s+@ @g;
781 sub seed_camelcase_file {
784 return if (!(-f $file));
788 open(my $include_file, '<', "$file")
789 or warn "$P: Can't read '$file' $!\n";
790 my $text = <$include_file>;
791 close($include_file);
793 my @lines = split('\n', $text);
795 foreach my $line (@lines) {
796 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
797 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
799 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
801 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
807 sub is_maintained_obsolete {
810 return 0 if (!$tree || !(-e "$root/scripts/get_maintainer.pl"));
812 my $status = `perl $root/scripts/get_maintainer.pl --status --nom --nol --nogit --nogit-fallback -f $filename 2>&1`;
814 return $status =~ /obsolete/i;
817 my $camelcase_seeded = 0;
818 sub seed_camelcase_includes {
819 return if ($camelcase_seeded);
822 my $camelcase_cache = "";
823 my @include_files = ();
825 $camelcase_seeded = 1;
828 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
829 chomp $git_last_include_commit;
830 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
832 my $last_mod_date = 0;
833 $files = `find $root/include -name "*.h"`;
834 @include_files = split('\n', $files);
835 foreach my $file (@include_files) {
836 my $date = POSIX::strftime("%Y%m%d%H%M",
837 localtime((stat $file)[9]));
838 $last_mod_date = $date if ($last_mod_date < $date);
840 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
843 if ($camelcase_cache ne "" && -f $camelcase_cache) {
844 open(my $camelcase_file, '<', "$camelcase_cache")
845 or warn "$P: Can't read '$camelcase_cache' $!\n";
846 while (<$camelcase_file>) {
850 close($camelcase_file);
856 $files = `git ls-files "include/*.h"`;
857 @include_files = split('\n', $files);
860 foreach my $file (@include_files) {
861 seed_camelcase_file($file);
864 if ($camelcase_cache ne "") {
865 unlink glob ".checkpatch-camelcase.*";
866 open(my $camelcase_file, '>', "$camelcase_cache")
867 or warn "$P: Can't write '$camelcase_cache' $!\n";
868 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
869 print $camelcase_file ("$_\n");
871 close($camelcase_file);
875 sub git_commit_info {
876 my ($commit, $id, $desc) = @_;
878 return ($id, $desc) if ((which("git") eq "") || !(-e ".git"));
880 my $output = `git log --no-color --format='%H %s' -1 $commit 2>&1`;
881 $output =~ s/^\s*//gm;
882 my @lines = split("\n", $output);
884 return ($id, $desc) if ($#lines < 0);
886 if ($lines[0] =~ /^error: short SHA1 $commit is ambiguous\./) {
887 # Maybe one day convert this block of bash into something that returns
888 # all matching commit ids, but it's very slow...
890 # echo "checking commits $1..."
891 # git rev-list --remotes | grep -i "^$1" |
892 # while read line ; do
893 # git log --format='%H %s' -1 $line |
894 # echo "commit $(cut -c 1-12,41-)"
896 } elsif ($lines[0] =~ /^fatal: ambiguous argument '$commit': unknown revision or path not in the working tree\./) {
899 $id = substr($lines[0], 0, 12);
900 $desc = substr($lines[0], 41);
906 $chk_signoff = 0 if ($file);
911 my @fixed_inserted = ();
912 my @fixed_deleted = ();
915 # If input is git commits, extract all commits from the commit expressions.
916 # For example, HEAD-3 means we need check 'HEAD, HEAD~1, HEAD~2'.
917 die "$P: No git repository found\n" if ($git && !-e ".git");
921 foreach my $commit_expr (@ARGV) {
923 if ($commit_expr =~ m/^(.*)-(\d+)$/) {
924 $git_range = "-$2 $1";
925 } elsif ($commit_expr =~ m/\.\./) {
926 $git_range = "$commit_expr";
928 $git_range = "-1 $commit_expr";
930 my $lines = `git log --no-color --no-merges --pretty=format:'%H %s' $git_range`;
931 foreach my $line (split(/\n/, $lines)) {
932 $line =~ /^([0-9a-fA-F]{40,40}) (.*)$/;
933 next if (!defined($1) || !defined($2));
936 unshift(@commits, $sha1);
937 $git_commits{$sha1} = $subject;
940 die "$P: no git commits after extraction!\n" if (@commits == 0);
945 for my $filename (@ARGV) {
948 open($FILE, '-|', "git format-patch -M --stdout -1 $filename") ||
949 die "$P: $filename: git format-patch failed - $!\n";
951 open($FILE, '-|', "diff -u /dev/null $filename") ||
952 die "$P: $filename: diff failed - $!\n";
953 } elsif ($filename eq '-') {
954 open($FILE, '<&STDIN');
956 open($FILE, '<', "$filename") ||
957 die "$P: $filename: open failed - $!\n";
959 if ($filename eq '-') {
960 $vname = 'Your patch';
962 $vname = "Commit " . substr($filename, 0, 12) . ' ("' . $git_commits{$filename} . '")';
972 if ($#ARGV > 0 && $quiet == 0) {
973 print '-' x length($vname) . "\n";
975 print '-' x length($vname) . "\n";
978 if (!process($filename)) {
984 @fixed_inserted = ();
987 @modifierListFile = ();
993 hash_show_words(\%use_type, "Used");
994 hash_show_words(\%ignore_type, "Ignored");
999 NOTE: perl $^V is not modern enough to detect all possible issues.
1000 An upgrade to at least perl v5.10.0 is suggested.
1006 NOTE: If any of the errors are false positives, please report
1007 them to the maintainer, see CHECKPATCH in MAINTAINERS.
1014 sub top_of_kernel_tree {
1018 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
1019 "README", "Documentation", "arch", "include", "drivers",
1020 "fs", "init", "ipc", "kernel", "lib", "scripts",
1023 foreach my $check (@tree_check) {
1024 if (! -e $root . '/' . $check) {
1032 my ($formatted_email) = @_;
1038 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
1041 $comment = $3 if defined $3;
1042 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
1044 $comment = $2 if defined $2;
1045 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
1047 $comment = $2 if defined $2;
1048 $formatted_email =~ s/$address.*$//;
1049 $name = $formatted_email;
1050 $name = trim($name);
1051 $name =~ s/^\"|\"$//g;
1052 # If there's a name left after stripping spaces and
1053 # leading quotes, and the address doesn't have both
1054 # leading and trailing angle brackets, the address
1056 # "joe smith joe@smith.com" bad
1057 # "joe smith <joe@smith.com" bad
1058 if ($name ne "" && $address !~ /^<[^>]+>$/) {
1065 $name = trim($name);
1066 $name =~ s/^\"|\"$//g;
1067 $address = trim($address);
1068 $address =~ s/^\<|\>$//g;
1070 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1071 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1072 $name = "\"$name\"";
1075 return ($name, $address, $comment);
1079 my ($name, $address) = @_;
1081 my $formatted_email;
1083 $name = trim($name);
1084 $name =~ s/^\"|\"$//g;
1085 $address = trim($address);
1087 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
1088 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
1089 $name = "\"$name\"";
1092 if ("$name" eq "") {
1093 $formatted_email = "$address";
1095 $formatted_email = "$name <$address>";
1098 return $formatted_email;
1104 foreach my $path (split(/:/, $ENV{PATH})) {
1105 if (-e "$path/$bin") {
1106 return "$path/$bin";
1116 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
1117 if (-e "$path/$conf") {
1118 return "$path/$conf";
1130 for my $c (split(//, $str)) {
1134 for (; ($n % 8) != 0; $n++) {
1146 (my $res = shift) =~ tr/\t/ /c;
1153 # Drop the diff line leader and expand tabs
1155 $line = expand_tabs($line);
1157 # Pick the indent from the front of the line.
1158 my ($white) = ($line =~ /^(\s*)/);
1160 return (length($line), length($white));
1163 my $sanitise_quote = '';
1165 sub sanitise_line_reset {
1166 my ($in_comment) = @_;
1169 $sanitise_quote = '*/';
1171 $sanitise_quote = '';
1184 # Always copy over the diff marker.
1185 $res = substr($line, 0, 1);
1187 for ($off = 1; $off < length($line); $off++) {
1188 $c = substr($line, $off, 1);
1190 # Comments we are wacking completly including the begin
1191 # and end, all to $;.
1192 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
1193 $sanitise_quote = '*/';
1195 substr($res, $off, 2, "$;$;");
1199 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
1200 $sanitise_quote = '';
1201 substr($res, $off, 2, "$;$;");
1205 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
1206 $sanitise_quote = '//';
1208 substr($res, $off, 2, $sanitise_quote);
1213 # A \ in a string means ignore the next character.
1214 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
1216 substr($res, $off, 2, 'XX');
1221 if ($c eq "'" || $c eq '"') {
1222 if ($sanitise_quote eq '') {
1223 $sanitise_quote = $c;
1225 substr($res, $off, 1, $c);
1227 } elsif ($sanitise_quote eq $c) {
1228 $sanitise_quote = '';
1232 #print "c<$c> SQ<$sanitise_quote>\n";
1233 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
1234 substr($res, $off, 1, $;);
1235 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
1236 substr($res, $off, 1, $;);
1237 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
1238 substr($res, $off, 1, 'X');
1240 substr($res, $off, 1, $c);
1244 if ($sanitise_quote eq '//') {
1245 $sanitise_quote = '';
1248 # The pathname on a #include may be surrounded by '<' and '>'.
1249 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
1250 my $clean = 'X' x length($1);
1251 $res =~ s@\<.*\>@<$clean>@;
1253 # The whole of a #error is a string.
1254 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
1255 my $clean = 'X' x length($1);
1256 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
1259 if ($allow_c99_comments && $res =~ m@(//.*$)@) {
1261 $res =~ s/\Q$match\E/"$;" x length($match)/e;
1267 sub get_quoted_string {
1268 my ($line, $rawline) = @_;
1270 return "" if ($line !~ m/($String)/g);
1271 return substr($rawline, $-[0], $+[0] - $-[0]);
1274 sub ctx_statement_block {
1275 my ($linenr, $remain, $off) = @_;
1276 my $line = $linenr - 1;
1279 my $coff = $off - 1;
1293 @stack = (['', 0]) if ($#stack == -1);
1295 #warn "CSB: blk<$blk> remain<$remain>\n";
1296 # If we are about to drop off the end, pull in more
1299 for (; $remain > 0; $line++) {
1300 last if (!defined $lines[$line]);
1301 next if ($lines[$line] =~ /^-/);
1304 $blk .= $lines[$line] . "\n";
1305 $len = length($blk);
1309 # Bail if there is no further context.
1310 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
1314 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
1320 $c = substr($blk, $off, 1);
1321 $remainder = substr($blk, $off);
1323 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
1325 # Handle nested #if/#else.
1326 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
1327 push(@stack, [ $type, $level ]);
1328 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
1329 ($type, $level) = @{$stack[$#stack - 1]};
1330 } elsif ($remainder =~ /^#\s*endif\b/) {
1331 ($type, $level) = @{pop(@stack)};
1334 # Statement ends at the ';' or a close '}' at the
1336 if ($level == 0 && $c eq ';') {
1340 # An else is really a conditional as long as its not else if
1341 if ($level == 0 && $coff_set == 0 &&
1342 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
1343 $remainder =~ /^(else)(?:\s|{)/ &&
1344 $remainder !~ /^else\s+if\b/) {
1345 $coff = $off + length($1) - 1;
1347 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
1348 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
1351 if (($type eq '' || $type eq '(') && $c eq '(') {
1355 if ($type eq '(' && $c eq ')') {
1357 $type = ($level != 0)? '(' : '';
1359 if ($level == 0 && $coff < $soff) {
1362 #warn "CSB: mark coff<$coff>\n";
1365 if (($type eq '' || $type eq '{') && $c eq '{') {
1369 if ($type eq '{' && $c eq '}') {
1371 $type = ($level != 0)? '{' : '';
1374 if (substr($blk, $off + 1, 1) eq ';') {
1380 # Preprocessor commands end at the newline unless escaped.
1381 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
1389 # We are truly at the end, so shuffle to the next line.
1396 my $statement = substr($blk, $soff, $off - $soff + 1);
1397 my $condition = substr($blk, $soff, $coff - $soff + 1);
1399 #warn "STATEMENT<$statement>\n";
1400 #warn "CONDITION<$condition>\n";
1402 #print "coff<$coff> soff<$off> loff<$loff>\n";
1404 return ($statement, $condition,
1405 $line, $remain + 1, $off - $loff + 1, $level);
1408 sub statement_lines {
1411 # Strip the diff line prefixes and rip blank lines at start and end.
1412 $stmt =~ s/(^|\n)./$1/g;
1416 my @stmt_lines = ($stmt =~ /\n/g);
1418 return $#stmt_lines + 2;
1421 sub statement_rawlines {
1424 my @stmt_lines = ($stmt =~ /\n/g);
1426 return $#stmt_lines + 2;
1429 sub statement_block_size {
1432 $stmt =~ s/(^|\n)./$1/g;
1438 my @stmt_lines = ($stmt =~ /\n/g);
1439 my @stmt_statements = ($stmt =~ /;/g);
1441 my $stmt_lines = $#stmt_lines + 2;
1442 my $stmt_statements = $#stmt_statements + 1;
1444 if ($stmt_lines > $stmt_statements) {
1447 return $stmt_statements;
1451 sub ctx_statement_full {
1452 my ($linenr, $remain, $off) = @_;
1453 my ($statement, $condition, $level);
1457 # Grab the first conditional/block pair.
1458 ($statement, $condition, $linenr, $remain, $off, $level) =
1459 ctx_statement_block($linenr, $remain, $off);
1460 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1461 push(@chunks, [ $condition, $statement ]);
1462 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1463 return ($level, $linenr, @chunks);
1466 # Pull in the following conditional/block pairs and see if they
1467 # could continue the statement.
1469 ($statement, $condition, $linenr, $remain, $off, $level) =
1470 ctx_statement_block($linenr, $remain, $off);
1471 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1472 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1474 push(@chunks, [ $condition, $statement ]);
1477 return ($level, $linenr, @chunks);
1481 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1483 my $start = $linenr - 1;
1490 my @stack = ($level);
1491 for ($line = $start; $remain > 0; $line++) {
1492 next if ($rawlines[$line] =~ /^-/);
1495 $blk .= $rawlines[$line];
1497 # Handle nested #if/#else.
1498 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1499 push(@stack, $level);
1500 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1501 $level = $stack[$#stack - 1];
1502 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1503 $level = pop(@stack);
1506 foreach my $c (split(//, $lines[$line])) {
1507 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1513 if ($c eq $close && $level > 0) {
1515 last if ($level == 0);
1516 } elsif ($c eq $open) {
1521 if (!$outer || $level <= 1) {
1522 push(@res, $rawlines[$line]);
1525 last if ($level == 0);
1528 return ($level, @res);
1530 sub ctx_block_outer {
1531 my ($linenr, $remain) = @_;
1533 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1537 my ($linenr, $remain) = @_;
1539 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1543 my ($linenr, $remain, $off) = @_;
1545 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1548 sub ctx_block_level {
1549 my ($linenr, $remain) = @_;
1551 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1553 sub ctx_statement_level {
1554 my ($linenr, $remain, $off) = @_;
1556 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1559 sub ctx_locate_comment {
1560 my ($first_line, $end_line) = @_;
1562 # Catch a comment on the end of the line itself.
1563 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1564 return $current_comment if (defined $current_comment);
1566 # Look through the context and try and figure out if there is a
1569 $current_comment = '';
1570 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1571 my $line = $rawlines[$linenr - 1];
1573 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1576 if ($line =~ m@/\*@) {
1579 if (!$in_comment && $current_comment ne '') {
1580 $current_comment = '';
1582 $current_comment .= $line . "\n" if ($in_comment);
1583 if ($line =~ m@\*/@) {
1588 chomp($current_comment);
1589 return($current_comment);
1591 sub ctx_has_comment {
1592 my ($first_line, $end_line) = @_;
1593 my $cmt = ctx_locate_comment($first_line, $end_line);
1595 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1596 ##print "CMMT: $cmt\n";
1598 return ($cmt ne '');
1602 my ($linenr, $cnt) = @_;
1604 my $offset = $linenr - 1;
1609 $line = $rawlines[$offset++];
1610 next if (defined($line) && $line =~ /^-/);
1622 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1625 $coded = sprintf("^%c", unpack('C', $2) + 64);
1634 my $av_preprocessor = 0;
1639 sub annotate_reset {
1640 $av_preprocessor = 0;
1642 @av_paren_type = ('E');
1643 $av_pend_colon = 'O';
1646 sub annotate_values {
1647 my ($stream, $type) = @_;
1650 my $var = '_' x length($stream);
1653 print "$stream\n" if ($dbg_values > 1);
1655 while (length($cur)) {
1656 @av_paren_type = ('E') if ($#av_paren_type < 0);
1657 print " <" . join('', @av_paren_type) .
1658 "> <$type> <$av_pending>" if ($dbg_values > 1);
1659 if ($cur =~ /^(\s+)/o) {
1660 print "WS($1)\n" if ($dbg_values > 1);
1661 if ($1 =~ /\n/ && $av_preprocessor) {
1662 $type = pop(@av_paren_type);
1663 $av_preprocessor = 0;
1666 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1667 print "CAST($1)\n" if ($dbg_values > 1);
1668 push(@av_paren_type, $type);
1671 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1672 print "DECLARE($1)\n" if ($dbg_values > 1);
1675 } elsif ($cur =~ /^($Modifier)\s*/) {
1676 print "MODIFIER($1)\n" if ($dbg_values > 1);
1679 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1680 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1681 $av_preprocessor = 1;
1682 push(@av_paren_type, $type);
1688 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1689 print "UNDEF($1)\n" if ($dbg_values > 1);
1690 $av_preprocessor = 1;
1691 push(@av_paren_type, $type);
1693 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1694 print "PRE_START($1)\n" if ($dbg_values > 1);
1695 $av_preprocessor = 1;
1697 push(@av_paren_type, $type);
1698 push(@av_paren_type, $type);
1701 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1702 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1703 $av_preprocessor = 1;
1705 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1709 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1710 print "PRE_END($1)\n" if ($dbg_values > 1);
1712 $av_preprocessor = 1;
1714 # Assume all arms of the conditional end as this
1715 # one does, and continue as if the #endif was not here.
1716 pop(@av_paren_type);
1717 push(@av_paren_type, $type);
1720 } elsif ($cur =~ /^(\\\n)/o) {
1721 print "PRECONT($1)\n" if ($dbg_values > 1);
1723 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1724 print "ATTR($1)\n" if ($dbg_values > 1);
1725 $av_pending = $type;
1728 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1729 print "SIZEOF($1)\n" if ($dbg_values > 1);
1735 } elsif ($cur =~ /^(if|while|for)\b/o) {
1736 print "COND($1)\n" if ($dbg_values > 1);
1740 } elsif ($cur =~/^(case)/o) {
1741 print "CASE($1)\n" if ($dbg_values > 1);
1742 $av_pend_colon = 'C';
1745 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1746 print "KEYWORD($1)\n" if ($dbg_values > 1);
1749 } elsif ($cur =~ /^(\()/o) {
1750 print "PAREN('$1')\n" if ($dbg_values > 1);
1751 push(@av_paren_type, $av_pending);
1755 } elsif ($cur =~ /^(\))/o) {
1756 my $new_type = pop(@av_paren_type);
1757 if ($new_type ne '_') {
1759 print "PAREN('$1') -> $type\n"
1760 if ($dbg_values > 1);
1762 print "PAREN('$1')\n" if ($dbg_values > 1);
1765 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1766 print "FUNC($1)\n" if ($dbg_values > 1);
1770 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1771 if (defined $2 && $type eq 'C' || $type eq 'T') {
1772 $av_pend_colon = 'B';
1773 } elsif ($type eq 'E') {
1774 $av_pend_colon = 'L';
1776 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1779 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1780 print "IDENT($1)\n" if ($dbg_values > 1);
1783 } elsif ($cur =~ /^($Assignment)/o) {
1784 print "ASSIGN($1)\n" if ($dbg_values > 1);
1787 } elsif ($cur =~/^(;|{|})/) {
1788 print "END($1)\n" if ($dbg_values > 1);
1790 $av_pend_colon = 'O';
1792 } elsif ($cur =~/^(,)/) {
1793 print "COMMA($1)\n" if ($dbg_values > 1);
1796 } elsif ($cur =~ /^(\?)/o) {
1797 print "QUESTION($1)\n" if ($dbg_values > 1);
1800 } elsif ($cur =~ /^(:)/o) {
1801 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1803 substr($var, length($res), 1, $av_pend_colon);
1804 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1809 $av_pend_colon = 'O';
1811 } elsif ($cur =~ /^(\[)/o) {
1812 print "CLOSE($1)\n" if ($dbg_values > 1);
1815 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1818 print "OPV($1)\n" if ($dbg_values > 1);
1825 substr($var, length($res), 1, $variant);
1828 } elsif ($cur =~ /^($Operators)/o) {
1829 print "OP($1)\n" if ($dbg_values > 1);
1830 if ($1 ne '++' && $1 ne '--') {
1834 } elsif ($cur =~ /(^.)/o) {
1835 print "C($1)\n" if ($dbg_values > 1);
1838 $cur = substr($cur, length($1));
1839 $res .= $type x length($1);
1843 return ($res, $var);
1847 my ($possible, $line) = @_;
1848 my $notPermitted = qr{(?:
1865 ^(?:typedef|struct|enum)\b
1867 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1868 if ($possible !~ $notPermitted) {
1869 # Check for modifiers.
1870 $possible =~ s/\s*$Storage\s*//g;
1871 $possible =~ s/\s*$Sparse\s*//g;
1872 if ($possible =~ /^\s*$/) {
1874 } elsif ($possible =~ /\s/) {
1875 $possible =~ s/\s*$Type\s*//g;
1876 for my $modifier (split(' ', $possible)) {
1877 if ($modifier !~ $notPermitted) {
1878 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1879 push(@modifierListFile, $modifier);
1884 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1885 push(@typeListFile, $possible);
1889 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1898 $type =~ tr/[a-z]/[A-Z]/;
1900 return defined $use_type{$type} if (scalar keys %use_type > 0);
1902 return !defined $ignore_type{$type};
1906 my ($level, $type, $msg) = @_;
1908 if (!show_type($type) ||
1909 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1914 if ($level eq 'ERROR') {
1916 } elsif ($level eq 'WARNING') {
1922 $output .= $prefix . $level . ':';
1924 $output .= BLUE if ($color);
1925 $output .= "$type:";
1927 $output .= RESET if ($color);
1928 $output .= ' ' . $msg . "\n";
1931 my @lines = split("\n", $output, -1);
1932 splice(@lines, 1, 1);
1933 $output = join("\n", @lines);
1935 $output = (split('\n', $output))[0] . "\n" if ($terse);
1937 push(our @report, $output);
1946 sub fixup_current_range {
1947 my ($lineRef, $offset, $length) = @_;
1949 if ($$lineRef =~ /^\@\@ -\d+,\d+ \+(\d+),(\d+) \@\@/) {
1952 my $no = $o + $offset;
1953 my $nl = $l + $length;
1954 $$lineRef =~ s/\+$o,$l \@\@/\+$no,$nl \@\@/;
1958 sub fix_inserted_deleted_lines {
1959 my ($linesRef, $insertedRef, $deletedRef) = @_;
1961 my $range_last_linenr = 0;
1962 my $delta_offset = 0;
1967 my $next_insert = 0;
1968 my $next_delete = 0;
1972 my $inserted = @{$insertedRef}[$next_insert++];
1973 my $deleted = @{$deletedRef}[$next_delete++];
1975 foreach my $old_line (@{$linesRef}) {
1977 my $line = $old_line; #don't modify the array
1978 if ($line =~ /^(?:\+\+\+|\-\-\-)\s+\S+/) { #new filename
1980 } elsif ($line =~ /^\@\@ -\d+,\d+ \+\d+,\d+ \@\@/) { #new hunk
1981 $range_last_linenr = $new_linenr;
1982 fixup_current_range(\$line, $delta_offset, 0);
1985 while (defined($deleted) && ${$deleted}{'LINENR'} == $old_linenr) {
1986 $deleted = @{$deletedRef}[$next_delete++];
1988 fixup_current_range(\$lines[$range_last_linenr], $delta_offset--, -1);
1991 while (defined($inserted) && ${$inserted}{'LINENR'} == $old_linenr) {
1992 push(@lines, ${$inserted}{'LINE'});
1993 $inserted = @{$insertedRef}[$next_insert++];
1995 fixup_current_range(\$lines[$range_last_linenr], $delta_offset++, 1);
1999 push(@lines, $line);
2009 sub fix_insert_line {
2010 my ($linenr, $line) = @_;
2016 push(@fixed_inserted, $inserted);
2019 sub fix_delete_line {
2020 my ($linenr, $line) = @_;
2027 push(@fixed_deleted, $deleted);
2031 my ($type, $msg) = @_;
2033 if (report("ERROR", $type, $msg)) {
2041 my ($type, $msg) = @_;
2043 if (report("WARNING", $type, $msg)) {
2051 my ($type, $msg) = @_;
2053 if ($check && report("CHECK", $type, $msg)) {
2061 sub check_absolute_file {
2062 my ($absolute, $herecurr) = @_;
2063 my $file = $absolute;
2065 ##print "absolute<$absolute>\n";
2067 # See if any suffix of this path is a path within the tree.
2068 while ($file =~ s@^[^/]*/@@) {
2069 if (-f "$root/$file") {
2070 ##print "file<$file>\n";
2078 # It is, so see if the prefix is acceptable.
2079 my $prefix = $absolute;
2080 substr($prefix, -length($file)) = '';
2082 ##print "prefix<$prefix>\n";
2083 if ($prefix ne ".../") {
2084 WARN("USE_RELATIVE_PATH",
2085 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
2092 $string =~ s/^\s+|\s+$//g;
2100 $string =~ s/^\s+//;
2108 $string =~ s/\s+$//;
2113 sub string_find_replace {
2114 my ($string, $find, $replace) = @_;
2116 $string =~ s/$find/$replace/g;
2124 my $source_indent = 8;
2125 my $max_spaces_before_tab = $source_indent - 1;
2126 my $spaces_to_tab = " " x $source_indent;
2128 #convert leading spaces to tabs
2129 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
2130 #Remove spaces before a tab
2131 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
2136 sub pos_last_openparen {
2141 my $opens = $line =~ tr/\(/\(/;
2142 my $closes = $line =~ tr/\)/\)/;
2144 my $last_openparen = 0;
2146 if (($opens == 0) || ($closes >= $opens)) {
2150 my $len = length($line);
2152 for ($pos = 0; $pos < $len; $pos++) {
2153 my $string = substr($line, $pos);
2154 if ($string =~ /^($FuncArg|$balanced_parens)/) {
2155 $pos += length($1) - 1;
2156 } elsif (substr($line, $pos, 1) eq '(') {
2157 $last_openparen = $pos;
2158 } elsif (index($string, '(') == -1) {
2163 return length(expand_tabs(substr($line, 0, $last_openparen))) + 1;
2167 my $filename = shift;
2173 my $stashrawline="";
2183 my $in_header_lines = $file ? 0 : 1;
2184 my $in_commit_log = 0; #Scanning lines before patch
2185 my $has_commit_log = 0; #Encountered lines before patch
2186 my $commit_log_possible_stack_dump = 0;
2187 my $commit_log_long_line = 0;
2188 my $commit_log_has_diff = 0;
2189 my $reported_maintainer_file = 0;
2190 my $non_utf8_charset = 0;
2192 my $last_blank_line = 0;
2193 my $last_coalesced_string_linenr = -1;
2201 # Trace the real file/line as we go.
2206 my $context_function; #undef'd unless there's a known function
2208 my $comment_edge = 0;
2212 my $prev_values = 'E';
2215 my %suppress_ifbraces;
2216 my %suppress_whiletrailers;
2217 my %suppress_export;
2218 my $suppress_statement = 0;
2220 my %signatures = ();
2222 # Pre-scan the patch sanitizing the lines.
2223 # Pre-scan the patch looking for any __setup documentation.
2225 my @setup_docs = ();
2228 my $camelcase_file_seeded = 0;
2230 sanitise_line_reset();
2232 foreach my $rawline (@rawlines) {
2236 push(@fixed, $rawline) if ($fix);
2238 if ($rawline=~/^\+\+\+\s+(\S+)/) {
2240 if ($1 =~ m@Documentation/admin-guide/kernel-parameters.rst$@) {
2245 if ($rawline =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
2254 # Guestimate if this is a continuing comment. Run
2255 # the context looking for a comment "edge". If this
2256 # edge is a close comment then we must be in a comment
2260 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
2261 next if (defined $rawlines[$ln - 1] &&
2262 $rawlines[$ln - 1] =~ /^-/);
2264 #print "RAW<$rawlines[$ln - 1]>\n";
2265 last if (!defined $rawlines[$ln - 1]);
2266 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
2267 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
2272 if (defined $edge && $edge eq '*/') {
2276 # Guestimate if this is a continuing comment. If this
2277 # is the start of a diff block and this line starts
2278 # ' *' then it is very likely a comment.
2279 if (!defined $edge &&
2280 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
2285 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
2286 sanitise_line_reset($in_comment);
2288 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
2289 # Standardise the strings and chars within the input to
2290 # simplify matching -- only bother with positive lines.
2291 $line = sanitise_line($rawline);
2293 push(@lines, $line);
2296 $realcnt-- if ($line =~ /^(?:\+| |$)/);
2301 #print "==>$rawline\n";
2302 #print "-->$line\n";
2304 if ($setup_docs && $line =~ /^\+/) {
2305 push(@setup_docs, $line);
2314 foreach my $line (@lines) {
2317 my $sline = $line; #copy of $line
2318 $sline =~ s/$;/ /g; #with comments as spaces
2320 my $rawline = $rawlines[$linenr - 1];
2322 #extract the line range in the file after the patch is applied
2323 if (!$in_commit_log &&
2324 $line =~ /^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@(.*)/) {
2327 $first_line = $linenr + 1;
2337 %suppress_ifbraces = ();
2338 %suppress_whiletrailers = ();
2339 %suppress_export = ();
2340 $suppress_statement = 0;
2341 if ($context =~ /\b(\w+)\s*\(/) {
2342 $context_function = $1;
2344 undef $context_function;
2348 # track the line number as we move through the hunk, note that
2349 # new versions of GNU diff omit the leading space on completely
2350 # blank context lines so we need to count that too.
2351 } elsif ($line =~ /^( |\+|$)/) {
2353 $realcnt-- if ($realcnt != 0);
2355 # Measure the line length and indent.
2356 ($length, $indent) = line_stats($rawline);
2358 # Track the previous line.
2359 ($prevline, $stashline) = ($stashline, $line);
2360 ($previndent, $stashindent) = ($stashindent, $indent);
2361 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
2363 #warn "line<$line>\n";
2365 } elsif ($realcnt == 1) {
2369 my $hunk_line = ($realcnt != 0);
2371 $here = "#$linenr: " if (!$file);
2372 $here = "#$realline: " if ($file);
2375 # extract the filename as it passes
2376 if ($line =~ /^diff --git.*?(\S+)$/) {
2378 $realfile =~ s@^([^/]*)/@@ if (!$file);
2381 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
2383 $realfile =~ s@^([^/]*)/@@ if (!$file);
2387 if (!$file && $tree && $p1_prefix ne '' &&
2388 -e "$root/$p1_prefix") {
2389 WARN("PATCH_PREFIX",
2390 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
2393 if ($realfile =~ m@^include/asm/@) {
2394 ERROR("MODIFIED_INCLUDE_ASM",
2395 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
2400 #make up the handle for any error we report on this line
2402 $prefix = "$realfile:$realline: "
2405 $prefix = "$filename:$realline: ";
2407 $prefix = "$filename:$linenr: ";
2412 if (is_maintained_obsolete($realfile)) {
2414 "$realfile is marked as 'obsolete' in the MAINTAINERS hierarchy. No unnecessary modifications please.\n");
2416 if ($realfile =~ m@^(?:drivers/net/|net/|drivers/staging/)@) {
2419 $check = $check_orig;
2424 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
2426 my $hereline = "$here\n$rawline\n";
2427 my $herecurr = "$here\n$rawline\n";
2428 my $hereprev = "$here\n$prevrawline\n$rawline\n";
2430 $cnt_lines++ if ($realcnt != 0);
2432 # Check if the commit log has what seems like a diff which can confuse patch
2433 if ($in_commit_log && !$commit_log_has_diff &&
2434 (($line =~ m@^\s+diff\b.*a/[\w/]+@ &&
2435 $line =~ m@^\s+diff\b.*a/([\w/]+)\s+b/$1\b@) ||
2436 $line =~ m@^\s*(?:\-\-\-\s+a/|\+\+\+\s+b/)@ ||
2437 $line =~ m/^\s*\@\@ \-\d+,\d+ \+\d+,\d+ \@\@/)) {
2438 ERROR("DIFF_IN_COMMIT_MSG",
2439 "Avoid using diff content in the commit message - patch(1) might not work\n" . $herecurr);
2440 $commit_log_has_diff = 1;
2443 # Check for incorrect file permissions
2444 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
2445 my $permhere = $here . "FILE: $realfile\n";
2446 if ($realfile !~ m@scripts/@ &&
2447 $realfile !~ /\.(py|pl|awk|sh)$/) {
2448 ERROR("EXECUTE_PERMISSIONS",
2449 "do not set execute permissions for source files\n" . $permhere);
2453 # Check the patch for a signoff:
2454 if ($line =~ /^\s*signed-off-by:/i) {
2459 # Check if MAINTAINERS is being updated. If so, there's probably no need to
2460 # emit the "does MAINTAINERS need updating?" message on file add/move/delete
2461 if ($line =~ /^\s*MAINTAINERS\s*\|/) {
2462 $reported_maintainer_file = 1;
2465 # Check signature styles
2466 if (!$in_header_lines &&
2467 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
2468 my $space_before = $1;
2470 my $space_after = $3;
2472 my $ucfirst_sign_off = ucfirst(lc($sign_off));
2474 if ($sign_off !~ /$signature_tags/) {
2475 WARN("BAD_SIGN_OFF",
2476 "Non-standard signature: $sign_off\n" . $herecurr);
2478 if (defined $space_before && $space_before ne "") {
2479 if (WARN("BAD_SIGN_OFF",
2480 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
2482 $fixed[$fixlinenr] =
2483 "$ucfirst_sign_off $email";
2486 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
2487 if (WARN("BAD_SIGN_OFF",
2488 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
2490 $fixed[$fixlinenr] =
2491 "$ucfirst_sign_off $email";
2495 if (!defined $space_after || $space_after ne " ") {
2496 if (WARN("BAD_SIGN_OFF",
2497 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
2499 $fixed[$fixlinenr] =
2500 "$ucfirst_sign_off $email";
2504 my ($email_name, $email_address, $comment) = parse_email($email);
2505 my $suggested_email = format_email(($email_name, $email_address));
2506 if ($suggested_email eq "") {
2507 ERROR("BAD_SIGN_OFF",
2508 "Unrecognized email address: '$email'\n" . $herecurr);
2510 my $dequoted = $suggested_email;
2511 $dequoted =~ s/^"//;
2512 $dequoted =~ s/" </ </;
2513 # Don't force email to have quotes
2514 # Allow just an angle bracketed address
2515 if ("$dequoted$comment" ne $email &&
2516 "<$email_address>$comment" ne $email &&
2517 "$suggested_email$comment" ne $email) {
2518 WARN("BAD_SIGN_OFF",
2519 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
2523 # Check for duplicate signatures
2524 my $sig_nospace = $line;
2525 $sig_nospace =~ s/\s//g;
2526 $sig_nospace = lc($sig_nospace);
2527 if (defined $signatures{$sig_nospace}) {
2528 WARN("BAD_SIGN_OFF",
2529 "Duplicate signature\n" . $herecurr);
2531 $signatures{$sig_nospace} = 1;
2535 # Check email subject for common tools that don't need to be mentioned
2536 if ($in_header_lines &&
2537 $line =~ /^Subject:.*\b(?:checkpatch|sparse|smatch)\b[^:]/i) {
2538 WARN("EMAIL_SUBJECT",
2539 "A patch subject line should describe the change not the tool that found it\n" . $herecurr);
2542 # Check for old stable address
2543 if ($line =~ /^\s*cc:\s*.*<?\bstable\@kernel\.org\b>?.*$/i) {
2544 ERROR("STABLE_ADDRESS",
2545 "The 'stable' address should be 'stable\@vger.kernel.org'\n" . $herecurr);
2548 # Check for unwanted Gerrit info
2549 if ($in_commit_log && $line =~ /^\s*change-id:/i) {
2550 ERROR("GERRIT_CHANGE_ID",
2551 "Remove Gerrit Change-Id's before submitting upstream.\n" . $herecurr);
2554 # Check if the commit log is in a possible stack dump
2555 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2556 ($line =~ /^\s*(?:WARNING:|BUG:)/ ||
2557 $line =~ /^\s*\[\s*\d+\.\d{6,6}\s*\]/ ||
2559 $line =~ /^\s*\[\<[0-9a-fA-F]{8,}\>\]/)) {
2560 # stack dump address
2561 $commit_log_possible_stack_dump = 1;
2564 # Check for line lengths > 75 in commit log, warn once
2565 if ($in_commit_log && !$commit_log_long_line &&
2566 length($line) > 75 &&
2567 !($line =~ /^\s*[a-zA-Z0-9_\/\.]+\s+\|\s+\d+/ ||
2568 # file delta changes
2569 $line =~ /^\s*(?:[\w\.\-]+\/)++[\w\.\-]+:/ ||
2571 $line =~ /^\s*(?:Fixes:|Link:)/i ||
2572 # A Fixes: or Link: line
2573 $commit_log_possible_stack_dump)) {
2574 WARN("COMMIT_LOG_LONG_LINE",
2575 "Possible unwrapped commit description (prefer a maximum 75 chars per line)\n" . $herecurr);
2576 $commit_log_long_line = 1;
2579 # Reset possible stack dump if a blank line is found
2580 if ($in_commit_log && $commit_log_possible_stack_dump &&
2582 $commit_log_possible_stack_dump = 0;
2585 # Check for git id commit length and improperly formed commit descriptions
2586 if ($in_commit_log && !$commit_log_possible_stack_dump &&
2587 $line !~ /^\s*(?:Link|Patchwork|http|https|BugLink):/i &&
2588 $line !~ /^This reverts commit [0-9a-f]{7,40}/ &&
2589 ($line =~ /\bcommit\s+[0-9a-f]{5,}\b/i ||
2590 ($line =~ /(?:\s|^)[0-9a-f]{12,40}(?:[\s"'\(\[]|$)/i &&
2591 $line !~ /[\<\[][0-9a-f]{12,40}[\>\]]/i &&
2592 $line !~ /\bfixes:\s*[0-9a-f]{12,40}/i))) {
2593 my $init_char = "c";
2594 my $orig_commit = "";
2601 my $id = '0123456789ab';
2602 my $orig_desc = "commit description";
2603 my $description = "";
2605 if ($line =~ /\b(c)ommit\s+([0-9a-f]{5,})\b/i) {
2607 $orig_commit = lc($2);
2608 } elsif ($line =~ /\b([0-9a-f]{12,40})\b/i) {
2609 $orig_commit = lc($1);
2612 $short = 0 if ($line =~ /\bcommit\s+[0-9a-f]{12,40}/i);
2613 $long = 1 if ($line =~ /\bcommit\s+[0-9a-f]{41,}/i);
2614 $space = 0 if ($line =~ /\bcommit [0-9a-f]/i);
2615 $case = 0 if ($line =~ /\b[Cc]ommit\s+[0-9a-f]{5,40}[^A-F]/);
2616 if ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)"\)/i) {
2619 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s*$/i &&
2620 defined $rawlines[$linenr] &&
2621 $rawlines[$linenr] =~ /^\s*\("([^"]+)"\)/) {
2624 } elsif ($line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("[^"]+$/i &&
2625 defined $rawlines[$linenr] &&
2626 $rawlines[$linenr] =~ /^\s*[^"]+"\)/) {
2627 $line =~ /\bcommit\s+[0-9a-f]{5,}\s+\("([^"]+)$/i;
2629 $rawlines[$linenr] =~ /^\s*([^"]+)"\)/;
2630 $orig_desc .= " " . $1;
2634 ($id, $description) = git_commit_info($orig_commit,
2638 ($short || $long || $space || $case || ($orig_desc ne $description) || !$hasparens)) {
2639 ERROR("GIT_COMMIT_ID",
2640 "Please use git commit description style 'commit <12+ chars of sha1> (\"<title line>\")' - ie: '${init_char}ommit $id (\"$description\")'\n" . $herecurr);
2644 # Check for added, moved or deleted files
2645 if (!$reported_maintainer_file && !$in_commit_log &&
2646 ($line =~ /^(?:new|deleted) file mode\s*\d+\s*$/ ||
2647 $line =~ /^rename (?:from|to) [\w\/\.\-]+\s*$/ ||
2648 ($line =~ /\{\s*([\w\/\.\-]*)\s*\=\>\s*([\w\/\.\-]*)\s*\}/ &&
2649 (defined($1) || defined($2))))) {
2651 $reported_maintainer_file = 1;
2652 WARN("FILE_PATH_CHANGES",
2653 "added, moved or deleted file(s), does MAINTAINERS need updating?\n" . $herecurr);
2656 # Check for wrappage within a valid hunk of the file
2657 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
2658 ERROR("CORRUPTED_PATCH",
2659 "patch seems to be corrupt (line wrapped?)\n" .
2660 $herecurr) if (!$emitted_corrupt++);
2663 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
2664 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
2665 $rawline !~ m/^$UTF8*$/) {
2666 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
2668 my $blank = copy_spacing($rawline);
2669 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
2670 my $hereptr = "$hereline$ptr\n";
2673 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
2676 # Check if it's the start of a commit log
2677 # (not a header line and we haven't seen the patch filename)
2678 if ($in_header_lines && $realfile =~ /^$/ &&
2679 !($rawline =~ /^\s+(?:\S|$)/ ||
2680 $rawline =~ /^(?:commit\b|from\b|[\w-]+:)/i)) {
2681 $in_header_lines = 0;
2683 $has_commit_log = 1;
2686 # Check if there is UTF-8 in a commit log when a mail header has explicitly
2687 # declined it, i.e defined some charset where it is missing.
2688 if ($in_header_lines &&
2689 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
2691 $non_utf8_charset = 1;
2694 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
2695 $rawline =~ /$NON_ASCII_UTF8/) {
2696 WARN("UTF8_BEFORE_PATCH",
2697 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
2700 # Check for absolute kernel paths in commit message
2701 if ($tree && $in_commit_log) {
2702 while ($line =~ m{(?:^|\s)(/\S*)}g) {
2705 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
2706 check_absolute_file($1, $herecurr)) {
2709 check_absolute_file($file, $herecurr);
2714 # Check for various typo / spelling mistakes
2715 if (defined($misspellings) &&
2716 ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
2717 while ($rawline =~ /(?:^|[^a-z@])($misspellings)(?:\b|$|[^a-z@])/gi) {
2719 my $typo_fix = $spelling_fix{lc($typo)};
2720 $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
2721 $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
2722 my $msg_type = \&WARN;
2723 $msg_type = \&CHK if ($file);
2724 if (&{$msg_type}("TYPO_SPELLING",
2725 "'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $herecurr) &&
2727 $fixed[$fixlinenr] =~ s/(^|[^A-Za-z@])($typo)($|[^A-Za-z@])/$1$typo_fix$3/;
2732 # ignore non-hunk lines and lines being removed
2733 next if (!$hunk_line || $line =~ /^-/);
2735 #trailing whitespace
2736 if ($line =~ /^\+.*\015/) {
2737 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2738 if (ERROR("DOS_LINE_ENDINGS",
2739 "DOS line endings\n" . $herevet) &&
2741 $fixed[$fixlinenr] =~ s/[\s\015]+$//;
2743 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
2744 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2745 if (ERROR("TRAILING_WHITESPACE",
2746 "trailing whitespace\n" . $herevet) &&
2748 $fixed[$fixlinenr] =~ s/\s+$//;
2754 # Check for FSF mailing addresses.
2755 if ($rawline =~ /\bwrite to the Free/i ||
2756 $rawline =~ /\b675\s+Mass\s+Ave/i ||
2757 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2758 $rawline =~ /\b51\s+Franklin\s+St/i) {
2759 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2760 my $msg_type = \&ERROR;
2761 $msg_type = \&CHK if ($file);
2762 &{$msg_type}("FSF_MAILING_ADDRESS",
2763 "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)
2766 # check for Kconfig help text having a real description
2767 # Only applies when adding the entry originally, after that we do not have
2768 # sufficient context to determine whether it is indeed long enough.
2769 if ($realfile =~ /Kconfig/ &&
2770 $line =~ /^\+\s*config\s+/) {
2773 my $ln = $linenr + 1;
2777 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2778 $f = $lines[$ln - 1];
2779 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2780 $is_end = $lines[$ln - 1] =~ /^\+/;
2782 next if ($f =~ /^-/);
2783 last if (!$file && $f =~ /^\@\@/);
2785 if ($lines[$ln - 1] =~ /^\+\s*(?:bool|tristate)\s*\"/) {
2787 } elsif ($lines[$ln - 1] =~ /^\+\s*(?:---)?help(?:---)?$/) {
2794 next if ($f =~ /^$/);
2795 if ($f =~ /^\s*config\s/) {
2801 if ($is_start && $is_end && $length < $min_conf_desc_length) {
2802 WARN("CONFIG_DESCRIPTION",
2803 "please write a paragraph that describes the config symbol fully\n" . $herecurr);
2805 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2808 # check for MAINTAINERS entries that don't have the right form
2809 if ($realfile =~ /^MAINTAINERS$/ &&
2810 $rawline =~ /^\+[A-Z]:/ &&
2811 $rawline !~ /^\+[A-Z]:\t\S/) {
2812 if (WARN("MAINTAINERS_STYLE",
2813 "MAINTAINERS entries use one tab after TYPE:\n" . $herecurr) &&
2815 $fixed[$fixlinenr] =~ s/^(\+[A-Z]):\s*/$1:\t/;
2819 # discourage the use of boolean for type definition attributes of Kconfig options
2820 if ($realfile =~ /Kconfig/ &&
2821 $line =~ /^\+\s*\bboolean\b/) {
2822 WARN("CONFIG_TYPE_BOOLEAN",
2823 "Use of boolean is deprecated, please use bool instead.\n" . $herecurr);
2826 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2827 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2830 'EXTRA_AFLAGS' => 'asflags-y',
2831 'EXTRA_CFLAGS' => 'ccflags-y',
2832 'EXTRA_CPPFLAGS' => 'cppflags-y',
2833 'EXTRA_LDFLAGS' => 'ldflags-y',
2836 WARN("DEPRECATED_VARIABLE",
2837 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2840 # check for DT compatible documentation
2841 if (defined $root &&
2842 (($realfile =~ /\.dtsi?$/ && $line =~ /^\+\s*compatible\s*=\s*\"/) ||
2843 ($realfile =~ /\.[ch]$/ && $line =~ /^\+.*\.compatible\s*=\s*\"/))) {
2845 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2847 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2848 my $vp_file = $dt_path . "vendor-prefixes.txt";
2850 foreach my $compat (@compats) {
2851 my $compat2 = $compat;
2852 $compat2 =~ s/\,[a-zA-Z0-9]*\-/\,<\.\*>\-/;
2853 my $compat3 = $compat;
2854 $compat3 =~ s/\,([a-z]*)[0-9]*\-/\,$1<\.\*>\-/;
2855 `grep -Erq "$compat|$compat2|$compat3" $dt_path`;
2857 WARN("UNDOCUMENTED_DT_STRING",
2858 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2861 next if $compat !~ /^([a-zA-Z0-9\-]+)\,/;
2863 `grep -Eq "^$vendor\\b" $vp_file`;
2865 WARN("UNDOCUMENTED_DT_STRING",
2866 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vp_file\n" . $herecurr);
2871 # check we are in a valid source file if not then ignore this hunk
2872 next if ($realfile !~ /\.(h|c|s|S|sh|dtsi|dts)$/);
2874 # line length limit (with some exclusions)
2876 # There are a few types of lines that may extend beyond $max_line_length:
2877 # logging functions like pr_info that end in a string
2878 # lines with a single string
2879 # #defines that are a single string
2881 # There are 3 different line length message types:
2882 # LONG_LINE_COMMENT a comment starts before but extends beyond $max_linelength
2883 # LONG_LINE_STRING a string starts before but extends beyond $max_line_length
2884 # LONG_LINE all other lines longer than $max_line_length
2886 # if LONG_LINE is ignored, the other 2 types are also ignored
2889 if ($line =~ /^\+/ && $length > $max_line_length) {
2890 my $msg_type = "LONG_LINE";
2892 # Check the allowed long line types first
2894 # logging functions that end in a string that starts
2895 # before $max_line_length
2896 if ($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(?:KERN_\S+\s*|[^"]*))?($String\s*(?:|,|\)\s*;)\s*)$/ &&
2897 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2900 # lines with only strings (w/ possible termination)
2901 # #defines with only strings
2902 } elsif ($line =~ /^\+\s*$String\s*(?:\s*|,|\)\s*;)\s*$/ ||
2903 $line =~ /^\+\s*#\s*define\s+\w+\s+$String$/) {
2906 # EFI_GUID is another special case
2907 } elsif ($line =~ /^\+.*\bEFI_GUID\s*\(/) {
2910 # Otherwise set the alternate message types
2912 # a comment starts before $max_line_length
2913 } elsif ($line =~ /($;[\s$;]*)$/ &&
2914 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2915 $msg_type = "LONG_LINE_COMMENT"
2917 # a quoted string starts before $max_line_length
2918 } elsif ($sline =~ /\s*($String(?:\s*(?:\\|,\s*|\)\s*;\s*))?)$/ &&
2919 length(expand_tabs(substr($line, 1, length($line) - length($1) - 1))) <= $max_line_length) {
2920 $msg_type = "LONG_LINE_STRING"
2923 if ($msg_type ne "" &&
2924 (show_type("LONG_LINE") || show_type($msg_type))) {
2926 "line over $max_line_length characters\n" . $herecurr);
2930 # check for adding lines without a newline.
2931 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2932 WARN("MISSING_EOF_NEWLINE",
2933 "adding a line without newline at end of file\n" . $herecurr);
2936 # Blackfin: use hi/lo macros
2937 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2938 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2939 my $herevet = "$here\n" . cat_vet($line) . "\n";
2941 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2943 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2944 my $herevet = "$here\n" . cat_vet($line) . "\n";
2946 "use the HI() macro, not (... >> 16)\n" . $herevet);
2950 # check we are in a valid source file C or perl if not then ignore this hunk
2951 next if ($realfile !~ /\.(h|c|pl|dtsi|dts|sh)$/);
2953 # at the beginning of a line any tabs must come first and anything
2954 # more than 8 must use tabs.
2955 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2956 $rawline =~ /^\+\s* \s*/) {
2957 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2959 if (ERROR("CODE_INDENT",
2960 "code indent should use tabs where possible\n" . $herevet) &&
2962 $fixed[$fixlinenr] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2966 # check for space before tabs.
2967 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2968 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2969 if (WARN("SPACE_BEFORE_TAB",
2970 "please, no space before tabs\n" . $herevet) &&
2972 while ($fixed[$fixlinenr] =~
2973 s/(^\+.*) {8,8}\t/$1\t\t/) {}
2974 while ($fixed[$fixlinenr] =~
2975 s/(^\+.*) +\t/$1\t/) {}
2979 # check for && or || at the start of a line
2980 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2981 CHK("LOGICAL_CONTINUATIONS",
2982 "Logical continuations should be on the previous line\n" . $hereprev);
2985 # check indentation starts on a tab stop
2986 if ($^V && $^V ge 5.10.0 &&
2987 $sline =~ /^\+\t+( +)(?:$c90_Keywords\b|\{\s*$|\}\s*(?:else\b|while\b|\s*$))/) {
2988 my $indent = length($1);
2991 "Statements should start on a tabstop\n" . $herecurr) &&
2993 $fixed[$fixlinenr] =~ s@(^\+\t+) +@$1 . "\t" x ($indent/8)@e;
2998 # check multi-line statement indentation matches previous line
2999 if ($^V && $^V ge 5.10.0 &&
3000 $prevline =~ /^\+([ \t]*)((?:$c90_Keywords(?:\s+if)\s*)|(?:$Declare\s*)?(?:$Ident|\(\s*\*\s*$Ident\s*\))\s*|(?:\*\s*)*$Lval\s*=\s*$Ident\s*)\(.*(\&\&|\|\||,)\s*$/) {
3001 $prevline =~ /^\+(\t*)(.*)$/;
3005 my $pos = pos_last_openparen($rest);
3007 $line =~ /^(\+| )([ \t]*)/;
3010 my $goodtabindent = $oldindent .
3013 my $goodspaceindent = $oldindent . " " x $pos;
3015 if ($newindent ne $goodtabindent &&
3016 $newindent ne $goodspaceindent) {
3018 if (CHK("PARENTHESIS_ALIGNMENT",
3019 "Alignment should match open parenthesis\n" . $hereprev) &&
3020 $fix && $line =~ /^\+/) {
3021 $fixed[$fixlinenr] =~
3022 s/^\+[ \t]*/\+$goodtabindent/;
3028 # check for space after cast like "(int) foo" or "(struct foo) bar"
3029 # avoid checking a few false positives:
3030 # "sizeof(<type>)" or "__alignof__(<type>)"
3031 # function pointer declarations like "(*foo)(int) = bar;"
3032 # structure definitions like "(struct foo) { 0 };"
3033 # multiline macros that define functions
3034 # known attributes or the __attribute__ keyword
3035 if ($line =~ /^\+(.*)\(\s*$Type\s*\)([ \t]++)((?![={]|\\$|$Attribute|__attribute__))/ &&
3036 (!defined($1) || $1 !~ /\b(?:sizeof|__alignof__)\s*$/)) {
3038 "No space is necessary after a cast\n" . $herecurr) &&
3040 $fixed[$fixlinenr] =~
3041 s/(\(\s*$Type\s*\))[ \t]+/$1/;
3045 # Block comment styles
3046 # Networking with an initial /*
3047 if ($realfile =~ m@^(drivers/net/|net/)@ &&
3048 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
3049 $rawline =~ /^\+[ \t]*\*/ &&
3051 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
3052 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
3055 # Block comments use * on subsequent lines
3056 if ($prevline =~ /$;[ \t]*$/ && #ends in comment