projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
checkpatch.pl: modify warning message for printk usage
[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / scripts / checkpatch.pl
1 #!/usr/bin/perl -w
2 # (c) 2001, Dave Jones. (the file handling bit)
3 # (c) 2005, Joel Schopp <jschopp@austin.ibm.com> (the ugly bit)
4 # (c) 2007,2008, Andy Whitcroft <apw@uk.ibm.com> (new conditions, test suite)
5 # (c) 2008-2010 Andy Whitcroft <apw@canonical.com>
6 # Licensed under the terms of the GNU GPL License version 2
7
8 use strict;
9 use POSIX;
10
11 my $P = $0;
12 $P =~ s@.*/@@g;
13
14 my $V = '0.32';
15
16 use Getopt::Long qw(:config no_auto_abbrev);
17
18 my $quiet = 0;
19 my $tree = 1;
20 my $chk_signoff = 1;
21 my $chk_patch = 1;
22 my $tst_only;
23 my $emacs = 0;
24 my $terse = 0;
25 my $file = 0;
26 my $check = 0;
27 my $summary = 1;
28 my $mailback = 0;
29 my $summary_file = 0;
30 my $show_types = 0;
31 my $fix = 0;
32 my $fix_inplace = 0;
33 my $root;
34 my %debug;
35 my %camelcase = ();
36 my %use_type = ();
37 my @use = ();
38 my %ignore_type = ();
39 my @ignore = ();
40 my $help = 0;
41 my $configuration_file = ".checkpatch.conf";
42 my $max_line_length = 80;
43 my $ignore_perl_version = 0;
44 my $minimum_perl_version = 5.10.0;
45
46 sub help {
47 my ($exitcode) = @_;
48
49 print << "EOM";
50 Usage: $P [OPTION]... [FILE]...
51 Version: $V
52
53 Options:
54 -q, --quiet quiet
55 --no-tree run without a kernel tree
56 --no-signoff do not check for 'Signed-off-by' line
57 --patch treat FILE as patchfile (default)
58 --emacs emacs compile window format
59 --terse one line per report
60 -f, --file treat FILE as regular source file
61 --subjective, --strict enable more subjective tests
62 --types TYPE(,TYPE2...) show only these comma separated message types
63 --ignore TYPE(,TYPE2...) ignore various comma separated message types
64 --max-line-length=n set the maximum line length, if exceeded, warn
65 --show-types show the message "types" in the output
66 --root=PATH PATH to the kernel tree root
67 --no-summary suppress the per-file summary
68 --mailback only produce a report in case of warnings/errors
69 --summary-file include the filename in summary
70 --debug KEY=[0|1] turn on/off debugging of KEY, where KEY is one of
71 'values', 'possible', 'type', and 'attr' (default
72 is all off)
73 --test-only=WORD report only warnings/errors containing WORD
74 literally
75 --fix EXPERIMENTAL - may create horrible results
76 If correctable single-line errors exist, create
77 "<inputfile>.EXPERIMENTAL-checkpatch-fixes"
78 with potential errors corrected to the preferred
79 checkpatch style
80 --fix-inplace EXPERIMENTAL - may create horrible results
81 Is the same as --fix, but overwrites the input
82 file. It's your fault if there's no backup or git
83 --ignore-perl-version override checking of perl version. expect
84 runtime errors.
85 -h, --help, --version display this help and exit
86
87 When FILE is - read standard input.
88 EOM
89
90 exit($exitcode);
91 }
92
93 my $conf = which_conf($configuration_file);
94 if (-f $conf) {
95 my @conf_args;
96 open(my $conffile, '<', "$conf")
97 or warn "$P: Can't find a readable $configuration_file file $!\n";
98
99 while (<$conffile>) {
100 my $line = $_;
101
102 $line =~ s/\s*\n?$//g;
103 $line =~ s/^\s*//g;
104 $line =~ s/\s+/ /g;
105
106 next if ($line =~ m/^\s*#/);
107 next if ($line =~ m/^\s*$/);
108
109 my @words = split(" ", $line);
110 foreach my $word (@words) {
111 last if ($word =~ m/^#/);
112 push (@conf_args, $word);
113 }
114 }
115 close($conffile);
116 unshift(@ARGV, @conf_args) if @conf_args;
117 }
118
119 GetOptions(
120 'q|quiet+' => \$quiet,
121 'tree!' => \$tree,
122 'signoff!' => \$chk_signoff,
123 'patch!' => \$chk_patch,
124 'emacs!' => \$emacs,
125 'terse!' => \$terse,
126 'f|file!' => \$file,
127 'subjective!' => \$check,
128 'strict!' => \$check,
129 'ignore=s' => \@ignore,
130 'types=s' => \@use,
131 'show-types!' => \$show_types,
132 'max-line-length=i' => \$max_line_length,
133 'root=s' => \$root,
134 'summary!' => \$summary,
135 'mailback!' => \$mailback,
136 'summary-file!' => \$summary_file,
137 'fix!' => \$fix,
138 'fix-inplace!' => \$fix_inplace,
139 'ignore-perl-version!' => \$ignore_perl_version,
140 'debug=s' => \%debug,
141 'test-only=s' => \$tst_only,
142 'h|help' => \$help,
143 'version' => \$help
144 ) or help(1);
145
146 help(0) if ($help);
147
148 $fix = 1 if ($fix_inplace);
149
150 my $exit = 0;
151
152 if ($^V && $^V lt $minimum_perl_version) {
153 printf "$P: requires at least perl version %vd\n", $minimum_perl_version;
154 if (!$ignore_perl_version) {
155 exit(1);
156 }
157 }
158
159 if ($#ARGV < 0) {
160 print "$P: no input files\n";
161 exit(1);
162 }
163
164 sub hash_save_array_words {
165 my ($hashRef, $arrayRef) = @_;
166
167 my @array = split(/,/, join(',', @$arrayRef));
168 foreach my $word (@array) {
169 $word =~ s/\s*\n?$//g;
170 $word =~ s/^\s*//g;
171 $word =~ s/\s+/ /g;
172 $word =~ tr/[a-z]/[A-Z]/;
173
174 next if ($word =~ m/^\s*#/);
175 next if ($word =~ m/^\s*$/);
176
177 $hashRef->{$word}++;
178 }
179 }
180
181 sub hash_show_words {
182 my ($hashRef, $prefix) = @_;
183
184 if ($quiet == 0 && keys %$hashRef) {
185 print "NOTE: $prefix message types:";
186 foreach my $word (sort keys %$hashRef) {
187 print " $word";
188 }
189 print "\n\n";
190 }
191 }
192
193 hash_save_array_words(\%ignore_type, \@ignore);
194 hash_save_array_words(\%use_type, \@use);
195
196 my $dbg_values = 0;
197 my $dbg_possible = 0;
198 my $dbg_type = 0;
199 my $dbg_attr = 0;
200 for my $key (keys %debug) {
201 ## no critic
202 eval "\${dbg_$key} = '$debug{$key}';";
203 die "$@" if ($@);
204 }
205
206 my $rpt_cleaners = 0;
207
208 if ($terse) {
209 $emacs = 1;
210 $quiet++;
211 }
212
213 if ($tree) {
214 if (defined $root) {
215 if (!top_of_kernel_tree($root)) {
216 die "$P: $root: --root does not point at a valid tree\n";
217 }
218 } else {
219 if (top_of_kernel_tree('.')) {
220 $root = '.';
221 } elsif ($0 =~ m@(.*)/scripts/[^/]*$@ &&
222 top_of_kernel_tree($1)) {
223 $root = $1;
224 }
225 }
226
227 if (!defined $root) {
228 print "Must be run from the top-level dir. of a kernel tree\n";
229 exit(2);
230 }
231 }
232
233 my $emitted_corrupt = 0;
234
235 our $Ident = qr{
236 [A-Za-z_][A-Za-z\d_]*
237 (?:\s*\#\#\s*[A-Za-z_][A-Za-z\d_]*)*
238 }x;
239 our $Storage = qr{extern|static|asmlinkage};
240 our $Sparse = qr{
241 __user|
242 __kernel|
243 __force|
244 __iomem|
245 __must_check|
246 __init_refok|
247 __kprobes|
248 __ref|
249 __rcu
250 }x;
251 our $InitAttributePrefix = qr{__(?:mem|cpu|dev|net_|)};
252 our $InitAttributeData = qr{$InitAttributePrefix(?:initdata\b)};
253 our $InitAttributeConst = qr{$InitAttributePrefix(?:initconst\b)};
254 our $InitAttributeInit = qr{$InitAttributePrefix(?:init\b)};
255 our $InitAttribute = qr{$InitAttributeData|$InitAttributeConst|$InitAttributeInit};
256
257 # Notes to $Attribute:
258 # We need \b after 'init' otherwise 'initconst' will cause a false positive in a check
259 our $Attribute = qr{
260 const|
261 __percpu|
262 __nocast|
263 __safe|
264 __bitwise__|
265 __packed__|
266 __packed2__|
267 __naked|
268 __maybe_unused|
269 __always_unused|
270 __noreturn|
271 __used|
272 __cold|
273 __noclone|
274 __deprecated|
275 __read_mostly|
276 __kprobes|
277 $InitAttribute|
278 ____cacheline_aligned|
279 ____cacheline_aligned_in_smp|
280 ____cacheline_internodealigned_in_smp|
281 __weak
282 }x;
283 our $Modifier;
284 our $Inline = qr{inline|__always_inline|noinline};
285 our $Member = qr{->$Ident|\.$Ident|\[[^]]*\]};
286 our $Lval = qr{$Ident(?:$Member)*};
287
288 our $Int_type = qr{(?i)llu|ull|ll|lu|ul|l|u};
289 our $Binary = qr{(?i)0b[01]+$Int_type?};
290 our $Hex = qr{(?i)0x[0-9a-f]+$Int_type?};
291 our $Int = qr{[0-9]+$Int_type?};
292 our $Octal = qr{0[0-7]+$Int_type?};
293 our $Float_hex = qr{(?i)0x[0-9a-f]+p-?[0-9]+[fl]?};
294 our $Float_dec = qr{(?i)(?:[0-9]+\.[0-9]*|[0-9]*\.[0-9]+)(?:e-?[0-9]+)?[fl]?};
295 our $Float_int = qr{(?i)[0-9]+e-?[0-9]+[fl]?};
296 our $Float = qr{$Float_hex|$Float_dec|$Float_int};
297 our $Constant = qr{$Float|$Binary|$Octal|$Hex|$Int};
298 our $Assignment = qr{\*\=|/=|%=|\+=|-=|<<=|>>=|&=|\^=|\|=|=};
299 our $Compare = qr{<=|>=|==|!=|<|(?<!-)>};
300 our $Arithmetic = qr{\+|-|\*|\/|%};
301 our $Operators = qr{
302 <=|>=|==|!=|
303 =>|->|<<|>>|<|>|!|~|
304 &&|\|\||,|\^|\+\+|--|&|\||$Arithmetic
305 }x;
306
307 our $NonptrType;
308 our $NonptrTypeWithAttr;
309 our $Type;
310 our $Declare;
311
312 our $NON_ASCII_UTF8 = qr{
313 [\xC2-\xDF][\x80-\xBF] # non-overlong 2-byte
314 | \xE0[\xA0-\xBF][\x80-\xBF] # excluding overlongs
315 | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2} # straight 3-byte
316 | \xED[\x80-\x9F][\x80-\xBF] # excluding surrogates
317 | \xF0[\x90-\xBF][\x80-\xBF]{2} # planes 1-3
318 | [\xF1-\xF3][\x80-\xBF]{3} # planes 4-15
319 | \xF4[\x80-\x8F][\x80-\xBF]{2} # plane 16
320 }x;
321
322 our $UTF8 = qr{
323 [\x09\x0A\x0D\x20-\x7E] # ASCII
324 | $NON_ASCII_UTF8
325 }x;
326
327 our $typeTypedefs = qr{(?x:
328 (?:__)?(?:u|s|be|le)(?:8|16|32|64)|
329 atomic_t
330 )};
331
332 our $logFunctions = qr{(?x:
333 printk(?:_ratelimited|_once|)|
334 (?:[a-z0-9]+_){1,2}(?:printk|emerg|alert|crit|err|warning|warn|notice|info|debug|dbg|vdbg|devel|cont|WARN)(?:_ratelimited|_once|)|
335 WARN(?:_RATELIMIT|_ONCE|)|
336 panic|
337 MODULE_[A-Z_]+|
338 seq_vprintf|seq_printf|seq_puts
339 )};
340
341 our $signature_tags = qr{(?xi:
342 Signed-off-by:|
343 Acked-by:|
344 Tested-by:|
345 Reviewed-by:|
346 Reported-by:|
347 Suggested-by:|
348 To:|
349 Cc:
350 )};
351
352 our @typeList = (
353 qr{void},
354 qr{(?:unsigned\s+)?char},
355 qr{(?:unsigned\s+)?short},
356 qr{(?:unsigned\s+)?int},
357 qr{(?:unsigned\s+)?long},
358 qr{(?:unsigned\s+)?long\s+int},
359 qr{(?:unsigned\s+)?long\s+long},
360 qr{(?:unsigned\s+)?long\s+long\s+int},
361 qr{unsigned},
362 qr{float},
363 qr{double},
364 qr{bool},
365 qr{struct\s+$Ident},
366 qr{union\s+$Ident},
367 qr{enum\s+$Ident},
368 qr{${Ident}_t},
369 qr{${Ident}_handler},
370 qr{${Ident}_handler_fn},
371 );
372 our @typeListWithAttr = (
373 @typeList,
374 qr{struct\s+$InitAttribute\s+$Ident},
375 qr{union\s+$InitAttribute\s+$Ident},
376 );
377
378 our @modifierList = (
379 qr{fastcall},
380 );
381
382 our @mode_permission_funcs = (
383 ["module_param", 3],
384 ["module_param_(?:array|named|string)", 4],
385 ["module_param_array_named", 5],
386 ["debugfs_create_(?:file|u8|u16|u32|u64|x8|x16|x32|x64|size_t|atomic_t|bool|blob|regset32|u32_array)", 2],
387 ["proc_create(?:_data|)", 2],
388 ["(?:CLASS|DEVICE|SENSOR)_ATTR", 2],
389 );
390
391 our $allowed_asm_includes = qr{(?x:
392 irq|
393 memory
394 )};
395 # memory.h: ARM has a custom one
396
397 sub build_types {
398 my $mods = "(?x: \n" . join("|\n ", @modifierList) . "\n)";
399 my $all = "(?x: \n" . join("|\n ", @typeList) . "\n)";
400 my $allWithAttr = "(?x: \n" . join("|\n ", @typeListWithAttr) . "\n)";
401 $Modifier = qr{(?:$Attribute|$Sparse|$mods)};
402 $NonptrType = qr{
403 (?:$Modifier\s+|const\s+)*
404 (?:
405 (?:typeof|__typeof__)\s*\([^\)]*\)|
406 (?:$typeTypedefs\b)|
407 (?:${all}\b)
408 )
409 (?:\s+$Modifier|\s+const)*
410 }x;
411 $NonptrTypeWithAttr = qr{
412 (?:$Modifier\s+|const\s+)*
413 (?:
414 (?:typeof|__typeof__)\s*\([^\)]*\)|
415 (?:$typeTypedefs\b)|
416 (?:${allWithAttr}\b)
417 )
418 (?:\s+$Modifier|\s+const)*
419 }x;
420 $Type = qr{
421 $NonptrType
422 (?:(?:\s|\*|\[\])+\s*const|(?:\s|\*|\[\])+|(?:\s*\[\s*\])+)?
423 (?:\s+$Inline|\s+$Modifier)*
424 }x;
425 $Declare = qr{(?:$Storage\s+)?$Type};
426 }
427 build_types();
428
429 our $Typecast = qr{\s*(\(\s*$NonptrType\s*\)){0,1}\s*};
430
431 # Using $balanced_parens, $LvalOrFunc, or $FuncArg
432 # requires at least perl version v5.10.0
433 # Any use must be runtime checked with $^V
434
435 our $balanced_parens = qr/(\((?:[^\(\)]++|(?-1))*\))/;
436 our $LvalOrFunc = qr{((?:[\&\*]\s*)?$Lval)\s*($balanced_parens{0,1})\s*};
437 our $FuncArg = qr{$Typecast{0,1}($LvalOrFunc|$Constant)};
438
439 sub deparenthesize {
440 my ($string) = @_;
441 return "" if (!defined($string));
442
443 while ($string =~ /^\s*\(.*\)\s*$/) {
444 $string =~ s@^\s*\(\s*@@;
445 $string =~ s@\s*\)\s*$@@;
446 }
447
448 $string =~ s@\s+@ @g;
449
450 return $string;
451 }
452
453 sub seed_camelcase_file {
454 my ($file) = @_;
455
456 return if (!(-f $file));
457
458 local $/;
459
460 open(my $include_file, '<', "$file")
461 or warn "$P: Can't read '$file' $!\n";
462 my $text = <$include_file>;
463 close($include_file);
464
465 my @lines = split('\n', $text);
466
467 foreach my $line (@lines) {
468 next if ($line !~ /(?:[A-Z][a-z]|[a-z][A-Z])/);
469 if ($line =~ /^[ \t]*(?:#[ \t]*define|typedef\s+$Type)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)/) {
470 $camelcase{$1} = 1;
471 } elsif ($line =~ /^\s*$Declare\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[\(\[,;]/) {
472 $camelcase{$1} = 1;
473 } elsif ($line =~ /^\s*(?:union|struct|enum)\s+(\w*(?:[A-Z][a-z]|[a-z][A-Z])\w*)\s*[;\{]/) {
474 $camelcase{$1} = 1;
475 }
476 }
477 }
478
479 my $camelcase_seeded = 0;
480 sub seed_camelcase_includes {
481 return if ($camelcase_seeded);
482
483 my $files;
484 my $camelcase_cache = "";
485 my @include_files = ();
486
487 $camelcase_seeded = 1;
488
489 if (-e ".git") {
490 my $git_last_include_commit = `git log --no-merges --pretty=format:"%h%n" -1 -- include`;
491 chomp $git_last_include_commit;
492 $camelcase_cache = ".checkpatch-camelcase.git.$git_last_include_commit";
493 } else {
494 my $last_mod_date = 0;
495 $files = `find $root/include -name "*.h"`;
496 @include_files = split('\n', $files);
497 foreach my $file (@include_files) {
498 my $date = POSIX::strftime("%Y%m%d%H%M",
499 localtime((stat $file)[9]));
500 $last_mod_date = $date if ($last_mod_date < $date);
501 }
502 $camelcase_cache = ".checkpatch-camelcase.date.$last_mod_date";
503 }
504
505 if ($camelcase_cache ne "" && -f $camelcase_cache) {
506 open(my $camelcase_file, '<', "$camelcase_cache")
507 or warn "$P: Can't read '$camelcase_cache' $!\n";
508 while (<$camelcase_file>) {
509 chomp;
510 $camelcase{$_} = 1;
511 }
512 close($camelcase_file);
513
514 return;
515 }
516
517 if (-e ".git") {
518 $files = `git ls-files "include/*.h"`;
519 @include_files = split('\n', $files);
520 }
521
522 foreach my $file (@include_files) {
523 seed_camelcase_file($file);
524 }
525
526 if ($camelcase_cache ne "") {
527 unlink glob ".checkpatch-camelcase.*";
528 open(my $camelcase_file, '>', "$camelcase_cache")
529 or warn "$P: Can't write '$camelcase_cache' $!\n";
530 foreach (sort { lc($a) cmp lc($b) } keys(%camelcase)) {
531 print $camelcase_file ("$_\n");
532 }
533 close($camelcase_file);
534 }
535 }
536
537 $chk_signoff = 0 if ($file);
538
539 my @rawlines = ();
540 my @lines = ();
541 my @fixed = ();
542 my $vname;
543 for my $filename (@ARGV) {
544 my $FILE;
545 if ($file) {
546 open($FILE, '-|', "diff -u /dev/null $filename") ||
547 die "$P: $filename: diff failed - $!\n";
548 } elsif ($filename eq '-') {
549 open($FILE, '<&STDIN');
550 } else {
551 open($FILE, '<', "$filename") ||
552 die "$P: $filename: open failed - $!\n";
553 }
554 if ($filename eq '-') {
555 $vname = 'Your patch';
556 } else {
557 $vname = $filename;
558 }
559 while (<$FILE>) {
560 chomp;
561 push(@rawlines, $_);
562 }
563 close($FILE);
564 if (!process($filename)) {
565 $exit = 1;
566 }
567 @rawlines = ();
568 @lines = ();
569 @fixed = ();
570 }
571
572 exit($exit);
573
574 sub top_of_kernel_tree {
575 my ($root) = @_;
576
577 my @tree_check = (
578 "COPYING", "CREDITS", "Kbuild", "MAINTAINERS", "Makefile",
579 "README", "Documentation", "arch", "include", "drivers",
580 "fs", "init", "ipc", "kernel", "lib", "scripts",
581 );
582
583 foreach my $check (@tree_check) {
584 if (! -e $root . '/' . $check) {
585 return 0;
586 }
587 }
588 return 1;
589 }
590
591 sub parse_email {
592 my ($formatted_email) = @_;
593
594 my $name = "";
595 my $address = "";
596 my $comment = "";
597
598 if ($formatted_email =~ /^(.*)<(\S+\@\S+)>(.*)$/) {
599 $name = $1;
600 $address = $2;
601 $comment = $3 if defined $3;
602 } elsif ($formatted_email =~ /^\s*<(\S+\@\S+)>(.*)$/) {
603 $address = $1;
604 $comment = $2 if defined $2;
605 } elsif ($formatted_email =~ /(\S+\@\S+)(.*)$/) {
606 $address = $1;
607 $comment = $2 if defined $2;
608 $formatted_email =~ s/$address.*$//;
609 $name = $formatted_email;
610 $name = trim($name);
611 $name =~ s/^\"|\"$//g;
612 # If there's a name left after stripping spaces and
613 # leading quotes, and the address doesn't have both
614 # leading and trailing angle brackets, the address
615 # is invalid. ie:
616 # "joe smith joe@smith.com" bad
617 # "joe smith <joe@smith.com" bad
618 if ($name ne "" && $address !~ /^<[^>]+>$/) {
619 $name = "";
620 $address = "";
621 $comment = "";
622 }
623 }
624
625 $name = trim($name);
626 $name =~ s/^\"|\"$//g;
627 $address = trim($address);
628 $address =~ s/^\<|\>$//g;
629
630 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
631 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
632 $name = "\"$name\"";
633 }
634
635 return ($name, $address, $comment);
636 }
637
638 sub format_email {
639 my ($name, $address) = @_;
640
641 my $formatted_email;
642
643 $name = trim($name);
644 $name =~ s/^\"|\"$//g;
645 $address = trim($address);
646
647 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars
648 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes
649 $name = "\"$name\"";
650 }
651
652 if ("$name" eq "") {
653 $formatted_email = "$address";
654 } else {
655 $formatted_email = "$name <$address>";
656 }
657
658 return $formatted_email;
659 }
660
661 sub which_conf {
662 my ($conf) = @_;
663
664 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) {
665 if (-e "$path/$conf") {
666 return "$path/$conf";
667 }
668 }
669
670 return "";
671 }
672
673 sub expand_tabs {
674 my ($str) = @_;
675
676 my $res = '';
677 my $n = 0;
678 for my $c (split(//, $str)) {
679 if ($c eq "\t") {
680 $res .= ' ';
681 $n++;
682 for (; ($n % 8) != 0; $n++) {
683 $res .= ' ';
684 }
685 next;
686 }
687 $res .= $c;
688 $n++;
689 }
690
691 return $res;
692 }
693 sub copy_spacing {
694 (my $res = shift) =~ tr/\t/ /c;
695 return $res;
696 }
697
698 sub line_stats {
699 my ($line) = @_;
700
701 # Drop the diff line leader and expand tabs
702 $line =~ s/^.//;
703 $line = expand_tabs($line);
704
705 # Pick the indent from the front of the line.
706 my ($white) = ($line =~ /^(\s*)/);
707
708 return (length($line), length($white));
709 }
710
711 my $sanitise_quote = '';
712
713 sub sanitise_line_reset {
714 my ($in_comment) = @_;
715
716 if ($in_comment) {
717 $sanitise_quote = '*/';
718 } else {
719 $sanitise_quote = '';
720 }
721 }
722 sub sanitise_line {
723 my ($line) = @_;
724
725 my $res = '';
726 my $l = '';
727
728 my $qlen = 0;
729 my $off = 0;
730 my $c;
731
732 # Always copy over the diff marker.
733 $res = substr($line, 0, 1);
734
735 for ($off = 1; $off < length($line); $off++) {
736 $c = substr($line, $off, 1);
737
738 # Comments we are wacking completly including the begin
739 # and end, all to $;.
740 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '/*') {
741 $sanitise_quote = '*/';
742
743 substr($res, $off, 2, "$;$;");
744 $off++;
745 next;
746 }
747 if ($sanitise_quote eq '*/' && substr($line, $off, 2) eq '*/') {
748 $sanitise_quote = '';
749 substr($res, $off, 2, "$;$;");
750 $off++;
751 next;
752 }
753 if ($sanitise_quote eq '' && substr($line, $off, 2) eq '//') {
754 $sanitise_quote = '//';
755
756 substr($res, $off, 2, $sanitise_quote);
757 $off++;
758 next;
759 }
760
761 # A \ in a string means ignore the next character.
762 if (($sanitise_quote eq "'" || $sanitise_quote eq '"') &&
763 $c eq "\\") {
764 substr($res, $off, 2, 'XX');
765 $off++;
766 next;
767 }
768 # Regular quotes.
769 if ($c eq "'" || $c eq '"') {
770 if ($sanitise_quote eq '') {
771 $sanitise_quote = $c;
772
773 substr($res, $off, 1, $c);
774 next;
775 } elsif ($sanitise_quote eq $c) {
776 $sanitise_quote = '';
777 }
778 }
779
780 #print "c<$c> SQ<$sanitise_quote>\n";
781 if ($off != 0 && $sanitise_quote eq '*/' && $c ne "\t") {
782 substr($res, $off, 1, $;);
783 } elsif ($off != 0 && $sanitise_quote eq '//' && $c ne "\t") {
784 substr($res, $off, 1, $;);
785 } elsif ($off != 0 && $sanitise_quote && $c ne "\t") {
786 substr($res, $off, 1, 'X');
787 } else {
788 substr($res, $off, 1, $c);
789 }
790 }
791
792 if ($sanitise_quote eq '//') {
793 $sanitise_quote = '';
794 }
795
796 # The pathname on a #include may be surrounded by '<' and '>'.
797 if ($res =~ /^.\s*\#\s*include\s+\<(.*)\>/) {
798 my $clean = 'X' x length($1);
799 $res =~ s@\<.*\>@<$clean>@;
800
801 # The whole of a #error is a string.
802 } elsif ($res =~ /^.\s*\#\s*(?:error|warning)\s+(.*)\b/) {
803 my $clean = 'X' x length($1);
804 $res =~ s@(\#\s*(?:error|warning)\s+).*@$1$clean@;
805 }
806
807 return $res;
808 }
809
810 sub get_quoted_string {
811 my ($line, $rawline) = @_;
812
813 return "" if ($line !~ m/(\"[X]+\")/g);
814 return substr($rawline, $-[0], $+[0] - $-[0]);
815 }
816
817 sub ctx_statement_block {
818 my ($linenr, $remain, $off) = @_;
819 my $line = $linenr - 1;
820 my $blk = '';
821 my $soff = $off;
822 my $coff = $off - 1;
823 my $coff_set = 0;
824
825 my $loff = 0;
826
827 my $type = '';
828 my $level = 0;
829 my @stack = ();
830 my $p;
831 my $c;
832 my $len = 0;
833
834 my $remainder;
835 while (1) {
836 @stack = (['', 0]) if ($#stack == -1);
837
838 #warn "CSB: blk<$blk> remain<$remain>\n";
839 # If we are about to drop off the end, pull in more
840 # context.
841 if ($off >= $len) {
842 for (; $remain > 0; $line++) {
843 last if (!defined $lines[$line]);
844 next if ($lines[$line] =~ /^-/);
845 $remain--;
846 $loff = $len;
847 $blk .= $lines[$line] . "\n";
848 $len = length($blk);
849 $line++;
850 last;
851 }
852 # Bail if there is no further context.
853 #warn "CSB: blk<$blk> off<$off> len<$len>\n";
854 if ($off >= $len) {
855 last;
856 }
857 if ($level == 0 && substr($blk, $off) =~ /^.\s*#\s*define/) {
858 $level++;
859 $type = '#';
860 }
861 }
862 $p = $c;
863 $c = substr($blk, $off, 1);
864 $remainder = substr($blk, $off);
865
866 #warn "CSB: c<$c> type<$type> level<$level> remainder<$remainder> coff_set<$coff_set>\n";
867
868 # Handle nested #if/#else.
869 if ($remainder =~ /^#\s*(?:ifndef|ifdef|if)\s/) {
870 push(@stack, [ $type, $level ]);
871 } elsif ($remainder =~ /^#\s*(?:else|elif)\b/) {
872 ($type, $level) = @{$stack[$#stack - 1]};
873 } elsif ($remainder =~ /^#\s*endif\b/) {
874 ($type, $level) = @{pop(@stack)};
875 }
876
877 # Statement ends at the ';' or a close '}' at the
878 # outermost level.
879 if ($level == 0 && $c eq ';') {
880 last;
881 }
882
883 # An else is really a conditional as long as its not else if
884 if ($level == 0 && $coff_set == 0 &&
885 (!defined($p) || $p =~ /(?:\s|\}|\+)/) &&
886 $remainder =~ /^(else)(?:\s|{)/ &&
887 $remainder !~ /^else\s+if\b/) {
888 $coff = $off + length($1) - 1;
889 $coff_set = 1;
890 #warn "CSB: mark coff<$coff> soff<$soff> 1<$1>\n";
891 #warn "[" . substr($blk, $soff, $coff - $soff + 1) . "]\n";
892 }
893
894 if (($type eq '' || $type eq '(') && $c eq '(') {
895 $level++;
896 $type = '(';
897 }
898 if ($type eq '(' && $c eq ')') {
899 $level--;
900 $type = ($level != 0)? '(' : '';
901
902 if ($level == 0 && $coff < $soff) {
903 $coff = $off;
904 $coff_set = 1;
905 #warn "CSB: mark coff<$coff>\n";
906 }
907 }
908 if (($type eq '' || $type eq '{') && $c eq '{') {
909 $level++;
910 $type = '{';
911 }
912 if ($type eq '{' && $c eq '}') {
913 $level--;
914 $type = ($level != 0)? '{' : '';
915
916 if ($level == 0) {
917 if (substr($blk, $off + 1, 1) eq ';') {
918 $off++;
919 }
920 last;
921 }
922 }
923 # Preprocessor commands end at the newline unless escaped.
924 if ($type eq '#' && $c eq "\n" && $p ne "\\") {
925 $level--;
926 $type = '';
927 $off++;
928 last;
929 }
930 $off++;
931 }
932 # We are truly at the end, so shuffle to the next line.
933 if ($off == $len) {
934 $loff = $len + 1;
935 $line++;
936 $remain--;
937 }
938
939 my $statement = substr($blk, $soff, $off - $soff + 1);
940 my $condition = substr($blk, $soff, $coff - $soff + 1);
941
942 #warn "STATEMENT<$statement>\n";
943 #warn "CONDITION<$condition>\n";
944
945 #print "coff<$coff> soff<$off> loff<$loff>\n";
946
947 return ($statement, $condition,
948 $line, $remain + 1, $off - $loff + 1, $level);
949 }
950
951 sub statement_lines {
952 my ($stmt) = @_;
953
954 # Strip the diff line prefixes and rip blank lines at start and end.
955 $stmt =~ s/(^|\n)./$1/g;
956 $stmt =~ s/^\s*//;
957 $stmt =~ s/\s*$//;
958
959 my @stmt_lines = ($stmt =~ /\n/g);
960
961 return $#stmt_lines + 2;
962 }
963
964 sub statement_rawlines {
965 my ($stmt) = @_;
966
967 my @stmt_lines = ($stmt =~ /\n/g);
968
969 return $#stmt_lines + 2;
970 }
971
972 sub statement_block_size {
973 my ($stmt) = @_;
974
975 $stmt =~ s/(^|\n)./$1/g;
976 $stmt =~ s/^\s*{//;
977 $stmt =~ s/}\s*$//;
978 $stmt =~ s/^\s*//;
979 $stmt =~ s/\s*$//;
980
981 my @stmt_lines = ($stmt =~ /\n/g);
982 my @stmt_statements = ($stmt =~ /;/g);
983
984 my $stmt_lines = $#stmt_lines + 2;
985 my $stmt_statements = $#stmt_statements + 1;
986
987 if ($stmt_lines > $stmt_statements) {
988 return $stmt_lines;
989 } else {
990 return $stmt_statements;
991 }
992 }
993
994 sub ctx_statement_full {
995 my ($linenr, $remain, $off) = @_;
996 my ($statement, $condition, $level);
997
998 my (@chunks);
999
1000 # Grab the first conditional/block pair.
1001 ($statement, $condition, $linenr, $remain, $off, $level) =
1002 ctx_statement_block($linenr, $remain, $off);
1003 #print "F: c<$condition> s<$statement> remain<$remain>\n";
1004 push(@chunks, [ $condition, $statement ]);
1005 if (!($remain > 0 && $condition =~ /^\s*(?:\n[+-])?\s*(?:if|else|do)\b/s)) {
1006 return ($level, $linenr, @chunks);
1007 }
1008
1009 # Pull in the following conditional/block pairs and see if they
1010 # could continue the statement.
1011 for (;;) {
1012 ($statement, $condition, $linenr, $remain, $off, $level) =
1013 ctx_statement_block($linenr, $remain, $off);
1014 #print "C: c<$condition> s<$statement> remain<$remain>\n";
1015 last if (!($remain > 0 && $condition =~ /^(?:\s*\n[+-])*\s*(?:else|do)\b/s));
1016 #print "C: push\n";
1017 push(@chunks, [ $condition, $statement ]);
1018 }
1019
1020 return ($level, $linenr, @chunks);
1021 }
1022
1023 sub ctx_block_get {
1024 my ($linenr, $remain, $outer, $open, $close, $off) = @_;
1025 my $line;
1026 my $start = $linenr - 1;
1027 my $blk = '';
1028 my @o;
1029 my @c;
1030 my @res = ();
1031
1032 my $level = 0;
1033 my @stack = ($level);
1034 for ($line = $start; $remain > 0; $line++) {
1035 next if ($rawlines[$line] =~ /^-/);
1036 $remain--;
1037
1038 $blk .= $rawlines[$line];
1039
1040 # Handle nested #if/#else.
1041 if ($lines[$line] =~ /^.\s*#\s*(?:ifndef|ifdef|if)\s/) {
1042 push(@stack, $level);
1043 } elsif ($lines[$line] =~ /^.\s*#\s*(?:else|elif)\b/) {
1044 $level = $stack[$#stack - 1];
1045 } elsif ($lines[$line] =~ /^.\s*#\s*endif\b/) {
1046 $level = pop(@stack);
1047 }
1048
1049 foreach my $c (split(//, $lines[$line])) {
1050 ##print "C<$c>L<$level><$open$close>O<$off>\n";
1051 if ($off > 0) {
1052 $off--;
1053 next;
1054 }
1055
1056 if ($c eq $close && $level > 0) {
1057 $level--;
1058 last if ($level == 0);
1059 } elsif ($c eq $open) {
1060 $level++;
1061 }
1062 }
1063
1064 if (!$outer || $level <= 1) {
1065 push(@res, $rawlines[$line]);
1066 }
1067
1068 last if ($level == 0);
1069 }
1070
1071 return ($level, @res);
1072 }
1073 sub ctx_block_outer {
1074 my ($linenr, $remain) = @_;
1075
1076 my ($level, @r) = ctx_block_get($linenr, $remain, 1, '{', '}', 0);
1077 return @r;
1078 }
1079 sub ctx_block {
1080 my ($linenr, $remain) = @_;
1081
1082 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1083 return @r;
1084 }
1085 sub ctx_statement {
1086 my ($linenr, $remain, $off) = @_;
1087
1088 my ($level, @r) = ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1089 return @r;
1090 }
1091 sub ctx_block_level {
1092 my ($linenr, $remain) = @_;
1093
1094 return ctx_block_get($linenr, $remain, 0, '{', '}', 0);
1095 }
1096 sub ctx_statement_level {
1097 my ($linenr, $remain, $off) = @_;
1098
1099 return ctx_block_get($linenr, $remain, 0, '(', ')', $off);
1100 }
1101
1102 sub ctx_locate_comment {
1103 my ($first_line, $end_line) = @_;
1104
1105 # Catch a comment on the end of the line itself.
1106 my ($current_comment) = ($rawlines[$end_line - 1] =~ m@.*(/\*.*\*/)\s*(?:\\\s*)?$@);
1107 return $current_comment if (defined $current_comment);
1108
1109 # Look through the context and try and figure out if there is a
1110 # comment.
1111 my $in_comment = 0;
1112 $current_comment = '';
1113 for (my $linenr = $first_line; $linenr < $end_line; $linenr++) {
1114 my $line = $rawlines[$linenr - 1];
1115 #warn " $line\n";
1116 if ($linenr == $first_line and $line =~ m@^.\s*\*@) {
1117 $in_comment = 1;
1118 }
1119 if ($line =~ m@/\*@) {
1120 $in_comment = 1;
1121 }
1122 if (!$in_comment && $current_comment ne '') {
1123 $current_comment = '';
1124 }
1125 $current_comment .= $line . "\n" if ($in_comment);
1126 if ($line =~ m@\*/@) {
1127 $in_comment = 0;
1128 }
1129 }
1130
1131 chomp($current_comment);
1132 return($current_comment);
1133 }
1134 sub ctx_has_comment {
1135 my ($first_line, $end_line) = @_;
1136 my $cmt = ctx_locate_comment($first_line, $end_line);
1137
1138 ##print "LINE: $rawlines[$end_line - 1 ]\n";
1139 ##print "CMMT: $cmt\n";
1140
1141 return ($cmt ne '');
1142 }
1143
1144 sub raw_line {
1145 my ($linenr, $cnt) = @_;
1146
1147 my $offset = $linenr - 1;
1148 $cnt++;
1149
1150 my $line;
1151 while ($cnt) {
1152 $line = $rawlines[$offset++];
1153 next if (defined($line) && $line =~ /^-/);
1154 $cnt--;
1155 }
1156
1157 return $line;
1158 }
1159
1160 sub cat_vet {
1161 my ($vet) = @_;
1162 my ($res, $coded);
1163
1164 $res = '';
1165 while ($vet =~ /([^[:cntrl:]]*)([[:cntrl:]]|$)/g) {
1166 $res .= $1;
1167 if ($2 ne '') {
1168 $coded = sprintf("^%c", unpack('C', $2) + 64);
1169 $res .= $coded;
1170 }
1171 }
1172 $res =~ s/$/\$/;
1173
1174 return $res;
1175 }
1176
1177 my $av_preprocessor = 0;
1178 my $av_pending;
1179 my @av_paren_type;
1180 my $av_pend_colon;
1181
1182 sub annotate_reset {
1183 $av_preprocessor = 0;
1184 $av_pending = '_';
1185 @av_paren_type = ('E');
1186 $av_pend_colon = 'O';
1187 }
1188
1189 sub annotate_values {
1190 my ($stream, $type) = @_;
1191
1192 my $res;
1193 my $var = '_' x length($stream);
1194 my $cur = $stream;
1195
1196 print "$stream\n" if ($dbg_values > 1);
1197
1198 while (length($cur)) {
1199 @av_paren_type = ('E') if ($#av_paren_type < 0);
1200 print " <" . join('', @av_paren_type) .
1201 "> <$type> <$av_pending>" if ($dbg_values > 1);
1202 if ($cur =~ /^(\s+)/o) {
1203 print "WS($1)\n" if ($dbg_values > 1);
1204 if ($1 =~ /\n/ && $av_preprocessor) {
1205 $type = pop(@av_paren_type);
1206 $av_preprocessor = 0;
1207 }
1208
1209 } elsif ($cur =~ /^(\(\s*$Type\s*)\)/ && $av_pending eq '_') {
1210 print "CAST($1)\n" if ($dbg_values > 1);
1211 push(@av_paren_type, $type);
1212 $type = 'c';
1213
1214 } elsif ($cur =~ /^($Type)\s*(?:$Ident|,|\)|\(|\s*$)/) {
1215 print "DECLARE($1)\n" if ($dbg_values > 1);
1216 $type = 'T';
1217
1218 } elsif ($cur =~ /^($Modifier)\s*/) {
1219 print "MODIFIER($1)\n" if ($dbg_values > 1);
1220 $type = 'T';
1221
1222 } elsif ($cur =~ /^(\#\s*define\s*$Ident)(\(?)/o) {
1223 print "DEFINE($1,$2)\n" if ($dbg_values > 1);
1224 $av_preprocessor = 1;
1225 push(@av_paren_type, $type);
1226 if ($2 ne '') {
1227 $av_pending = 'N';
1228 }
1229 $type = 'E';
1230
1231 } elsif ($cur =~ /^(\#\s*(?:undef\s*$Ident|include\b))/o) {
1232 print "UNDEF($1)\n" if ($dbg_values > 1);
1233 $av_preprocessor = 1;
1234 push(@av_paren_type, $type);
1235
1236 } elsif ($cur =~ /^(\#\s*(?:ifdef|ifndef|if))/o) {
1237 print "PRE_START($1)\n" if ($dbg_values > 1);
1238 $av_preprocessor = 1;
1239
1240 push(@av_paren_type, $type);
1241 push(@av_paren_type, $type);
1242 $type = 'E';
1243
1244 } elsif ($cur =~ /^(\#\s*(?:else|elif))/o) {
1245 print "PRE_RESTART($1)\n" if ($dbg_values > 1);
1246 $av_preprocessor = 1;
1247
1248 push(@av_paren_type, $av_paren_type[$#av_paren_type]);
1249
1250 $type = 'E';
1251
1252 } elsif ($cur =~ /^(\#\s*(?:endif))/o) {
1253 print "PRE_END($1)\n" if ($dbg_values > 1);
1254
1255 $av_preprocessor = 1;
1256
1257 # Assume all arms of the conditional end as this
1258 # one does, and continue as if the #endif was not here.
1259 pop(@av_paren_type);
1260 push(@av_paren_type, $type);
1261 $type = 'E';
1262
1263 } elsif ($cur =~ /^(\\\n)/o) {
1264 print "PRECONT($1)\n" if ($dbg_values > 1);
1265
1266 } elsif ($cur =~ /^(__attribute__)\s*\(?/o) {
1267 print "ATTR($1)\n" if ($dbg_values > 1);
1268 $av_pending = $type;
1269 $type = 'N';
1270
1271 } elsif ($cur =~ /^(sizeof)\s*(\()?/o) {
1272 print "SIZEOF($1)\n" if ($dbg_values > 1);
1273 if (defined $2) {
1274 $av_pending = 'V';
1275 }
1276 $type = 'N';
1277
1278 } elsif ($cur =~ /^(if|while|for)\b/o) {
1279 print "COND($1)\n" if ($dbg_values > 1);
1280 $av_pending = 'E';
1281 $type = 'N';
1282
1283 } elsif ($cur =~/^(case)/o) {
1284 print "CASE($1)\n" if ($dbg_values > 1);
1285 $av_pend_colon = 'C';
1286 $type = 'N';
1287
1288 } elsif ($cur =~/^(return|else|goto|typeof|__typeof__)\b/o) {
1289 print "KEYWORD($1)\n" if ($dbg_values > 1);
1290 $type = 'N';
1291
1292 } elsif ($cur =~ /^(\()/o) {
1293 print "PAREN('$1')\n" if ($dbg_values > 1);
1294 push(@av_paren_type, $av_pending);
1295 $av_pending = '_';
1296 $type = 'N';
1297
1298 } elsif ($cur =~ /^(\))/o) {
1299 my $new_type = pop(@av_paren_type);
1300 if ($new_type ne '_') {
1301 $type = $new_type;
1302 print "PAREN('$1') -> $type\n"
1303 if ($dbg_values > 1);
1304 } else {
1305 print "PAREN('$1')\n" if ($dbg_values > 1);
1306 }
1307
1308 } elsif ($cur =~ /^($Ident)\s*\(/o) {
1309 print "FUNC($1)\n" if ($dbg_values > 1);
1310 $type = 'V';
1311 $av_pending = 'V';
1312
1313 } elsif ($cur =~ /^($Ident\s*):(?:\s*\d+\s*(,|=|;))?/) {
1314 if (defined $2 && $type eq 'C' || $type eq 'T') {
1315 $av_pend_colon = 'B';
1316 } elsif ($type eq 'E') {
1317 $av_pend_colon = 'L';
1318 }
1319 print "IDENT_COLON($1,$type>$av_pend_colon)\n" if ($dbg_values > 1);
1320 $type = 'V';
1321
1322 } elsif ($cur =~ /^($Ident|$Constant)/o) {
1323 print "IDENT($1)\n" if ($dbg_values > 1);
1324 $type = 'V';
1325
1326 } elsif ($cur =~ /^($Assignment)/o) {
1327 print "ASSIGN($1)\n" if ($dbg_values > 1);
1328 $type = 'N';
1329
1330 } elsif ($cur =~/^(;|{|})/) {
1331 print "END($1)\n" if ($dbg_values > 1);
1332 $type = 'E';
1333 $av_pend_colon = 'O';
1334
1335 } elsif ($cur =~/^(,)/) {
1336 print "COMMA($1)\n" if ($dbg_values > 1);
1337 $type = 'C';
1338
1339 } elsif ($cur =~ /^(\?)/o) {
1340 print "QUESTION($1)\n" if ($dbg_values > 1);
1341 $type = 'N';
1342
1343 } elsif ($cur =~ /^(:)/o) {
1344 print "COLON($1,$av_pend_colon)\n" if ($dbg_values > 1);
1345
1346 substr($var, length($res), 1, $av_pend_colon);
1347 if ($av_pend_colon eq 'C' || $av_pend_colon eq 'L') {
1348 $type = 'E';
1349 } else {
1350 $type = 'N';
1351 }
1352 $av_pend_colon = 'O';
1353
1354 } elsif ($cur =~ /^(\[)/o) {
1355 print "CLOSE($1)\n" if ($dbg_values > 1);
1356 $type = 'N';
1357
1358 } elsif ($cur =~ /^(-(?![->])|\+(?!\+)|\*|\&\&|\&)/o) {
1359 my $variant;
1360
1361 print "OPV($1)\n" if ($dbg_values > 1);
1362 if ($type eq 'V') {
1363 $variant = 'B';
1364 } else {
1365 $variant = 'U';
1366 }
1367
1368 substr($var, length($res), 1, $variant);
1369 $type = 'N';
1370
1371 } elsif ($cur =~ /^($Operators)/o) {
1372 print "OP($1)\n" if ($dbg_values > 1);
1373 if ($1 ne '++' && $1 ne '--') {
1374 $type = 'N';
1375 }
1376
1377 } elsif ($cur =~ /(^.)/o) {
1378 print "C($1)\n" if ($dbg_values > 1);
1379 }
1380 if (defined $1) {
1381 $cur = substr($cur, length($1));
1382 $res .= $type x length($1);
1383 }
1384 }
1385
1386 return ($res, $var);
1387 }
1388
1389 sub possible {
1390 my ($possible, $line) = @_;
1391 my $notPermitted = qr{(?:
1392 ^(?:
1393 $Modifier|
1394 $Storage|
1395 $Type|
1396 DEFINE_\S+
1397 )$|
1398 ^(?:
1399 goto|
1400 return|
1401 case|
1402 else|
1403 asm|__asm__|
1404 do|
1405 \#|
1406 \#\#|
1407 )(?:\s|$)|
1408 ^(?:typedef|struct|enum)\b
1409 )}x;
1410 warn "CHECK<$possible> ($line)\n" if ($dbg_possible > 2);
1411 if ($possible !~ $notPermitted) {
1412 # Check for modifiers.
1413 $possible =~ s/\s*$Storage\s*//g;
1414 $possible =~ s/\s*$Sparse\s*//g;
1415 if ($possible =~ /^\s*$/) {
1416
1417 } elsif ($possible =~ /\s/) {
1418 $possible =~ s/\s*$Type\s*//g;
1419 for my $modifier (split(' ', $possible)) {
1420 if ($modifier !~ $notPermitted) {
1421 warn "MODIFIER: $modifier ($possible) ($line)\n" if ($dbg_possible);
1422 push(@modifierList, $modifier);
1423 }
1424 }
1425
1426 } else {
1427 warn "POSSIBLE: $possible ($line)\n" if ($dbg_possible);
1428 push(@typeList, $possible);
1429 }
1430 build_types();
1431 } else {
1432 warn "NOTPOSS: $possible ($line)\n" if ($dbg_possible > 1);
1433 }
1434 }
1435
1436 my $prefix = '';
1437
1438 sub show_type {
1439 my ($type) = @_;
1440
1441 return defined $use_type{$type} if (scalar keys %use_type > 0);
1442
1443 return !defined $ignore_type{$type};
1444 }
1445
1446 sub report {
1447 my ($level, $type, $msg) = @_;
1448
1449 if (!show_type($type) ||
1450 (defined $tst_only && $msg !~ /\Q$tst_only\E/)) {
1451 return 0;
1452 }
1453 my $line;
1454 if ($show_types) {
1455 $line = "$prefix$level:$type: $msg\n";
1456 } else {
1457 $line = "$prefix$level: $msg\n";
1458 }
1459 $line = (split('\n', $line))[0] . "\n" if ($terse);
1460
1461 push(our @report, $line);
1462
1463 return 1;
1464 }
1465
1466 sub report_dump {
1467 our @report;
1468 }
1469
1470 sub ERROR {
1471 my ($type, $msg) = @_;
1472
1473 if (report("ERROR", $type, $msg)) {
1474 our $clean = 0;
1475 our $cnt_error++;
1476 return 1;
1477 }
1478 return 0;
1479 }
1480 sub WARN {
1481 my ($type, $msg) = @_;
1482
1483 if (report("WARNING", $type, $msg)) {
1484 our $clean = 0;
1485 our $cnt_warn++;
1486 return 1;
1487 }
1488 return 0;
1489 }
1490 sub CHK {
1491 my ($type, $msg) = @_;
1492
1493 if ($check && report("CHECK", $type, $msg)) {
1494 our $clean = 0;
1495 our $cnt_chk++;
1496 return 1;
1497 }
1498 return 0;
1499 }
1500
1501 sub check_absolute_file {
1502 my ($absolute, $herecurr) = @_;
1503 my $file = $absolute;
1504
1505 ##print "absolute<$absolute>\n";
1506
1507 # See if any suffix of this path is a path within the tree.
1508 while ($file =~ s@^[^/]*/@@) {
1509 if (-f "$root/$file") {
1510 ##print "file<$file>\n";
1511 last;
1512 }
1513 }
1514 if (! -f _) {
1515 return 0;
1516 }
1517
1518 # It is, so see if the prefix is acceptable.
1519 my $prefix = $absolute;
1520 substr($prefix, -length($file)) = '';
1521
1522 ##print "prefix<$prefix>\n";
1523 if ($prefix ne ".../") {
1524 WARN("USE_RELATIVE_PATH",
1525 "use relative pathname instead of absolute in changelog text\n" . $herecurr);
1526 }
1527 }
1528
1529 sub trim {
1530 my ($string) = @_;
1531
1532 $string =~ s/^\s+|\s+$//g;
1533
1534 return $string;
1535 }
1536
1537 sub ltrim {
1538 my ($string) = @_;
1539
1540 $string =~ s/^\s+//;
1541
1542 return $string;
1543 }
1544
1545 sub rtrim {
1546 my ($string) = @_;
1547
1548 $string =~ s/\s+$//;
1549
1550 return $string;
1551 }
1552
1553 sub string_find_replace {
1554 my ($string, $find, $replace) = @_;
1555
1556 $string =~ s/$find/$replace/g;
1557
1558 return $string;
1559 }
1560
1561 sub tabify {
1562 my ($leading) = @_;
1563
1564 my $source_indent = 8;
1565 my $max_spaces_before_tab = $source_indent - 1;
1566 my $spaces_to_tab = " " x $source_indent;
1567
1568 #convert leading spaces to tabs
1569 1 while $leading =~ s@^([\t]*)$spaces_to_tab@$1\t@g;
1570 #Remove spaces before a tab
1571 1 while $leading =~ s@^([\t]*)( {1,$max_spaces_before_tab})\t@$1\t@g;
1572
1573 return "$leading";
1574 }
1575
1576 sub pos_last_openparen {
1577 my ($line) = @_;
1578
1579 my $pos = 0;
1580
1581 my $opens = $line =~ tr/\(/\(/;
1582 my $closes = $line =~ tr/\)/\)/;
1583
1584 my $last_openparen = 0;
1585
1586 if (($opens == 0) || ($closes >= $opens)) {
1587 return -1;
1588 }
1589
1590 my $len = length($line);
1591
1592 for ($pos = 0; $pos < $len; $pos++) {
1593 my $string = substr($line, $pos);
1594 if ($string =~ /^($FuncArg|$balanced_parens)/) {
1595 $pos += length($1) - 1;
1596 } elsif (substr($line, $pos, 1) eq '(') {
1597 $last_openparen = $pos;
1598 } elsif (index($string, '(') == -1) {
1599 last;
1600 }
1601 }
1602
1603 return $last_openparen + 1;
1604 }
1605
1606 sub process {
1607 my $filename = shift;
1608
1609 my $linenr=0;
1610 my $prevline="";
1611 my $prevrawline="";
1612 my $stashline="";
1613 my $stashrawline="";
1614
1615 my $length;
1616 my $indent;
1617 my $previndent=0;
1618 my $stashindent=0;
1619
1620 our $clean = 1;
1621 my $signoff = 0;
1622 my $is_patch = 0;
1623
1624 my $in_header_lines = 1;
1625 my $in_commit_log = 0; #Scanning lines before patch
1626
1627 my $non_utf8_charset = 0;
1628
1629 our @report = ();
1630 our $cnt_lines = 0;
1631 our $cnt_error = 0;
1632 our $cnt_warn = 0;
1633 our $cnt_chk = 0;
1634
1635 # Trace the real file/line as we go.
1636 my $realfile = '';
1637 my $realline = 0;
1638 my $realcnt = 0;
1639 my $here = '';
1640 my $in_comment = 0;
1641 my $comment_edge = 0;
1642 my $first_line = 0;
1643 my $p1_prefix = '';
1644
1645 my $prev_values = 'E';
1646
1647 # suppression flags
1648 my %suppress_ifbraces;
1649 my %suppress_whiletrailers;
1650 my %suppress_export;
1651 my $suppress_statement = 0;
1652
1653 my %signatures = ();
1654
1655 # Pre-scan the patch sanitizing the lines.
1656 # Pre-scan the patch looking for any __setup documentation.
1657 #
1658 my @setup_docs = ();
1659 my $setup_docs = 0;
1660
1661 my $camelcase_file_seeded = 0;
1662
1663 sanitise_line_reset();
1664 my $line;
1665 foreach my $rawline (@rawlines) {
1666 $linenr++;
1667 $line = $rawline;
1668
1669 push(@fixed, $rawline) if ($fix);
1670
1671 if ($rawline=~/^\+\+\+\s+(\S+)/) {
1672 $setup_docs = 0;
1673 if ($1 =~ m@Documentation/kernel-parameters.txt$@) {
1674 $setup_docs = 1;
1675 }
1676 #next;
1677 }
1678 if ($rawline=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1679 $realline=$1-1;
1680 if (defined $2) {
1681 $realcnt=$3+1;
1682 } else {
1683 $realcnt=1+1;
1684 }
1685 $in_comment = 0;
1686
1687 # Guestimate if this is a continuing comment. Run
1688 # the context looking for a comment "edge". If this
1689 # edge is a close comment then we must be in a comment
1690 # at context start.
1691 my $edge;
1692 my $cnt = $realcnt;
1693 for (my $ln = $linenr + 1; $cnt > 0; $ln++) {
1694 next if (defined $rawlines[$ln - 1] &&
1695 $rawlines[$ln - 1] =~ /^-/);
1696 $cnt--;
1697 #print "RAW<$rawlines[$ln - 1]>\n";
1698 last if (!defined $rawlines[$ln - 1]);
1699 if ($rawlines[$ln - 1] =~ m@(/\*|\*/)@ &&
1700 $rawlines[$ln - 1] !~ m@"[^"]*(?:/\*|\*/)[^"]*"@) {
1701 ($edge) = $1;
1702 last;
1703 }
1704 }
1705 if (defined $edge && $edge eq '*/') {
1706 $in_comment = 1;
1707 }
1708
1709 # Guestimate if this is a continuing comment. If this
1710 # is the start of a diff block and this line starts
1711 # ' *' then it is very likely a comment.
1712 if (!defined $edge &&
1713 $rawlines[$linenr] =~ m@^.\s*(?:\*\*+| \*)(?:\s|$)@)
1714 {
1715 $in_comment = 1;
1716 }
1717
1718 ##print "COMMENT:$in_comment edge<$edge> $rawline\n";
1719 sanitise_line_reset($in_comment);
1720
1721 } elsif ($realcnt && $rawline =~ /^(?:\+| |$)/) {
1722 # Standardise the strings and chars within the input to
1723 # simplify matching -- only bother with positive lines.
1724 $line = sanitise_line($rawline);
1725 }
1726 push(@lines, $line);
1727
1728 if ($realcnt > 1) {
1729 $realcnt-- if ($line =~ /^(?:\+| |$)/);
1730 } else {
1731 $realcnt = 0;
1732 }
1733
1734 #print "==>$rawline\n";
1735 #print "-->$line\n";
1736
1737 if ($setup_docs && $line =~ /^\+/) {
1738 push(@setup_docs, $line);
1739 }
1740 }
1741
1742 $prefix = '';
1743
1744 $realcnt = 0;
1745 $linenr = 0;
1746 foreach my $line (@lines) {
1747 $linenr++;
1748 my $sline = $line; #copy of $line
1749 $sline =~ s/$;/ /g; #with comments as spaces
1750
1751 my $rawline = $rawlines[$linenr - 1];
1752
1753 #extract the line range in the file after the patch is applied
1754 if ($line=~/^\@\@ -\d+(?:,\d+)? \+(\d+)(,(\d+))? \@\@/) {
1755 $is_patch = 1;
1756 $first_line = $linenr + 1;
1757 $realline=$1-1;
1758 if (defined $2) {
1759 $realcnt=$3+1;
1760 } else {
1761 $realcnt=1+1;
1762 }
1763 annotate_reset();
1764 $prev_values = 'E';
1765
1766 %suppress_ifbraces = ();
1767 %suppress_whiletrailers = ();
1768 %suppress_export = ();
1769 $suppress_statement = 0;
1770 next;
1771
1772 # track the line number as we move through the hunk, note that
1773 # new versions of GNU diff omit the leading space on completely
1774 # blank context lines so we need to count that too.
1775 } elsif ($line =~ /^( |\+|$)/) {
1776 $realline++;
1777 $realcnt-- if ($realcnt != 0);
1778
1779 # Measure the line length and indent.
1780 ($length, $indent) = line_stats($rawline);
1781
1782 # Track the previous line.
1783 ($prevline, $stashline) = ($stashline, $line);
1784 ($previndent, $stashindent) = ($stashindent, $indent);
1785 ($prevrawline, $stashrawline) = ($stashrawline, $rawline);
1786
1787 #warn "line<$line>\n";
1788
1789 } elsif ($realcnt == 1) {
1790 $realcnt--;
1791 }
1792
1793 my $hunk_line = ($realcnt != 0);
1794
1795 #make up the handle for any error we report on this line
1796 $prefix = "$filename:$realline: " if ($emacs && $file);
1797 $prefix = "$filename:$linenr: " if ($emacs && !$file);
1798
1799 $here = "#$linenr: " if (!$file);
1800 $here = "#$realline: " if ($file);
1801
1802 # extract the filename as it passes
1803 if ($line =~ /^diff --git.*?(\S+)$/) {
1804 $realfile = $1;
1805 $realfile =~ s@^([^/]*)/@@ if (!$file);
1806 $in_commit_log = 0;
1807 } elsif ($line =~ /^\+\+\+\s+(\S+)/) {
1808 $realfile = $1;
1809 $realfile =~ s@^([^/]*)/@@ if (!$file);
1810 $in_commit_log = 0;
1811
1812 $p1_prefix = $1;
1813 if (!$file && $tree && $p1_prefix ne '' &&
1814 -e "$root/$p1_prefix") {
1815 WARN("PATCH_PREFIX",
1816 "patch prefix '$p1_prefix' exists, appears to be a -p0 patch\n");
1817 }
1818
1819 if ($realfile =~ m@^include/asm/@) {
1820 ERROR("MODIFIED_INCLUDE_ASM",
1821 "do not modify files in include/asm, change architecture specific files in include/asm-<architecture>\n" . "$here$rawline\n");
1822 }
1823 next;
1824 }
1825
1826 $here .= "FILE: $realfile:$realline:" if ($realcnt != 0);
1827
1828 my $hereline = "$here\n$rawline\n";
1829 my $herecurr = "$here\n$rawline\n";
1830 my $hereprev = "$here\n$prevrawline\n$rawline\n";
1831
1832 $cnt_lines++ if ($realcnt != 0);
1833
1834 # Check for incorrect file permissions
1835 if ($line =~ /^new (file )?mode.*[7531]\d{0,2}$/) {
1836 my $permhere = $here . "FILE: $realfile\n";
1837 if ($realfile !~ m@scripts/@ &&
1838 $realfile !~ /\.(py|pl|awk|sh)$/) {
1839 ERROR("EXECUTE_PERMISSIONS",
1840 "do not set execute permissions for source files\n" . $permhere);
1841 }
1842 }
1843
1844 # Check the patch for a signoff:
1845 if ($line =~ /^\s*signed-off-by:/i) {
1846 $signoff++;
1847 $in_commit_log = 0;
1848 }
1849
1850 # Check signature styles
1851 if (!$in_header_lines &&
1852 $line =~ /^(\s*)([a-z0-9_-]+by:|$signature_tags)(\s*)(.*)/i) {
1853 my $space_before = $1;
1854 my $sign_off = $2;
1855 my $space_after = $3;
1856 my $email = $4;
1857 my $ucfirst_sign_off = ucfirst(lc($sign_off));
1858
1859 if ($sign_off !~ /$signature_tags/) {
1860 WARN("BAD_SIGN_OFF",
1861 "Non-standard signature: $sign_off\n" . $herecurr);
1862 }
1863 if (defined $space_before && $space_before ne "") {
1864 if (WARN("BAD_SIGN_OFF",
1865 "Do not use whitespace before $ucfirst_sign_off\n" . $herecurr) &&
1866 $fix) {
1867 $fixed[$linenr - 1] =
1868 "$ucfirst_sign_off $email";
1869 }
1870 }
1871 if ($sign_off =~ /-by:$/i && $sign_off ne $ucfirst_sign_off) {
1872 if (WARN("BAD_SIGN_OFF",
1873 "'$ucfirst_sign_off' is the preferred signature form\n" . $herecurr) &&
1874 $fix) {
1875 $fixed[$linenr - 1] =
1876 "$ucfirst_sign_off $email";
1877 }
1878
1879 }
1880 if (!defined $space_after || $space_after ne " ") {
1881 if (WARN("BAD_SIGN_OFF",
1882 "Use a single space after $ucfirst_sign_off\n" . $herecurr) &&
1883 $fix) {
1884 $fixed[$linenr - 1] =
1885 "$ucfirst_sign_off $email";
1886 }
1887 }
1888
1889 my ($email_name, $email_address, $comment) = parse_email($email);
1890 my $suggested_email = format_email(($email_name, $email_address));
1891 if ($suggested_email eq "") {
1892 ERROR("BAD_SIGN_OFF",
1893 "Unrecognized email address: '$email'\n" . $herecurr);
1894 } else {
1895 my $dequoted = $suggested_email;
1896 $dequoted =~ s/^"//;
1897 $dequoted =~ s/" </ </;
1898 # Don't force email to have quotes
1899 # Allow just an angle bracketed address
1900 if ("$dequoted$comment" ne $email &&
1901 "<$email_address>$comment" ne $email &&
1902 "$suggested_email$comment" ne $email) {
1903 WARN("BAD_SIGN_OFF",
1904 "email address '$email' might be better as '$suggested_email$comment'\n" . $herecurr);
1905 }
1906 }
1907
1908 # Check for duplicate signatures
1909 my $sig_nospace = $line;
1910 $sig_nospace =~ s/\s//g;
1911 $sig_nospace = lc($sig_nospace);
1912 if (defined $signatures{$sig_nospace}) {
1913 WARN("BAD_SIGN_OFF",
1914 "Duplicate signature\n" . $herecurr);
1915 } else {
1916 $signatures{$sig_nospace} = 1;
1917 }
1918 }
1919
1920 # Check for wrappage within a valid hunk of the file
1921 if ($realcnt != 0 && $line !~ m{^(?:\+|-| |\\ No newline|$)}) {
1922 ERROR("CORRUPTED_PATCH",
1923 "patch seems to be corrupt (line wrapped?)\n" .
1924 $herecurr) if (!$emitted_corrupt++);
1925 }
1926
1927 # Check for absolute kernel paths.
1928 if ($tree) {
1929 while ($line =~ m{(?:^|\s)(/\S*)}g) {
1930 my $file = $1;
1931
1932 if ($file =~ m{^(.*?)(?::\d+)+:?$} &&
1933 check_absolute_file($1, $herecurr)) {
1934 #
1935 } else {
1936 check_absolute_file($file, $herecurr);
1937 }
1938 }
1939 }
1940
1941 # UTF-8 regex found at http://www.w3.org/International/questions/qa-forms-utf-8.en.php
1942 if (($realfile =~ /^$/ || $line =~ /^\+/) &&
1943 $rawline !~ m/^$UTF8*$/) {
1944 my ($utf8_prefix) = ($rawline =~ /^($UTF8*)/);
1945
1946 my $blank = copy_spacing($rawline);
1947 my $ptr = substr($blank, 0, length($utf8_prefix)) . "^";
1948 my $hereptr = "$hereline$ptr\n";
1949
1950 CHK("INVALID_UTF8",
1951 "Invalid UTF-8, patch and commit message should be encoded in UTF-8\n" . $hereptr);
1952 }
1953
1954 # Check if it's the start of a commit log
1955 # (not a header line and we haven't seen the patch filename)
1956 if ($in_header_lines && $realfile =~ /^$/ &&
1957 $rawline !~ /^(commit\b|from\b|[\w-]+:).+$/i) {
1958 $in_header_lines = 0;
1959 $in_commit_log = 1;
1960 }
1961
1962 # Check if there is UTF-8 in a commit log when a mail header has explicitly
1963 # declined it, i.e defined some charset where it is missing.
1964 if ($in_header_lines &&
1965 $rawline =~ /^Content-Type:.+charset="(.+)".*$/ &&
1966 $1 !~ /utf-8/i) {
1967 $non_utf8_charset = 1;
1968 }
1969
1970 if ($in_commit_log && $non_utf8_charset && $realfile =~ /^$/ &&
1971 $rawline =~ /$NON_ASCII_UTF8/) {
1972 WARN("UTF8_BEFORE_PATCH",
1973 "8-bit UTF-8 used in possible commit log\n" . $herecurr);
1974 }
1975
1976 # ignore non-hunk lines and lines being removed
1977 next if (!$hunk_line || $line =~ /^-/);
1978
1979 #trailing whitespace
1980 if ($line =~ /^\+.*\015/) {
1981 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1982 if (ERROR("DOS_LINE_ENDINGS",
1983 "DOS line endings\n" . $herevet) &&
1984 $fix) {
1985 $fixed[$linenr - 1] =~ s/[\s\015]+$//;
1986 }
1987 } elsif ($rawline =~ /^\+.*\S\s+$/ || $rawline =~ /^\+\s+$/) {
1988 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
1989 if (ERROR("TRAILING_WHITESPACE",
1990 "trailing whitespace\n" . $herevet) &&
1991 $fix) {
1992 $fixed[$linenr - 1] =~ s/\s+$//;
1993 }
1994
1995 $rpt_cleaners = 1;
1996 }
1997
1998 # Check for FSF mailing addresses.
1999 if ($rawline =~ /\bwrite to the Free/i ||
2000 $rawline =~ /\b59\s+Temple\s+Pl/i ||
2001 $rawline =~ /\b51\s+Franklin\s+St/i) {
2002 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2003 my $msg_type = \&ERROR;
2004 $msg_type = \&CHK if ($file);
2005 &{$msg_type}("FSF_MAILING_ADDRESS",
2006 "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)
2007 }
2008
2009 # check for Kconfig help text having a real description
2010 # Only applies when adding the entry originally, after that we do not have
2011 # sufficient context to determine whether it is indeed long enough.
2012 if ($realfile =~ /Kconfig/ &&
2013 $line =~ /.\s*config\s+/) {
2014 my $length = 0;
2015 my $cnt = $realcnt;
2016 my $ln = $linenr + 1;
2017 my $f;
2018 my $is_start = 0;
2019 my $is_end = 0;
2020 for (; $cnt > 0 && defined $lines[$ln - 1]; $ln++) {
2021 $f = $lines[$ln - 1];
2022 $cnt-- if ($lines[$ln - 1] !~ /^-/);
2023 $is_end = $lines[$ln - 1] =~ /^\+/;
2024
2025 next if ($f =~ /^-/);
2026
2027 if ($lines[$ln - 1] =~ /.\s*(?:bool|tristate)\s*\"/) {
2028 $is_start = 1;
2029 } elsif ($lines[$ln - 1] =~ /.\s*(?:---)?help(?:---)?$/) {
2030 $length = -1;
2031 }
2032
2033 $f =~ s/^.//;
2034 $f =~ s/#.*//;
2035 $f =~ s/^\s+//;
2036 next if ($f =~ /^$/);
2037 if ($f =~ /^\s*config\s/) {
2038 $is_end = 1;
2039 last;
2040 }
2041 $length++;
2042 }
2043 WARN("CONFIG_DESCRIPTION",
2044 "please write a paragraph that describes the config symbol fully\n" . $herecurr) if ($is_start && $is_end && $length < 4);
2045 #print "is_start<$is_start> is_end<$is_end> length<$length>\n";
2046 }
2047
2048 # discourage the addition of CONFIG_EXPERIMENTAL in Kconfig.
2049 if ($realfile =~ /Kconfig/ &&
2050 $line =~ /.\s*depends on\s+.*\bEXPERIMENTAL\b/) {
2051 WARN("CONFIG_EXPERIMENTAL",
2052 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2053 }
2054
2055 if (($realfile =~ /Makefile.*/ || $realfile =~ /Kbuild.*/) &&
2056 ($line =~ /\+(EXTRA_[A-Z]+FLAGS).*/)) {
2057 my $flag = $1;
2058 my $replacement = {
2059 'EXTRA_AFLAGS' => 'asflags-y',
2060 'EXTRA_CFLAGS' => 'ccflags-y',
2061 'EXTRA_CPPFLAGS' => 'cppflags-y',
2062 'EXTRA_LDFLAGS' => 'ldflags-y',
2063 };
2064
2065 WARN("DEPRECATED_VARIABLE",
2066 "Use of $flag is deprecated, please use \`$replacement->{$flag} instead.\n" . $herecurr) if ($replacement->{$flag});
2067 }
2068
2069 # check for DT compatible documentation
2070 if (defined $root && $realfile =~ /\.dts/ &&
2071 $rawline =~ /^\+\s*compatible\s*=/) {
2072 my @compats = $rawline =~ /\"([a-zA-Z0-9\-\,\.\+_]+)\"/g;
2073
2074 foreach my $compat (@compats) {
2075 my $compat2 = $compat;
2076 my $dt_path = $root . "/Documentation/devicetree/bindings/";
2077 $compat2 =~ s/\,[a-z]*\-/\,<\.\*>\-/;
2078 `grep -Erq "$compat|$compat2" $dt_path`;
2079 if ( $? >> 8 ) {
2080 WARN("UNDOCUMENTED_DT_STRING",
2081 "DT compatible string \"$compat\" appears un-documented -- check $dt_path\n" . $herecurr);
2082 }
2083
2084 my $vendor = $compat;
2085 my $vendor_path = $dt_path . "vendor-prefixes.txt";
2086 next if (! -f $vendor_path);
2087 $vendor =~ s/^([a-zA-Z0-9]+)\,.*/$1/;
2088 `grep -Eq "$vendor" $vendor_path`;
2089 if ( $? >> 8 ) {
2090 WARN("UNDOCUMENTED_DT_STRING",
2091 "DT compatible string vendor \"$vendor\" appears un-documented -- check $vendor_path\n" . $herecurr);
2092 }
2093 }
2094 }
2095
2096 # check we are in a valid source file if not then ignore this hunk
2097 next if ($realfile !~ /\.(h|c|s|S|pl|sh)$/);
2098
2099 #line length limit
2100 if ($line =~ /^\+/ && $prevrawline !~ /\/\*\*/ &&
2101 $rawline !~ /^.\s*\*\s*\@$Ident\s/ &&
2102 !($line =~ /^\+\s*$logFunctions\s*\(\s*(?:(KERN_\S+\s*|[^"]*))?"[X\t]*"\s*(?:|,|\)\s*;)\s*$/ ||
2103 $line =~ /^\+\s*"[^"]*"\s*(?:\s*|,|\)\s*;)\s*$/) &&
2104 $length > $max_line_length)
2105 {
2106 WARN("LONG_LINE",
2107 "line over $max_line_length characters\n" . $herecurr);
2108 }
2109
2110 # Check for user-visible strings broken across lines, which breaks the ability
2111 # to grep for the string. Make exceptions when the previous string ends in a
2112 # newline (multiple lines in one string constant) or '\t', '\r', ';', or '{'
2113 # (common in inline assembly) or is a octal \123 or hexadecimal \xaf value
2114 if ($line =~ /^\+\s*"/ &&
2115 $prevline =~ /"\s*$/ &&
2116 $prevrawline !~ /(?:\\(?:[ntr]|[0-7]{1,3}|x[0-9a-fA-F]{1,2})|;\s*|\{\s*)"\s*$/) {
2117 WARN("SPLIT_STRING",
2118 "quoted string split across lines\n" . $hereprev);
2119 }
2120
2121 # check for spaces before a quoted newline
2122 if ($rawline =~ /^.*\".*\s\\n/) {
2123 if (WARN("QUOTED_WHITESPACE_BEFORE_NEWLINE",
2124 "unnecessary whitespace before a quoted newline\n" . $herecurr) &&
2125 $fix) {
2126 $fixed[$linenr - 1] =~ s/^(\+.*\".*)\s+\\n/$1\\n/;
2127 }
2128
2129 }
2130
2131 # check for adding lines without a newline.
2132 if ($line =~ /^\+/ && defined $lines[$linenr] && $lines[$linenr] =~ /^\\ No newline at end of file/) {
2133 WARN("MISSING_EOF_NEWLINE",
2134 "adding a line without newline at end of file\n" . $herecurr);
2135 }
2136
2137 # Blackfin: use hi/lo macros
2138 if ($realfile =~ m@arch/blackfin/.*\.S$@) {
2139 if ($line =~ /\.[lL][[:space:]]*=.*&[[:space:]]*0x[fF][fF][fF][fF]/) {
2140 my $herevet = "$here\n" . cat_vet($line) . "\n";
2141 ERROR("LO_MACRO",
2142 "use the LO() macro, not (... & 0xFFFF)\n" . $herevet);
2143 }
2144 if ($line =~ /\.[hH][[:space:]]*=.*>>[[:space:]]*16/) {
2145 my $herevet = "$here\n" . cat_vet($line) . "\n";
2146 ERROR("HI_MACRO",
2147 "use the HI() macro, not (... >> 16)\n" . $herevet);
2148 }
2149 }
2150
2151 # check we are in a valid source file C or perl if not then ignore this hunk
2152 next if ($realfile !~ /\.(h|c|pl)$/);
2153
2154 # at the beginning of a line any tabs must come first and anything
2155 # more than 8 must use tabs.
2156 if ($rawline =~ /^\+\s* \t\s*\S/ ||
2157 $rawline =~ /^\+\s* \s*/) {
2158 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2159 $rpt_cleaners = 1;
2160 if (ERROR("CODE_INDENT",
2161 "code indent should use tabs where possible\n" . $herevet) &&
2162 $fix) {
2163 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2164 }
2165 }
2166
2167 # check for space before tabs.
2168 if ($rawline =~ /^\+/ && $rawline =~ / \t/) {
2169 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2170 if (WARN("SPACE_BEFORE_TAB",
2171 "please, no space before tabs\n" . $herevet) &&
2172 $fix) {
2173 while ($fixed[$linenr - 1] =~
2174 s/(^\+.*) {8,8}+\t/$1\t\t/) {}
2175 while ($fixed[$linenr - 1] =~
2176 s/(^\+.*) +\t/$1\t/) {}
2177 }
2178 }
2179
2180 # check for && or || at the start of a line
2181 if ($rawline =~ /^\+\s*(&&|\|\|)/) {
2182 CHK("LOGICAL_CONTINUATIONS",
2183 "Logical continuations should be on the previous line\n" . $hereprev);
2184 }
2185
2186 # check multi-line statement indentation matches previous line
2187 if ($^V && $^V ge 5.10.0 &&
2188 $prevline =~ /^\+(\t*)(if \(|$Ident\().*(\&\&|\|\||,)\s*$/) {
2189 $prevline =~ /^\+(\t*)(.*)$/;
2190 my $oldindent = $1;
2191 my $rest = $2;
2192
2193 my $pos = pos_last_openparen($rest);
2194 if ($pos >= 0) {
2195 $line =~ /^(\+| )([ \t]*)/;
2196 my $newindent = $2;
2197
2198 my $goodtabindent = $oldindent .
2199 "\t" x ($pos / 8) .
2200 " " x ($pos % 8);
2201 my $goodspaceindent = $oldindent . " " x $pos;
2202
2203 if ($newindent ne $goodtabindent &&
2204 $newindent ne $goodspaceindent) {
2205
2206 if (CHK("PARENTHESIS_ALIGNMENT",
2207 "Alignment should match open parenthesis\n" . $hereprev) &&
2208 $fix && $line =~ /^\+/) {
2209 $fixed[$linenr - 1] =~
2210 s/^\+[ \t]*/\+$goodtabindent/;
2211 }
2212 }
2213 }
2214 }
2215
2216 if ($line =~ /^\+.*\*[ \t]*\)[ \t]+(?!$Assignment|$Arithmetic)/) {
2217 if (CHK("SPACING",
2218 "No space is necessary after a cast\n" . $hereprev) &&
2219 $fix) {
2220 $fixed[$linenr - 1] =~
2221 s/^(\+.*\*[ \t]*\))[ \t]+/$1/;
2222 }
2223 }
2224
2225 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2226 $prevrawline =~ /^\+[ \t]*\/\*[ \t]*$/ &&
2227 $rawline =~ /^\+[ \t]*\*/ &&
2228 $realline > 2) {
2229 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2230 "networking block comments don't use an empty /* line, use /* Comment...\n" . $hereprev);
2231 }
2232
2233 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2234 $prevrawline =~ /^\+[ \t]*\/\*/ && #starting /*
2235 $prevrawline !~ /\*\/[ \t]*$/ && #no trailing */
2236 $rawline =~ /^\+/ && #line is new
2237 $rawline !~ /^\+[ \t]*\*/) { #no leading *
2238 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2239 "networking block comments start with * on subsequent lines\n" . $hereprev);
2240 }
2241
2242 if ($realfile =~ m@^(drivers/net/|net/)@ &&
2243 $rawline !~ m@^\+[ \t]*\*/[ \t]*$@ && #trailing */
2244 $rawline !~ m@^\+.*/\*.*\*/[ \t]*$@ && #inline /*...*/
2245 $rawline !~ m@^\+.*\*{2,}/[ \t]*$@ && #trailing **/
2246 $rawline =~ m@^\+[ \t]*.+\*\/[ \t]*$@) { #non blank */
2247 WARN("NETWORKING_BLOCK_COMMENT_STYLE",
2248 "networking block comments put the trailing */ on a separate line\n" . $herecurr);
2249 }
2250
2251 # check for spaces at the beginning of a line.
2252 # Exceptions:
2253 # 1) within comments
2254 # 2) indented preprocessor commands
2255 # 3) hanging labels
2256 if ($rawline =~ /^\+ / && $line !~ /^\+ *(?:$;|#|$Ident:)/) {
2257 my $herevet = "$here\n" . cat_vet($rawline) . "\n";
2258 if (WARN("LEADING_SPACE",
2259 "please, no spaces at the start of a line\n" . $herevet) &&
2260 $fix) {
2261 $fixed[$linenr - 1] =~ s/^\+([ \t]+)/"\+" . tabify($1)/e;
2262 }
2263 }
2264
2265 # check we are in a valid C source file if not then ignore this hunk
2266 next if ($realfile !~ /\.(h|c)$/);
2267
2268 # discourage the addition of CONFIG_EXPERIMENTAL in #if(def).
2269 if ($line =~ /^\+\s*\#\s*if.*\bCONFIG_EXPERIMENTAL\b/) {
2270 WARN("CONFIG_EXPERIMENTAL",
2271 "Use of CONFIG_EXPERIMENTAL is deprecated. For alternatives, see https://lkml.org/lkml/2012/10/23/580\n");
2272 }
2273
2274 # check for RCS/CVS revision markers
2275 if ($rawline =~ /^\+.*\$(Revision|Log|Id)(?:\$|)/) {
2276 WARN("CVS_KEYWORD",
2277 "CVS style keyword markers, these will _not_ be updated\n". $herecurr);
2278 }
2279
2280 # Blackfin: don't use __builtin_bfin_[cs]sync
2281 if ($line =~ /__builtin_bfin_csync/) {
2282 my $herevet = "$here\n" . cat_vet($line) . "\n";
2283 ERROR("CSYNC",
2284 "use the CSYNC() macro in asm/blackfin.h\n" . $herevet);
2285 }
2286 if ($line =~ /__builtin_bfin_ssync/) {
2287 my $herevet = "$here\n" . cat_vet($line) . "\n";
2288 ERROR("SSYNC",
2289 "use the SSYNC() macro in asm/blackfin.h\n" . $herevet);
2290 }
2291
2292 # check for old HOTPLUG __dev<foo> section markings
2293 if ($line =~ /\b(__dev(init|exit)(data|const|))\b/) {
2294 WARN("HOTPLUG_SECTION",
2295 "Using $1 is unnecessary\n" . $herecurr);
2296 }
2297
2298 # Check for potential 'bare' types
2299 my ($stat, $cond, $line_nr_next, $remain_next, $off_next,
2300 $realline_next);
2301 #print "LINE<$line>\n";
2302 if ($linenr >= $suppress_statement &&
2303 $realcnt && $sline =~ /.\s*\S/) {
2304 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2305 ctx_statement_block($linenr, $realcnt, 0);
2306 $stat =~ s/\n./\n /g;
2307 $cond =~ s/\n./\n /g;
2308
2309 #print "linenr<$linenr> <$stat>\n";
2310 # If this statement has no statement boundaries within
2311 # it there is no point in retrying a statement scan
2312 # until we hit end of it.
2313 my $frag = $stat; $frag =~ s/;+\s*$//;
2314 if ($frag !~ /(?:{|;)/) {
2315 #print "skip<$line_nr_next>\n";
2316 $suppress_statement = $line_nr_next;
2317 }
2318
2319 # Find the real next line.
2320 $realline_next = $line_nr_next;
2321 if (defined $realline_next &&
2322 (!defined $lines[$realline_next - 1] ||
2323 substr($lines[$realline_next - 1], $off_next) =~ /^\s*$/)) {
2324 $realline_next++;
2325 }
2326
2327 my $s = $stat;
2328 $s =~ s/{.*$//s;
2329
2330 # Ignore goto labels.
2331 if ($s =~ /$Ident:\*$/s) {
2332
2333 # Ignore functions being called
2334 } elsif ($s =~ /^.\s*$Ident\s*\(/s) {
2335
2336 } elsif ($s =~ /^.\s*else\b/s) {
2337
2338 # declarations always start with types
2339 } 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) {
2340 my $type = $1;
2341 $type =~ s/\s+/ /g;
2342 possible($type, "A:" . $s);
2343
2344 # definitions in global scope can only start with types
2345 } elsif ($s =~ /^.(?:$Storage\s+)?(?:$Inline\s+)?(?:const\s+)?($Ident)\b\s*(?!:)/s) {
2346 possible($1, "B:" . $s);
2347 }
2348
2349 # any (foo ... *) is a pointer cast, and foo is a type
2350 while ($s =~ /\(($Ident)(?:\s+$Sparse)*[\s\*]+\s*\)/sg) {
2351 possible($1, "C:" . $s);
2352 }
2353
2354 # Check for any sort of function declaration.
2355 # int foo(something bar, other baz);
2356 # void (*store_gdt)(x86_descr_ptr *);
2357 if ($prev_values eq 'E' && $s =~ /^(.(?:typedef\s*)?(?:(?:$Storage|$Inline)\s*)*\s*$Type\s*(?:\b$Ident|\(\*\s*$Ident\))\s*)\(/s) {
2358 my ($name_len) = length($1);
2359
2360 my $ctx = $s;
2361 substr($ctx, 0, $name_len + 1, '');
2362 $ctx =~ s/\)[^\)]*$//;
2363
2364 for my $arg (split(/\s*,\s*/, $ctx)) {
2365 if ($arg =~ /^(?:const\s+)?($Ident)(?:\s+$Sparse)*\s*\**\s*(:?\b$Ident)?$/s || $arg =~ /^($Ident)$/s) {
2366
2367 possible($1, "D:" . $s);
2368 }
2369 }
2370 }
2371
2372 }
2373
2374 #
2375 # Checks which may be anchored in the context.
2376 #
2377
2378 # Check for switch () and associated case and default
2379 # statements should be at the same indent.
2380 if ($line=~/\bswitch\s*\(.*\)/) {
2381 my $err = '';
2382 my $sep = '';
2383 my @ctx = ctx_block_outer($linenr, $realcnt);
2384 shift(@ctx);
2385 for my $ctx (@ctx) {
2386 my ($clen, $cindent) = line_stats($ctx);
2387 if ($ctx =~ /^\+\s*(case\s+|default:)/ &&
2388 $indent != $cindent) {
2389 $err .= "$sep$ctx\n";
2390 $sep = '';
2391 } else {
2392 $sep = "[...]\n";
2393 }
2394 }
2395 if ($err ne '') {
2396 ERROR("SWITCH_CASE_INDENT_LEVEL",
2397 "switch and case should be at the same indent\n$hereline$err");
2398 }
2399 }
2400
2401 # if/while/etc brace do not go on next line, unless defining a do while loop,
2402 # or if that brace on the next line is for something else
2403 if ($line =~ /(.*)\b((?:if|while|for|switch)\s*\(|do\b|else\b)/ && $line !~ /^.\s*\#/) {
2404 my $pre_ctx = "$1$2";
2405
2406 my ($level, @ctx) = ctx_statement_level($linenr, $realcnt, 0);
2407
2408 if ($line =~ /^\+\t{6,}/) {
2409 WARN("DEEP_INDENTATION",
2410 "Too many leading tabs - consider code refactoring\n" . $herecurr);
2411 }
2412
2413 my $ctx_cnt = $realcnt - $#ctx - 1;
2414 my $ctx = join("\n", @ctx);
2415
2416 my $ctx_ln = $linenr;
2417 my $ctx_skip = $realcnt;
2418
2419 while ($ctx_skip > $ctx_cnt || ($ctx_skip == $ctx_cnt &&
2420 defined $lines[$ctx_ln - 1] &&
2421 $lines[$ctx_ln - 1] =~ /^-/)) {
2422 ##print "SKIP<$ctx_skip> CNT<$ctx_cnt>\n";
2423 $ctx_skip-- if (!defined $lines[$ctx_ln - 1] || $lines[$ctx_ln - 1] !~ /^-/);
2424 $ctx_ln++;
2425 }
2426
2427 #print "realcnt<$realcnt> ctx_cnt<$ctx_cnt>\n";
2428 #print "pre<$pre_ctx>\nline<$line>\nctx<$ctx>\nnext<$lines[$ctx_ln - 1]>\n";
2429
2430 if ($ctx !~ /{\s*/ && defined($lines[$ctx_ln -1]) && $lines[$ctx_ln - 1] =~ /^\+\s*{/) {
2431 ERROR("OPEN_BRACE",
2432 "that open brace { should be on the previous line\n" .
2433 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2434 }
2435 if ($level == 0 && $pre_ctx !~ /}\s*while\s*\($/ &&
2436 $ctx =~ /\)\s*\;\s*$/ &&
2437 defined $lines[$ctx_ln - 1])
2438 {
2439 my ($nlength, $nindent) = line_stats($lines[$ctx_ln - 1]);
2440 if ($nindent > $indent) {
2441 WARN("TRAILING_SEMICOLON",
2442 "trailing semicolon indicates no statements, indent implies otherwise\n" .
2443 "$here\n$ctx\n$rawlines[$ctx_ln - 1]\n");
2444 }
2445 }
2446 }
2447
2448 # Check relative indent for conditionals and blocks.
2449 if ($line =~ /\b(?:(?:if|while|for)\s*\(|do\b)/ && $line !~ /^.\s*#/ && $line !~ /\}\s*while\s*/) {
2450 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
2451 ctx_statement_block($linenr, $realcnt, 0)
2452 if (!defined $stat);
2453 my ($s, $c) = ($stat, $cond);
2454
2455 substr($s, 0, length($c), '');
2456
2457 # Make sure we remove the line prefixes as we have
2458 # none on the first line, and are going to readd them
2459 # where necessary.
2460 $s =~ s/\n./\n/gs;
2461
2462 # Find out how long the conditional actually is.
2463 my @newlines = ($c =~ /\n/gs);
2464 my $cond_lines = 1 + $#newlines;
2465
2466 # We want to check the first line inside the block
2467 # starting at the end of the conditional, so remove:
2468 # 1) any blank line termination
2469 # 2) any opening brace { on end of the line
2470 # 3) any do (...) {
2471 my $continuation = 0;
2472 my $check = 0;
2473 $s =~ s/^.*\bdo\b//;
2474 $s =~ s/^\s*{//;
2475 if ($s =~ s/^\s*\\//) {
2476 $continuation = 1;
2477 }
2478 if ($s =~ s/^\s*?\n//) {
2479 $check = 1;
2480 $cond_lines++;
2481 }
2482
2483 # Also ignore a loop construct at the end of a
2484 # preprocessor statement.
2485 if (($prevline =~ /^.\s*#\s*define\s/ ||
2486 $prevline =~ /\\\s*$/) && $continuation == 0) {
2487 $check = 0;
2488 }
2489
2490 my $cond_ptr = -1;
2491 $continuation = 0;
2492 while ($cond_ptr != $cond_lines) {
2493 $cond_ptr = $cond_lines;
2494
2495 # If we see an #else/#elif then the code
2496 # is not linear.
2497 if ($s =~ /^\s*\#\s*(?:else|elif)/) {
2498 $check = 0;
2499 }
2500
2501 # Ignore:
2502 # 1) blank lines, they should be at 0,
2503 # 2) preprocessor lines, and
2504 # 3) labels.
2505 if ($continuation ||
2506 $s =~ /^\s*?\n/ ||
2507 $s =~ /^\s*#\s*?/ ||
2508 $s =~ /^\s*$Ident\s*:/) {
2509 $continuation = ($s =~ /^.*?\\\n/) ? 1 : 0;
2510 if ($s =~ s/^.*?\n//) {
2511 $cond_lines++;
2512 }
2513 }
2514 }
2515
2516 my (undef, $sindent) = line_stats("+" . $s);
2517 my $stat_real = raw_line($linenr, $cond_lines);
2518
2519 # Check if either of these lines are modified, else
2520 # this is not this patch's fault.
2521 if (!defined($stat_real) ||
2522 $stat !~ /^\+/ && $stat_real !~ /^\+/) {
2523 $check = 0;
2524 }
2525 if (defined($stat_real) && $cond_lines > 1) {
2526 $stat_real = "[...]\n$stat_real";
2527 }
2528
2529 #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";
2530
2531 if ($check && (($sindent % 8) != 0 ||
2532 ($sindent <= $indent && $s ne ''))) {
2533 WARN("SUSPECT_CODE_INDENT",
2534 "suspect code indent for conditional statements ($indent, $sindent)\n" . $herecurr . "$stat_real\n");
2535 }
2536 }
2537
2538 # Track the 'values' across context and added lines.
2539 my $opline = $line; $opline =~ s/^./ /;
2540 my ($curr_values, $curr_vars) =
2541 annotate_values($opline . "\n", $prev_values);
2542 $curr_values = $prev_values . $curr_values;
2543 if ($dbg_values) {
2544 my $outline = $opline; $outline =~ s/\t/ /g;
2545 print "$linenr > .$outline\n";
2546 print "$linenr > $curr_values\n";
2547 print "$linenr > $curr_vars\n";
2548 }
2549 $prev_values = substr($curr_values, -1);
2550
2551 #ignore lines not being added
2552 next if ($line =~ /^[^\+]/);
2553
2554 # TEST: allow direct testing of the type matcher.
2555 if ($dbg_type) {
2556 if ($line =~ /^.\s*$Declare\s*$/) {
2557 ERROR("TEST_TYPE",
2558 "TEST: is type\n" . $herecurr);
2559 } elsif ($dbg_type > 1 && $line =~ /^.+($Declare)/) {
2560 ERROR("TEST_NOT_TYPE",
2561 "TEST: is not type ($1 is)\n". $herecurr);
2562 }
2563 next;
2564 }
2565 # TEST: allow direct testing of the attribute matcher.
2566 if ($dbg_attr) {
2567 if ($line =~ /^.\s*$Modifier\s*$/) {
2568 ERROR("TEST_ATTR",
2569 "TEST: is attr\n" . $herecurr);
2570 } elsif ($dbg_attr > 1 && $line =~ /^.+($Modifier)/) {
2571 ERROR("TEST_NOT_ATTR",
2572 "TEST: is not attr ($1 is)\n". $herecurr);
2573 }
2574 next;
2575 }
2576
2577 # check for initialisation to aggregates open brace on the next line
2578 if ($line =~ /^.\s*{/ &&
2579 $prevline =~ /(?:^|[^=])=\s*$/) {
2580 ERROR("OPEN_BRACE",
2581 "that open brace { should be on the previous line\n" . $hereprev);
2582 }
2583
2584 #
2585 # Checks which are anchored on the added line.
2586 #
2587
2588 # check for malformed paths in #include statements (uses RAW line)
2589 if ($rawline =~ m{^.\s*\#\s*include\s+[<"](.*)[">]}) {
2590 my $path = $1;
2591 if ($path =~ m{//}) {
2592 ERROR("MALFORMED_INCLUDE",
2593 "malformed #include filename\n" . $herecurr);
2594 }
2595 if ($path =~ "^uapi/" && $realfile =~ m@\binclude/uapi/@) {
2596 ERROR("UAPI_INCLUDE",
2597 "No #include in ...include/uapi/... should use a uapi/ path prefix\n" . $herecurr);
2598 }
2599 }
2600
2601 # no C99 // comments
2602 if ($line =~ m{//}) {
2603 if (ERROR("C99_COMMENTS",
2604 "do not use C99 // comments\n" . $herecurr) &&
2605 $fix) {
2606 my $line = $fixed[$linenr - 1];
2607 if ($line =~ /\/\/(.*)$/) {
2608 my $comment = trim($1);
2609 $fixed[$linenr - 1] =~ s@\/\/(.*)$@/\* $comment \*/@;
2610 }
2611 }
2612 }
2613 # Remove C99 comments.
2614 $line =~ s@//.*@@;
2615 $opline =~ s@//.*@@;
2616
2617 # EXPORT_SYMBOL should immediately follow the thing it is exporting, consider
2618 # the whole statement.
2619 #print "APW <$lines[$realline_next - 1]>\n";
2620 if (defined $realline_next &&
2621 exists $lines[$realline_next - 1] &&
2622 !defined $suppress_export{$realline_next} &&
2623 ($lines[$realline_next - 1] =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2624 $lines[$realline_next - 1] =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2625 # Handle definitions which produce identifiers with
2626 # a prefix:
2627 # XXX(foo);
2628 # EXPORT_SYMBOL(something_foo);
2629 my $name = $1;
2630 if ($stat =~ /^(?:.\s*}\s*\n)?.([A-Z_]+)\s*\(\s*($Ident)/ &&
2631 $name =~ /^${Ident}_$2/) {
2632 #print "FOO C name<$name>\n";
2633 $suppress_export{$realline_next} = 1;
2634
2635 } elsif ($stat !~ /(?:
2636 \n.}\s*$|
2637 ^.DEFINE_$Ident\(\Q$name\E\)|
2638 ^.DECLARE_$Ident\(\Q$name\E\)|
2639 ^.LIST_HEAD\(\Q$name\E\)|
2640 ^.(?:$Storage\s+)?$Type\s*\(\s*\*\s*\Q$name\E\s*\)\s*\(|
2641 \b\Q$name\E(?:\s+$Attribute)*\s*(?:;|=|\[|\()
2642 )/x) {
2643 #print "FOO A<$lines[$realline_next - 1]> stat<$stat> name<$name>\n";
2644 $suppress_export{$realline_next} = 2;
2645 } else {
2646 $suppress_export{$realline_next} = 1;
2647 }
2648 }
2649 if (!defined $suppress_export{$linenr} &&
2650 $prevline =~ /^.\s*$/ &&
2651 ($line =~ /EXPORT_SYMBOL.*\((.*)\)/ ||
2652 $line =~ /EXPORT_UNUSED_SYMBOL.*\((.*)\)/)) {
2653 #print "FOO B <$lines[$linenr - 1]>\n";
2654 $suppress_export{$linenr} = 2;
2655 }
2656 if (defined $suppress_export{$linenr} &&
2657 $suppress_export{$linenr} == 2) {
2658 WARN("EXPORT_SYMBOL",
2659 "EXPORT_SYMBOL(foo); should immediately follow its function/variable\n" . $herecurr);
2660 }
2661
2662 # check for global initialisers.
2663 if ($line =~ /^\+(\s*$Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/) {
2664 if (ERROR("GLOBAL_INITIALISERS",
2665 "do not initialise globals to 0 or NULL\n" .
2666 $herecurr) &&
2667 $fix) {
2668 $fixed[$linenr - 1] =~ s/($Type\s*$Ident\s*(?:\s+$Modifier))*\s*=\s*(0|NULL|false)\s*;/$1;/;
2669 }
2670 }
2671 # check for static initialisers.
2672 if ($line =~ /^\+.*\bstatic\s.*=\s*(0|NULL|false)\s*;/) {
2673 if (ERROR("INITIALISED_STATIC",
2674 "do not initialise statics to 0 or NULL\n" .
2675 $herecurr) &&
2676 $fix) {
2677 $fixed[$linenr - 1] =~ s/(\bstatic\s.*?)\s*=\s*(0|NULL|false)\s*;/$1;/;
2678 }
2679 }
2680
2681 # check for static const char * arrays.
2682 if ($line =~ /\bstatic\s+const\s+char\s*\*\s*(\w+)\s*\[\s*\]\s*=\s*/) {
2683 WARN("STATIC_CONST_CHAR_ARRAY",
2684 "static const char * array should probably be static const char * const\n" .
2685 $herecurr);
2686 }
2687
2688 # check for static char foo[] = "bar" declarations.
2689 if ($line =~ /\bstatic\s+char\s+(\w+)\s*\[\s*\]\s*=\s*"/) {
2690 WARN("STATIC_CONST_CHAR_ARRAY",
2691 "static char array declaration should probably be static const char\n" .
2692 $herecurr);
2693 }
2694
2695 # check for non-global char *foo[] = {"bar", ...} declarations.
2696 if ($line =~ /^.\s+(?:static\s+|const\s+)?char\s+\*\s*\w+\s*\[\s*\]\s*=\s*\{/) {
2697 WARN("STATIC_CONST_CHAR_ARRAY",
2698 "char * array declaration might be better as static const\n" .
2699 $herecurr);
2700 }
2701
2702 # check for function declarations without arguments like "int foo()"
2703 if ($line =~ /(\b$Type\s+$Ident)\s*\(\s*\)/) {
2704 if (ERROR("FUNCTION_WITHOUT_ARGS",
2705 "Bad function definition - $1() should probably be $1(void)\n" . $herecurr) &&
2706 $fix) {
2707 $fixed[$linenr - 1] =~ s/(\b($Type)\s+($Ident))\s*\(\s*\)/$2 $3(void)/;
2708 }
2709 }
2710
2711 # check for uses of DEFINE_PCI_DEVICE_TABLE
2712 if ($line =~ /\bDEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=/) {
2713 if (WARN("DEFINE_PCI_DEVICE_TABLE",
2714 "Prefer struct pci_device_id over deprecated DEFINE_PCI_DEVICE_TABLE\n" . $herecurr) &&
2715 $fix) {
2716 $fixed[$linenr - 1] =~ s/\b(?:static\s+|)DEFINE_PCI_DEVICE_TABLE\s*\(\s*(\w+)\s*\)\s*=\s*/static const struct pci_device_id $1\[\] = /;
2717 }
2718 }
2719
2720 # check for new typedefs, only function parameters and sparse annotations
2721 # make sense.
2722 if ($line =~ /\btypedef\s/ &&
2723 $line !~ /\btypedef\s+$Type\s*\(\s*\*?$Ident\s*\)\s*\(/ &&
2724 $line !~ /\btypedef\s+$Type\s+$Ident\s*\(/ &&
2725 $line !~ /\b$typeTypedefs\b/ &&
2726 $line !~ /\b__bitwise(?:__|)\b/) {
2727 WARN("NEW_TYPEDEFS",
2728 "do not add new typedefs\n" . $herecurr);
2729 }
2730
2731 # * goes on variable not on type
2732 # (char*[ const])
2733 while ($line =~ m{(\($NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)\))}g) {
2734 #print "AA<$1>\n";
2735 my ($ident, $from, $to) = ($1, $2, $2);
2736
2737 # Should start with a space.
2738 $to =~ s/^(\S)/ $1/;
2739 # Should not end with a space.
2740 $to =~ s/\s+$//;
2741 # '*'s should not have spaces between.
2742 while ($to =~ s/\*\s+\*/\*\*/) {
2743 }
2744
2745 ## print "1: from<$from> to<$to> ident<$ident>\n";
2746 if ($from ne $to) {
2747 if (ERROR("POINTER_LOCATION",
2748 "\"(foo$from)\" should be \"(foo$to)\"\n" . $herecurr) &&
2749 $fix) {
2750 my $sub_from = $ident;
2751 my $sub_to = $ident;
2752 $sub_to =~ s/\Q$from\E/$to/;
2753 $fixed[$linenr - 1] =~
2754 s@\Q$sub_from\E@$sub_to@;
2755 }
2756 }
2757 }
2758 while ($line =~ m{(\b$NonptrType(\s*(?:$Modifier\b\s*|\*\s*)+)($Ident))}g) {
2759 #print "BB<$1>\n";
2760 my ($match, $from, $to, $ident) = ($1, $2, $2, $3);
2761
2762 # Should start with a space.
2763 $to =~ s/^(\S)/ $1/;
2764 # Should not end with a space.
2765 $to =~ s/\s+$//;
2766 # '*'s should not have spaces between.
2767 while ($to =~ s/\*\s+\*/\*\*/) {
2768 }
2769 # Modifiers should have spaces.
2770 $to =~ s/(\b$Modifier$)/$1 /;
2771
2772 ## print "2: from<$from> to<$to> ident<$ident>\n";
2773 if ($from ne $to && $ident !~ /^$Modifier$/) {
2774 if (ERROR("POINTER_LOCATION",
2775 "\"foo${from}bar\" should be \"foo${to}bar\"\n" . $herecurr) &&
2776 $fix) {
2777
2778 my $sub_from = $match;
2779 my $sub_to = $match;
2780 $sub_to =~ s/\Q$from\E/$to/;
2781 $fixed[$linenr - 1] =~
2782 s@\Q$sub_from\E@$sub_to@;
2783 }
2784 }
2785 }
2786
2787 # # no BUG() or BUG_ON()
2788 # if ($line =~ /\b(BUG|BUG_ON)\b/) {
2789 # print "Try to use WARN_ON & Recovery code rather than BUG() or BUG_ON()\n";
2790 # print "$herecurr";
2791 # $clean = 0;
2792 # }
2793
2794 if ($line =~ /\bLINUX_VERSION_CODE\b/) {
2795 WARN("LINUX_VERSION_CODE",
2796 "LINUX_VERSION_CODE should be avoided, code should be for the version to which it is merged\n" . $herecurr);
2797 }
2798
2799 # check for uses of printk_ratelimit
2800 if ($line =~ /\bprintk_ratelimit\s*\(/) {
2801 WARN("PRINTK_RATELIMITED",
2802 "Prefer printk_ratelimited or pr_<level>_ratelimited to printk_ratelimit\n" . $herecurr);
2803 }
2804
2805 # printk should use KERN_* levels. Note that follow on printk's on the
2806 # same line do not need a level, so we use the current block context
2807 # to try and find and validate the current printk. In summary the current
2808 # printk includes all preceding printk's which have no newline on the end.
2809 # we assume the first bad printk is the one to report.
2810 if ($line =~ /\bprintk\((?!KERN_)\s*"/) {
2811 my $ok = 0;
2812 for (my $ln = $linenr - 1; $ln >= $first_line; $ln--) {
2813 #print "CHECK<$lines[$ln - 1]\n";
2814 # we have a preceding printk if it ends
2815 # with "\n" ignore it, else it is to blame
2816 if ($lines[$ln - 1] =~ m{\bprintk\(}) {
2817 if ($rawlines[$ln - 1] !~ m{\\n"}) {
2818 $ok = 1;
2819 }
2820 last;
2821 }
2822 }
2823 if ($ok == 0) {
2824 WARN("PRINTK_WITHOUT_KERN_LEVEL",
2825 "printk() should include KERN_ facility level\n" . $herecurr);
2826 }
2827 }
2828
2829 if ($line =~ /\bprintk\s*\(\s*KERN_([A-Z]+)/) {
2830 my $orig = $1;
2831 my $level = lc($orig);
2832 $level = "warn" if ($level eq "warning");
2833 my $level2 = $level;
2834 $level2 = "dbg" if ($level eq "debug");
2835 WARN("PREFER_PR_LEVEL",
2836 "Prefer [subsystem eg: netdev]_$level2([subsystem]dev, ... then dev_$level2(dev, ... then pr_$level(... to printk(KERN_$orig ...\n" . $herecurr);
2837 }
2838
2839 if ($line =~ /\bpr_warning\s*\(/) {
2840 if (WARN("PREFER_PR_LEVEL",
2841 "Prefer pr_warn(... to pr_warning(...\n" . $herecurr) &&
2842 $fix) {
2843 $fixed[$linenr - 1] =~
2844 s/\bpr_warning\b/pr_warn/;
2845 }
2846 }
2847
2848 if ($line =~ /\bdev_printk\s*\(\s*KERN_([A-Z]+)/) {
2849 my $orig = $1;
2850 my $level = lc($orig);
2851 $level = "warn" if ($level eq "warning");
2852 $level = "dbg" if ($level eq "debug");
2853 WARN("PREFER_DEV_LEVEL",
2854 "Prefer dev_$level(... to dev_printk(KERN_$orig, ...\n" . $herecurr);
2855 }
2856
2857 # function brace can't be on same line, except for #defines of do while,
2858 # or if closed on same line
2859 if (($line=~/$Type\s*$Ident\(.*\).*\s{/) and
2860 !($line=~/\#\s*define.*do\s{/) and !($line=~/}/)) {
2861 ERROR("OPEN_BRACE",
2862 "open brace '{' following function declarations go on the next line\n" . $herecurr);
2863 }
2864
2865 # open braces for enum, union and struct go on the same line.
2866 if ($line =~ /^.\s*{/ &&
2867 $prevline =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident)?\s*$/) {
2868 ERROR("OPEN_BRACE",
2869 "open brace '{' following $1 go on the same line\n" . $hereprev);
2870 }
2871
2872 # missing space after union, struct or enum definition
2873 if ($line =~ /^.\s*(?:typedef\s+)?(enum|union|struct)(?:\s+$Ident){1,2}[=\{]/) {
2874 if (WARN("SPACING",
2875 "missing space after $1 definition\n" . $herecurr) &&
2876 $fix) {
2877 $fixed[$linenr - 1] =~
2878 s/^(.\s*(?:typedef\s+)?(?:enum|union|struct)(?:\s+$Ident){1,2})([=\{])/$1 $2/;
2879 }
2880 }
2881
2882 # Function pointer declarations
2883 # check spacing between type, funcptr, and args
2884 # canonical declaration is "type (*funcptr)(args...)"
2885 if ($line =~ /^.\s*($Declare)\((\s*)\*(\s*)($Ident)(\s*)\)(\s*)\(/) {
2886 my $declare = $1;
2887 my $pre_pointer_space = $2;
2888 my $post_pointer_space = $3;
2889 my $funcname = $4;
2890 my $post_funcname_space = $5;
2891 my $pre_args_space = $6;
2892
2893 # the $Declare variable will capture all spaces after the type
2894 # so check it for a missing trailing missing space but pointer return types
2895 # don't need a space so don't warn for those.
2896 my $post_declare_space = "";
2897 if ($declare =~ /(\s+)$/) {
2898 $post_declare_space = $1;
2899 $declare = rtrim($declare);
2900 }
2901 if ($declare !~ /\*$/ && $post_declare_space =~ /^$/) {
2902 WARN("SPACING",
2903 "missing space after return type\n" . $herecurr);
2904 $post_declare_space = " ";
2905 }
2906
2907 # unnecessary space "type (*funcptr)(args...)"
2908 # This test is not currently implemented because these declarations are
2909 # equivalent to
2910 # int foo(int bar, ...)
2911 # and this is form shouldn't/doesn't generate a checkpatch warning.
2912 #
2913 # elsif ($declare =~ /\s{2,}$/) {
2914 # WARN("SPACING",
2915 # "Multiple spaces after return type\n" . $herecurr);
2916 # }
2917
2918 # unnecessary space "type ( *funcptr)(args...)"
2919 if (defined $pre_pointer_space &&
2920 $pre_pointer_space =~ /^\s/) {
2921 WARN("SPACING",
2922 "Unnecessary space after function pointer open parenthesis\n" . $herecurr);
2923 }
2924
2925 # unnecessary space "type (* funcptr)(args...)"
2926 if (defined $post_pointer_space &&
2927 $post_pointer_space =~ /^\s/) {
2928 WARN("SPACING",
2929 "Unnecessary space before function pointer name\n" . $herecurr);
2930 }
2931
2932 # unnecessary space "type (*funcptr )(args...)"
2933 if (defined $post_funcname_space &&
2934 $post_funcname_space =~ /^\s/) {
2935 WARN("SPACING",
2936 "Unnecessary space after function pointer name\n" . $herecurr);
2937 }
2938
2939 # unnecessary space "type (*funcptr) (args...)"
2940 if (defined $pre_args_space &&
2941 $pre_args_space =~ /^\s/) {
2942 WARN("SPACING",
2943 "Unnecessary space before function pointer arguments\n" . $herecurr);
2944 }
2945
2946 if (show_type("SPACING") && $fix) {
2947 $fixed[$linenr - 1] =~
2948 s/^(.\s*)$Declare\s*\(\s*\*\s*$Ident\s*\)\s*\(/$1 . $declare . $post_declare_space . '(*' . $funcname . ')('/ex;
2949 }
2950 }
2951
2952 # check for spacing round square brackets; allowed:
2953 # 1. with a type on the left -- int [] a;
2954 # 2. at the beginning of a line for slice initialisers -- [0...10] = 5,
2955 # 3. inside a curly brace -- = { [0...10] = 5 }
2956 while ($line =~ /(.*?\s)\[/g) {
2957 my ($where, $prefix) = ($-[1], $1);
2958 if ($prefix !~ /$Type\s+$/ &&
2959 ($where != 0 || $prefix !~ /^.\s+$/) &&
2960 $prefix !~ /[{,]\s+$/) {
2961 if (ERROR("BRACKET_SPACE",
2962 "space prohibited before open square bracket '['\n" . $herecurr) &&
2963 $fix) {
2964 $fixed[$linenr - 1] =~
2965 s/^(\+.*?)\s+\[/$1\[/;
2966 }
2967 }
2968 }
2969
2970 # check for spaces between functions and their parentheses.
2971 while ($line =~ /($Ident)\s+\(/g) {
2972 my $name = $1;
2973 my $ctx_before = substr($line, 0, $-[1]);
2974 my $ctx = "$ctx_before$name";
2975
2976 # Ignore those directives where spaces _are_ permitted.
2977 if ($name =~ /^(?:
2978 if|for|while|switch|return|case|
2979 volatile|__volatile__|
2980 __attribute__|format|__extension__|
2981 asm|__asm__)$/x)
2982 {
2983 # cpp #define statements have non-optional spaces, ie
2984 # if there is a space between the name and the open
2985 # parenthesis it is simply not a parameter group.
2986 } elsif ($ctx_before =~ /^.\s*\#\s*define\s*$/) {
2987
2988 # cpp #elif statement condition may start with a (
2989 } elsif ($ctx =~ /^.\s*\#\s*elif\s*$/) {
2990
2991 # If this whole things ends with a type its most
2992 # likely a typedef for a function.
2993 } elsif ($ctx =~ /$Type$/) {
2994
2995 } else {
2996 if (WARN("SPACING",
2997 "space prohibited between function name and open parenthesis '('\n" . $herecurr) &&
2998 $fix) {
2999 $fixed[$linenr - 1] =~
3000 s/\b$name\s+\(/$name\(/;
3001 }
3002 }
3003 }
3004
3005 # Check operator spacing.
3006 if (!($line=~/\#\s*include/)) {
3007 my $fixed_line = "";
3008 my $line_fixed = 0;
3009
3010 my $ops = qr{
3011 <<=|>>=|<=|>=|==|!=|
3012 \+=|-=|\*=|\/=|%=|\^=|\|=|&=|
3013 =>|->|<<|>>|<|>|=|!|~|
3014 &&|\|\||,|\^|\+\+|--|&|\||\+|-|\*|\/|%|
3015 \?:|\?|:
3016 }x;
3017 my @elements = split(/($ops|;)/, $opline);
3018
3019 ## print("element count: <" . $#elements . ">\n");
3020 ## foreach my $el (@elements) {
3021 ## print("el: <$el>\n");
3022 ## }
3023
3024 my @fix_elements = ();
3025 my $off = 0;
3026
3027 foreach my $el (@elements) {
3028 push(@fix_elements, substr($rawline, $off, length($el)));
3029 $off += length($el);
3030 }
3031
3032 $off = 0;
3033
3034 my $blank = copy_spacing($opline);
3035 my $last_after = -1;
3036
3037 for (my $n = 0; $n < $#elements; $n += 2) {
3038
3039 my $good = $fix_elements[$n] . $fix_elements[$n + 1];
3040
3041 ## print("n: <$n> good: <$good>\n");
3042
3043 $off += length($elements[$n]);
3044
3045 # Pick up the preceding and succeeding characters.
3046 my $ca = substr($opline, 0, $off);
3047 my $cc = '';
3048 if (length($opline) >= ($off + length($elements[$n + 1]))) {
3049 $cc = substr($opline, $off + length($elements[$n + 1]));
3050 }
3051 my $cb = "$ca$;$cc";
3052
3053 my $a = '';
3054 $a = 'V' if ($elements[$n] ne '');
3055 $a = 'W' if ($elements[$n] =~ /\s$/);
3056 $a = 'C' if ($elements[$n] =~ /$;$/);
3057 $a = 'B' if ($elements[$n] =~ /(\[|\()$/);
3058 $a = 'O' if ($elements[$n] eq '');
3059 $a = 'E' if ($ca =~ /^\s*$/);
3060
3061 my $op = $elements[$n + 1];
3062
3063 my $c = '';
3064 if (defined $elements[$n + 2]) {
3065 $c = 'V' if ($elements[$n + 2] ne '');
3066 $c = 'W' if ($elements[$n + 2] =~ /^\s/);
3067 $c = 'C' if ($elements[$n + 2] =~ /^$;/);
3068 $c = 'B' if ($elements[$n + 2] =~ /^(\)|\]|;)/);
3069 $c = 'O' if ($elements[$n + 2] eq '');
3070 $c = 'E' if ($elements[$n + 2] =~ /^\s*\\$/);
3071 } else {
3072 $c = 'E';
3073 }
3074
3075 my $ctx = "${a}x${c}";
3076
3077 my $at = "(ctx:$ctx)";
3078
3079 my $ptr = substr($blank, 0, $off) . "^";
3080 my $hereptr = "$hereline$ptr\n";
3081
3082 # Pull out the value of this operator.
3083 my $op_type = substr($curr_values, $off + 1, 1);
3084
3085 # Get the full operator variant.
3086 my $opv = $op . substr($curr_vars, $off, 1);
3087
3088 # Ignore operators passed as parameters.
3089 if ($op_type ne 'V' &&
3090 $ca =~ /\s$/ && $cc =~ /^\s*,/) {
3091
3092 # # Ignore comments
3093 # } elsif ($op =~ /^$;+$/) {
3094
3095 # ; should have either the end of line or a space or \ after it
3096 } elsif ($op eq ';') {
3097 if ($ctx !~ /.x[WEBC]/ &&
3098 $cc !~ /^\\/ && $cc !~ /^;/) {
3099 if (ERROR("SPACING",
3100 "space required after that '$op' $at\n" . $hereptr)) {
3101 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3102 $line_fixed = 1;
3103 }
3104 }
3105
3106 # // is a comment
3107 } elsif ($op eq '//') {
3108
3109 # No spaces for:
3110 # ->
3111 # : when part of a bitfield
3112 } elsif ($op eq '->' || $opv eq ':B') {
3113 if ($ctx =~ /Wx.|.xW/) {
3114 if (ERROR("SPACING",
3115 "spaces prohibited around that '$op' $at\n" . $hereptr)) {
3116 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3117 if (defined $fix_elements[$n + 2]) {
3118 $fix_elements[$n + 2] =~ s/^\s+//;
3119 }
3120 $line_fixed = 1;
3121 }
3122 }
3123
3124 # , must have a space on the right.
3125 } elsif ($op eq ',') {
3126 if ($ctx !~ /.x[WEC]/ && $cc !~ /^}/) {
3127 if (ERROR("SPACING",
3128 "space required after that '$op' $at\n" . $hereptr)) {
3129 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3130 $line_fixed = 1;
3131 $last_after = $n;
3132 }
3133 }
3134
3135 # '*' as part of a type definition -- reported already.
3136 } elsif ($opv eq '*_') {
3137 #warn "'*' is part of type\n";
3138
3139 # unary operators should have a space before and
3140 # none after. May be left adjacent to another
3141 # unary operator, or a cast
3142 } elsif ($op eq '!' || $op eq '~' ||
3143 $opv eq '*U' || $opv eq '-U' ||
3144 $opv eq '&U' || $opv eq '&&U') {
3145 if ($ctx !~ /[WEBC]x./ && $ca !~ /(?:\)|!|~|\*|-|\&|\||\+\+|\-\-|\{)$/) {
3146 if (ERROR("SPACING",
3147 "space required before that '$op' $at\n" . $hereptr)) {
3148 if ($n != $last_after + 2) {
3149 $good = $fix_elements[$n] . " " . ltrim($fix_elements[$n + 1]);
3150 $line_fixed = 1;
3151 }
3152 }
3153 }
3154 if ($op eq '*' && $cc =~/\s*$Modifier\b/) {
3155 # A unary '*' may be const
3156
3157 } elsif ($ctx =~ /.xW/) {
3158 if (ERROR("SPACING",
3159 "space prohibited after that '$op' $at\n" . $hereptr)) {
3160 $good = $fix_elements[$n] . rtrim($fix_elements[$n + 1]);
3161 if (defined $fix_elements[$n + 2]) {
3162 $fix_elements[$n + 2] =~ s/^\s+//;
3163 }
3164 $line_fixed = 1;
3165 }
3166 }
3167
3168 # unary ++ and unary -- are allowed no space on one side.
3169 } elsif ($op eq '++' or $op eq '--') {
3170 if ($ctx !~ /[WEOBC]x[^W]/ && $ctx !~ /[^W]x[WOBEC]/) {
3171 if (ERROR("SPACING",
3172 "space required one side of that '$op' $at\n" . $hereptr)) {
3173 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]) . " ";
3174 $line_fixed = 1;
3175 }
3176 }
3177 if ($ctx =~ /Wx[BE]/ ||
3178 ($ctx =~ /Wx./ && $cc =~ /^;/)) {
3179 if (ERROR("SPACING",
3180 "space prohibited before that '$op' $at\n" . $hereptr)) {
3181 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3182 $line_fixed = 1;
3183 }
3184 }
3185 if ($ctx =~ /ExW/) {
3186 if (ERROR("SPACING",
3187 "space prohibited after that '$op' $at\n" . $hereptr)) {
3188 $good = $fix_elements[$n] . trim($fix_elements[$n + 1]);
3189 if (defined $fix_elements[$n + 2]) {
3190 $fix_elements[$n + 2] =~ s/^\s+//;
3191 }
3192 $line_fixed = 1;
3193 }
3194 }
3195
3196 # << and >> may either have or not have spaces both sides
3197 } elsif ($op eq '<<' or $op eq '>>' or
3198 $op eq '&' or $op eq '^' or $op eq '|' or
3199 $op eq '+' or $op eq '-' or
3200 $op eq '*' or $op eq '/' or
3201 $op eq '%')
3202 {
3203 if ($ctx =~ /Wx[^WCE]|[^WCE]xW/) {
3204 if (ERROR("SPACING",
3205 "need consistent spacing around '$op' $at\n" . $hereptr)) {
3206 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3207 if (defined $fix_elements[$n + 2]) {
3208 $fix_elements[$n + 2] =~ s/^\s+//;
3209 }
3210 $line_fixed = 1;
3211 }
3212 }
3213
3214 # A colon needs no spaces before when it is
3215 # terminating a case value or a label.
3216 } elsif ($opv eq ':C' || $opv eq ':L') {
3217 if ($ctx =~ /Wx./) {
3218 if (ERROR("SPACING",
3219 "space prohibited before that '$op' $at\n" . $hereptr)) {
3220 $good = rtrim($fix_elements[$n]) . trim($fix_elements[$n + 1]);
3221 $line_fixed = 1;
3222 }
3223 }
3224
3225 # All the others need spaces both sides.
3226 } elsif ($ctx !~ /[EWC]x[CWE]/) {
3227 my $ok = 0;
3228
3229 # Ignore email addresses <foo@bar>
3230 if (($op eq '<' &&
3231 $cc =~ /^\S+\@\S+>/) ||
3232 ($op eq '>' &&
3233 $ca =~ /<\S+\@\S+$/))
3234 {
3235 $ok = 1;
3236 }
3237
3238 # messages are ERROR, but ?: are CHK
3239 if ($ok == 0) {
3240 my $msg_type = \&ERROR;
3241 $msg_type = \&CHK if (($op eq '?:' || $op eq '?' || $op eq ':') && $ctx =~ /VxV/);
3242
3243 if (&{$msg_type}("SPACING",
3244 "spaces required around that '$op' $at\n" . $hereptr)) {
3245 $good = rtrim($fix_elements[$n]) . " " . trim($fix_elements[$n + 1]) . " ";
3246 if (defined $fix_elements[$n + 2]) {
3247 $fix_elements[$n + 2] =~ s/^\s+//;
3248 }
3249 $line_fixed = 1;
3250 }
3251 }
3252 }
3253 $off += length($elements[$n + 1]);
3254
3255 ## print("n: <$n> GOOD: <$good>\n");
3256
3257 $fixed_line = $fixed_line . $good;
3258 }
3259
3260 if (($#elements % 2) == 0) {
3261 $fixed_line = $fixed_line . $fix_elements[$#elements];
3262 }
3263
3264 if ($fix && $line_fixed && $fixed_line ne $fixed[$linenr - 1]) {
3265 $fixed[$linenr - 1] = $fixed_line;
3266 }
3267
3268
3269 }
3270
3271 # check for whitespace before a non-naked semicolon
3272 if ($line =~ /^\+.*\S\s+;\s*$/) {
3273 if (WARN("SPACING",
3274 "space prohibited before semicolon\n" . $herecurr) &&
3275 $fix) {
3276 1 while $fixed[$linenr - 1] =~
3277 s/^(\+.*\S)\s+;/$1;/;
3278 }
3279 }
3280
3281 # check for multiple assignments
3282 if ($line =~ /^.\s*$Lval\s*=\s*$Lval\s*=(?!=)/) {
3283 CHK("MULTIPLE_ASSIGNMENTS",
3284 "multiple assignments should be avoided\n" . $herecurr);
3285 }
3286
3287 ## # check for multiple declarations, allowing for a function declaration
3288 ## # continuation.
3289 ## if ($line =~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Ident.*/ &&
3290 ## $line !~ /^.\s*$Type\s+$Ident(?:\s*=[^,{]*)?\s*,\s*$Type\s*$Ident.*/) {
3291 ##
3292 ## # Remove any bracketed sections to ensure we do not
3293 ## # falsly report the parameters of functions.
3294 ## my $ln = $line;
3295 ## while ($ln =~ s/\([^\(\)]*\)//g) {
3296 ## }
3297 ## if ($ln =~ /,/) {
3298 ## WARN("MULTIPLE_DECLARATION",
3299 ## "declaring multiple variables together should be avoided\n" . $herecurr);
3300 ## }
3301 ## }
3302
3303 #need space before brace following if, while, etc
3304 if (($line =~ /\(.*\){/ && $line !~ /\($Type\){/) ||
3305 $line =~ /do{/) {
3306 if (ERROR("SPACING",
3307 "space required before the open brace '{'\n" . $herecurr) &&
3308 $fix) {
3309 $fixed[$linenr - 1] =~ s/^(\+.*(?:do|\))){/$1 {/;
3310 }
3311 }
3312
3313 ## # check for blank lines before declarations
3314 ## if ($line =~ /^.\t+$Type\s+$Ident(?:\s*=.*)?;/ &&
3315 ## $prevrawline =~ /^.\s*$/) {
3316 ## WARN("SPACING",
3317 ## "No blank lines before declarations\n" . $hereprev);
3318 ## }
3319 ##
3320
3321 # closing brace should have a space following it when it has anything
3322 # on the line
3323 if ($line =~ /}(?!(?:,|;|\)))\S/) {
3324 if (ERROR("SPACING",
3325 "space required after that close brace '}'\n" . $herecurr) &&
3326 $fix) {
3327 $fixed[$linenr - 1] =~
3328 s/}((?!(?:,|;|\)))\S)/} $1/;
3329 }
3330 }
3331
3332 # check spacing on square brackets
3333 if ($line =~ /\[\s/ && $line !~ /\[\s*$/) {
3334 if (ERROR("SPACING",
3335 "space prohibited after that open square bracket '['\n" . $herecurr) &&
3336 $fix) {
3337 $fixed[$linenr - 1] =~
3338 s/\[\s+/\[/;
3339 }
3340 }
3341 if ($line =~ /\s\]/) {
3342 if (ERROR("SPACING",
3343 "space prohibited before that close square bracket ']'\n" . $herecurr) &&
3344 $fix) {
3345 $fixed[$linenr - 1] =~
3346 s/\s+\]/\]/;
3347 }
3348 }
3349
3350 # check spacing on parentheses
3351 if ($line =~ /\(\s/ && $line !~ /\(\s*(?:\\)?$/ &&
3352 $line !~ /for\s*\(\s+;/) {
3353 if (ERROR("SPACING",
3354 "space prohibited after that open parenthesis '('\n" . $herecurr) &&
3355 $fix) {
3356 $fixed[$linenr - 1] =~
3357 s/\(\s+/\(/;
3358 }
3359 }
3360 if ($line =~ /(\s+)\)/ && $line !~ /^.\s*\)/ &&
3361 $line !~ /for\s*\(.*;\s+\)/ &&
3362 $line !~ /:\s+\)/) {
3363 if (ERROR("SPACING",
3364 "space prohibited before that close parenthesis ')'\n" . $herecurr) &&
3365 $fix) {
3366 $fixed[$linenr - 1] =~
3367 s/\s+\)/\)/;
3368 }
3369 }
3370
3371 #goto labels aren't indented, allow a single space however
3372 if ($line=~/^.\s+[A-Za-z\d_]+:(?![0-9]+)/ and
3373 !($line=~/^. [A-Za-z\d_]+:/) and !($line=~/^.\s+default:/)) {
3374 if (WARN("INDENTED_LABEL",
3375 "labels should not be indented\n" . $herecurr) &&
3376 $fix) {
3377 $fixed[$linenr - 1] =~
3378 s/^(.)\s+/$1/;
3379 }
3380 }
3381
3382 # return is not a function
3383 if (defined($stat) && $stat =~ /^.\s*return(\s*)\(/s) {
3384 my $spacing = $1;
3385 if ($^V && $^V ge 5.10.0 &&
3386 $stat =~ /^.\s*return\s*($balanced_parens)\s*;\s*$/) {
3387 my $value = $1;
3388 $value = deparenthesize($value);
3389 if ($value =~ m/^\s*$FuncArg\s*(?:\?|$)/) {
3390 ERROR("RETURN_PARENTHESES",
3391 "return is not a function, parentheses are not required\n" . $herecurr);
3392 }
3393 } elsif ($spacing !~ /\s+/) {
3394 ERROR("SPACING",
3395 "space required before the open parenthesis '('\n" . $herecurr);
3396 }
3397 }
3398
3399 # if statements using unnecessary parentheses - ie: if ((foo == bar))
3400 if ($^V && $^V ge 5.10.0 &&
3401 $line =~ /\bif\s*((?:\(\s*){2,})/) {
3402 my $openparens = $1;
3403 my $count = $openparens =~ tr@\(@\(@;
3404 my $msg = "";
3405 if ($line =~ /\bif\s*(?:\(\s*){$count,$count}$LvalOrFunc\s*($Compare)\s*$LvalOrFunc(?:\s*\)){$count,$count}/) {
3406 my $comp = $4; #Not $1 because of $LvalOrFunc
3407 $msg = " - maybe == should be = ?" if ($comp eq "==");
3408 WARN("UNNECESSARY_PARENTHESES",
3409 "Unnecessary parentheses$msg\n" . $herecurr);
3410 }
3411 }
3412
3413 # Return of what appears to be an errno should normally be -'ve
3414 if ($line =~ /^.\s*return\s*(E[A-Z]*)\s*;/) {
3415 my $name = $1;
3416 if ($name ne 'EOF' && $name ne 'ERROR') {
3417 WARN("USE_NEGATIVE_ERRNO",
3418 "return of an errno should typically be -ve (return -$1)\n" . $herecurr);
3419 }
3420 }
3421
3422 # Need a space before open parenthesis after if, while etc
3423 if ($line =~ /\b(if|while|for|switch)\(/) {
3424 if (ERROR("SPACING",
3425 "space required before the open parenthesis '('\n" . $herecurr) &&
3426 $fix) {
3427 $fixed[$linenr - 1] =~
3428 s/\b(if|while|for|switch)\(/$1 \(/;
3429 }
3430 }
3431
3432 # Check for illegal assignment in if conditional -- and check for trailing
3433 # statements after the conditional.
3434 if ($line =~ /do\s*(?!{)/) {
3435 ($stat, $cond, $line_nr_next, $remain_next, $off_next) =
3436 ctx_statement_block($linenr, $realcnt, 0)
3437 if (!defined $stat);
3438 my ($stat_next) = ctx_statement_block($line_nr_next,
3439 $remain_next, $off_next);
3440 $stat_next =~ s/\n./\n /g;
3441 ##print "stat<$stat> stat_next<$stat_next>\n";
3442
3443 if ($stat_next =~ /^\s*while\b/) {
3444 # If the statement carries leading newlines,
3445 # then count those as offsets.
3446 my ($whitespace) =
3447 ($stat_next =~ /^((?:\s*\n[+-])*\s*)/s);
3448 my $offset =
3449 statement_rawlines($whitespace) - 1;
3450
3451 $suppress_whiletrailers{$line_nr_next +
3452 $offset} = 1;
3453 }
3454 }
3455 if (!defined $suppress_whiletrailers{$linenr} &&
3456 defined($stat) && defined($cond) &&
3457 $line =~ /\b(?:if|while|for)\s*\(/ && $line !~ /^.\s*#/) {
3458 my ($s, $c) = ($stat, $cond);
3459
3460 if ($c =~ /\bif\s*\(.*[^<>!=]=[^=].*/s) {
3461 ERROR("ASSIGN_IN_IF",
3462 "do not use assignment in if condition\n" . $herecurr);
3463 }
3464
3465 # Find out what is on the end of the line after the
3466 # conditional.
3467 substr($s, 0, length($c), '');
3468 $s =~ s/\n.*//g;
3469 $s =~ s/$;//g; # Remove any comments
3470 if (length($c) && $s !~ /^\s*{?\s*\\*\s*$/ &&
3471 $c !~ /}\s*while\s*/)
3472 {
3473 # Find out how long the conditional actually is.
3474 my @newlines = ($c =~ /\n/gs);
3475 my $cond_lines = 1 + $#newlines;
3476 my $stat_real = '';
3477
3478 $stat_real = raw_line($linenr, $cond_lines)
3479 . "\n" if ($cond_lines);
3480 if (defined($stat_real) && $cond_lines > 1) {
3481 $stat_real = "[...]\n$stat_real";
3482 }
3483
3484 ERROR("TRAILING_STATEMENTS",
3485 "trailing statements should be on next line\n" . $herecurr . $stat_real);
3486 }
3487 }
3488
3489 # Check for bitwise tests written as boolean
3490 if ($line =~ /
3491 (?:
3492 (?:\[|\(|\&\&|\|\|)
3493 \s*0[xX][0-9]+\s*
3494 (?:\&\&|\|\|)
3495 |
3496 (?:\&\&|\|\|)
3497 \s*0[xX][0-9]+\s*
3498 (?:\&\&|\|\||\)|\])
3499 )/x)
3500 {
3501 WARN("HEXADECIMAL_BOOLEAN_TEST",
3502 "boolean test with hexadecimal, perhaps just 1 \& or \|?\n" . $herecurr);
3503 }
3504
3505 # if and else should not have general statements after it
3506 if ($line =~ /^.\s*(?:}\s*)?else\b(.*)/) {
3507 my $s = $1;
3508 $s =~ s/$;//g; # Remove any comments
3509 if ($s !~ /^\s*(?:\sif|(?:{|)\s*\\?\s*$)/) {
3510 ERROR("TRAILING_STATEMENTS",
3511 "trailing statements should be on next line\n" . $herecurr);
3512 }
3513 }
3514 # if should not continue a brace
3515 if ($line =~ /}\s*if\b/) {
3516 ERROR("TRAILING_STATEMENTS",
3517 "trailing statements should be on next line\n" .
3518 $herecurr);
3519 }
3520 # case and default should not have general statements after them
3521 if ($line =~ /^.\s*(?:case\s*.*|default\s*):/g &&
3522 $line !~ /\G(?:
3523 (?:\s*$;*)(?:\s*{)?(?:\s*$;*)(?:\s*\\)?\s*$|
3524 \s*return\s+
3525 )/xg)
3526 {
3527 ERROR("TRAILING_STATEMENTS",
3528 "trailing statements should be on next line\n" . $herecurr);
3529 }
3530
3531 # Check for }<nl>else {, these must be at the same
3532 # indent level to be relevant to each other.
3533 if ($prevline=~/}\s*$/ and $line=~/^.\s*else\s*/ and
3534 $previndent == $indent) {
3535 ERROR("ELSE_AFTER_BRACE",
3536 "else should follow close brace '}'\n" . $hereprev);
3537 }
3538
3539 if ($prevline=~/}\s*$/ and $line=~/^.\s*while\s*/ and
3540 $previndent == $indent) {
3541 my ($s, $c) = ctx_statement_block($linenr, $realcnt, 0);
3542
3543 # Find out what is on the end of the line after the
3544 # conditional.
3545 substr($s, 0, length($c), '');
3546 $s =~ s/\n.*//g;
3547
3548 if ($s =~ /^\s*;/) {
3549 ERROR("WHILE_AFTER_BRACE",
3550 "while should follow close brace '}'\n" . $hereprev);
3551 }
3552 }
3553
3554 #Specific variable tests
3555 while ($line =~ m{($Constant|$Lval)}g) {
3556 my $var = $1;
3557
3558 #gcc binary extension
3559 if ($var =~ /^$Binary$/) {
3560 if (WARN("GCC_BINARY_CONSTANT",
3561 "Avoid gcc v4.3+ binary constant extension: <$var>\n" . $herecurr) &&
3562 $fix) {
3563 my $hexval = sprintf("0x%x", oct($var));
3564 $fixed[$linenr - 1] =~
3565 s/\b$var\b/$hexval/;
3566 }
3567 }
3568
3569 #CamelCase
3570 if ($var !~ /^$Constant$/ &&
3571 $var =~ /[A-Z][a-z]|[a-z][A-Z]/ &&
3572 #Ignore Page<foo> variants
3573 $var !~ /^(?:Clear|Set|TestClear|TestSet|)Page[A-Z]/ &&
3574 #Ignore SI style variants like nS, mV and dB (ie: max_uV, regulator_min_uA_show)
3575 $var !~ /^(?:[a-z_]*?)_?[a-z][A-Z](?:_[a-z_]+)?$/) {
3576 while ($var =~ m{($Ident)}g) {
3577 my $word = $1;
3578 next if ($word !~ /[A-Z][a-z]|[a-z][A-Z]/);
3579 if ($check) {
3580 seed_camelcase_includes();
3581 if (!$file && !$camelcase_file_seeded) {
3582 seed_camelcase_file($realfile);
3583 $camelcase_file_seeded = 1;
3584 }
3585 }
3586 if (!defined $camelcase{$word}) {
3587 $camelcase{$word} = 1;
3588 CHK("CAMELCASE",
3589 "Avoid CamelCase: <$word>\n" . $herecurr);
3590 }
3591 }
3592 }
3593 }
3594
3595 #no spaces allowed after \ in define
3596 if ($line =~ /\#\s*define.*\\\s+$/) {
3597 if (WARN("WHITESPACE_AFTER_LINE_CONTINUATION",
3598 "Whitespace after \\ makes next lines useless\n" . $herecurr) &&
3599 $fix) {
3600 $fixed[$linenr - 1] =~ s/\s+$//;
3601 }
3602 }
3603
3604 #warn if <asm/foo.h> is #included and <linux/foo.h> is available (uses RAW line)
3605 if ($tree && $rawline =~ m{^.\s*\#\s*include\s*\<asm\/(.*)\.h\>}) {
3606 my $file = "$1.h";
3607 my $checkfile = "include/linux/$file";
3608 if (-f "$root/$checkfile" &&
3609 $realfile ne $checkfile &&
3610 $1 !~ /$allowed_asm_includes/)
3611 {
3612 if ($realfile =~ m{^arch/}) {
3613 CHK("ARCH_INCLUDE_LINUX",
3614 "Consider using #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3615 } else {
3616 WARN("INCLUDE_LINUX",
3617 "Use #include <linux/$file> instead of <asm/$file>\n" . $herecurr);
3618 }
3619 }
3620 }
3621
3622 # multi-statement macros should be enclosed in a do while loop, grab the
3623 # first statement and ensure its the whole macro if its not enclosed
3624 # in a known good container
3625 if ($realfile !~ m@/vmlinux.lds.h$@ &&
3626 $line =~ /^.\s*\#\s*define\s*$Ident(\()?/) {
3627 my $ln = $linenr;
3628 my $cnt = $realcnt;
3629 my ($off, $dstat, $dcond, $rest);
3630 my $ctx = '';
3631 ($dstat, $dcond, $ln, $cnt, $off) =
3632 ctx_statement_block($linenr, $realcnt, 0);
3633 $ctx = $dstat;
3634 #print "dstat<$dstat> dcond<$dcond> cnt<$cnt> off<$off>\n";
3635 #print "LINE<$lines[$ln-1]> len<" . length($lines[$ln-1]) . "\n";
3636
3637 $dstat =~ s/^.\s*\#\s*define\s+$Ident(?:\([^\)]*\))?\s*//;
3638 $dstat =~ s/$;//g;
3639 $dstat =~ s/\\\n.//g;
3640 $dstat =~ s/^\s*//s;
3641 $dstat =~ s/\s*$//s;
3642
3643 # Flatten any parentheses and braces
3644 while ($dstat =~ s/\([^\(\)]*\)/1/ ||
3645 $dstat =~ s/\{[^\{\}]*\}/1/ ||
3646 $dstat =~ s/\[[^\[\]]*\]/1/)
3647 {
3648 }
3649
3650 # Flatten any obvious string concatentation.
3651 while ($dstat =~ s/("X*")\s*$Ident/$1/ ||
3652 $dstat =~ s/$Ident\s*("X*")/$1/)
3653 {
3654 }
3655
3656 my $exceptions = qr{
3657 $Declare|
3658 module_param_named|
3659 MODULE_PARM_DESC|
3660 DECLARE_PER_CPU|
3661 DEFINE_PER_CPU|
3662 __typeof__\(|
3663 union|
3664 struct|
3665 \.$Ident\s*=\s*|
3666 ^\"|\"$
3667 }x;
3668 #print "REST<$rest> dstat<$dstat> ctx<$ctx>\n";
3669 if ($dstat ne '' &&
3670 $dstat !~ /^(?:$Ident|-?$Constant),$/ && # 10, // foo(),
3671 $dstat !~ /^(?:$Ident|-?$Constant);$/ && # foo();
3672 $dstat !~ /^[!~-]?(?:$Lval|$Constant)$/ && # 10 // foo() // !foo // ~foo // -foo // foo->bar // foo.bar->baz
3673 $dstat !~ /^'X'$/ && # character constants
3674 $dstat !~ /$exceptions/ &&
3675 $dstat !~ /^\.$Ident\s*=/ && # .foo =
3676 $dstat !~ /^(?:\#\s*$Ident|\#\s*$Constant)\s*$/ && # stringification #foo
3677 $dstat !~ /^do\s*$Constant\s*while\s*$Constant;?$/ && # do {...} while (...); // do {...} while (...)
3678 $dstat !~ /^for\s*$Constant$/ && # for (...)
3679 $dstat !~ /^for\s*$Constant\s+(?:$Ident|-?$Constant)$/ && # for (...) bar()
3680 $dstat !~ /^do\s*{/ && # do {...
3681 $dstat !~ /^\({/ && # ({...
3682 $ctx !~ /^.\s*#\s*define\s+TRACE_(?:SYSTEM|INCLUDE_FILE|INCLUDE_PATH)\b/)
3683 {
3684 $ctx =~ s/\n*$//;
3685 my $herectx = $here . "\n";
3686 my $cnt = statement_rawlines($ctx);
3687
3688 for (my $n = 0; $n < $cnt; $n++) {
3689 $herectx .= raw_line($linenr, $n) . "\n";
3690 }
3691
3692 if ($dstat =~ /;/) {
3693 ERROR("MULTISTATEMENT_MACRO_USE_DO_WHILE",
3694 "Macros with multiple statements should be enclosed in a do - while loop\n" . "$herectx");
3695 } else {
3696 ERROR("COMPLEX_MACRO",
3697 "Macros with complex values should be enclosed in parenthesis\n" . "$herectx");
3698 }
3699 }
3700
3701 # check for line continuations outside of #defines, preprocessor #, and asm
3702
3703 } else {
3704 if ($prevline !~ /^..*\\$/ &&
3705 $line !~ /^\+\s*\#.*\\$/ && # preprocessor
3706 $line !~ /^\+.*\b(__asm__|asm)\b.*\\$/ && # asm
3707 $line =~ /^\+.*\\$/) {
3708 WARN("LINE_CONTINUATIONS",
3709 "Avoid unnecessary line continuations\n" . $herecurr);
3710 }
3711 }
3712
3713 # do {} while (0) macro tests:
3714 # single-statement macros do not need to be enclosed in do while (0) loop,
3715 # macro should not end with a semicolon
3716 if ($^V && $^V ge 5.10.0 &&
3717 $realfile !~ m@/vmlinux.lds.h$@ &&
3718 $line =~ /^.\s*\#\s*define\s+$Ident(\()?/) {
3719 my $ln = $linenr;
3720 my $cnt = $realcnt;
3721 my ($off, $dstat, $dcond, $rest);
3722 my $ctx = '';
3723 ($dstat, $dcond, $ln, $cnt, $off) =
3724 ctx_statement_block($linenr, $realcnt, 0);
3725 $ctx = $dstat;
3726
3727 $dstat =~ s/\\\n.//g;
3728
3729 if ($dstat =~ /^\+\s*#\s*define\s+$Ident\s*${balanced_parens}\s*do\s*{(.*)\s*}\s*while\s*\(\s*0\s*\)\s*([;\s]*)\s*$/) {
3730 my $stmts = $2;
3731 my $semis = $3;
3732
3733 $ctx =~ s/\n*$//;
3734 my $cnt = statement_rawlines($ctx);
3735 my $herectx = $here . "\n";
3736
3737 for (my $n = 0; $n < $cnt; $n++) {
3738 $herectx .= raw_line($linenr, $n) . "\n";
3739 }
3740
3741 if (($stmts =~ tr/;/;/) == 1 &&
3742 $stmts !~ /^\s*(if|while|for|switch)\b/) {
3743 WARN("SINGLE_STATEMENT_DO_WHILE_MACRO",
3744 "Single statement macros should not use a do {} while (0) loop\n" . "$herectx");
3745 }
3746 if (defined $semis && $semis ne "") {
3747 WARN("DO_WHILE_MACRO_WITH_TRAILING_SEMICOLON",
3748 "do {} while (0) macros should not be semicolon terminated\n" . "$herectx");
3749 }
3750 }
3751 }
3752
3753 # make sure symbols are always wrapped with VMLINUX_SYMBOL() ...
3754 # all assignments may have only one of the following with an assignment:
3755 # .
3756 # ALIGN(...)
3757 # VMLINUX_SYMBOL(...)
3758 if ($realfile eq 'vmlinux.lds.h' && $line =~ /(?:(?:^|\s)$Ident\s*=|=\s*$Ident(?:\s|$))/) {
3759 WARN("MISSING_VMLINUX_SYMBOL",
3760 "vmlinux.lds.h needs VMLINUX_SYMBOL() around C-visible symbols\n" . $herecurr);
3761 }
3762
3763 # check for redundant bracing round if etc
3764 if ($line =~ /(^.*)\bif\b/ && $1 !~ /else\s*$/) {
3765 my ($level, $endln, @chunks) =
3766 ctx_statement_full($linenr, $realcnt, 1);
3767 #print "chunks<$#chunks> linenr<$linenr> endln<$endln> level<$level>\n";
3768 #print "APW: <<$chunks[1][0]>><<$chunks[1][1]>>\n";
3769 if ($#chunks > 0 && $level == 0) {
3770 my @allowed = ();
3771 my $allow = 0;
3772 my $seen = 0;
3773 my $herectx = $here . "\n";
3774 my $ln = $linenr - 1;
3775 for my $chunk (@chunks) {
3776 my ($cond, $block) = @{$chunk};
3777
3778 # If the condition carries leading newlines, then count those as offsets.
3779 my ($whitespace) = ($cond =~ /^((?:\s*\n[+-])*\s*)/s);
3780 my $offset = statement_rawlines($whitespace) - 1;
3781
3782 $allowed[$allow] = 0;
3783 #print "COND<$cond> whitespace<$whitespace> offset<$offset>\n";
3784
3785 # We have looked at and allowed this specific line.
3786 $suppress_ifbraces{$ln + $offset} = 1;
3787
3788 $herectx .= "$rawlines[$ln + $offset]\n[...]\n";
3789 $ln += statement_rawlines($block) - 1;
3790
3791 substr($block, 0, length($cond), '');
3792
3793 $seen++ if ($block =~ /^\s*{/);
3794
3795 #print "cond<$cond> block<$block> allowed<$allowed[$allow]>\n";
3796 if (statement_lines($cond) > 1) {
3797 #print "APW: ALLOWED: cond<$cond>\n";
3798 $allowed[$allow] = 1;
3799 }
3800 if ($block =~/\b(?:if|for|while)\b/) {
3801 #print "APW: ALLOWED: block<$block>\n";
3802 $allowed[$allow] = 1;
3803 }
3804 if (statement_block_size($block) > 1) {
3805 #print "APW: ALLOWED: lines block<$block>\n";
3806 $allowed[$allow] = 1;
3807 }
3808 $allow++;
3809 }
3810 if ($seen) {
3811 my $sum_allowed = 0;
3812 foreach (@allowed) {
3813 $sum_allowed += $_;
3814 }
3815 if ($sum_allowed == 0) {
3816 WARN("BRACES",
3817 "braces {} are not necessary for any arm of this statement\n" . $herectx);
3818 } elsif ($sum_allowed != $allow &&
3819 $seen != $allow) {
3820 CHK("BRACES",
3821 "braces {} should be used on all arms of this statement\n" . $herectx);
3822 }
3823 }
3824 }
3825 }
3826 if (!defined $suppress_ifbraces{$linenr - 1} &&
3827 $line =~ /\b(if|while|for|else)\b/) {
3828 my $allowed = 0;
3829
3830 # Check the pre-context.
3831 if (substr($line, 0, $-[0]) =~ /(\}\s*)$/) {
3832 #print "APW: ALLOWED: pre<$1>\n";
3833 $allowed = 1;
3834 }
3835
3836 my ($level, $endln, @chunks) =
3837 ctx_statement_full($linenr, $realcnt, $-[0]);
3838
3839 # Check the condition.
3840 my ($cond, $block) = @{$chunks[0]};
3841 #print "CHECKING<$linenr> cond<$cond> block<$block>\n";
3842 if (defined $cond) {
3843 substr($block, 0, length($cond), '');
3844 }
3845 if (statement_lines($cond) > 1) {
3846 #print "APW: ALLOWED: cond<$cond>\n";
3847 $allowed = 1;
3848 }
3849 if ($block =~/\b(?:if|for|while)\b/) {
3850 #print "APW: ALLOWED: block<$block>\n";
3851 $allowed = 1;
3852 }
3853 if (statement_block_size($block) > 1) {
3854 #print "APW: ALLOWED: lines block<$block>\n";
3855 $allowed = 1;
3856 }
3857 # Check the post-context.
3858 if (defined $chunks[1]) {
3859 my ($cond, $block) = @{$chunks[1]};
3860 if (defined $cond) {
3861 substr($block, 0, length($cond), '');
3862 }
3863 if ($block =~ /^\s*\{/) {
3864 #print "APW: ALLOWED: chunk-1 block<$block>\n";
3865 $allowed = 1;
3866 }
3867 }
3868 if ($level == 0 && $block =~ /^\s*\{/ && !$allowed) {
3869 my $herectx = $here . "\n";
3870 my $cnt = statement_rawlines($block);
3871
3872 for (my $n = 0; $n < $cnt; $n++) {
3873 $herectx .= raw_line($linenr, $n) . "\n";
3874 }
3875
3876 WARN("BRACES",
3877 "braces {} are not necessary for single statement blocks\n" . $herectx);
3878 }
3879 }
3880
3881 # check for unnecessary blank lines around braces
3882 if (($line =~ /^.\s*}\s*$/ && $prevrawline =~ /^.\s*$/)) {
3883 CHK("BRACES",
3884 "Blank lines aren't necessary before a close brace '}'\n" . $hereprev);
3885 }
3886 if (($rawline =~ /^.\s*$/ && $prevline =~ /^..*{\s*$/)) {
3887 CHK("BRACES",
3888 "Blank lines aren't necessary after an open brace '{'\n" . $hereprev);
3889 }
3890
3891 # no volatiles please
3892 my $asm_volatile = qr{\b(__asm__|asm)\s+(__volatile__|volatile)\b};
3893 if ($line =~ /\bvolatile\b/ && $line !~ /$asm_volatile/) {
3894 WARN("VOLATILE",
3895 "Use of volatile is usually wrong: see Documentation/volatile-considered-harmful.txt\n" . $herecurr);
3896 }
3897
3898 # warn about #if 0
3899 if ($line =~ /^.\s*\#\s*if\s+0\b/) {
3900 CHK("REDUNDANT_CODE",
3901 "if this code is redundant consider removing it\n" .
3902 $herecurr);
3903 }
3904
3905 # check for needless "if (<foo>) fn(<foo>)" uses
3906 if ($prevline =~ /\bif\s*\(\s*($Lval)\s*\)/) {
3907 my $expr = '\s*\(\s*' . quotemeta($1) . '\s*\)\s*;';
3908 if ($line =~ /\b(kfree|usb_free_urb|debugfs_remove(?:_recursive)?)$expr/) {
3909 WARN('NEEDLESS_IF',
3910 "$1(NULL) is safe this check is probably not required\n" . $hereprev);
3911 }
3912 }
3913
3914 # check for bad placement of section $InitAttribute (e.g.: __initdata)
3915 if ($line =~ /(\b$InitAttribute\b)/) {
3916 my $attr = $1;
3917 if ($line =~ /^\+\s*static\s+(?:const\s+)?(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*[=;]/) {
3918 my $ptr = $1;
3919 my $var = $2;
3920 if ((($ptr =~ /\b(union|struct)\s+$attr\b/ &&
3921 ERROR("MISPLACED_INIT",
3922 "$attr should be placed after $var\n" . $herecurr)) ||
3923 ($ptr !~ /\b(union|struct)\s+$attr\b/ &&
3924 WARN("MISPLACED_INIT",
3925 "$attr should be placed after $var\n" . $herecurr))) &&
3926 $fix) {
3927 $fixed[$linenr - 1] =~ s/(\bstatic\s+(?:const\s+)?)(?:$attr\s+)?($NonptrTypeWithAttr)\s+(?:$attr\s+)?($Ident(?:\[[^]]*\])?)\s*([=;])\s*/"$1" . trim(string_find_replace($2, "\\s*$attr\\s*", " ")) . " " . trim(string_find_replace($3, "\\s*$attr\\s*", "")) . " $attr" . ("$4" eq ";" ? ";" : " = ")/e;
3928 }
3929 }
3930 }
3931
3932 # check for $InitAttributeData (ie: __initdata) with const
3933 if ($line =~ /\bconst\b/ && $line =~ /($InitAttributeData)/) {
3934 my $attr = $1;
3935 $attr =~ /($InitAttributePrefix)(.*)/;
3936 my $attr_prefix = $1;
3937 my $attr_type = $2;
3938 if (ERROR("INIT_ATTRIBUTE",
3939 "Use of const init definition must use ${attr_prefix}initconst\n" . $herecurr) &&
3940 $fix) {
3941 $fixed[$linenr - 1] =~
3942 s/$InitAttributeData/${attr_prefix}initconst/;
3943 }
3944 }
3945
3946 # check for $InitAttributeConst (ie: __initconst) without const
3947 if ($line !~ /\bconst\b/ && $line =~ /($InitAttributeConst)/) {
3948 my $attr = $1;
3949 if (ERROR("INIT_ATTRIBUTE",
3950 "Use of $attr requires a separate use of const\n" . $herecurr) &&
3951 $fix) {
3952 my $lead = $fixed[$linenr - 1] =~
3953 /(^\+\s*(?:static\s+))/;
3954 $lead = rtrim($1);
3955 $lead = "$lead " if ($lead !~ /^\+$/);
3956 $lead = "${lead}const ";
3957 $fixed[$linenr - 1] =~ s/(^\+\s*(?:static\s+))/$lead/;
3958 }
3959 }
3960
3961 # don't use __constant_<foo> functions outside of include/uapi/
3962 if ($realfile !~ m@^include/uapi/@ &&
3963 $line =~ /(__constant_(?:htons|ntohs|[bl]e(?:16|32|64)_to_cpu|cpu_to_[bl]e(?:16|32|64)))\s*\(/) {
3964 my $constant_func = $1;
3965 my $func = $constant_func;
3966 $func =~ s/^__constant_//;
3967 if (WARN("CONSTANT_CONVERSION",
3968 "$constant_func should be $func\n" . $herecurr) &&
3969 $fix) {
3970 $fixed[$linenr - 1] =~ s/\b$constant_func\b/$func/g;
3971 }
3972 }
3973
3974 # prefer usleep_range over udelay
3975 if ($line =~ /\budelay\s*\(\s*(\d+)\s*\)/) {
3976 my $delay = $1;
3977 # ignore udelay's < 10, however
3978 if (! ($delay < 10) ) {
3979 CHK("USLEEP_RANGE",
3980 "usleep_range is preferred over udelay; see Documentation/timers/timers-howto.txt\n" . $herecurr);
3981 }
3982 if ($delay > 2000) {
3983 WARN("LONG_UDELAY",
3984 "long udelay - prefer mdelay; see arch/arm/include/asm/delay.h\n" . $herecurr);
3985 }
3986 }
3987
3988 # warn about unexpectedly long msleep's
3989 if ($line =~ /\bmsleep\s*\((\d+)\);/) {
3990 if ($1 < 20) {
3991 WARN("MSLEEP",
3992 "msleep < 20ms can sleep for up to 20ms; see Documentation/timers/timers-howto.txt\n" . $herecurr);
3993 }
3994 }
3995
3996 # check for comparisons of jiffies
3997 if ($line =~ /\bjiffies\s*$Compare|$Compare\s*jiffies\b/) {
3998 WARN("JIFFIES_COMPARISON",
3999 "Comparing jiffies is almost always wrong; prefer time_after, time_before and friends\n" . $herecurr);
4000 }
4001
4002 # check for comparisons of get_jiffies_64()
4003 if ($line =~ /\bget_jiffies_64\s*\(\s*\)\s*$Compare|$Compare\s*get_jiffies_64\s*\(\s*\)/) {
4004 WARN("JIFFIES_COMPARISON",
4005 "Comparing get_jiffies_64() is almost always wrong; prefer time_after64, time_before64 and friends\n" . $herecurr);
4006 }
4007
4008 # warn about #ifdefs in C files
4009 # if ($line =~ /^.\s*\#\s*if(|n)def/ && ($realfile =~ /\.c$/)) {
4010 # print "#ifdef in C files should be avoided\n";
4011 # print "$herecurr";
4012 # $clean = 0;
4013 # }
4014
4015 # warn about spacing in #ifdefs
4016 if ($line =~ /^.\s*\#\s*(ifdef|ifndef|elif)\s\s+/) {
4017 if (ERROR("SPACING",
4018 "exactly one space required after that #$1\n" . $herecurr) &&
4019 $fix) {
4020 $fixed[$linenr - 1] =~
4021 s/^(.\s*\#\s*(ifdef|ifndef|elif))\s{2,}/$1 /;
4022 }
4023
4024 }
4025
4026 # check for spinlock_t definitions without a comment.
4027 if ($line =~ /^.\s*(struct\s+mutex|spinlock_t)\s+\S+;/ ||
4028 $line =~ /^.\s*(DEFINE_MUTEX)\s*\(/) {
4029 my $which = $1;
4030 if (!ctx_has_comment($first_line, $linenr)) {
4031 CHK("UNCOMMENTED_DEFINITION",
4032 "$1 definition without comment\n" . $herecurr);
4033 }
4034 }
4035 # check for memory barriers without a comment.
4036 if ($line =~ /\b(mb|rmb|wmb|read_barrier_depends|smp_mb|smp_rmb|smp_wmb|smp_read_barrier_depends)\(/) {
4037 if (!ctx_has_comment($first_line, $linenr)) {
4038 WARN("MEMORY_BARRIER",
4039 "memory barrier without comment\n" . $herecurr);
4040 }
4041 }
4042 # check of hardware specific defines
4043 if ($line =~ m@^.\s*\#\s*if.*\b(__i386__|__powerpc64__|__sun__|__s390x__)\b@ && $realfile !~ m@include/asm-@) {
4044 CHK("ARCH_DEFINES",
4045 "architecture specific defines should be avoided\n" . $herecurr);
4046 }
4047
4048 # Check that the storage class is at the beginning of a declaration
4049 if ($line =~ /\b$Storage\b/ && $line !~ /^.\s*$Storage\b/) {
4050 WARN("STORAGE_CLASS",
4051 "storage class should be at the beginning of the declaration\n" . $herecurr)
4052 }
4053
4054 # check the location of the inline attribute, that it is between
4055 # storage class and type.
4056 if ($line =~ /\b$Type\s+$Inline\b/ ||
4057 $line =~ /\b$Inline\s+$Storage\b/) {
4058 ERROR("INLINE_LOCATION",
4059 "inline keyword should sit between storage class and type\n" . $herecurr);
4060 }
4061
4062 # Check for __inline__ and __inline, prefer inline
4063 if ($realfile !~ m@\binclude/uapi/@ &&
4064 $line =~ /\b(__inline__|__inline)\b/) {
4065 if (WARN("INLINE",
4066 "plain inline is preferred over $1\n" . $herecurr) &&
4067 $fix) {
4068 $fixed[$linenr - 1] =~ s/\b(__inline__|__inline)\b/inline/;
4069
4070 }
4071 }
4072
4073 # Check for __attribute__ packed, prefer __packed
4074 if ($realfile !~ m@\binclude/uapi/@ &&
4075 $line =~ /\b__attribute__\s*\(\s*\(.*\bpacked\b/) {
4076 WARN("PREFER_PACKED",
4077 "__packed is preferred over __attribute__((packed))\n" . $herecurr);
4078 }
4079
4080 # Check for __attribute__ aligned, prefer __aligned
4081 if ($realfile !~ m@\binclude/uapi/@ &&
4082 $line =~ /\b__attribute__\s*\(\s*\(.*aligned/) {
4083 WARN("PREFER_ALIGNED",
4084 "__aligned(size) is preferred over __attribute__((aligned(size)))\n" . $herecurr);
4085 }
4086
4087 # Check for __attribute__ format(printf, prefer __printf
4088 if ($realfile !~ m@\binclude/uapi/@ &&
4089 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf/) {
4090 if (WARN("PREFER_PRINTF",
4091 "__printf(string-index, first-to-check) is preferred over __attribute__((format(printf, string-index, first-to-check)))\n" . $herecurr) &&
4092 $fix) {
4093 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*printf\s*,\s*(.*)\)\s*\)\s*\)/"__printf(" . trim($1) . ")"/ex;
4094
4095 }
4096 }
4097
4098 # Check for __attribute__ format(scanf, prefer __scanf
4099 if ($realfile !~ m@\binclude/uapi/@ &&
4100 $line =~ /\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\b/) {
4101 if (WARN("PREFER_SCANF",
4102 "__scanf(string-index, first-to-check) is preferred over __attribute__((format(scanf, string-index, first-to-check)))\n" . $herecurr) &&
4103 $fix) {
4104 $fixed[$linenr - 1] =~ s/\b__attribute__\s*\(\s*\(\s*format\s*\(\s*scanf\s*,\s*(.*)\)\s*\)\s*\)/"__scanf(" . trim($1) . ")"/ex;
4105 }
4106 }
4107
4108 # check for sizeof(&)
4109 if ($line =~ /\bsizeof\s*\(\s*\&/) {
4110 WARN("SIZEOF_ADDRESS",
4111 "sizeof(& should be avoided\n" . $herecurr);
4112 }
4113
4114 # check for sizeof without parenthesis
4115 if ($line =~ /\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/) {
4116 if (WARN("SIZEOF_PARENTHESIS",
4117 "sizeof $1 should be sizeof($1)\n" . $herecurr) &&
4118 $fix) {
4119 $fixed[$linenr - 1] =~ s/\bsizeof\s+((?:\*\s*|)$Lval|$Type(?:\s+$Lval|))/"sizeof(" . trim($1) . ")"/ex;
4120 }
4121 }
4122
4123 # check for line continuations in quoted strings with odd counts of "
4124 if ($rawline =~ /\\$/ && $rawline =~ tr/"/"/ % 2) {
4125 WARN("LINE_CONTINUATIONS",
4126 "Avoid line continuations in quoted strings\n" . $herecurr);
4127 }
4128
4129 # check for struct spinlock declarations
4130 if ($line =~ /^.\s*\bstruct\s+spinlock\s+\w+\s*;/) {
4131 WARN("USE_SPINLOCK_T",
4132 "struct spinlock should be spinlock_t\n" . $herecurr);
4133 }
4134
4135 # check for seq_printf uses that could be seq_puts
4136 if ($sline =~ /\bseq_printf\s*\(.*"\s*\)\s*;\s*$/) {
4137 my $fmt = get_quoted_string($line, $rawline);
4138 if ($fmt ne "" && $fmt !~ /[^\\]\%/) {
4139 if (WARN("PREFER_SEQ_PUTS",
4140 "Prefer seq_puts to seq_printf\n" . $herecurr) &&
4141 $fix) {
4142 $fixed[$linenr - 1] =~ s/\bseq_printf\b/seq_puts/;
4143 }
4144 }
4145 }
4146
4147 # Check for misused memsets
4148 if ($^V && $^V ge 5.10.0 &&
4149 defined $stat &&
4150 $stat =~ /^\+(?:.*?)\bmemset\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*$FuncArg\s*\)/s) {
4151
4152 my $ms_addr = $2;
4153 my $ms_val = $7;
4154 my $ms_size = $12;
4155
4156 if ($ms_size =~ /^(0x|)0$/i) {
4157 ERROR("MEMSET",
4158 "memset to 0's uses 0 as the 2nd argument, not the 3rd\n" . "$here\n$stat\n");
4159 } elsif ($ms_size =~ /^(0x|)1$/i) {
4160 WARN("MEMSET",
4161 "single byte memset is suspicious. Swapped 2nd/3rd argument?\n" . "$here\n$stat\n");
4162 }
4163 }
4164
4165 # Check for memcpy(foo, bar, ETH_ALEN) that could be ether_addr_copy(foo, bar)
4166 if ($^V && $^V ge 5.10.0 &&
4167 $line =~ /^\+(?:.*?)\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/s) {
4168 if (WARN("PREFER_ETHER_ADDR_COPY",
4169 "Prefer ether_addr_copy() over memcpy() if the Ethernet addresses are __aligned(2)\n" . $herecurr) &&
4170 $fix) {
4171 $fixed[$linenr - 1] =~ s/\bmemcpy\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\,\s*ETH_ALEN\s*\)/ether_addr_copy($2, $7)/;
4172 }
4173 }
4174
4175 # typecasts on min/max could be min_t/max_t
4176 if ($^V && $^V ge 5.10.0 &&
4177 defined $stat &&
4178 $stat =~ /^\+(?:.*?)\b(min|max)\s*\(\s*$FuncArg\s*,\s*$FuncArg\s*\)/) {
4179 if (defined $2 || defined $7) {
4180 my $call = $1;
4181 my $cast1 = deparenthesize($2);
4182 my $arg1 = $3;
4183 my $cast2 = deparenthesize($7);
4184 my $arg2 = $8;
4185 my $cast;
4186
4187 if ($cast1 ne "" && $cast2 ne "" && $cast1 ne $cast2) {
4188 $cast = "$cast1 or $cast2";
4189 } elsif ($cast1 ne "") {
4190 $cast = $cast1;
4191 } else {
4192 $cast = $cast2;
4193 }
4194 WARN("MINMAX",
4195 "$call() should probably be ${call}_t($cast, $arg1, $arg2)\n" . "$here\n$stat\n");
4196 }
4197 }
4198
4199 # check usleep_range arguments
4200 if ($^V && $^V ge 5.10.0 &&
4201 defined $stat &&
4202 $stat =~ /^\+(?:.*?)\busleep_range\s*\(\s*($FuncArg)\s*,\s*($FuncArg)\s*\)/) {
4203 my $min = $1;
4204 my $max = $7;
4205 if ($min eq $max) {
4206 WARN("USLEEP_RANGE",
4207 "usleep_range should not use min == max args; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4208 } elsif ($min =~ /^\d+$/ && $max =~ /^\d+$/ &&
4209 $min > $max) {
4210 WARN("USLEEP_RANGE",
4211 "usleep_range args reversed, use min then max; see Documentation/timers/timers-howto.txt\n" . "$here\n$stat\n");
4212 }
4213 }
4214
4215 # check for naked sscanf
4216 if ($^V && $^V ge 5.10.0 &&
4217 defined $stat &&
4218 $line =~ /\bsscanf\b/ &&
4219 ($stat !~ /$Ident\s*=\s*sscanf\s*$balanced_parens/ &&
4220 $stat !~ /\bsscanf\s*$balanced_parens\s*(?:$Compare)/ &&
4221 $stat !~ /(?:$Compare)\s*\bsscanf\s*$balanced_parens/)) {
4222 my $lc = $stat =~ tr@\n@@;
4223 $lc = $lc + $linenr;
4224 my $stat_real = raw_line($linenr, 0);
4225 for (my $count = $linenr + 1; $count <= $lc; $count++) {
4226 $stat_real = $stat_real . "\n" . raw_line($count, 0);
4227 }
4228 WARN("NAKED_SSCANF",
4229 "unchecked sscanf return value\n" . "$here\n$stat_real\n");
4230 }
4231
4232 # check for new externs in .h files.
4233 if ($realfile =~ /\.h$/ &&
4234 $line =~ /^\+\s*(extern\s+)$Type\s*$Ident\s*\(/s) {
4235 if (CHK("AVOID_EXTERNS",
4236 "extern prototypes should be avoided in .h files\n" . $herecurr) &&
4237 $fix) {
4238 $fixed[$linenr - 1] =~ s/(.*)\bextern\b\s*(.*)/$1$2/;
4239 }
4240 }
4241
4242 # check for new externs in .c files.
4243 if ($realfile =~ /\.c$/ && defined $stat &&
4244 $stat =~ /^.\s*(?:extern\s+)?$Type\s+($Ident)(\s*)\(/s)
4245 {
4246 my $function_name = $1;
4247 my $paren_space = $2;
4248
4249 my $s = $stat;
4250 if (defined $cond) {
4251 substr($s, 0, length($cond), '');
4252 }
4253 if ($s =~ /^\s*;/ &&
4254 $function_name ne 'uninitialized_var')
4255 {
4256 WARN("AVOID_EXTERNS",
4257 "externs should be avoided in .c files\n" . $herecurr);
4258 }
4259
4260 if ($paren_space =~ /\n/) {
4261 WARN("FUNCTION_ARGUMENTS",
4262 "arguments for function declarations should follow identifier\n" . $herecurr);
4263 }
4264
4265 } elsif ($realfile =~ /\.c$/ && defined $stat &&
4266 $stat =~ /^.\s*extern\s+/)
4267 {
4268 WARN("AVOID_EXTERNS",
4269 "externs should be avoided in .c files\n" . $herecurr);
4270 }
4271
4272 # checks for new __setup's
4273 if ($rawline =~ /\b__setup\("([^"]*)"/) {
4274 my $name = $1;
4275
4276 if (!grep(/$name/, @setup_docs)) {
4277 CHK("UNDOCUMENTED_SETUP",
4278 "__setup appears un-documented -- check Documentation/kernel-parameters.txt\n" . $herecurr);
4279 }
4280 }
4281
4282 # check for pointless casting of kmalloc return
4283 if ($line =~ /\*\s*\)\s*[kv][czm]alloc(_node){0,1}\b/) {
4284 WARN("UNNECESSARY_CASTS",
4285 "unnecessary cast may hide bugs, see http://c-faq.com/malloc/mallocnocast.html\n" . $herecurr);
4286 }
4287
4288 # alloc style
4289 # p = alloc(sizeof(struct foo), ...) should be p = alloc(sizeof(*p), ...)
4290 if ($^V && $^V ge 5.10.0 &&
4291 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*([kv][mz]alloc(?:_node)?)\s*\(\s*(sizeof\s*\(\s*struct\s+$Lval\s*\))/) {
4292 CHK("ALLOC_SIZEOF_STRUCT",
4293 "Prefer $3(sizeof(*$1)...) over $3($4...)\n" . $herecurr);
4294 }
4295
4296 # check for krealloc arg reuse
4297 if ($^V && $^V ge 5.10.0 &&
4298 $line =~ /\b($Lval)\s*\=\s*(?:$balanced_parens)?\s*krealloc\s*\(\s*\1\s*,/) {
4299 WARN("KREALLOC_ARG_REUSE",
4300 "Reusing the krealloc arg is almost always a bug\n" . $herecurr);
4301 }
4302
4303 # check for alloc argument mismatch
4304 if ($line =~ /\b(kcalloc|kmalloc_array)\s*\(\s*sizeof\b/) {
4305 WARN("ALLOC_ARRAY_ARGS",
4306 "$1 uses number as first arg, sizeof is generally wrong\n" . $herecurr);
4307 }
4308
4309 # check for GFP_NOWAIT use
4310 if ($line =~ /\b__GFP_NOFAIL\b/) {
4311 WARN("__GFP_NOFAIL",
4312 "Use of __GFP_NOFAIL is deprecated, no new users should be added\n" . $herecurr);
4313 }
4314
4315 # check for multiple semicolons
4316 if ($line =~ /;\s*;\s*$/) {
4317 if (WARN("ONE_SEMICOLON",
4318 "Statements terminations use 1 semicolon\n" . $herecurr) &&
4319 $fix) {
4320 $fixed[$linenr - 1] =~ s/(\s*;\s*){2,}$/;/g;
4321 }
4322 }
4323
4324 # check for case / default statements not preceeded by break/fallthrough/switch
4325 if ($line =~ /^.\s*(?:case\s+(?:$Ident|$Constant)\s*|default):/) {
4326 my $has_break = 0;
4327 my $has_statement = 0;
4328 my $count = 0;
4329 my $prevline = $linenr;
4330 while ($prevline > 1 && $count < 3 && !$has_break) {
4331 $prevline--;
4332 my $rline = $rawlines[$prevline - 1];
4333 my $fline = $lines[$prevline - 1];
4334 last if ($fline =~ /^\@\@/);
4335 next if ($fline =~ /^\-/);
4336 next if ($fline =~ /^.(?:\s*(?:case\s+(?:$Ident|$Constant)[\s$;]*|default):[\s$;]*)*$/);
4337 $has_break = 1 if ($rline =~ /fall[\s_-]*(through|thru)/i);
4338 next if ($fline =~ /^.[\s$;]*$/);
4339 $has_statement = 1;
4340 $count++;
4341 $has_break = 1 if ($fline =~ /\bswitch\b|\b(?:break\s*;[\s$;]*$|return\b|goto\b|continue\b)/);
4342 }
4343 if (!$has_break && $has_statement) {
4344 WARN("MISSING_BREAK",
4345 "Possible switch case/default not preceeded by break or fallthrough comment\n" . $herecurr);
4346 }
4347 }
4348
4349 # check for switch/default statements without a break;
4350 if ($^V && $^V ge 5.10.0 &&
4351 defined $stat &&
4352 $stat =~ /^\+[$;\s]*(?:case[$;\s]+\w+[$;\s]*:[$;\s]*|)*[$;\s]*\bdefault[$;\s]*:[$;\s]*;/g) {
4353 my $ctx = '';
4354 my $herectx = $here . "\n";
4355 my $cnt = statement_rawlines($stat);
4356 for (my $n = 0; $n < $cnt; $n++) {
4357 $herectx .= raw_line($linenr, $n) . "\n";
4358 }
4359 WARN("DEFAULT_NO_BREAK",
4360 "switch default: should use break\n" . $herectx);
4361 }
4362
4363 # check for gcc specific __FUNCTION__
4364 if ($line =~ /\b__FUNCTION__\b/) {
4365 if (WARN("USE_FUNC",
4366 "__func__ should be used instead of gcc specific __FUNCTION__\n" . $herecurr) &&
4367 $fix) {
4368 $fixed[$linenr - 1] =~ s/\b__FUNCTION__\b/__func__/g;
4369 }
4370 }
4371
4372 # check for use of yield()
4373 if ($line =~ /\byield\s*\(\s*\)/) {
4374 WARN("YIELD",
4375 "Using yield() is generally wrong. See yield() kernel-doc (sched/core.c)\n" . $herecurr);
4376 }
4377
4378 # check for comparisons against true and false
4379 if ($line =~ /\+\s*(.*?)\b(true|false|$Lval)\s*(==|\!=)\s*(true|false|$Lval)\b(.*)$/i) {
4380 my $lead = $1;
4381 my $arg = $2;
4382 my $test = $3;
4383 my $otype = $4;
4384 my $trail = $5;
4385 my $op = "!";
4386
4387 ($arg, $otype) = ($otype, $arg) if ($arg =~ /^(?:true|false)$/i);
4388
4389 my $type = lc($otype);
4390 if ($type =~ /^(?:true|false)$/) {
4391 if (("$test" eq "==" && "$type" eq "true") ||
4392 ("$test" eq "!=" && "$type" eq "false")) {
4393 $op = "";
4394 }
4395
4396 CHK("BOOL_COMPARISON",
4397 "Using comparison to $otype is error prone\n" . $herecurr);
4398
4399 ## maybe suggesting a correct construct would better
4400 ## "Using comparison to $otype is error prone. Perhaps use '${lead}${op}${arg}${trail}'\n" . $herecurr);
4401
4402 }
4403 }
4404
4405 # check for semaphores initialized locked
4406 if ($line =~ /^.\s*sema_init.+,\W?0\W?\)/) {
4407 WARN("CONSIDER_COMPLETION",
4408 "consider using a completion\n" . $herecurr);
4409 }
4410
4411 # recommend kstrto* over simple_strto* and strict_strto*
4412 if ($line =~ /\b((simple|strict)_(strto(l|ll|ul|ull)))\s*\(/) {
4413 WARN("CONSIDER_KSTRTO",
4414 "$1 is obsolete, use k$3 instead\n" . $herecurr);
4415 }
4416
4417 # check for __initcall(), use device_initcall() explicitly please
4418 if ($line =~ /^.\s*__initcall\s*\(/) {
4419 WARN("USE_DEVICE_INITCALL",
4420 "please use device_initcall() instead of __initcall()\n" . $herecurr);
4421 }
4422
4423 # check for various ops structs, ensure they are const.
4424 my $struct_ops = qr{acpi_dock_ops|
4425 address_space_operations|
4426 backlight_ops|
4427 block_device_operations|
4428 dentry_operations|
4429 dev_pm_ops|
4430 dma_map_ops|
4431 extent_io_ops|
4432 file_lock_operations|
4433 file_operations|
4434 hv_ops|
4435 ide_dma_ops|
4436 intel_dvo_dev_ops|
4437 item_operations|
4438 iwl_ops|
4439 kgdb_arch|
4440 kgdb_io|
4441 kset_uevent_ops|
4442 lock_manager_operations|
4443 microcode_ops|
4444 mtrr_ops|
4445 neigh_ops|
4446 nlmsvc_binding|
4447 pci_raw_ops|
4448 pipe_buf_operations|
4449 platform_hibernation_ops|
4450 platform_suspend_ops|
4451 proto_ops|
4452 rpc_pipe_ops|
4453 seq_operations|
4454 snd_ac97_build_ops|
4455 soc_pcmcia_socket_ops|
4456 stacktrace_ops|
4457 sysfs_ops|
4458 tty_operations|
4459 usb_mon_operations|
4460 wd_ops}x;
4461 if ($line !~ /\bconst\b/ &&
4462 $line =~ /\bstruct\s+($struct_ops)\b/) {
4463 WARN("CONST_STRUCT",
4464 "struct $1 should normally be const\n" .
4465 $herecurr);
4466 }
4467
4468 # use of NR_CPUS is usually wrong
4469 # ignore definitions of NR_CPUS and usage to define arrays as likely right
4470 if ($line =~ /\bNR_CPUS\b/ &&
4471 $line !~ /^.\s*\s*#\s*if\b.*\bNR_CPUS\b/ &&
4472 $line !~ /^.\s*\s*#\s*define\b.*\bNR_CPUS\b/ &&
4473 $line !~ /^.\s*$Declare\s.*\[[^\]]*NR_CPUS[^\]]*\]/ &&
4474 $line !~ /\[[^\]]*\.\.\.[^\]]*NR_CPUS[^\]]*\]/ &&
4475 $line !~ /\[[^\]]*NR_CPUS[^\]]*\.\.\.[^\]]*\]/)
4476 {
4477 WARN("NR_CPUS",
4478 "usage of NR_CPUS is often wrong - consider using cpu_possible(), num_possible_cpus(), for_each_possible_cpu(), etc\n" . $herecurr);
4479 }
4480
4481 # Use of __ARCH_HAS_<FOO> or ARCH_HAVE_<BAR> is wrong.
4482 if ($line =~ /\+\s*#\s*define\s+((?:__)?ARCH_(?:HAS|HAVE)\w*)\b/) {
4483 ERROR("DEFINE_ARCH_HAS",
4484 "#define of '$1' is wrong - use Kconfig variables or standard guards instead\n" . $herecurr);
4485 }
4486
4487 # check for %L{u,d,i} in strings
4488 my $string;
4489 while ($line =~ /(?:^|")([X\t]*)(?:"|$)/g) {
4490 $string = substr($rawline, $-[1], $+[1] - $-[1]);
4491 $string =~ s/%%/__/g;
4492 if ($string =~ /(?<!%)%L[udi]/) {
4493 WARN("PRINTF_L",
4494 "\%Ld/%Lu are not-standard C, use %lld/%llu\n" . $herecurr);
4495 last;
4496 }
4497 }
4498
4499 # whine mightly about in_atomic
4500 if ($line =~ /\bin_atomic\s*\(/) {
4501 if ($realfile =~ m@^drivers/@) {
4502 ERROR("IN_ATOMIC",
4503 "do not use in_atomic in drivers\n" . $herecurr);
4504 } elsif ($realfile !~ m@^kernel/@) {
4505 WARN("IN_ATOMIC",
4506 "use of in_atomic() is incorrect outside core kernel code\n" . $herecurr);
4507 }
4508 }
4509
4510 # check for lockdep_set_novalidate_class
4511 if ($line =~ /^.\s*lockdep_set_novalidate_class\s*\(/ ||
4512 $line =~ /__lockdep_no_validate__\s*\)/ ) {
4513 if ($realfile !~ m@^kernel/lockdep@ &&
4514 $realfile !~ m@^include/linux/lockdep@ &&
4515 $realfile !~ m@^drivers/base/core@) {
4516 ERROR("LOCKDEP",
4517 "lockdep_no_validate class is reserved for device->mutex.\n" . $herecurr);
4518 }
4519 }
4520
4521 if ($line =~ /debugfs_create_file.*S_IWUGO/ ||
4522 $line =~ /DEVICE_ATTR.*S_IWUGO/ ) {
4523 WARN("EXPORTED_WORLD_WRITABLE",
4524 "Exporting world writable files is usually an error. Consider more restrictive permissions.\n" . $herecurr);
4525 }
4526
4527 foreach my $entry (@mode_permission_funcs) {
4528 my $func = $entry->[0];
4529 my $arg_pos = $entry->[1];
4530
4531 my $skip_args = "";
4532 if ($arg_pos > 1) {
4533 $arg_pos--;
4534 $skip_args = "(?:\\s*$FuncArg\\s*,\\s*){$arg_pos,$arg_pos}";
4535 }
4536 my $test = "\\b$func\\s*\\(${skip_args}([\\d]+)\\s*[,\\)]";
4537 if ($^V && $^V ge 5.10.0 &&
4538 $line =~ /$test/) {
4539 my $val = $1;
4540 $val = $6 if ($skip_args ne "");
4541
4542 if ($val !~ /^0$/ &&
4543 (($val =~ /^$Int$/ && $val !~ /^$Octal$/) ||
4544 length($val) ne 4)) {
4545 ERROR("NON_OCTAL_PERMISSIONS",
4546 "Use 4 digit octal (0777) not decimal permissions\n" . $herecurr);
4547 }
4548 }
4549 }
4550 }
4551
4552 # If we have no input at all, then there is nothing to report on
4553 # so just keep quiet.
4554 if ($#rawlines == -1) {
4555 exit(0);
4556 }
4557
4558 # In mailback mode only produce a report in the negative, for
4559 # things that appear to be patches.
4560 if ($mailback && ($clean == 1 || !$is_patch)) {
4561 exit(0);
4562 }
4563
4564 # This is not a patch, and we are are in 'no-patch' mode so
4565 # just keep quiet.
4566 if (!$chk_patch && !$is_patch) {
4567 exit(0);
4568 }
4569
4570 if (!$is_patch) {
4571 ERROR("NOT_UNIFIED_DIFF",
4572 "Does not appear to be a unified-diff format patch\n");
4573 }
4574 if ($is_patch && $chk_signoff && $signoff == 0) {
4575 ERROR("MISSING_SIGN_OFF",
4576 "Missing Signed-off-by: line(s)\n");
4577 }
4578
4579 print report_dump();
4580 if ($summary && !($clean == 1 && $quiet == 1)) {
4581 print "$filename " if ($summary_file);
4582 print "total: $cnt_error errors, $cnt_warn warnings, " .
4583 (($check)? "$cnt_chk checks, " : "") .
4584 "$cnt_lines lines checked\n";
4585 print "\n" if ($quiet == 0);
4586 }
4587
4588 if ($quiet == 0) {
4589
4590 if ($^V lt 5.10.0) {
4591 print("NOTE: perl $^V is not modern enough to detect all possible issues.\n");
4592 print("An upgrade to at least perl v5.10.0 is suggested.\n\n");
4593 }
4594
4595 # If there were whitespace errors which cleanpatch can fix
4596 # then suggest that.
4597 if ($rpt_cleaners) {
4598 print "NOTE: whitespace errors detected, you may wish to use scripts/cleanpatch or\n";
4599 print " scripts/cleanfile\n\n";
4600 $rpt_cleaners = 0;
4601 }
4602 }
4603
4604 hash_show_words(\%use_type, "Used");
4605 hash_show_words(\%ignore_type, "Ignored");
4606
4607 if ($clean == 0 && $fix && "@rawlines" ne "@fixed") {
4608 my $newfile = $filename;
4609 $newfile .= ".EXPERIMENTAL-checkpatch-fixes" if (!$fix_inplace);
4610 my $linecount = 0;
4611 my $f;
4612
4613 open($f, '>', $newfile)
4614 or die "$P: Can't open $newfile for write\n";
4615 foreach my $fixed_line (@fixed) {
4616 $linecount++;
4617 if ($file) {
4618 if ($linecount > 3) {
4619 $fixed_line =~ s/^\+//;
4620 print $f $fixed_line. "\n";
4621 }
4622 } else {
4623 print $f $fixed_line . "\n";
4624 }
4625 }
4626 close($f);
4627
4628 if (!$quiet) {
4629 print << "EOM";
4630 Wrote EXPERIMENTAL --fix correction(s) to '$newfile'
4631
4632 Do _NOT_ trust the results written to this file.
4633 Do _NOT_ submit these changes without inspecting them for correctness.
4634
4635 This EXPERIMENTAL file is simply a convenience to help rewrite patches.
4636 No warranties, expressed or implied...
4637
4638 EOM
4639 }
4640 }
4641
4642 if ($clean == 1 && $quiet == 0) {
4643 print "$vname has no obvious style problems and is ready for submission.\n"
4644 }
4645 if ($clean == 0 && $quiet == 0) {
4646 print << "EOM";
4647 $vname has style problems, please review.
4648
4649 If any of these errors are false positives, please report
4650 them to the maintainer, see CHECKPATCH in MAINTAINERS.
4651 EOM
4652 }
4653
4654 return $clean;
4655 }